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_ntfs_3g_probe_0_skip (void)
159 str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0");
160 if (str && strcmp (str, "1") == 0) return 1;
161 str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
162 if (str && strcmp (str, "1") == 0) return 1;
166 static int test_ntfs_3g_probe_0 (void)
168 if (test_ntfs_3g_probe_0_skip ()) {
169 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ntfs_3g_probe_0");
173 /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
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);
196 /* TestOutputInt for ntfs_3g_probe (0) */
198 char device[] = "/dev/sda";
199 char lines_0[] = ",";
206 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
211 char fstype[] = "ntfs";
212 char device[] = "/dev/sda1";
215 r = guestfs_mkfs (g, fstype, device);
220 char device[] = "/dev/sda1";
223 r = guestfs_ntfs_3g_probe (g, 1, device);
227 fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n", (int) r);
234 static int test_ntfs_3g_probe_1_skip (void)
238 str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
239 if (str && strcmp (str, "1") == 0) return 1;
240 str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
241 if (str && strcmp (str, "1") == 0) return 1;
245 static int test_ntfs_3g_probe_1 (void)
247 if (test_ntfs_3g_probe_1_skip ()) {
248 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ntfs_3g_probe_1");
252 /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
254 char device[] = "/dev/sda";
257 r = guestfs_blockdev_setrw (g, device);
264 r = guestfs_umount_all (g);
271 r = guestfs_lvm_remove_all (g);
275 /* TestOutputInt for ntfs_3g_probe (1) */
277 char device[] = "/dev/sda";
278 char lines_0[] = ",";
285 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
290 char fstype[] = "ext2";
291 char device[] = "/dev/sda1";
294 r = guestfs_mkfs (g, fstype, device);
299 char device[] = "/dev/sda1";
302 r = guestfs_ntfs_3g_probe (g, 1, device);
306 fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n", (int) r);
313 static int test_sleep_0_skip (void)
317 str = getenv ("SKIP_TEST_SLEEP_0");
318 if (str && strcmp (str, "1") == 0) return 1;
319 str = getenv ("SKIP_TEST_SLEEP");
320 if (str && strcmp (str, "1") == 0) return 1;
324 static int test_sleep_0 (void)
326 if (test_sleep_0_skip ()) {
327 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sleep_0");
331 /* InitNone|InitEmpty for test_sleep_0 */
333 char device[] = "/dev/sda";
336 r = guestfs_blockdev_setrw (g, device);
343 r = guestfs_umount_all (g);
350 r = guestfs_lvm_remove_all (g);
354 /* TestRun for sleep (0) */
358 r = guestfs_sleep (g, 1);
365 static int test_find_0_skip (void)
369 str = getenv ("SKIP_TEST_FIND_0");
370 if (str && strcmp (str, "1") == 0) return 1;
371 str = getenv ("SKIP_TEST_FIND");
372 if (str && strcmp (str, "1") == 0) return 1;
376 static int test_find_0 (void)
378 if (test_find_0_skip ()) {
379 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_0");
383 /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
385 char device[] = "/dev/sda";
388 r = guestfs_blockdev_setrw (g, device);
395 r = guestfs_umount_all (g);
402 r = guestfs_lvm_remove_all (g);
407 char device[] = "/dev/sda";
408 char lines_0[] = ",";
415 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
420 char fstype[] = "ext2";
421 char device[] = "/dev/sda1";
424 r = guestfs_mkfs (g, fstype, device);
429 char device[] = "/dev/sda1";
430 char mountpoint[] = "/";
433 r = guestfs_mount (g, device, mountpoint);
437 /* TestOutputList for find (0) */
439 char directory[] = "/";
443 r = guestfs_find (g, directory);
447 fprintf (stderr, "test_find_0: short list returned from command\n");
452 char expected[] = "lost+found";
453 if (strcmp (r[0], expected) != 0) {
454 fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
459 fprintf (stderr, "test_find_0: extra elements returned from command\n");
463 for (i = 0; r[i] != NULL; ++i)
470 static int test_find_1_skip (void)
474 str = getenv ("SKIP_TEST_FIND_1");
475 if (str && strcmp (str, "1") == 0) return 1;
476 str = getenv ("SKIP_TEST_FIND");
477 if (str && strcmp (str, "1") == 0) return 1;
481 static int test_find_1 (void)
483 if (test_find_1_skip ()) {
484 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_1");
488 /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
490 char device[] = "/dev/sda";
493 r = guestfs_blockdev_setrw (g, device);
500 r = guestfs_umount_all (g);
507 r = guestfs_lvm_remove_all (g);
512 char device[] = "/dev/sda";
513 char lines_0[] = ",";
520 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
525 char fstype[] = "ext2";
526 char device[] = "/dev/sda1";
529 r = guestfs_mkfs (g, fstype, device);
534 char device[] = "/dev/sda1";
535 char mountpoint[] = "/";
538 r = guestfs_mount (g, device, mountpoint);
542 /* TestOutputList for find (1) */
547 r = guestfs_touch (g, path);
555 r = guestfs_mkdir (g, path);
560 char path[] = "/b/c";
563 r = guestfs_touch (g, path);
568 char directory[] = "/";
572 r = guestfs_find (g, directory);
576 fprintf (stderr, "test_find_1: short list returned from command\n");
581 char expected[] = "a";
582 if (strcmp (r[0], expected) != 0) {
583 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
588 fprintf (stderr, "test_find_1: short list returned from command\n");
593 char expected[] = "b";
594 if (strcmp (r[1], expected) != 0) {
595 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
600 fprintf (stderr, "test_find_1: short list returned from command\n");
605 char expected[] = "b/c";
606 if (strcmp (r[2], expected) != 0) {
607 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
612 fprintf (stderr, "test_find_1: short list returned from command\n");
617 char expected[] = "lost+found";
618 if (strcmp (r[3], expected) != 0) {
619 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
624 fprintf (stderr, "test_find_1: extra elements returned from command\n");
628 for (i = 0; r[i] != NULL; ++i)
635 static int test_find_2_skip (void)
639 str = getenv ("SKIP_TEST_FIND_2");
640 if (str && strcmp (str, "1") == 0) return 1;
641 str = getenv ("SKIP_TEST_FIND");
642 if (str && strcmp (str, "1") == 0) return 1;
646 static int test_find_2 (void)
648 if (test_find_2_skip ()) {
649 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_2");
653 /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
655 char device[] = "/dev/sda";
658 r = guestfs_blockdev_setrw (g, device);
665 r = guestfs_umount_all (g);
672 r = guestfs_lvm_remove_all (g);
677 char device[] = "/dev/sda";
678 char lines_0[] = ",";
685 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
690 char fstype[] = "ext2";
691 char device[] = "/dev/sda1";
694 r = guestfs_mkfs (g, fstype, device);
699 char device[] = "/dev/sda1";
700 char mountpoint[] = "/";
703 r = guestfs_mount (g, device, mountpoint);
707 /* TestOutputList for find (2) */
709 char path[] = "/a/b/c";
712 r = guestfs_mkdir_p (g, path);
717 char path[] = "/a/b/c/d";
720 r = guestfs_touch (g, path);
725 char directory[] = "/a/b/";
729 r = guestfs_find (g, directory);
733 fprintf (stderr, "test_find_2: short list returned from command\n");
738 char expected[] = "c";
739 if (strcmp (r[0], expected) != 0) {
740 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
745 fprintf (stderr, "test_find_2: short list returned from command\n");
750 char expected[] = "c/d";
751 if (strcmp (r[1], expected) != 0) {
752 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
757 fprintf (stderr, "test_find_2: extra elements returned from command\n");
761 for (i = 0; r[i] != NULL; ++i)
768 static int test_lvresize_0_skip (void)
772 str = getenv ("SKIP_TEST_LVRESIZE_0");
773 if (str && strcmp (str, "1") == 0) return 1;
774 str = getenv ("SKIP_TEST_LVRESIZE");
775 if (str && strcmp (str, "1") == 0) return 1;
779 static int test_lvresize_0 (void)
781 if (test_lvresize_0_skip ()) {
782 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvresize_0");
786 /* InitNone|InitEmpty for test_lvresize_0 */
788 char device[] = "/dev/sda";
791 r = guestfs_blockdev_setrw (g, device);
798 r = guestfs_umount_all (g);
805 r = guestfs_lvm_remove_all (g);
809 /* TestOutput for lvresize (0) */
810 char expected[] = "test content";
812 char device[] = "/dev/sda";
813 char lines_0[] = ",";
820 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
825 char device[] = "/dev/sda1";
828 r = guestfs_pvcreate (g, device);
833 char volgroup[] = "VG";
834 char physvols_0[] = "/dev/sda1";
841 r = guestfs_vgcreate (g, volgroup, physvols);
846 char logvol[] = "LV";
847 char volgroup[] = "VG";
850 r = guestfs_lvcreate (g, logvol, volgroup, 10);
855 char fstype[] = "ext2";
856 char device[] = "/dev/VG/LV";
859 r = guestfs_mkfs (g, fstype, device);
864 char device[] = "/dev/VG/LV";
865 char mountpoint[] = "/";
868 r = guestfs_mount (g, device, mountpoint);
873 char path[] = "/new";
874 char content[] = "test content";
877 r = guestfs_write_file (g, path, content, 0);
882 char pathordevice[] = "/";
885 r = guestfs_umount (g, pathordevice);
890 char device[] = "/dev/VG/LV";
893 r = guestfs_lvresize (g, device, 20);
898 char device[] = "/dev/VG/LV";
901 r = guestfs_e2fsck_f (g, device);
906 char device[] = "/dev/VG/LV";
909 r = guestfs_resize2fs (g, device);
914 char device[] = "/dev/VG/LV";
915 char mountpoint[] = "/";
918 r = guestfs_mount (g, device, mountpoint);
923 char path[] = "/new";
926 r = guestfs_cat (g, path);
929 if (strcmp (r, expected) != 0) {
930 fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
938 static int test_zerofree_0_skip (void)
942 str = getenv ("SKIP_TEST_ZEROFREE_0");
943 if (str && strcmp (str, "1") == 0) return 1;
944 str = getenv ("SKIP_TEST_ZEROFREE");
945 if (str && strcmp (str, "1") == 0) return 1;
949 static int test_zerofree_0 (void)
951 if (test_zerofree_0_skip ()) {
952 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zerofree_0");
956 /* InitNone|InitEmpty for test_zerofree_0 */
958 char device[] = "/dev/sda";
961 r = guestfs_blockdev_setrw (g, device);
968 r = guestfs_umount_all (g);
975 r = guestfs_lvm_remove_all (g);
979 /* TestOutput for zerofree (0) */
980 char expected[] = "test file";
982 char device[] = "/dev/sda";
983 char lines_0[] = ",";
990 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
995 char fstype[] = "ext3";
996 char device[] = "/dev/sda1";
999 r = guestfs_mkfs (g, fstype, device);
1004 char device[] = "/dev/sda1";
1005 char mountpoint[] = "/";
1008 r = guestfs_mount (g, device, mountpoint);
1013 char path[] = "/new";
1014 char content[] = "test file";
1017 r = guestfs_write_file (g, path, content, 0);
1022 char pathordevice[] = "/dev/sda1";
1025 r = guestfs_umount (g, pathordevice);
1030 char device[] = "/dev/sda1";
1033 r = guestfs_zerofree (g, device);
1038 char device[] = "/dev/sda1";
1039 char mountpoint[] = "/";
1042 r = guestfs_mount (g, device, mountpoint);
1047 char path[] = "/new";
1050 r = guestfs_cat (g, path);
1053 if (strcmp (r, expected) != 0) {
1054 fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
1062 static int test_hexdump_0_skip (void)
1066 str = getenv ("SKIP_TEST_HEXDUMP_0");
1067 if (str && strcmp (str, "1") == 0) return 1;
1068 str = getenv ("SKIP_TEST_HEXDUMP");
1069 if (str && strcmp (str, "1") == 0) return 1;
1073 static int test_hexdump_0 (void)
1075 if (test_hexdump_0_skip ()) {
1076 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_hexdump_0");
1080 /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
1082 char device[] = "/dev/sda";
1085 r = guestfs_blockdev_setrw (g, device);
1092 r = guestfs_umount_all (g);
1099 r = guestfs_lvm_remove_all (g);
1104 char device[] = "/dev/sda";
1105 char lines_0[] = ",";
1112 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1117 char fstype[] = "ext2";
1118 char device[] = "/dev/sda1";
1121 r = guestfs_mkfs (g, fstype, device);
1126 char device[] = "/dev/sda1";
1127 char mountpoint[] = "/";
1130 r = guestfs_mount (g, device, mountpoint);
1134 /* TestOutput for hexdump (0) */
1135 char expected[] = "00000000 68 65 6c 6c 6f 0a 77 6f 72 6c 64 0a |hello.world.|\n0000000c\n";
1137 char path[] = "/new";
1138 char content[] = "hello\nworld\n";
1141 r = guestfs_write_file (g, path, content, 12);
1146 char path[] = "/new";
1149 r = guestfs_hexdump (g, path);
1152 if (strcmp (r, expected) != 0) {
1153 fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
1161 static int test_strings_e_0_skip (void)
1165 str = getenv ("SKIP_TEST_STRINGS_E_0");
1166 if (str && strcmp (str, "1") == 0) return 1;
1167 str = getenv ("SKIP_TEST_STRINGS_E");
1168 if (str && strcmp (str, "1") == 0) return 1;
1172 static int test_strings_e_0 (void)
1174 if (test_strings_e_0_skip ()) {
1175 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_0");
1179 /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
1181 char device[] = "/dev/sda";
1184 r = guestfs_blockdev_setrw (g, device);
1191 r = guestfs_umount_all (g);
1198 r = guestfs_lvm_remove_all (g);
1203 char device[] = "/dev/sda";
1204 char lines_0[] = ",";
1211 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1216 char fstype[] = "ext2";
1217 char device[] = "/dev/sda1";
1220 r = guestfs_mkfs (g, fstype, device);
1225 char device[] = "/dev/sda1";
1226 char mountpoint[] = "/";
1229 r = guestfs_mount (g, device, mountpoint);
1233 /* TestOutputList for strings_e (0) */
1235 char path[] = "/new";
1236 char content[] = "hello\nworld\n";
1239 r = guestfs_write_file (g, path, content, 0);
1244 char encoding[] = "b";
1245 char path[] = "/new";
1249 r = guestfs_strings_e (g, encoding, path);
1253 fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
1257 for (i = 0; r[i] != NULL; ++i)
1264 static int test_strings_e_1_skip (void)
1268 str = getenv ("SKIP_TEST_STRINGS_E_1");
1269 if (str && strcmp (str, "1") == 0) return 1;
1270 str = getenv ("SKIP_TEST_STRINGS_E");
1271 if (str && strcmp (str, "1") == 0) return 1;
1275 static int test_strings_e_1 (void)
1277 if (test_strings_e_1_skip ()) {
1278 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_1");
1282 printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
1286 static int test_strings_0_skip (void)
1290 str = getenv ("SKIP_TEST_STRINGS_0");
1291 if (str && strcmp (str, "1") == 0) return 1;
1292 str = getenv ("SKIP_TEST_STRINGS");
1293 if (str && strcmp (str, "1") == 0) return 1;
1297 static int test_strings_0 (void)
1299 if (test_strings_0_skip ()) {
1300 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_0");
1304 /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
1306 char device[] = "/dev/sda";
1309 r = guestfs_blockdev_setrw (g, device);
1316 r = guestfs_umount_all (g);
1323 r = guestfs_lvm_remove_all (g);
1328 char device[] = "/dev/sda";
1329 char lines_0[] = ",";
1336 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1341 char fstype[] = "ext2";
1342 char device[] = "/dev/sda1";
1345 r = guestfs_mkfs (g, fstype, device);
1350 char device[] = "/dev/sda1";
1351 char mountpoint[] = "/";
1354 r = guestfs_mount (g, device, mountpoint);
1358 /* TestOutputList for strings (0) */
1360 char path[] = "/new";
1361 char content[] = "hello\nworld\n";
1364 r = guestfs_write_file (g, path, content, 0);
1369 char path[] = "/new";
1373 r = guestfs_strings (g, path);
1377 fprintf (stderr, "test_strings_0: short list returned from command\n");
1382 char expected[] = "hello";
1383 if (strcmp (r[0], expected) != 0) {
1384 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1389 fprintf (stderr, "test_strings_0: short list returned from command\n");
1394 char expected[] = "world";
1395 if (strcmp (r[1], expected) != 0) {
1396 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1401 fprintf (stderr, "test_strings_0: extra elements returned from command\n");
1405 for (i = 0; r[i] != NULL; ++i)
1412 static int test_strings_1_skip (void)
1416 str = getenv ("SKIP_TEST_STRINGS_1");
1417 if (str && strcmp (str, "1") == 0) return 1;
1418 str = getenv ("SKIP_TEST_STRINGS");
1419 if (str && strcmp (str, "1") == 0) return 1;
1423 static int test_strings_1 (void)
1425 if (test_strings_1_skip ()) {
1426 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_1");
1430 /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
1432 char device[] = "/dev/sda";
1435 r = guestfs_blockdev_setrw (g, device);
1442 r = guestfs_umount_all (g);
1449 r = guestfs_lvm_remove_all (g);
1454 char device[] = "/dev/sda";
1455 char lines_0[] = ",";
1462 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1467 char fstype[] = "ext2";
1468 char device[] = "/dev/sda1";
1471 r = guestfs_mkfs (g, fstype, device);
1476 char device[] = "/dev/sda1";
1477 char mountpoint[] = "/";
1480 r = guestfs_mount (g, device, mountpoint);
1484 /* TestOutputList for strings (1) */
1486 char path[] = "/new";
1489 r = guestfs_touch (g, path);
1494 char path[] = "/new";
1498 r = guestfs_strings (g, path);
1502 fprintf (stderr, "test_strings_1: extra elements returned from command\n");
1506 for (i = 0; r[i] != NULL; ++i)
1513 static int test_equal_0_skip (void)
1517 str = getenv ("SKIP_TEST_EQUAL_0");
1518 if (str && strcmp (str, "1") == 0) return 1;
1519 str = getenv ("SKIP_TEST_EQUAL");
1520 if (str && strcmp (str, "1") == 0) return 1;
1524 static int test_equal_0 (void)
1526 if (test_equal_0_skip ()) {
1527 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_0");
1531 /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
1533 char device[] = "/dev/sda";
1536 r = guestfs_blockdev_setrw (g, device);
1543 r = guestfs_umount_all (g);
1550 r = guestfs_lvm_remove_all (g);
1555 char device[] = "/dev/sda";
1556 char lines_0[] = ",";
1563 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1568 char fstype[] = "ext2";
1569 char device[] = "/dev/sda1";
1572 r = guestfs_mkfs (g, fstype, device);
1577 char device[] = "/dev/sda1";
1578 char mountpoint[] = "/";
1581 r = guestfs_mount (g, device, mountpoint);
1585 /* TestOutputTrue for equal (0) */
1587 char path[] = "/file1";
1588 char content[] = "contents of a file";
1591 r = guestfs_write_file (g, path, content, 0);
1596 char src[] = "/file1";
1597 char dest[] = "/file2";
1600 r = guestfs_cp (g, src, dest);
1605 char file1[] = "/file1";
1606 char file2[] = "/file2";
1609 r = guestfs_equal (g, file1, file2);
1613 fprintf (stderr, "test_equal_0: expected true, got false\n");
1620 static int test_equal_1_skip (void)
1624 str = getenv ("SKIP_TEST_EQUAL_1");
1625 if (str && strcmp (str, "1") == 0) return 1;
1626 str = getenv ("SKIP_TEST_EQUAL");
1627 if (str && strcmp (str, "1") == 0) return 1;
1631 static int test_equal_1 (void)
1633 if (test_equal_1_skip ()) {
1634 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_1");
1638 /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
1640 char device[] = "/dev/sda";
1643 r = guestfs_blockdev_setrw (g, device);
1650 r = guestfs_umount_all (g);
1657 r = guestfs_lvm_remove_all (g);
1662 char device[] = "/dev/sda";
1663 char lines_0[] = ",";
1670 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1675 char fstype[] = "ext2";
1676 char device[] = "/dev/sda1";
1679 r = guestfs_mkfs (g, fstype, device);
1684 char device[] = "/dev/sda1";
1685 char mountpoint[] = "/";
1688 r = guestfs_mount (g, device, mountpoint);
1692 /* TestOutputFalse for equal (1) */
1694 char path[] = "/file1";
1695 char content[] = "contents of a file";
1698 r = guestfs_write_file (g, path, content, 0);
1703 char path[] = "/file2";
1704 char content[] = "contents of another file";
1707 r = guestfs_write_file (g, path, content, 0);
1712 char file1[] = "/file1";
1713 char file2[] = "/file2";
1716 r = guestfs_equal (g, file1, file2);
1720 fprintf (stderr, "test_equal_1: expected false, got true\n");
1727 static int test_equal_2_skip (void)
1731 str = getenv ("SKIP_TEST_EQUAL_2");
1732 if (str && strcmp (str, "1") == 0) return 1;
1733 str = getenv ("SKIP_TEST_EQUAL");
1734 if (str && strcmp (str, "1") == 0) return 1;
1738 static int test_equal_2 (void)
1740 if (test_equal_2_skip ()) {
1741 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_2");
1745 /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
1747 char device[] = "/dev/sda";
1750 r = guestfs_blockdev_setrw (g, device);
1757 r = guestfs_umount_all (g);
1764 r = guestfs_lvm_remove_all (g);
1769 char device[] = "/dev/sda";
1770 char lines_0[] = ",";
1777 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1782 char fstype[] = "ext2";
1783 char device[] = "/dev/sda1";
1786 r = guestfs_mkfs (g, fstype, device);
1791 char device[] = "/dev/sda1";
1792 char mountpoint[] = "/";
1795 r = guestfs_mount (g, device, mountpoint);
1799 /* TestLastFail for equal (2) */
1801 char file1[] = "/file1";
1802 char file2[] = "/file2";
1805 r = guestfs_equal (g, file1, file2);
1812 static int test_ping_daemon_0_skip (void)
1816 str = getenv ("SKIP_TEST_PING_DAEMON_0");
1817 if (str && strcmp (str, "1") == 0) return 1;
1818 str = getenv ("SKIP_TEST_PING_DAEMON");
1819 if (str && strcmp (str, "1") == 0) return 1;
1823 static int test_ping_daemon_0 (void)
1825 if (test_ping_daemon_0_skip ()) {
1826 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ping_daemon_0");
1830 /* InitNone|InitEmpty for test_ping_daemon_0 */
1832 char device[] = "/dev/sda";
1835 r = guestfs_blockdev_setrw (g, device);
1842 r = guestfs_umount_all (g);
1849 r = guestfs_lvm_remove_all (g);
1853 /* TestRun for ping_daemon (0) */
1857 r = guestfs_ping_daemon (g);
1864 static int test_dmesg_0_skip (void)
1868 str = getenv ("SKIP_TEST_DMESG_0");
1869 if (str && strcmp (str, "1") == 0) return 1;
1870 str = getenv ("SKIP_TEST_DMESG");
1871 if (str && strcmp (str, "1") == 0) return 1;
1875 static int test_dmesg_0 (void)
1877 if (test_dmesg_0_skip ()) {
1878 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_dmesg_0");
1882 /* InitNone|InitEmpty for test_dmesg_0 */
1884 char device[] = "/dev/sda";
1887 r = guestfs_blockdev_setrw (g, device);
1894 r = guestfs_umount_all (g);
1901 r = guestfs_lvm_remove_all (g);
1905 /* TestRun for dmesg (0) */
1909 r = guestfs_dmesg (g);
1917 static int test_drop_caches_0_skip (void)
1921 str = getenv ("SKIP_TEST_DROP_CACHES_0");
1922 if (str && strcmp (str, "1") == 0) return 1;
1923 str = getenv ("SKIP_TEST_DROP_CACHES");
1924 if (str && strcmp (str, "1") == 0) return 1;
1928 static int test_drop_caches_0 (void)
1930 if (test_drop_caches_0_skip ()) {
1931 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_drop_caches_0");
1935 /* InitNone|InitEmpty for test_drop_caches_0 */
1937 char device[] = "/dev/sda";
1940 r = guestfs_blockdev_setrw (g, device);
1947 r = guestfs_umount_all (g);
1954 r = guestfs_lvm_remove_all (g);
1958 /* TestRun for drop_caches (0) */
1962 r = guestfs_drop_caches (g, 3);
1969 static int test_mv_0_skip (void)
1973 str = getenv ("SKIP_TEST_MV_0");
1974 if (str && strcmp (str, "1") == 0) return 1;
1975 str = getenv ("SKIP_TEST_MV");
1976 if (str && strcmp (str, "1") == 0) return 1;
1980 static int test_mv_0 (void)
1982 if (test_mv_0_skip ()) {
1983 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_0");
1987 /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
1989 char device[] = "/dev/sda";
1992 r = guestfs_blockdev_setrw (g, device);
1999 r = guestfs_umount_all (g);
2006 r = guestfs_lvm_remove_all (g);
2011 char device[] = "/dev/sda";
2012 char lines_0[] = ",";
2019 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2024 char fstype[] = "ext2";
2025 char device[] = "/dev/sda1";
2028 r = guestfs_mkfs (g, fstype, device);
2033 char device[] = "/dev/sda1";
2034 char mountpoint[] = "/";
2037 r = guestfs_mount (g, device, mountpoint);
2041 /* TestOutput for mv (0) */
2042 char expected[] = "file content";
2044 char path[] = "/old";
2045 char content[] = "file content";
2048 r = guestfs_write_file (g, path, content, 0);
2053 char src[] = "/old";
2054 char dest[] = "/new";
2057 r = guestfs_mv (g, src, dest);
2062 char path[] = "/new";
2065 r = guestfs_cat (g, path);
2068 if (strcmp (r, expected) != 0) {
2069 fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
2077 static int test_mv_1_skip (void)
2081 str = getenv ("SKIP_TEST_MV_1");
2082 if (str && strcmp (str, "1") == 0) return 1;
2083 str = getenv ("SKIP_TEST_MV");
2084 if (str && strcmp (str, "1") == 0) return 1;
2088 static int test_mv_1 (void)
2090 if (test_mv_1_skip ()) {
2091 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_1");
2095 /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
2097 char device[] = "/dev/sda";
2100 r = guestfs_blockdev_setrw (g, device);
2107 r = guestfs_umount_all (g);
2114 r = guestfs_lvm_remove_all (g);
2119 char device[] = "/dev/sda";
2120 char lines_0[] = ",";
2127 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2132 char fstype[] = "ext2";
2133 char device[] = "/dev/sda1";
2136 r = guestfs_mkfs (g, fstype, device);
2141 char device[] = "/dev/sda1";
2142 char mountpoint[] = "/";
2145 r = guestfs_mount (g, device, mountpoint);
2149 /* TestOutputFalse for mv (1) */
2151 char path[] = "/old";
2152 char content[] = "file content";
2155 r = guestfs_write_file (g, path, content, 0);
2160 char src[] = "/old";
2161 char dest[] = "/new";
2164 r = guestfs_mv (g, src, dest);
2169 char path[] = "/old";
2172 r = guestfs_is_file (g, path);
2176 fprintf (stderr, "test_mv_1: expected false, got true\n");
2183 static int test_cp_a_0_skip (void)
2187 str = getenv ("SKIP_TEST_CP_A_0");
2188 if (str && strcmp (str, "1") == 0) return 1;
2189 str = getenv ("SKIP_TEST_CP_A");
2190 if (str && strcmp (str, "1") == 0) return 1;
2194 static int test_cp_a_0 (void)
2196 if (test_cp_a_0_skip ()) {
2197 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_a_0");
2201 /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
2203 char device[] = "/dev/sda";
2206 r = guestfs_blockdev_setrw (g, device);
2213 r = guestfs_umount_all (g);
2220 r = guestfs_lvm_remove_all (g);
2225 char device[] = "/dev/sda";
2226 char lines_0[] = ",";
2233 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2238 char fstype[] = "ext2";
2239 char device[] = "/dev/sda1";
2242 r = guestfs_mkfs (g, fstype, device);
2247 char device[] = "/dev/sda1";
2248 char mountpoint[] = "/";
2251 r = guestfs_mount (g, device, mountpoint);
2255 /* TestOutput for cp_a (0) */
2256 char expected[] = "file content";
2258 char path[] = "/olddir";
2261 r = guestfs_mkdir (g, path);
2266 char path[] = "/newdir";
2269 r = guestfs_mkdir (g, path);
2274 char path[] = "/olddir/file";
2275 char content[] = "file content";
2278 r = guestfs_write_file (g, path, content, 0);
2283 char src[] = "/olddir";
2284 char dest[] = "/newdir";
2287 r = guestfs_cp_a (g, src, dest);
2292 char path[] = "/newdir/olddir/file";
2295 r = guestfs_cat (g, path);
2298 if (strcmp (r, expected) != 0) {
2299 fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
2307 static int test_cp_0_skip (void)
2311 str = getenv ("SKIP_TEST_CP_0");
2312 if (str && strcmp (str, "1") == 0) return 1;
2313 str = getenv ("SKIP_TEST_CP");
2314 if (str && strcmp (str, "1") == 0) return 1;
2318 static int test_cp_0 (void)
2320 if (test_cp_0_skip ()) {
2321 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_0");
2325 /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
2327 char device[] = "/dev/sda";
2330 r = guestfs_blockdev_setrw (g, device);
2337 r = guestfs_umount_all (g);
2344 r = guestfs_lvm_remove_all (g);
2349 char device[] = "/dev/sda";
2350 char lines_0[] = ",";
2357 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2362 char fstype[] = "ext2";
2363 char device[] = "/dev/sda1";
2366 r = guestfs_mkfs (g, fstype, device);
2371 char device[] = "/dev/sda1";
2372 char mountpoint[] = "/";
2375 r = guestfs_mount (g, device, mountpoint);
2379 /* TestOutput for cp (0) */
2380 char expected[] = "file content";
2382 char path[] = "/old";
2383 char content[] = "file content";
2386 r = guestfs_write_file (g, path, content, 0);
2391 char src[] = "/old";
2392 char dest[] = "/new";
2395 r = guestfs_cp (g, src, dest);
2400 char path[] = "/new";
2403 r = guestfs_cat (g, path);
2406 if (strcmp (r, expected) != 0) {
2407 fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
2415 static int test_cp_1_skip (void)
2419 str = getenv ("SKIP_TEST_CP_1");
2420 if (str && strcmp (str, "1") == 0) return 1;
2421 str = getenv ("SKIP_TEST_CP");
2422 if (str && strcmp (str, "1") == 0) return 1;
2426 static int test_cp_1 (void)
2428 if (test_cp_1_skip ()) {
2429 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_1");
2433 /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
2435 char device[] = "/dev/sda";
2438 r = guestfs_blockdev_setrw (g, device);
2445 r = guestfs_umount_all (g);
2452 r = guestfs_lvm_remove_all (g);
2457 char device[] = "/dev/sda";
2458 char lines_0[] = ",";
2465 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2470 char fstype[] = "ext2";
2471 char device[] = "/dev/sda1";
2474 r = guestfs_mkfs (g, fstype, device);
2479 char device[] = "/dev/sda1";
2480 char mountpoint[] = "/";
2483 r = guestfs_mount (g, device, mountpoint);
2487 /* TestOutputTrue for cp (1) */
2489 char path[] = "/old";
2490 char content[] = "file content";
2493 r = guestfs_write_file (g, path, content, 0);
2498 char src[] = "/old";
2499 char dest[] = "/new";
2502 r = guestfs_cp (g, src, dest);
2507 char path[] = "/old";
2510 r = guestfs_is_file (g, path);
2514 fprintf (stderr, "test_cp_1: expected true, got false\n");
2521 static int test_cp_2_skip (void)
2525 str = getenv ("SKIP_TEST_CP_2");
2526 if (str && strcmp (str, "1") == 0) return 1;
2527 str = getenv ("SKIP_TEST_CP");
2528 if (str && strcmp (str, "1") == 0) return 1;
2532 static int test_cp_2 (void)
2534 if (test_cp_2_skip ()) {
2535 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_2");
2539 /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
2541 char device[] = "/dev/sda";
2544 r = guestfs_blockdev_setrw (g, device);
2551 r = guestfs_umount_all (g);
2558 r = guestfs_lvm_remove_all (g);
2563 char device[] = "/dev/sda";
2564 char lines_0[] = ",";
2571 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2576 char fstype[] = "ext2";
2577 char device[] = "/dev/sda1";
2580 r = guestfs_mkfs (g, fstype, device);
2585 char device[] = "/dev/sda1";
2586 char mountpoint[] = "/";
2589 r = guestfs_mount (g, device, mountpoint);
2593 /* TestOutput for cp (2) */
2594 char expected[] = "file content";
2596 char path[] = "/old";
2597 char content[] = "file content";
2600 r = guestfs_write_file (g, path, content, 0);
2605 char path[] = "/dir";
2608 r = guestfs_mkdir (g, path);
2613 char src[] = "/old";
2614 char dest[] = "/dir/new";
2617 r = guestfs_cp (g, src, dest);
2622 char path[] = "/dir/new";
2625 r = guestfs_cat (g, path);
2628 if (strcmp (r, expected) != 0) {
2629 fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
2637 static int test_grub_install_0_skip (void)
2641 str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
2642 if (str && strcmp (str, "1") == 0) return 1;
2643 str = getenv ("SKIP_TEST_GRUB_INSTALL");
2644 if (str && strcmp (str, "1") == 0) return 1;
2648 static int test_grub_install_0 (void)
2650 if (test_grub_install_0_skip ()) {
2651 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_grub_install_0");
2655 /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
2657 char device[] = "/dev/sda";
2660 r = guestfs_blockdev_setrw (g, device);
2667 r = guestfs_umount_all (g);
2674 r = guestfs_lvm_remove_all (g);
2679 char device[] = "/dev/sda";
2680 char lines_0[] = ",";
2687 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2692 char fstype[] = "ext2";
2693 char device[] = "/dev/sda1";
2696 r = guestfs_mkfs (g, fstype, device);
2701 char device[] = "/dev/sda1";
2702 char mountpoint[] = "/";
2705 r = guestfs_mount (g, device, mountpoint);
2709 /* TestOutputTrue for grub_install (0) */
2712 char device[] = "/dev/sda1";
2715 r = guestfs_grub_install (g, root, device);
2720 char path[] = "/boot";
2723 r = guestfs_is_dir (g, path);
2727 fprintf (stderr, "test_grub_install_0: expected true, got false\n");
2734 static int test_zero_0_skip (void)
2738 str = getenv ("SKIP_TEST_ZERO_0");
2739 if (str && strcmp (str, "1") == 0) return 1;
2740 str = getenv ("SKIP_TEST_ZERO");
2741 if (str && strcmp (str, "1") == 0) return 1;
2745 static int test_zero_0 (void)
2747 if (test_zero_0_skip ()) {
2748 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zero_0");
2752 /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
2754 char device[] = "/dev/sda";
2757 r = guestfs_blockdev_setrw (g, device);
2764 r = guestfs_umount_all (g);
2771 r = guestfs_lvm_remove_all (g);
2776 char device[] = "/dev/sda";
2777 char lines_0[] = ",";
2784 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2789 char fstype[] = "ext2";
2790 char device[] = "/dev/sda1";
2793 r = guestfs_mkfs (g, fstype, device);
2798 char device[] = "/dev/sda1";
2799 char mountpoint[] = "/";
2802 r = guestfs_mount (g, device, mountpoint);
2806 /* TestOutput for zero (0) */
2807 char expected[] = "data";
2809 char pathordevice[] = "/dev/sda1";
2812 r = guestfs_umount (g, pathordevice);
2817 char device[] = "/dev/sda1";
2820 r = guestfs_zero (g, device);
2825 char path[] = "/dev/sda1";
2828 r = guestfs_file (g, path);
2831 if (strcmp (r, expected) != 0) {
2832 fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
2840 static int test_fsck_0_skip (void)
2844 str = getenv ("SKIP_TEST_FSCK_0");
2845 if (str && strcmp (str, "1") == 0) return 1;
2846 str = getenv ("SKIP_TEST_FSCK");
2847 if (str && strcmp (str, "1") == 0) return 1;
2851 static int test_fsck_0 (void)
2853 if (test_fsck_0_skip ()) {
2854 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_0");
2858 /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
2860 char device[] = "/dev/sda";
2863 r = guestfs_blockdev_setrw (g, device);
2870 r = guestfs_umount_all (g);
2877 r = guestfs_lvm_remove_all (g);
2882 char device[] = "/dev/sda";
2883 char lines_0[] = ",";
2890 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2895 char fstype[] = "ext2";
2896 char device[] = "/dev/sda1";
2899 r = guestfs_mkfs (g, fstype, device);
2904 char device[] = "/dev/sda1";
2905 char mountpoint[] = "/";
2908 r = guestfs_mount (g, device, mountpoint);
2912 /* TestOutputInt for fsck (0) */
2914 char pathordevice[] = "/dev/sda1";
2917 r = guestfs_umount (g, pathordevice);
2922 char fstype[] = "ext2";
2923 char device[] = "/dev/sda1";
2926 r = guestfs_fsck (g, fstype, device);
2930 fprintf (stderr, "test_fsck_0: expected 0 but got %d\n", (int) r);
2937 static int test_fsck_1_skip (void)
2941 str = getenv ("SKIP_TEST_FSCK_1");
2942 if (str && strcmp (str, "1") == 0) return 1;
2943 str = getenv ("SKIP_TEST_FSCK");
2944 if (str && strcmp (str, "1") == 0) return 1;
2948 static int test_fsck_1 (void)
2950 if (test_fsck_1_skip ()) {
2951 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_1");
2955 /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
2957 char device[] = "/dev/sda";
2960 r = guestfs_blockdev_setrw (g, device);
2967 r = guestfs_umount_all (g);
2974 r = guestfs_lvm_remove_all (g);
2979 char device[] = "/dev/sda";
2980 char lines_0[] = ",";
2987 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2992 char fstype[] = "ext2";
2993 char device[] = "/dev/sda1";
2996 r = guestfs_mkfs (g, fstype, device);
3001 char device[] = "/dev/sda1";
3002 char mountpoint[] = "/";
3005 r = guestfs_mount (g, device, mountpoint);
3009 /* TestOutputInt for fsck (1) */
3011 char pathordevice[] = "/dev/sda1";
3014 r = guestfs_umount (g, pathordevice);
3019 char device[] = "/dev/sda1";
3022 r = guestfs_zero (g, device);
3027 char fstype[] = "ext2";
3028 char device[] = "/dev/sda1";
3031 r = guestfs_fsck (g, fstype, device);
3035 fprintf (stderr, "test_fsck_1: expected 8 but got %d\n", (int) r);
3042 static int test_set_e2uuid_0_skip (void)
3046 str = getenv ("SKIP_TEST_SET_E2UUID_0");
3047 if (str && strcmp (str, "1") == 0) return 1;
3048 str = getenv ("SKIP_TEST_SET_E2UUID");
3049 if (str && strcmp (str, "1") == 0) return 1;
3053 static int test_set_e2uuid_0 (void)
3055 if (test_set_e2uuid_0_skip ()) {
3056 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_0");
3060 /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
3062 char device[] = "/dev/sda";
3065 r = guestfs_blockdev_setrw (g, device);
3072 r = guestfs_umount_all (g);
3079 r = guestfs_lvm_remove_all (g);
3084 char device[] = "/dev/sda";
3085 char lines_0[] = ",";
3092 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3097 char fstype[] = "ext2";
3098 char device[] = "/dev/sda1";
3101 r = guestfs_mkfs (g, fstype, device);
3106 char device[] = "/dev/sda1";
3107 char mountpoint[] = "/";
3110 r = guestfs_mount (g, device, mountpoint);
3114 /* TestOutput for set_e2uuid (0) */
3115 char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3117 char device[] = "/dev/sda1";
3118 char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3121 r = guestfs_set_e2uuid (g, device, uuid);
3126 char device[] = "/dev/sda1";
3129 r = guestfs_get_e2uuid (g, device);
3132 if (strcmp (r, expected) != 0) {
3133 fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
3141 static int test_set_e2uuid_1_skip (void)
3145 str = getenv ("SKIP_TEST_SET_E2UUID_1");
3146 if (str && strcmp (str, "1") == 0) return 1;
3147 str = getenv ("SKIP_TEST_SET_E2UUID");
3148 if (str && strcmp (str, "1") == 0) return 1;
3152 static int test_set_e2uuid_1 (void)
3154 if (test_set_e2uuid_1_skip ()) {
3155 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_1");
3159 /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
3161 char device[] = "/dev/sda";
3164 r = guestfs_blockdev_setrw (g, device);
3171 r = guestfs_umount_all (g);
3178 r = guestfs_lvm_remove_all (g);
3183 char device[] = "/dev/sda";
3184 char lines_0[] = ",";
3191 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3196 char fstype[] = "ext2";
3197 char device[] = "/dev/sda1";
3200 r = guestfs_mkfs (g, fstype, device);
3205 char device[] = "/dev/sda1";
3206 char mountpoint[] = "/";
3209 r = guestfs_mount (g, device, mountpoint);
3213 /* TestOutput for set_e2uuid (1) */
3214 char expected[] = "";
3216 char device[] = "/dev/sda1";
3217 char uuid[] = "clear";
3220 r = guestfs_set_e2uuid (g, device, uuid);
3225 char device[] = "/dev/sda1";
3228 r = guestfs_get_e2uuid (g, device);
3231 if (strcmp (r, expected) != 0) {
3232 fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
3240 static int test_set_e2uuid_2_skip (void)
3244 str = getenv ("SKIP_TEST_SET_E2UUID_2");
3245 if (str && strcmp (str, "1") == 0) return 1;
3246 str = getenv ("SKIP_TEST_SET_E2UUID");
3247 if (str && strcmp (str, "1") == 0) return 1;
3251 static int test_set_e2uuid_2 (void)
3253 if (test_set_e2uuid_2_skip ()) {
3254 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_2");
3258 /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
3260 char device[] = "/dev/sda";
3263 r = guestfs_blockdev_setrw (g, device);
3270 r = guestfs_umount_all (g);
3277 r = guestfs_lvm_remove_all (g);
3282 char device[] = "/dev/sda";
3283 char lines_0[] = ",";
3290 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3295 char fstype[] = "ext2";
3296 char device[] = "/dev/sda1";
3299 r = guestfs_mkfs (g, fstype, device);
3304 char device[] = "/dev/sda1";
3305 char mountpoint[] = "/";
3308 r = guestfs_mount (g, device, mountpoint);
3312 /* TestRun for set_e2uuid (2) */
3314 char device[] = "/dev/sda1";
3315 char uuid[] = "random";
3318 r = guestfs_set_e2uuid (g, device, uuid);
3325 static int test_set_e2uuid_3_skip (void)
3329 str = getenv ("SKIP_TEST_SET_E2UUID_3");
3330 if (str && strcmp (str, "1") == 0) return 1;
3331 str = getenv ("SKIP_TEST_SET_E2UUID");
3332 if (str && strcmp (str, "1") == 0) return 1;
3336 static int test_set_e2uuid_3 (void)
3338 if (test_set_e2uuid_3_skip ()) {
3339 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_3");
3343 /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
3345 char device[] = "/dev/sda";
3348 r = guestfs_blockdev_setrw (g, device);
3355 r = guestfs_umount_all (g);
3362 r = guestfs_lvm_remove_all (g);
3367 char device[] = "/dev/sda";
3368 char lines_0[] = ",";
3375 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3380 char fstype[] = "ext2";
3381 char device[] = "/dev/sda1";
3384 r = guestfs_mkfs (g, fstype, device);
3389 char device[] = "/dev/sda1";
3390 char mountpoint[] = "/";
3393 r = guestfs_mount (g, device, mountpoint);
3397 /* TestRun for set_e2uuid (3) */
3399 char device[] = "/dev/sda1";
3400 char uuid[] = "time";
3403 r = guestfs_set_e2uuid (g, device, uuid);
3410 static int test_set_e2label_0_skip (void)
3414 str = getenv ("SKIP_TEST_SET_E2LABEL_0");
3415 if (str && strcmp (str, "1") == 0) return 1;
3416 str = getenv ("SKIP_TEST_SET_E2LABEL");
3417 if (str && strcmp (str, "1") == 0) return 1;
3421 static int test_set_e2label_0 (void)
3423 if (test_set_e2label_0_skip ()) {
3424 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2label_0");
3428 /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
3430 char device[] = "/dev/sda";
3433 r = guestfs_blockdev_setrw (g, device);
3440 r = guestfs_umount_all (g);
3447 r = guestfs_lvm_remove_all (g);
3452 char device[] = "/dev/sda";
3453 char lines_0[] = ",";
3460 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3465 char fstype[] = "ext2";
3466 char device[] = "/dev/sda1";
3469 r = guestfs_mkfs (g, fstype, device);
3474 char device[] = "/dev/sda1";
3475 char mountpoint[] = "/";
3478 r = guestfs_mount (g, device, mountpoint);
3482 /* TestOutput for set_e2label (0) */
3483 char expected[] = "testlabel";
3485 char device[] = "/dev/sda1";
3486 char label[] = "testlabel";
3489 r = guestfs_set_e2label (g, device, label);
3494 char device[] = "/dev/sda1";
3497 r = guestfs_get_e2label (g, device);
3500 if (strcmp (r, expected) != 0) {
3501 fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
3509 static int test_pvremove_0_skip (void)
3513 str = getenv ("SKIP_TEST_PVREMOVE_0");
3514 if (str && strcmp (str, "1") == 0) return 1;
3515 str = getenv ("SKIP_TEST_PVREMOVE");
3516 if (str && strcmp (str, "1") == 0) return 1;
3520 static int test_pvremove_0 (void)
3522 if (test_pvremove_0_skip ()) {
3523 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_0");
3527 /* InitNone|InitEmpty for test_pvremove_0 */
3529 char device[] = "/dev/sda";
3532 r = guestfs_blockdev_setrw (g, device);
3539 r = guestfs_umount_all (g);
3546 r = guestfs_lvm_remove_all (g);
3550 /* TestOutputListOfDevices for pvremove (0) */
3552 char device[] = "/dev/sda";
3553 char lines_0[] = ",";
3560 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3565 char device[] = "/dev/sda1";
3568 r = guestfs_pvcreate (g, device);
3573 char volgroup[] = "VG";
3574 char physvols_0[] = "/dev/sda1";
3575 char *physvols[] = {
3581 r = guestfs_vgcreate (g, volgroup, physvols);
3586 char logvol[] = "LV1";
3587 char volgroup[] = "VG";
3590 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3595 char logvol[] = "LV2";
3596 char volgroup[] = "VG";
3599 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3604 char vgname[] = "VG";
3607 r = guestfs_vgremove (g, vgname);
3612 char device[] = "/dev/sda1";
3615 r = guestfs_pvremove (g, device);
3623 r = guestfs_lvs (g);
3627 fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
3631 for (i = 0; r[i] != NULL; ++i)
3638 static int test_pvremove_1_skip (void)
3642 str = getenv ("SKIP_TEST_PVREMOVE_1");
3643 if (str && strcmp (str, "1") == 0) return 1;
3644 str = getenv ("SKIP_TEST_PVREMOVE");
3645 if (str && strcmp (str, "1") == 0) return 1;
3649 static int test_pvremove_1 (void)
3651 if (test_pvremove_1_skip ()) {
3652 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_1");
3656 /* InitNone|InitEmpty for test_pvremove_1 */
3658 char device[] = "/dev/sda";
3661 r = guestfs_blockdev_setrw (g, device);
3668 r = guestfs_umount_all (g);
3675 r = guestfs_lvm_remove_all (g);
3679 /* TestOutputListOfDevices for pvremove (1) */
3681 char device[] = "/dev/sda";
3682 char lines_0[] = ",";
3689 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3694 char device[] = "/dev/sda1";
3697 r = guestfs_pvcreate (g, device);
3702 char volgroup[] = "VG";
3703 char physvols_0[] = "/dev/sda1";
3704 char *physvols[] = {
3710 r = guestfs_vgcreate (g, volgroup, physvols);
3715 char logvol[] = "LV1";
3716 char volgroup[] = "VG";
3719 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3724 char logvol[] = "LV2";
3725 char volgroup[] = "VG";
3728 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3733 char vgname[] = "VG";
3736 r = guestfs_vgremove (g, vgname);
3741 char device[] = "/dev/sda1";
3744 r = guestfs_pvremove (g, device);
3752 r = guestfs_vgs (g);
3756 fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
3760 for (i = 0; r[i] != NULL; ++i)
3767 static int test_pvremove_2_skip (void)
3771 str = getenv ("SKIP_TEST_PVREMOVE_2");
3772 if (str && strcmp (str, "1") == 0) return 1;
3773 str = getenv ("SKIP_TEST_PVREMOVE");
3774 if (str && strcmp (str, "1") == 0) return 1;
3778 static int test_pvremove_2 (void)
3780 if (test_pvremove_2_skip ()) {
3781 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_2");
3785 /* InitNone|InitEmpty for test_pvremove_2 */
3787 char device[] = "/dev/sda";
3790 r = guestfs_blockdev_setrw (g, device);
3797 r = guestfs_umount_all (g);
3804 r = guestfs_lvm_remove_all (g);
3808 /* TestOutputListOfDevices for pvremove (2) */
3810 char device[] = "/dev/sda";
3811 char lines_0[] = ",";
3818 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3823 char device[] = "/dev/sda1";
3826 r = guestfs_pvcreate (g, device);
3831 char volgroup[] = "VG";
3832 char physvols_0[] = "/dev/sda1";
3833 char *physvols[] = {
3839 r = guestfs_vgcreate (g, volgroup, physvols);
3844 char logvol[] = "LV1";
3845 char volgroup[] = "VG";
3848 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3853 char logvol[] = "LV2";
3854 char volgroup[] = "VG";
3857 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3862 char vgname[] = "VG";
3865 r = guestfs_vgremove (g, vgname);
3870 char device[] = "/dev/sda1";
3873 r = guestfs_pvremove (g, device);
3881 r = guestfs_pvs (g);
3885 fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
3889 for (i = 0; r[i] != NULL; ++i)
3896 static int test_vgremove_0_skip (void)
3900 str = getenv ("SKIP_TEST_VGREMOVE_0");
3901 if (str && strcmp (str, "1") == 0) return 1;
3902 str = getenv ("SKIP_TEST_VGREMOVE");
3903 if (str && strcmp (str, "1") == 0) return 1;
3907 static int test_vgremove_0 (void)
3909 if (test_vgremove_0_skip ()) {
3910 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_0");
3914 /* InitNone|InitEmpty for test_vgremove_0 */
3916 char device[] = "/dev/sda";
3919 r = guestfs_blockdev_setrw (g, device);
3926 r = guestfs_umount_all (g);
3933 r = guestfs_lvm_remove_all (g);
3937 /* TestOutputList for vgremove (0) */
3939 char device[] = "/dev/sda";
3940 char lines_0[] = ",";
3947 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3952 char device[] = "/dev/sda1";
3955 r = guestfs_pvcreate (g, device);
3960 char volgroup[] = "VG";
3961 char physvols_0[] = "/dev/sda1";
3962 char *physvols[] = {
3968 r = guestfs_vgcreate (g, volgroup, physvols);
3973 char logvol[] = "LV1";
3974 char volgroup[] = "VG";
3977 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3982 char logvol[] = "LV2";
3983 char volgroup[] = "VG";
3986 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3991 char vgname[] = "VG";
3994 r = guestfs_vgremove (g, vgname);
4002 r = guestfs_lvs (g);
4006 fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
4010 for (i = 0; r[i] != NULL; ++i)
4017 static int test_vgremove_1_skip (void)
4021 str = getenv ("SKIP_TEST_VGREMOVE_1");
4022 if (str && strcmp (str, "1") == 0) return 1;
4023 str = getenv ("SKIP_TEST_VGREMOVE");
4024 if (str && strcmp (str, "1") == 0) return 1;
4028 static int test_vgremove_1 (void)
4030 if (test_vgremove_1_skip ()) {
4031 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_1");
4035 /* InitNone|InitEmpty for test_vgremove_1 */
4037 char device[] = "/dev/sda";
4040 r = guestfs_blockdev_setrw (g, device);
4047 r = guestfs_umount_all (g);
4054 r = guestfs_lvm_remove_all (g);
4058 /* TestOutputList for vgremove (1) */
4060 char device[] = "/dev/sda";
4061 char lines_0[] = ",";
4068 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4073 char device[] = "/dev/sda1";
4076 r = guestfs_pvcreate (g, device);
4081 char volgroup[] = "VG";
4082 char physvols_0[] = "/dev/sda1";
4083 char *physvols[] = {
4089 r = guestfs_vgcreate (g, volgroup, physvols);
4094 char logvol[] = "LV1";
4095 char volgroup[] = "VG";
4098 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4103 char logvol[] = "LV2";
4104 char volgroup[] = "VG";
4107 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4112 char vgname[] = "VG";
4115 r = guestfs_vgremove (g, vgname);
4123 r = guestfs_vgs (g);
4127 fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
4131 for (i = 0; r[i] != NULL; ++i)
4138 static int test_lvremove_0_skip (void)
4142 str = getenv ("SKIP_TEST_LVREMOVE_0");
4143 if (str && strcmp (str, "1") == 0) return 1;
4144 str = getenv ("SKIP_TEST_LVREMOVE");
4145 if (str && strcmp (str, "1") == 0) return 1;
4149 static int test_lvremove_0 (void)
4151 if (test_lvremove_0_skip ()) {
4152 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_0");
4156 /* InitNone|InitEmpty for test_lvremove_0 */
4158 char device[] = "/dev/sda";
4161 r = guestfs_blockdev_setrw (g, device);
4168 r = guestfs_umount_all (g);
4175 r = guestfs_lvm_remove_all (g);
4179 /* TestOutputList for lvremove (0) */
4181 char device[] = "/dev/sda";
4182 char lines_0[] = ",";
4189 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4194 char device[] = "/dev/sda1";
4197 r = guestfs_pvcreate (g, device);
4202 char volgroup[] = "VG";
4203 char physvols_0[] = "/dev/sda1";
4204 char *physvols[] = {
4210 r = guestfs_vgcreate (g, volgroup, physvols);
4215 char logvol[] = "LV1";
4216 char volgroup[] = "VG";
4219 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4224 char logvol[] = "LV2";
4225 char volgroup[] = "VG";
4228 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4233 char device[] = "/dev/VG/LV1";
4236 r = guestfs_lvremove (g, device);
4244 r = guestfs_lvs (g);
4248 fprintf (stderr, "test_lvremove_0: short list returned from command\n");
4253 char expected[] = "/dev/VG/LV2";
4254 if (strcmp (r[0], expected) != 0) {
4255 fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4260 fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
4264 for (i = 0; r[i] != NULL; ++i)
4271 static int test_lvremove_1_skip (void)
4275 str = getenv ("SKIP_TEST_LVREMOVE_1");
4276 if (str && strcmp (str, "1") == 0) return 1;
4277 str = getenv ("SKIP_TEST_LVREMOVE");
4278 if (str && strcmp (str, "1") == 0) return 1;
4282 static int test_lvremove_1 (void)
4284 if (test_lvremove_1_skip ()) {
4285 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_1");
4289 /* InitNone|InitEmpty for test_lvremove_1 */
4291 char device[] = "/dev/sda";
4294 r = guestfs_blockdev_setrw (g, device);
4301 r = guestfs_umount_all (g);
4308 r = guestfs_lvm_remove_all (g);
4312 /* TestOutputList for lvremove (1) */
4314 char device[] = "/dev/sda";
4315 char lines_0[] = ",";
4322 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4327 char device[] = "/dev/sda1";
4330 r = guestfs_pvcreate (g, device);
4335 char volgroup[] = "VG";
4336 char physvols_0[] = "/dev/sda1";
4337 char *physvols[] = {
4343 r = guestfs_vgcreate (g, volgroup, physvols);
4348 char logvol[] = "LV1";
4349 char volgroup[] = "VG";
4352 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4357 char logvol[] = "LV2";
4358 char volgroup[] = "VG";
4361 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4366 char device[] = "/dev/VG";
4369 r = guestfs_lvremove (g, device);
4377 r = guestfs_lvs (g);
4381 fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
4385 for (i = 0; r[i] != NULL; ++i)
4392 static int test_lvremove_2_skip (void)
4396 str = getenv ("SKIP_TEST_LVREMOVE_2");
4397 if (str && strcmp (str, "1") == 0) return 1;
4398 str = getenv ("SKIP_TEST_LVREMOVE");
4399 if (str && strcmp (str, "1") == 0) return 1;
4403 static int test_lvremove_2 (void)
4405 if (test_lvremove_2_skip ()) {
4406 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_2");
4410 /* InitNone|InitEmpty for test_lvremove_2 */
4412 char device[] = "/dev/sda";
4415 r = guestfs_blockdev_setrw (g, device);
4422 r = guestfs_umount_all (g);
4429 r = guestfs_lvm_remove_all (g);
4433 /* TestOutputList for lvremove (2) */
4435 char device[] = "/dev/sda";
4436 char lines_0[] = ",";
4443 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4448 char device[] = "/dev/sda1";
4451 r = guestfs_pvcreate (g, device);
4456 char volgroup[] = "VG";
4457 char physvols_0[] = "/dev/sda1";
4458 char *physvols[] = {
4464 r = guestfs_vgcreate (g, volgroup, physvols);
4469 char logvol[] = "LV1";
4470 char volgroup[] = "VG";
4473 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4478 char logvol[] = "LV2";
4479 char volgroup[] = "VG";
4482 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4487 char device[] = "/dev/VG";
4490 r = guestfs_lvremove (g, device);
4498 r = guestfs_vgs (g);
4502 fprintf (stderr, "test_lvremove_2: short list returned from command\n");
4507 char expected[] = "VG";
4508 if (strcmp (r[0], expected) != 0) {
4509 fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4514 fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
4518 for (i = 0; r[i] != NULL; ++i)
4525 static int test_mount_ro_0_skip (void)
4529 str = getenv ("SKIP_TEST_MOUNT_RO_0");
4530 if (str && strcmp (str, "1") == 0) return 1;
4531 str = getenv ("SKIP_TEST_MOUNT_RO");
4532 if (str && strcmp (str, "1") == 0) return 1;
4536 static int test_mount_ro_0 (void)
4538 if (test_mount_ro_0_skip ()) {
4539 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_0");
4543 /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
4545 char device[] = "/dev/sda";
4548 r = guestfs_blockdev_setrw (g, device);
4555 r = guestfs_umount_all (g);
4562 r = guestfs_lvm_remove_all (g);
4567 char device[] = "/dev/sda";
4568 char lines_0[] = ",";
4575 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4580 char fstype[] = "ext2";
4581 char device[] = "/dev/sda1";
4584 r = guestfs_mkfs (g, fstype, device);
4589 char device[] = "/dev/sda1";
4590 char mountpoint[] = "/";
4593 r = guestfs_mount (g, device, mountpoint);
4597 /* TestLastFail for mount_ro (0) */
4599 char pathordevice[] = "/";
4602 r = guestfs_umount (g, pathordevice);
4607 char device[] = "/dev/sda1";
4608 char mountpoint[] = "/";
4611 r = guestfs_mount_ro (g, device, mountpoint);
4616 char path[] = "/new";
4619 r = guestfs_touch (g, path);
4626 static int test_mount_ro_1_skip (void)
4630 str = getenv ("SKIP_TEST_MOUNT_RO_1");
4631 if (str && strcmp (str, "1") == 0) return 1;
4632 str = getenv ("SKIP_TEST_MOUNT_RO");
4633 if (str && strcmp (str, "1") == 0) return 1;
4637 static int test_mount_ro_1 (void)
4639 if (test_mount_ro_1_skip ()) {
4640 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_1");
4644 /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
4646 char device[] = "/dev/sda";
4649 r = guestfs_blockdev_setrw (g, device);
4656 r = guestfs_umount_all (g);
4663 r = guestfs_lvm_remove_all (g);
4668 char device[] = "/dev/sda";
4669 char lines_0[] = ",";
4676 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4681 char fstype[] = "ext2";
4682 char device[] = "/dev/sda1";
4685 r = guestfs_mkfs (g, fstype, device);
4690 char device[] = "/dev/sda1";
4691 char mountpoint[] = "/";
4694 r = guestfs_mount (g, device, mountpoint);
4698 /* TestOutput for mount_ro (1) */
4699 char expected[] = "data";
4701 char path[] = "/new";
4702 char content[] = "data";
4705 r = guestfs_write_file (g, path, content, 0);
4710 char pathordevice[] = "/";
4713 r = guestfs_umount (g, pathordevice);
4718 char device[] = "/dev/sda1";
4719 char mountpoint[] = "/";
4722 r = guestfs_mount_ro (g, device, mountpoint);
4727 char path[] = "/new";
4730 r = guestfs_cat (g, path);
4733 if (strcmp (r, expected) != 0) {
4734 fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
4742 static int test_tgz_in_0_skip (void)
4746 str = getenv ("SKIP_TEST_TGZ_IN_0");
4747 if (str && strcmp (str, "1") == 0) return 1;
4748 str = getenv ("SKIP_TEST_TGZ_IN");
4749 if (str && strcmp (str, "1") == 0) return 1;
4753 static int test_tgz_in_0 (void)
4755 if (test_tgz_in_0_skip ()) {
4756 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tgz_in_0");
4760 /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
4762 char device[] = "/dev/sda";
4765 r = guestfs_blockdev_setrw (g, device);
4772 r = guestfs_umount_all (g);
4779 r = guestfs_lvm_remove_all (g);
4784 char device[] = "/dev/sda";
4785 char lines_0[] = ",";
4792 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4797 char fstype[] = "ext2";
4798 char device[] = "/dev/sda1";
4801 r = guestfs_mkfs (g, fstype, device);
4806 char device[] = "/dev/sda1";
4807 char mountpoint[] = "/";
4810 r = guestfs_mount (g, device, mountpoint);
4814 /* TestOutput for tgz_in (0) */
4815 char expected[] = "hello\n";
4817 char directory[] = "/";
4820 r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
4825 char path[] = "/hello";
4828 r = guestfs_cat (g, path);
4831 if (strcmp (r, expected) != 0) {
4832 fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
4840 static int test_tar_in_0_skip (void)
4844 str = getenv ("SKIP_TEST_TAR_IN_0");
4845 if (str && strcmp (str, "1") == 0) return 1;
4846 str = getenv ("SKIP_TEST_TAR_IN");
4847 if (str && strcmp (str, "1") == 0) return 1;
4851 static int test_tar_in_0 (void)
4853 if (test_tar_in_0_skip ()) {
4854 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tar_in_0");
4858 /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
4860 char device[] = "/dev/sda";
4863 r = guestfs_blockdev_setrw (g, device);
4870 r = guestfs_umount_all (g);
4877 r = guestfs_lvm_remove_all (g);
4882 char device[] = "/dev/sda";
4883 char lines_0[] = ",";
4890 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4895 char fstype[] = "ext2";
4896 char device[] = "/dev/sda1";
4899 r = guestfs_mkfs (g, fstype, device);
4904 char device[] = "/dev/sda1";
4905 char mountpoint[] = "/";
4908 r = guestfs_mount (g, device, mountpoint);
4912 /* TestOutput for tar_in (0) */
4913 char expected[] = "hello\n";
4915 char directory[] = "/";
4918 r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
4923 char path[] = "/hello";
4926 r = guestfs_cat (g, path);
4929 if (strcmp (r, expected) != 0) {
4930 fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
4938 static int test_checksum_0_skip (void)
4942 str = getenv ("SKIP_TEST_CHECKSUM_0");
4943 if (str && strcmp (str, "1") == 0) return 1;
4944 str = getenv ("SKIP_TEST_CHECKSUM");
4945 if (str && strcmp (str, "1") == 0) return 1;
4949 static int test_checksum_0 (void)
4951 if (test_checksum_0_skip ()) {
4952 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_0");
4956 /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
4958 char device[] = "/dev/sda";
4961 r = guestfs_blockdev_setrw (g, device);
4968 r = guestfs_umount_all (g);
4975 r = guestfs_lvm_remove_all (g);
4980 char device[] = "/dev/sda";
4981 char lines_0[] = ",";
4988 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4993 char fstype[] = "ext2";
4994 char device[] = "/dev/sda1";
4997 r = guestfs_mkfs (g, fstype, device);
5002 char device[] = "/dev/sda1";
5003 char mountpoint[] = "/";
5006 r = guestfs_mount (g, device, mountpoint);
5010 /* TestOutput for checksum (0) */
5011 char expected[] = "935282863";
5013 char path[] = "/new";
5014 char content[] = "test\n";
5017 r = guestfs_write_file (g, path, content, 0);
5022 char csumtype[] = "crc";
5023 char path[] = "/new";
5026 r = guestfs_checksum (g, csumtype, path);
5029 if (strcmp (r, expected) != 0) {
5030 fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
5038 static int test_checksum_1_skip (void)
5042 str = getenv ("SKIP_TEST_CHECKSUM_1");
5043 if (str && strcmp (str, "1") == 0) return 1;
5044 str = getenv ("SKIP_TEST_CHECKSUM");
5045 if (str && strcmp (str, "1") == 0) return 1;
5049 static int test_checksum_1 (void)
5051 if (test_checksum_1_skip ()) {
5052 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_1");
5056 /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
5058 char device[] = "/dev/sda";
5061 r = guestfs_blockdev_setrw (g, device);
5068 r = guestfs_umount_all (g);
5075 r = guestfs_lvm_remove_all (g);
5080 char device[] = "/dev/sda";
5081 char lines_0[] = ",";
5088 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5093 char fstype[] = "ext2";
5094 char device[] = "/dev/sda1";
5097 r = guestfs_mkfs (g, fstype, device);
5102 char device[] = "/dev/sda1";
5103 char mountpoint[] = "/";
5106 r = guestfs_mount (g, device, mountpoint);
5110 /* TestLastFail for checksum (1) */
5112 char csumtype[] = "crc";
5113 char path[] = "/new";
5116 r = guestfs_checksum (g, csumtype, path);
5124 static int test_checksum_2_skip (void)
5128 str = getenv ("SKIP_TEST_CHECKSUM_2");
5129 if (str && strcmp (str, "1") == 0) return 1;
5130 str = getenv ("SKIP_TEST_CHECKSUM");
5131 if (str && strcmp (str, "1") == 0) return 1;
5135 static int test_checksum_2 (void)
5137 if (test_checksum_2_skip ()) {
5138 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_2");
5142 /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
5144 char device[] = "/dev/sda";
5147 r = guestfs_blockdev_setrw (g, device);
5154 r = guestfs_umount_all (g);
5161 r = guestfs_lvm_remove_all (g);
5166 char device[] = "/dev/sda";
5167 char lines_0[] = ",";
5174 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5179 char fstype[] = "ext2";
5180 char device[] = "/dev/sda1";
5183 r = guestfs_mkfs (g, fstype, device);
5188 char device[] = "/dev/sda1";
5189 char mountpoint[] = "/";
5192 r = guestfs_mount (g, device, mountpoint);
5196 /* TestOutput for checksum (2) */
5197 char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
5199 char path[] = "/new";
5200 char content[] = "test\n";
5203 r = guestfs_write_file (g, path, content, 0);
5208 char csumtype[] = "md5";
5209 char path[] = "/new";
5212 r = guestfs_checksum (g, csumtype, path);
5215 if (strcmp (r, expected) != 0) {
5216 fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
5224 static int test_checksum_3_skip (void)
5228 str = getenv ("SKIP_TEST_CHECKSUM_3");
5229 if (str && strcmp (str, "1") == 0) return 1;
5230 str = getenv ("SKIP_TEST_CHECKSUM");
5231 if (str && strcmp (str, "1") == 0) return 1;
5235 static int test_checksum_3 (void)
5237 if (test_checksum_3_skip ()) {
5238 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_3");
5242 /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
5244 char device[] = "/dev/sda";
5247 r = guestfs_blockdev_setrw (g, device);
5254 r = guestfs_umount_all (g);
5261 r = guestfs_lvm_remove_all (g);
5266 char device[] = "/dev/sda";
5267 char lines_0[] = ",";
5274 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5279 char fstype[] = "ext2";
5280 char device[] = "/dev/sda1";
5283 r = guestfs_mkfs (g, fstype, device);
5288 char device[] = "/dev/sda1";
5289 char mountpoint[] = "/";
5292 r = guestfs_mount (g, device, mountpoint);
5296 /* TestOutput for checksum (3) */
5297 char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
5299 char path[] = "/new";
5300 char content[] = "test\n";
5303 r = guestfs_write_file (g, path, content, 0);
5308 char csumtype[] = "sha1";
5309 char path[] = "/new";
5312 r = guestfs_checksum (g, csumtype, path);
5315 if (strcmp (r, expected) != 0) {
5316 fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
5324 static int test_checksum_4_skip (void)
5328 str = getenv ("SKIP_TEST_CHECKSUM_4");
5329 if (str && strcmp (str, "1") == 0) return 1;
5330 str = getenv ("SKIP_TEST_CHECKSUM");
5331 if (str && strcmp (str, "1") == 0) return 1;
5335 static int test_checksum_4 (void)
5337 if (test_checksum_4_skip ()) {
5338 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_4");
5342 /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
5344 char device[] = "/dev/sda";
5347 r = guestfs_blockdev_setrw (g, device);
5354 r = guestfs_umount_all (g);
5361 r = guestfs_lvm_remove_all (g);
5366 char device[] = "/dev/sda";
5367 char lines_0[] = ",";
5374 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5379 char fstype[] = "ext2";
5380 char device[] = "/dev/sda1";
5383 r = guestfs_mkfs (g, fstype, device);
5388 char device[] = "/dev/sda1";
5389 char mountpoint[] = "/";
5392 r = guestfs_mount (g, device, mountpoint);
5396 /* TestOutput for checksum (4) */
5397 char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
5399 char path[] = "/new";
5400 char content[] = "test\n";
5403 r = guestfs_write_file (g, path, content, 0);
5408 char csumtype[] = "sha224";
5409 char path[] = "/new";
5412 r = guestfs_checksum (g, csumtype, path);
5415 if (strcmp (r, expected) != 0) {
5416 fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
5424 static int test_checksum_5_skip (void)
5428 str = getenv ("SKIP_TEST_CHECKSUM_5");
5429 if (str && strcmp (str, "1") == 0) return 1;
5430 str = getenv ("SKIP_TEST_CHECKSUM");
5431 if (str && strcmp (str, "1") == 0) return 1;
5435 static int test_checksum_5 (void)
5437 if (test_checksum_5_skip ()) {
5438 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_5");
5442 /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
5444 char device[] = "/dev/sda";
5447 r = guestfs_blockdev_setrw (g, device);
5454 r = guestfs_umount_all (g);
5461 r = guestfs_lvm_remove_all (g);
5466 char device[] = "/dev/sda";
5467 char lines_0[] = ",";
5474 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5479 char fstype[] = "ext2";
5480 char device[] = "/dev/sda1";
5483 r = guestfs_mkfs (g, fstype, device);
5488 char device[] = "/dev/sda1";
5489 char mountpoint[] = "/";
5492 r = guestfs_mount (g, device, mountpoint);
5496 /* TestOutput for checksum (5) */
5497 char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
5499 char path[] = "/new";
5500 char content[] = "test\n";
5503 r = guestfs_write_file (g, path, content, 0);
5508 char csumtype[] = "sha256";
5509 char path[] = "/new";
5512 r = guestfs_checksum (g, csumtype, path);
5515 if (strcmp (r, expected) != 0) {
5516 fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
5524 static int test_checksum_6_skip (void)
5528 str = getenv ("SKIP_TEST_CHECKSUM_6");
5529 if (str && strcmp (str, "1") == 0) return 1;
5530 str = getenv ("SKIP_TEST_CHECKSUM");
5531 if (str && strcmp (str, "1") == 0) return 1;
5535 static int test_checksum_6 (void)
5537 if (test_checksum_6_skip ()) {
5538 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_6");
5542 /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
5544 char device[] = "/dev/sda";
5547 r = guestfs_blockdev_setrw (g, device);
5554 r = guestfs_umount_all (g);
5561 r = guestfs_lvm_remove_all (g);
5566 char device[] = "/dev/sda";
5567 char lines_0[] = ",";
5574 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5579 char fstype[] = "ext2";
5580 char device[] = "/dev/sda1";
5583 r = guestfs_mkfs (g, fstype, device);
5588 char device[] = "/dev/sda1";
5589 char mountpoint[] = "/";
5592 r = guestfs_mount (g, device, mountpoint);
5596 /* TestOutput for checksum (6) */
5597 char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
5599 char path[] = "/new";
5600 char content[] = "test\n";
5603 r = guestfs_write_file (g, path, content, 0);
5608 char csumtype[] = "sha384";
5609 char path[] = "/new";
5612 r = guestfs_checksum (g, csumtype, path);
5615 if (strcmp (r, expected) != 0) {
5616 fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
5624 static int test_checksum_7_skip (void)
5628 str = getenv ("SKIP_TEST_CHECKSUM_7");
5629 if (str && strcmp (str, "1") == 0) return 1;
5630 str = getenv ("SKIP_TEST_CHECKSUM");
5631 if (str && strcmp (str, "1") == 0) return 1;
5635 static int test_checksum_7 (void)
5637 if (test_checksum_7_skip ()) {
5638 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_7");
5642 /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
5644 char device[] = "/dev/sda";
5647 r = guestfs_blockdev_setrw (g, device);
5654 r = guestfs_umount_all (g);
5661 r = guestfs_lvm_remove_all (g);
5666 char device[] = "/dev/sda";
5667 char lines_0[] = ",";
5674 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5679 char fstype[] = "ext2";
5680 char device[] = "/dev/sda1";
5683 r = guestfs_mkfs (g, fstype, device);
5688 char device[] = "/dev/sda1";
5689 char mountpoint[] = "/";
5692 r = guestfs_mount (g, device, mountpoint);
5696 /* TestOutput for checksum (7) */
5697 char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
5699 char path[] = "/new";
5700 char content[] = "test\n";
5703 r = guestfs_write_file (g, path, content, 0);
5708 char csumtype[] = "sha512";
5709 char path[] = "/new";
5712 r = guestfs_checksum (g, csumtype, path);
5715 if (strcmp (r, expected) != 0) {
5716 fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
5724 static int test_checksum_8_skip (void)
5728 str = getenv ("SKIP_TEST_CHECKSUM_8");
5729 if (str && strcmp (str, "1") == 0) return 1;
5730 str = getenv ("SKIP_TEST_CHECKSUM");
5731 if (str && strcmp (str, "1") == 0) return 1;
5735 static int test_checksum_8 (void)
5737 if (test_checksum_8_skip ()) {
5738 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_8");
5742 /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
5744 char device[] = "/dev/sda";
5747 r = guestfs_blockdev_setrw (g, device);
5754 r = guestfs_umount_all (g);
5761 r = guestfs_lvm_remove_all (g);
5766 char device[] = "/dev/sda";
5767 char lines_0[] = ",";
5774 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5779 char fstype[] = "ext2";
5780 char device[] = "/dev/sda1";
5783 r = guestfs_mkfs (g, fstype, device);
5788 char device[] = "/dev/sda1";
5789 char mountpoint[] = "/";
5792 r = guestfs_mount (g, device, mountpoint);
5796 /* TestOutput for checksum (8) */
5797 char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
5799 char options[] = "ro";
5800 char vfstype[] = "squashfs";
5801 char device[] = "/dev/sdd";
5802 char mountpoint[] = "/";
5805 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
5810 char csumtype[] = "md5";
5811 char path[] = "/known-3";
5814 r = guestfs_checksum (g, csumtype, path);
5817 if (strcmp (r, expected) != 0) {
5818 fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
5826 static int test_download_0_skip (void)
5830 str = getenv ("SKIP_TEST_DOWNLOAD_0");
5831 if (str && strcmp (str, "1") == 0) return 1;
5832 str = getenv ("SKIP_TEST_DOWNLOAD");
5833 if (str && strcmp (str, "1") == 0) return 1;
5837 static int test_download_0 (void)
5839 if (test_download_0_skip ()) {
5840 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_download_0");
5844 /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
5846 char device[] = "/dev/sda";
5849 r = guestfs_blockdev_setrw (g, device);
5856 r = guestfs_umount_all (g);
5863 r = guestfs_lvm_remove_all (g);
5868 char device[] = "/dev/sda";
5869 char lines_0[] = ",";
5876 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5881 char fstype[] = "ext2";
5882 char device[] = "/dev/sda1";
5885 r = guestfs_mkfs (g, fstype, device);
5890 char device[] = "/dev/sda1";
5891 char mountpoint[] = "/";
5894 r = guestfs_mount (g, device, mountpoint);
5898 /* TestOutput for download (0) */
5899 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
5901 char remotefilename[] = "/COPYING.LIB";
5904 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
5909 char remotefilename[] = "/COPYING.LIB";
5912 r = guestfs_download (g, remotefilename, "testdownload.tmp");
5917 char remotefilename[] = "/upload";
5920 r = guestfs_upload (g, "testdownload.tmp", remotefilename);
5925 char csumtype[] = "md5";
5926 char path[] = "/upload";
5929 r = guestfs_checksum (g, csumtype, path);
5932 if (strcmp (r, expected) != 0) {
5933 fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
5941 static int test_upload_0_skip (void)
5945 str = getenv ("SKIP_TEST_UPLOAD_0");
5946 if (str && strcmp (str, "1") == 0) return 1;
5947 str = getenv ("SKIP_TEST_UPLOAD");
5948 if (str && strcmp (str, "1") == 0) return 1;
5952 static int test_upload_0 (void)
5954 if (test_upload_0_skip ()) {
5955 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_upload_0");
5959 /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
5961 char device[] = "/dev/sda";
5964 r = guestfs_blockdev_setrw (g, device);
5971 r = guestfs_umount_all (g);
5978 r = guestfs_lvm_remove_all (g);
5983 char device[] = "/dev/sda";
5984 char lines_0[] = ",";
5991 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5996 char fstype[] = "ext2";
5997 char device[] = "/dev/sda1";
6000 r = guestfs_mkfs (g, fstype, device);
6005 char device[] = "/dev/sda1";
6006 char mountpoint[] = "/";
6009 r = guestfs_mount (g, device, mountpoint);
6013 /* TestOutput for upload (0) */
6014 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
6016 char remotefilename[] = "/COPYING.LIB";
6019 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
6024 char csumtype[] = "md5";
6025 char path[] = "/COPYING.LIB";
6028 r = guestfs_checksum (g, csumtype, path);
6031 if (strcmp (r, expected) != 0) {
6032 fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
6040 static int test_blockdev_rereadpt_0_skip (void)
6044 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
6045 if (str && strcmp (str, "1") == 0) return 1;
6046 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
6047 if (str && strcmp (str, "1") == 0) return 1;
6051 static int test_blockdev_rereadpt_0 (void)
6053 if (test_blockdev_rereadpt_0_skip ()) {
6054 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_rereadpt_0");
6058 /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
6060 char device[] = "/dev/sda";
6063 r = guestfs_blockdev_setrw (g, device);
6070 r = guestfs_umount_all (g);
6077 r = guestfs_lvm_remove_all (g);
6081 /* TestRun for blockdev_rereadpt (0) */
6083 char device[] = "/dev/sda";
6086 r = guestfs_blockdev_rereadpt (g, device);
6093 static int test_blockdev_flushbufs_0_skip (void)
6097 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
6098 if (str && strcmp (str, "1") == 0) return 1;
6099 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
6100 if (str && strcmp (str, "1") == 0) return 1;
6104 static int test_blockdev_flushbufs_0 (void)
6106 if (test_blockdev_flushbufs_0_skip ()) {
6107 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_flushbufs_0");
6111 /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
6113 char device[] = "/dev/sda";
6116 r = guestfs_blockdev_setrw (g, device);
6123 r = guestfs_umount_all (g);
6130 r = guestfs_lvm_remove_all (g);
6134 /* TestRun for blockdev_flushbufs (0) */
6136 char device[] = "/dev/sda";
6139 r = guestfs_blockdev_flushbufs (g, device);
6146 static int test_blockdev_getsize64_0_skip (void)
6150 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
6151 if (str && strcmp (str, "1") == 0) return 1;
6152 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
6153 if (str && strcmp (str, "1") == 0) return 1;
6157 static int test_blockdev_getsize64_0 (void)
6159 if (test_blockdev_getsize64_0_skip ()) {
6160 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsize64_0");
6164 /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
6166 char device[] = "/dev/sda";
6169 r = guestfs_blockdev_setrw (g, device);
6176 r = guestfs_umount_all (g);
6183 r = guestfs_lvm_remove_all (g);
6187 /* TestOutputInt for blockdev_getsize64 (0) */
6189 char device[] = "/dev/sda";
6192 r = guestfs_blockdev_getsize64 (g, device);
6195 if (r != 524288000) {
6196 fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n", (int) r);
6203 static int test_blockdev_getsz_0_skip (void)
6207 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
6208 if (str && strcmp (str, "1") == 0) return 1;
6209 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
6210 if (str && strcmp (str, "1") == 0) return 1;
6214 static int test_blockdev_getsz_0 (void)
6216 if (test_blockdev_getsz_0_skip ()) {
6217 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsz_0");
6221 /* InitNone|InitEmpty for test_blockdev_getsz_0 */
6223 char device[] = "/dev/sda";
6226 r = guestfs_blockdev_setrw (g, device);
6233 r = guestfs_umount_all (g);
6240 r = guestfs_lvm_remove_all (g);
6244 /* TestOutputInt for blockdev_getsz (0) */
6246 char device[] = "/dev/sda";
6249 r = guestfs_blockdev_getsz (g, device);
6253 fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n", (int) r);
6260 static int test_blockdev_getbsz_0_skip (void)
6264 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
6265 if (str && strcmp (str, "1") == 0) return 1;
6266 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
6267 if (str && strcmp (str, "1") == 0) return 1;
6271 static int test_blockdev_getbsz_0 (void)
6273 if (test_blockdev_getbsz_0_skip ()) {
6274 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getbsz_0");
6278 /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
6280 char device[] = "/dev/sda";
6283 r = guestfs_blockdev_setrw (g, device);
6290 r = guestfs_umount_all (g);
6297 r = guestfs_lvm_remove_all (g);
6301 /* TestOutputInt for blockdev_getbsz (0) */
6303 char device[] = "/dev/sda";
6306 r = guestfs_blockdev_getbsz (g, device);
6310 fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n", (int) r);
6317 static int test_blockdev_getss_0_skip (void)
6321 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
6322 if (str && strcmp (str, "1") == 0) return 1;
6323 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
6324 if (str && strcmp (str, "1") == 0) return 1;
6328 static int test_blockdev_getss_0 (void)
6330 if (test_blockdev_getss_0_skip ()) {
6331 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getss_0");
6335 /* InitNone|InitEmpty for test_blockdev_getss_0 */
6337 char device[] = "/dev/sda";
6340 r = guestfs_blockdev_setrw (g, device);
6347 r = guestfs_umount_all (g);
6354 r = guestfs_lvm_remove_all (g);
6358 /* TestOutputInt for blockdev_getss (0) */
6360 char device[] = "/dev/sda";
6363 r = guestfs_blockdev_getss (g, device);
6367 fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n", (int) r);
6374 static int test_blockdev_getro_0_skip (void)
6378 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
6379 if (str && strcmp (str, "1") == 0) return 1;
6380 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
6381 if (str && strcmp (str, "1") == 0) return 1;
6385 static int test_blockdev_getro_0 (void)
6387 if (test_blockdev_getro_0_skip ()) {
6388 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getro_0");
6392 /* InitNone|InitEmpty for test_blockdev_getro_0 */
6394 char device[] = "/dev/sda";
6397 r = guestfs_blockdev_setrw (g, device);
6404 r = guestfs_umount_all (g);
6411 r = guestfs_lvm_remove_all (g);
6415 /* TestOutputTrue for blockdev_getro (0) */
6417 char device[] = "/dev/sda";
6420 r = guestfs_blockdev_setro (g, device);
6425 char device[] = "/dev/sda";
6428 r = guestfs_blockdev_getro (g, device);
6432 fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
6439 static int test_blockdev_setrw_0_skip (void)
6443 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
6444 if (str && strcmp (str, "1") == 0) return 1;
6445 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
6446 if (str && strcmp (str, "1") == 0) return 1;
6450 static int test_blockdev_setrw_0 (void)
6452 if (test_blockdev_setrw_0_skip ()) {
6453 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setrw_0");
6457 /* InitNone|InitEmpty for test_blockdev_setrw_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 /* TestOutputFalse for blockdev_setrw (0) */
6482 char device[] = "/dev/sda";
6485 r = guestfs_blockdev_setrw (g, device);
6490 char device[] = "/dev/sda";
6493 r = guestfs_blockdev_getro (g, device);
6497 fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
6504 static int test_blockdev_setro_0_skip (void)
6508 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
6509 if (str && strcmp (str, "1") == 0) return 1;
6510 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
6511 if (str && strcmp (str, "1") == 0) return 1;
6515 static int test_blockdev_setro_0 (void)
6517 if (test_blockdev_setro_0_skip ()) {
6518 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setro_0");
6522 /* InitNone|InitEmpty for test_blockdev_setro_0 */
6524 char device[] = "/dev/sda";
6527 r = guestfs_blockdev_setrw (g, device);
6534 r = guestfs_umount_all (g);
6541 r = guestfs_lvm_remove_all (g);
6545 /* TestOutputTrue for blockdev_setro (0) */
6547 char device[] = "/dev/sda";
6550 r = guestfs_blockdev_setro (g, device);
6555 char device[] = "/dev/sda";
6558 r = guestfs_blockdev_getro (g, device);
6562 fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
6569 static int test_statvfs_0_skip (void)
6573 str = getenv ("SKIP_TEST_STATVFS_0");
6574 if (str && strcmp (str, "1") == 0) return 1;
6575 str = getenv ("SKIP_TEST_STATVFS");
6576 if (str && strcmp (str, "1") == 0) return 1;
6580 static int test_statvfs_0 (void)
6582 if (test_statvfs_0_skip ()) {
6583 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_statvfs_0");
6587 /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
6589 char device[] = "/dev/sda";
6592 r = guestfs_blockdev_setrw (g, device);
6599 r = guestfs_umount_all (g);
6606 r = guestfs_lvm_remove_all (g);
6611 char device[] = "/dev/sda";
6612 char lines_0[] = ",";
6619 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6624 char fstype[] = "ext2";
6625 char device[] = "/dev/sda1";
6628 r = guestfs_mkfs (g, fstype, device);
6633 char device[] = "/dev/sda1";
6634 char mountpoint[] = "/";
6637 r = guestfs_mount (g, device, mountpoint);
6641 /* TestOutputStruct for statvfs (0) */
6644 struct guestfs_statvfs *r;
6646 r = guestfs_statvfs (g, path);
6649 if (r->bfree != 487702) {
6650 fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
6654 if (r->blocks != 490020) {
6655 fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
6659 if (r->bsize != 1024) {
6660 fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
6669 static int test_lstat_0_skip (void)
6673 str = getenv ("SKIP_TEST_LSTAT_0");
6674 if (str && strcmp (str, "1") == 0) return 1;
6675 str = getenv ("SKIP_TEST_LSTAT");
6676 if (str && strcmp (str, "1") == 0) return 1;
6680 static int test_lstat_0 (void)
6682 if (test_lstat_0_skip ()) {
6683 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lstat_0");
6687 /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
6689 char device[] = "/dev/sda";
6692 r = guestfs_blockdev_setrw (g, device);
6699 r = guestfs_umount_all (g);
6706 r = guestfs_lvm_remove_all (g);
6711 char device[] = "/dev/sda";
6712 char lines_0[] = ",";
6719 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6724 char fstype[] = "ext2";
6725 char device[] = "/dev/sda1";
6728 r = guestfs_mkfs (g, fstype, device);
6733 char device[] = "/dev/sda1";
6734 char mountpoint[] = "/";
6737 r = guestfs_mount (g, device, mountpoint);
6741 /* TestOutputStruct for lstat (0) */
6743 char path[] = "/new";
6746 r = guestfs_touch (g, path);
6751 char path[] = "/new";
6752 struct guestfs_stat *r;
6754 r = guestfs_lstat (g, path);
6758 fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
6767 static int test_stat_0_skip (void)
6771 str = getenv ("SKIP_TEST_STAT_0");
6772 if (str && strcmp (str, "1") == 0) return 1;
6773 str = getenv ("SKIP_TEST_STAT");
6774 if (str && strcmp (str, "1") == 0) return 1;
6778 static int test_stat_0 (void)
6780 if (test_stat_0_skip ()) {
6781 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_stat_0");
6785 /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
6787 char device[] = "/dev/sda";
6790 r = guestfs_blockdev_setrw (g, device);
6797 r = guestfs_umount_all (g);
6804 r = guestfs_lvm_remove_all (g);
6809 char device[] = "/dev/sda";
6810 char lines_0[] = ",";
6817 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6822 char fstype[] = "ext2";
6823 char device[] = "/dev/sda1";
6826 r = guestfs_mkfs (g, fstype, device);
6831 char device[] = "/dev/sda1";
6832 char mountpoint[] = "/";
6835 r = guestfs_mount (g, device, mountpoint);
6839 /* TestOutputStruct for stat (0) */
6841 char path[] = "/new";
6844 r = guestfs_touch (g, path);
6849 char path[] = "/new";
6850 struct guestfs_stat *r;
6852 r = guestfs_stat (g, path);
6856 fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
6865 static int test_command_lines_0_skip (void)
6869 str = getenv ("SKIP_TEST_COMMAND_LINES_0");
6870 if (str && strcmp (str, "1") == 0) return 1;
6871 str = getenv ("SKIP_TEST_COMMAND_LINES");
6872 if (str && strcmp (str, "1") == 0) return 1;
6876 static int test_command_lines_0 (void)
6878 if (test_command_lines_0_skip ()) {
6879 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_0");
6883 /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
6885 char device[] = "/dev/sda";
6888 r = guestfs_blockdev_setrw (g, device);
6895 r = guestfs_umount_all (g);
6902 r = guestfs_lvm_remove_all (g);
6907 char device[] = "/dev/sda";
6908 char lines_0[] = ",";
6915 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6920 char fstype[] = "ext2";
6921 char device[] = "/dev/sda1";
6924 r = guestfs_mkfs (g, fstype, device);
6929 char device[] = "/dev/sda1";
6930 char mountpoint[] = "/";
6933 r = guestfs_mount (g, device, mountpoint);
6937 /* TestOutputList for command_lines (0) */
6939 char remotefilename[] = "/test-command";
6942 r = guestfs_upload (g, "test-command", remotefilename);
6947 char path[] = "/test-command";
6950 r = guestfs_chmod (g, 493, path);
6955 char arguments_0[] = "/test-command";
6956 char arguments_1[] = "1";
6957 char *arguments[] = {
6965 r = guestfs_command_lines (g, arguments);
6969 fprintf (stderr, "test_command_lines_0: short list returned from command\n");
6974 char expected[] = "Result1";
6975 if (strcmp (r[0], expected) != 0) {
6976 fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6981 fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
6985 for (i = 0; r[i] != NULL; ++i)
6992 static int test_command_lines_1_skip (void)
6996 str = getenv ("SKIP_TEST_COMMAND_LINES_1");
6997 if (str && strcmp (str, "1") == 0) return 1;
6998 str = getenv ("SKIP_TEST_COMMAND_LINES");
6999 if (str && strcmp (str, "1") == 0) return 1;
7003 static int test_command_lines_1 (void)
7005 if (test_command_lines_1_skip ()) {
7006 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_1");
7010 /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
7012 char device[] = "/dev/sda";
7015 r = guestfs_blockdev_setrw (g, device);
7022 r = guestfs_umount_all (g);
7029 r = guestfs_lvm_remove_all (g);
7034 char device[] = "/dev/sda";
7035 char lines_0[] = ",";
7042 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7047 char fstype[] = "ext2";
7048 char device[] = "/dev/sda1";
7051 r = guestfs_mkfs (g, fstype, device);
7056 char device[] = "/dev/sda1";
7057 char mountpoint[] = "/";
7060 r = guestfs_mount (g, device, mountpoint);
7064 /* TestOutputList for command_lines (1) */
7066 char remotefilename[] = "/test-command";
7069 r = guestfs_upload (g, "test-command", remotefilename);
7074 char path[] = "/test-command";
7077 r = guestfs_chmod (g, 493, path);
7082 char arguments_0[] = "/test-command";
7083 char arguments_1[] = "2";
7084 char *arguments[] = {
7092 r = guestfs_command_lines (g, arguments);
7096 fprintf (stderr, "test_command_lines_1: short list returned from command\n");
7101 char expected[] = "Result2";
7102 if (strcmp (r[0], expected) != 0) {
7103 fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7108 fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
7112 for (i = 0; r[i] != NULL; ++i)
7119 static int test_command_lines_2_skip (void)
7123 str = getenv ("SKIP_TEST_COMMAND_LINES_2");
7124 if (str && strcmp (str, "1") == 0) return 1;
7125 str = getenv ("SKIP_TEST_COMMAND_LINES");
7126 if (str && strcmp (str, "1") == 0) return 1;
7130 static int test_command_lines_2 (void)
7132 if (test_command_lines_2_skip ()) {
7133 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_2");
7137 /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
7139 char device[] = "/dev/sda";
7142 r = guestfs_blockdev_setrw (g, device);
7149 r = guestfs_umount_all (g);
7156 r = guestfs_lvm_remove_all (g);
7161 char device[] = "/dev/sda";
7162 char lines_0[] = ",";
7169 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7174 char fstype[] = "ext2";
7175 char device[] = "/dev/sda1";
7178 r = guestfs_mkfs (g, fstype, device);
7183 char device[] = "/dev/sda1";
7184 char mountpoint[] = "/";
7187 r = guestfs_mount (g, device, mountpoint);
7191 /* TestOutputList for command_lines (2) */
7193 char remotefilename[] = "/test-command";
7196 r = guestfs_upload (g, "test-command", remotefilename);
7201 char path[] = "/test-command";
7204 r = guestfs_chmod (g, 493, path);
7209 char arguments_0[] = "/test-command";
7210 char arguments_1[] = "3";
7211 char *arguments[] = {
7219 r = guestfs_command_lines (g, arguments);
7223 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7228 char expected[] = "";
7229 if (strcmp (r[0], expected) != 0) {
7230 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7235 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7240 char expected[] = "Result3";
7241 if (strcmp (r[1], expected) != 0) {
7242 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7247 fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
7251 for (i = 0; r[i] != NULL; ++i)
7258 static int test_command_lines_3_skip (void)
7262 str = getenv ("SKIP_TEST_COMMAND_LINES_3");
7263 if (str && strcmp (str, "1") == 0) return 1;
7264 str = getenv ("SKIP_TEST_COMMAND_LINES");
7265 if (str && strcmp (str, "1") == 0) return 1;
7269 static int test_command_lines_3 (void)
7271 if (test_command_lines_3_skip ()) {
7272 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_3");
7276 /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
7278 char device[] = "/dev/sda";
7281 r = guestfs_blockdev_setrw (g, device);
7288 r = guestfs_umount_all (g);
7295 r = guestfs_lvm_remove_all (g);
7300 char device[] = "/dev/sda";
7301 char lines_0[] = ",";
7308 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7313 char fstype[] = "ext2";
7314 char device[] = "/dev/sda1";
7317 r = guestfs_mkfs (g, fstype, device);
7322 char device[] = "/dev/sda1";
7323 char mountpoint[] = "/";
7326 r = guestfs_mount (g, device, mountpoint);
7330 /* TestOutputList for command_lines (3) */
7332 char remotefilename[] = "/test-command";
7335 r = guestfs_upload (g, "test-command", remotefilename);
7340 char path[] = "/test-command";
7343 r = guestfs_chmod (g, 493, path);
7348 char arguments_0[] = "/test-command";
7349 char arguments_1[] = "4";
7350 char *arguments[] = {
7358 r = guestfs_command_lines (g, arguments);
7362 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7367 char expected[] = "";
7368 if (strcmp (r[0], expected) != 0) {
7369 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7374 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7379 char expected[] = "Result4";
7380 if (strcmp (r[1], expected) != 0) {
7381 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7386 fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
7390 for (i = 0; r[i] != NULL; ++i)
7397 static int test_command_lines_4_skip (void)
7401 str = getenv ("SKIP_TEST_COMMAND_LINES_4");
7402 if (str && strcmp (str, "1") == 0) return 1;
7403 str = getenv ("SKIP_TEST_COMMAND_LINES");
7404 if (str && strcmp (str, "1") == 0) return 1;
7408 static int test_command_lines_4 (void)
7410 if (test_command_lines_4_skip ()) {
7411 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_4");
7415 /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
7417 char device[] = "/dev/sda";
7420 r = guestfs_blockdev_setrw (g, device);
7427 r = guestfs_umount_all (g);
7434 r = guestfs_lvm_remove_all (g);
7439 char device[] = "/dev/sda";
7440 char lines_0[] = ",";
7447 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7452 char fstype[] = "ext2";
7453 char device[] = "/dev/sda1";
7456 r = guestfs_mkfs (g, fstype, device);
7461 char device[] = "/dev/sda1";
7462 char mountpoint[] = "/";
7465 r = guestfs_mount (g, device, mountpoint);
7469 /* TestOutputList for command_lines (4) */
7471 char remotefilename[] = "/test-command";
7474 r = guestfs_upload (g, "test-command", remotefilename);
7479 char path[] = "/test-command";
7482 r = guestfs_chmod (g, 493, path);
7487 char arguments_0[] = "/test-command";
7488 char arguments_1[] = "5";
7489 char *arguments[] = {
7497 r = guestfs_command_lines (g, arguments);
7501 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7506 char expected[] = "";
7507 if (strcmp (r[0], expected) != 0) {
7508 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7513 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7518 char expected[] = "Result5";
7519 if (strcmp (r[1], expected) != 0) {
7520 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7525 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7530 char expected[] = "";
7531 if (strcmp (r[2], expected) != 0) {
7532 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
7537 fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
7541 for (i = 0; r[i] != NULL; ++i)
7548 static int test_command_lines_5_skip (void)
7552 str = getenv ("SKIP_TEST_COMMAND_LINES_5");
7553 if (str && strcmp (str, "1") == 0) return 1;
7554 str = getenv ("SKIP_TEST_COMMAND_LINES");
7555 if (str && strcmp (str, "1") == 0) return 1;
7559 static int test_command_lines_5 (void)
7561 if (test_command_lines_5_skip ()) {
7562 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_5");
7566 /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
7568 char device[] = "/dev/sda";
7571 r = guestfs_blockdev_setrw (g, device);
7578 r = guestfs_umount_all (g);
7585 r = guestfs_lvm_remove_all (g);
7590 char device[] = "/dev/sda";
7591 char lines_0[] = ",";
7598 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7603 char fstype[] = "ext2";
7604 char device[] = "/dev/sda1";
7607 r = guestfs_mkfs (g, fstype, device);
7612 char device[] = "/dev/sda1";
7613 char mountpoint[] = "/";
7616 r = guestfs_mount (g, device, mountpoint);
7620 /* TestOutputList for command_lines (5) */
7622 char remotefilename[] = "/test-command";
7625 r = guestfs_upload (g, "test-command", remotefilename);
7630 char path[] = "/test-command";
7633 r = guestfs_chmod (g, 493, path);
7638 char arguments_0[] = "/test-command";
7639 char arguments_1[] = "6";
7640 char *arguments[] = {
7648 r = guestfs_command_lines (g, arguments);
7652 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7657 char expected[] = "";
7658 if (strcmp (r[0], expected) != 0) {
7659 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7664 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7669 char expected[] = "";
7670 if (strcmp (r[1], expected) != 0) {
7671 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7676 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7681 char expected[] = "Result6";
7682 if (strcmp (r[2], expected) != 0) {
7683 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
7688 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7693 char expected[] = "";
7694 if (strcmp (r[3], expected) != 0) {
7695 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
7700 fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
7704 for (i = 0; r[i] != NULL; ++i)
7711 static int test_command_lines_6_skip (void)
7715 str = getenv ("SKIP_TEST_COMMAND_LINES_6");
7716 if (str && strcmp (str, "1") == 0) return 1;
7717 str = getenv ("SKIP_TEST_COMMAND_LINES");
7718 if (str && strcmp (str, "1") == 0) return 1;
7722 static int test_command_lines_6 (void)
7724 if (test_command_lines_6_skip ()) {
7725 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_6");
7729 /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
7731 char device[] = "/dev/sda";
7734 r = guestfs_blockdev_setrw (g, device);
7741 r = guestfs_umount_all (g);
7748 r = guestfs_lvm_remove_all (g);
7753 char device[] = "/dev/sda";
7754 char lines_0[] = ",";
7761 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7766 char fstype[] = "ext2";
7767 char device[] = "/dev/sda1";
7770 r = guestfs_mkfs (g, fstype, device);
7775 char device[] = "/dev/sda1";
7776 char mountpoint[] = "/";
7779 r = guestfs_mount (g, device, mountpoint);
7783 /* TestOutputList for command_lines (6) */
7785 char remotefilename[] = "/test-command";
7788 r = guestfs_upload (g, "test-command", remotefilename);
7793 char path[] = "/test-command";
7796 r = guestfs_chmod (g, 493, path);
7801 char arguments_0[] = "/test-command";
7802 char arguments_1[] = "7";
7803 char *arguments[] = {
7811 r = guestfs_command_lines (g, arguments);
7815 fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
7819 for (i = 0; r[i] != NULL; ++i)
7826 static int test_command_lines_7_skip (void)
7830 str = getenv ("SKIP_TEST_COMMAND_LINES_7");
7831 if (str && strcmp (str, "1") == 0) return 1;
7832 str = getenv ("SKIP_TEST_COMMAND_LINES");
7833 if (str && strcmp (str, "1") == 0) return 1;
7837 static int test_command_lines_7 (void)
7839 if (test_command_lines_7_skip ()) {
7840 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_7");
7844 /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
7846 char device[] = "/dev/sda";
7849 r = guestfs_blockdev_setrw (g, device);
7856 r = guestfs_umount_all (g);
7863 r = guestfs_lvm_remove_all (g);
7868 char device[] = "/dev/sda";
7869 char lines_0[] = ",";
7876 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7881 char fstype[] = "ext2";
7882 char device[] = "/dev/sda1";
7885 r = guestfs_mkfs (g, fstype, device);
7890 char device[] = "/dev/sda1";
7891 char mountpoint[] = "/";
7894 r = guestfs_mount (g, device, mountpoint);
7898 /* TestOutputList for command_lines (7) */
7900 char remotefilename[] = "/test-command";
7903 r = guestfs_upload (g, "test-command", remotefilename);
7908 char path[] = "/test-command";
7911 r = guestfs_chmod (g, 493, path);
7916 char arguments_0[] = "/test-command";
7917 char arguments_1[] = "8";
7918 char *arguments[] = {
7926 r = guestfs_command_lines (g, arguments);
7930 fprintf (stderr, "test_command_lines_7: short list returned from command\n");
7935 char expected[] = "";
7936 if (strcmp (r[0], expected) != 0) {
7937 fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7942 fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
7946 for (i = 0; r[i] != NULL; ++i)
7953 static int test_command_lines_8_skip (void)
7957 str = getenv ("SKIP_TEST_COMMAND_LINES_8");
7958 if (str && strcmp (str, "1") == 0) return 1;
7959 str = getenv ("SKIP_TEST_COMMAND_LINES");
7960 if (str && strcmp (str, "1") == 0) return 1;
7964 static int test_command_lines_8 (void)
7966 if (test_command_lines_8_skip ()) {
7967 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_8");
7971 /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
7973 char device[] = "/dev/sda";
7976 r = guestfs_blockdev_setrw (g, device);
7983 r = guestfs_umount_all (g);
7990 r = guestfs_lvm_remove_all (g);
7995 char device[] = "/dev/sda";
7996 char lines_0[] = ",";
8003 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8008 char fstype[] = "ext2";
8009 char device[] = "/dev/sda1";
8012 r = guestfs_mkfs (g, fstype, device);
8017 char device[] = "/dev/sda1";
8018 char mountpoint[] = "/";
8021 r = guestfs_mount (g, device, mountpoint);
8025 /* TestOutputList for command_lines (8) */
8027 char remotefilename[] = "/test-command";
8030 r = guestfs_upload (g, "test-command", remotefilename);
8035 char path[] = "/test-command";
8038 r = guestfs_chmod (g, 493, path);
8043 char arguments_0[] = "/test-command";
8044 char arguments_1[] = "9";
8045 char *arguments[] = {
8053 r = guestfs_command_lines (g, arguments);
8057 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8062 char expected[] = "";
8063 if (strcmp (r[0], expected) != 0) {
8064 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8069 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8074 char expected[] = "";
8075 if (strcmp (r[1], expected) != 0) {
8076 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8081 fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
8085 for (i = 0; r[i] != NULL; ++i)
8092 static int test_command_lines_9_skip (void)
8096 str = getenv ("SKIP_TEST_COMMAND_LINES_9");
8097 if (str && strcmp (str, "1") == 0) return 1;
8098 str = getenv ("SKIP_TEST_COMMAND_LINES");
8099 if (str && strcmp (str, "1") == 0) return 1;
8103 static int test_command_lines_9 (void)
8105 if (test_command_lines_9_skip ()) {
8106 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_9");
8110 /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
8112 char device[] = "/dev/sda";
8115 r = guestfs_blockdev_setrw (g, device);
8122 r = guestfs_umount_all (g);
8129 r = guestfs_lvm_remove_all (g);
8134 char device[] = "/dev/sda";
8135 char lines_0[] = ",";
8142 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8147 char fstype[] = "ext2";
8148 char device[] = "/dev/sda1";
8151 r = guestfs_mkfs (g, fstype, device);
8156 char device[] = "/dev/sda1";
8157 char mountpoint[] = "/";
8160 r = guestfs_mount (g, device, mountpoint);
8164 /* TestOutputList for command_lines (9) */
8166 char remotefilename[] = "/test-command";
8169 r = guestfs_upload (g, "test-command", remotefilename);
8174 char path[] = "/test-command";
8177 r = guestfs_chmod (g, 493, path);
8182 char arguments_0[] = "/test-command";
8183 char arguments_1[] = "10";
8184 char *arguments[] = {
8192 r = guestfs_command_lines (g, arguments);
8196 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8201 char expected[] = "Result10-1";
8202 if (strcmp (r[0], expected) != 0) {
8203 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8208 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8213 char expected[] = "Result10-2";
8214 if (strcmp (r[1], expected) != 0) {
8215 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8220 fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
8224 for (i = 0; r[i] != NULL; ++i)
8231 static int test_command_lines_10_skip (void)
8235 str = getenv ("SKIP_TEST_COMMAND_LINES_10");
8236 if (str && strcmp (str, "1") == 0) return 1;
8237 str = getenv ("SKIP_TEST_COMMAND_LINES");
8238 if (str && strcmp (str, "1") == 0) return 1;
8242 static int test_command_lines_10 (void)
8244 if (test_command_lines_10_skip ()) {
8245 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_10");
8249 /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
8251 char device[] = "/dev/sda";
8254 r = guestfs_blockdev_setrw (g, device);
8261 r = guestfs_umount_all (g);
8268 r = guestfs_lvm_remove_all (g);
8273 char device[] = "/dev/sda";
8274 char lines_0[] = ",";
8281 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8286 char fstype[] = "ext2";
8287 char device[] = "/dev/sda1";
8290 r = guestfs_mkfs (g, fstype, device);
8295 char device[] = "/dev/sda1";
8296 char mountpoint[] = "/";
8299 r = guestfs_mount (g, device, mountpoint);
8303 /* TestOutputList for command_lines (10) */
8305 char remotefilename[] = "/test-command";
8308 r = guestfs_upload (g, "test-command", remotefilename);
8313 char path[] = "/test-command";
8316 r = guestfs_chmod (g, 493, path);
8321 char arguments_0[] = "/test-command";
8322 char arguments_1[] = "11";
8323 char *arguments[] = {
8331 r = guestfs_command_lines (g, arguments);
8335 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8340 char expected[] = "Result11-1";
8341 if (strcmp (r[0], expected) != 0) {
8342 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8347 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8352 char expected[] = "Result11-2";
8353 if (strcmp (r[1], expected) != 0) {
8354 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8359 fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
8363 for (i = 0; r[i] != NULL; ++i)
8370 static int test_command_0_skip (void)
8374 str = getenv ("SKIP_TEST_COMMAND_0");
8375 if (str && strcmp (str, "1") == 0) return 1;
8376 str = getenv ("SKIP_TEST_COMMAND");
8377 if (str && strcmp (str, "1") == 0) return 1;
8381 static int test_command_0 (void)
8383 if (test_command_0_skip ()) {
8384 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_0");
8388 /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
8390 char device[] = "/dev/sda";
8393 r = guestfs_blockdev_setrw (g, device);
8400 r = guestfs_umount_all (g);
8407 r = guestfs_lvm_remove_all (g);
8412 char device[] = "/dev/sda";
8413 char lines_0[] = ",";
8420 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8425 char fstype[] = "ext2";
8426 char device[] = "/dev/sda1";
8429 r = guestfs_mkfs (g, fstype, device);
8434 char device[] = "/dev/sda1";
8435 char mountpoint[] = "/";
8438 r = guestfs_mount (g, device, mountpoint);
8442 /* TestOutput for command (0) */
8443 char expected[] = "Result1";
8445 char remotefilename[] = "/test-command";
8448 r = guestfs_upload (g, "test-command", remotefilename);
8453 char path[] = "/test-command";
8456 r = guestfs_chmod (g, 493, path);
8461 char arguments_0[] = "/test-command";
8462 char arguments_1[] = "1";
8463 char *arguments[] = {
8470 r = guestfs_command (g, arguments);
8473 if (strcmp (r, expected) != 0) {
8474 fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
8482 static int test_command_1_skip (void)
8486 str = getenv ("SKIP_TEST_COMMAND_1");
8487 if (str && strcmp (str, "1") == 0) return 1;
8488 str = getenv ("SKIP_TEST_COMMAND");
8489 if (str && strcmp (str, "1") == 0) return 1;
8493 static int test_command_1 (void)
8495 if (test_command_1_skip ()) {
8496 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_1");
8500 /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
8502 char device[] = "/dev/sda";
8505 r = guestfs_blockdev_setrw (g, device);
8512 r = guestfs_umount_all (g);
8519 r = guestfs_lvm_remove_all (g);
8524 char device[] = "/dev/sda";
8525 char lines_0[] = ",";
8532 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8537 char fstype[] = "ext2";
8538 char device[] = "/dev/sda1";
8541 r = guestfs_mkfs (g, fstype, device);
8546 char device[] = "/dev/sda1";
8547 char mountpoint[] = "/";
8550 r = guestfs_mount (g, device, mountpoint);
8554 /* TestOutput for command (1) */
8555 char expected[] = "Result2\n";
8557 char remotefilename[] = "/test-command";
8560 r = guestfs_upload (g, "test-command", remotefilename);
8565 char path[] = "/test-command";
8568 r = guestfs_chmod (g, 493, path);
8573 char arguments_0[] = "/test-command";
8574 char arguments_1[] = "2";
8575 char *arguments[] = {
8582 r = guestfs_command (g, arguments);
8585 if (strcmp (r, expected) != 0) {
8586 fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
8594 static int test_command_2_skip (void)
8598 str = getenv ("SKIP_TEST_COMMAND_2");
8599 if (str && strcmp (str, "1") == 0) return 1;
8600 str = getenv ("SKIP_TEST_COMMAND");
8601 if (str && strcmp (str, "1") == 0) return 1;
8605 static int test_command_2 (void)
8607 if (test_command_2_skip ()) {
8608 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_2");
8612 /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
8614 char device[] = "/dev/sda";
8617 r = guestfs_blockdev_setrw (g, device);
8624 r = guestfs_umount_all (g);
8631 r = guestfs_lvm_remove_all (g);
8636 char device[] = "/dev/sda";
8637 char lines_0[] = ",";
8644 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8649 char fstype[] = "ext2";
8650 char device[] = "/dev/sda1";
8653 r = guestfs_mkfs (g, fstype, device);
8658 char device[] = "/dev/sda1";
8659 char mountpoint[] = "/";
8662 r = guestfs_mount (g, device, mountpoint);
8666 /* TestOutput for command (2) */
8667 char expected[] = "\nResult3";
8669 char remotefilename[] = "/test-command";
8672 r = guestfs_upload (g, "test-command", remotefilename);
8677 char path[] = "/test-command";
8680 r = guestfs_chmod (g, 493, path);
8685 char arguments_0[] = "/test-command";
8686 char arguments_1[] = "3";
8687 char *arguments[] = {
8694 r = guestfs_command (g, arguments);
8697 if (strcmp (r, expected) != 0) {
8698 fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
8706 static int test_command_3_skip (void)
8710 str = getenv ("SKIP_TEST_COMMAND_3");
8711 if (str && strcmp (str, "1") == 0) return 1;
8712 str = getenv ("SKIP_TEST_COMMAND");
8713 if (str && strcmp (str, "1") == 0) return 1;
8717 static int test_command_3 (void)
8719 if (test_command_3_skip ()) {
8720 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_3");
8724 /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
8726 char device[] = "/dev/sda";
8729 r = guestfs_blockdev_setrw (g, device);
8736 r = guestfs_umount_all (g);
8743 r = guestfs_lvm_remove_all (g);
8748 char device[] = "/dev/sda";
8749 char lines_0[] = ",";
8756 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8761 char fstype[] = "ext2";
8762 char device[] = "/dev/sda1";
8765 r = guestfs_mkfs (g, fstype, device);
8770 char device[] = "/dev/sda1";
8771 char mountpoint[] = "/";
8774 r = guestfs_mount (g, device, mountpoint);
8778 /* TestOutput for command (3) */
8779 char expected[] = "\nResult4\n";
8781 char remotefilename[] = "/test-command";
8784 r = guestfs_upload (g, "test-command", remotefilename);
8789 char path[] = "/test-command";
8792 r = guestfs_chmod (g, 493, path);
8797 char arguments_0[] = "/test-command";
8798 char arguments_1[] = "4";
8799 char *arguments[] = {
8806 r = guestfs_command (g, arguments);
8809 if (strcmp (r, expected) != 0) {
8810 fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
8818 static int test_command_4_skip (void)
8822 str = getenv ("SKIP_TEST_COMMAND_4");
8823 if (str && strcmp (str, "1") == 0) return 1;
8824 str = getenv ("SKIP_TEST_COMMAND");
8825 if (str && strcmp (str, "1") == 0) return 1;
8829 static int test_command_4 (void)
8831 if (test_command_4_skip ()) {
8832 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_4");
8836 /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
8838 char device[] = "/dev/sda";
8841 r = guestfs_blockdev_setrw (g, device);
8848 r = guestfs_umount_all (g);
8855 r = guestfs_lvm_remove_all (g);
8860 char device[] = "/dev/sda";
8861 char lines_0[] = ",";
8868 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8873 char fstype[] = "ext2";
8874 char device[] = "/dev/sda1";
8877 r = guestfs_mkfs (g, fstype, device);
8882 char device[] = "/dev/sda1";
8883 char mountpoint[] = "/";
8886 r = guestfs_mount (g, device, mountpoint);
8890 /* TestOutput for command (4) */
8891 char expected[] = "\nResult5\n\n";
8893 char remotefilename[] = "/test-command";
8896 r = guestfs_upload (g, "test-command", remotefilename);
8901 char path[] = "/test-command";
8904 r = guestfs_chmod (g, 493, path);
8909 char arguments_0[] = "/test-command";
8910 char arguments_1[] = "5";
8911 char *arguments[] = {
8918 r = guestfs_command (g, arguments);
8921 if (strcmp (r, expected) != 0) {
8922 fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
8930 static int test_command_5_skip (void)
8934 str = getenv ("SKIP_TEST_COMMAND_5");
8935 if (str && strcmp (str, "1") == 0) return 1;
8936 str = getenv ("SKIP_TEST_COMMAND");
8937 if (str && strcmp (str, "1") == 0) return 1;
8941 static int test_command_5 (void)
8943 if (test_command_5_skip ()) {
8944 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_5");
8948 /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
8950 char device[] = "/dev/sda";
8953 r = guestfs_blockdev_setrw (g, device);
8960 r = guestfs_umount_all (g);
8967 r = guestfs_lvm_remove_all (g);
8972 char device[] = "/dev/sda";
8973 char lines_0[] = ",";
8980 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8985 char fstype[] = "ext2";
8986 char device[] = "/dev/sda1";
8989 r = guestfs_mkfs (g, fstype, device);
8994 char device[] = "/dev/sda1";
8995 char mountpoint[] = "/";
8998 r = guestfs_mount (g, device, mountpoint);
9002 /* TestOutput for command (5) */
9003 char expected[] = "\n\nResult6\n\n";
9005 char remotefilename[] = "/test-command";
9008 r = guestfs_upload (g, "test-command", remotefilename);
9013 char path[] = "/test-command";
9016 r = guestfs_chmod (g, 493, path);
9021 char arguments_0[] = "/test-command";
9022 char arguments_1[] = "6";
9023 char *arguments[] = {
9030 r = guestfs_command (g, arguments);
9033 if (strcmp (r, expected) != 0) {
9034 fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
9042 static int test_command_6_skip (void)
9046 str = getenv ("SKIP_TEST_COMMAND_6");
9047 if (str && strcmp (str, "1") == 0) return 1;
9048 str = getenv ("SKIP_TEST_COMMAND");
9049 if (str && strcmp (str, "1") == 0) return 1;
9053 static int test_command_6 (void)
9055 if (test_command_6_skip ()) {
9056 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_6");
9060 /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
9062 char device[] = "/dev/sda";
9065 r = guestfs_blockdev_setrw (g, device);
9072 r = guestfs_umount_all (g);
9079 r = guestfs_lvm_remove_all (g);
9084 char device[] = "/dev/sda";
9085 char lines_0[] = ",";
9092 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9097 char fstype[] = "ext2";
9098 char device[] = "/dev/sda1";
9101 r = guestfs_mkfs (g, fstype, device);
9106 char device[] = "/dev/sda1";
9107 char mountpoint[] = "/";
9110 r = guestfs_mount (g, device, mountpoint);
9114 /* TestOutput for command (6) */
9115 char expected[] = "";
9117 char remotefilename[] = "/test-command";
9120 r = guestfs_upload (g, "test-command", remotefilename);
9125 char path[] = "/test-command";
9128 r = guestfs_chmod (g, 493, path);
9133 char arguments_0[] = "/test-command";
9134 char arguments_1[] = "7";
9135 char *arguments[] = {
9142 r = guestfs_command (g, arguments);
9145 if (strcmp (r, expected) != 0) {
9146 fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
9154 static int test_command_7_skip (void)
9158 str = getenv ("SKIP_TEST_COMMAND_7");
9159 if (str && strcmp (str, "1") == 0) return 1;
9160 str = getenv ("SKIP_TEST_COMMAND");
9161 if (str && strcmp (str, "1") == 0) return 1;
9165 static int test_command_7 (void)
9167 if (test_command_7_skip ()) {
9168 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_7");
9172 /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
9174 char device[] = "/dev/sda";
9177 r = guestfs_blockdev_setrw (g, device);
9184 r = guestfs_umount_all (g);
9191 r = guestfs_lvm_remove_all (g);
9196 char device[] = "/dev/sda";
9197 char lines_0[] = ",";
9204 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9209 char fstype[] = "ext2";
9210 char device[] = "/dev/sda1";
9213 r = guestfs_mkfs (g, fstype, device);
9218 char device[] = "/dev/sda1";
9219 char mountpoint[] = "/";
9222 r = guestfs_mount (g, device, mountpoint);
9226 /* TestOutput for command (7) */
9227 char expected[] = "\n";
9229 char remotefilename[] = "/test-command";
9232 r = guestfs_upload (g, "test-command", remotefilename);
9237 char path[] = "/test-command";
9240 r = guestfs_chmod (g, 493, path);
9245 char arguments_0[] = "/test-command";
9246 char arguments_1[] = "8";
9247 char *arguments[] = {
9254 r = guestfs_command (g, arguments);
9257 if (strcmp (r, expected) != 0) {
9258 fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
9266 static int test_command_8_skip (void)
9270 str = getenv ("SKIP_TEST_COMMAND_8");
9271 if (str && strcmp (str, "1") == 0) return 1;
9272 str = getenv ("SKIP_TEST_COMMAND");
9273 if (str && strcmp (str, "1") == 0) return 1;
9277 static int test_command_8 (void)
9279 if (test_command_8_skip ()) {
9280 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_8");
9284 /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
9286 char device[] = "/dev/sda";
9289 r = guestfs_blockdev_setrw (g, device);
9296 r = guestfs_umount_all (g);
9303 r = guestfs_lvm_remove_all (g);
9308 char device[] = "/dev/sda";
9309 char lines_0[] = ",";
9316 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9321 char fstype[] = "ext2";
9322 char device[] = "/dev/sda1";
9325 r = guestfs_mkfs (g, fstype, device);
9330 char device[] = "/dev/sda1";
9331 char mountpoint[] = "/";
9334 r = guestfs_mount (g, device, mountpoint);
9338 /* TestOutput for command (8) */
9339 char expected[] = "\n\n";
9341 char remotefilename[] = "/test-command";
9344 r = guestfs_upload (g, "test-command", remotefilename);
9349 char path[] = "/test-command";
9352 r = guestfs_chmod (g, 493, path);
9357 char arguments_0[] = "/test-command";
9358 char arguments_1[] = "9";
9359 char *arguments[] = {
9366 r = guestfs_command (g, arguments);
9369 if (strcmp (r, expected) != 0) {
9370 fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
9378 static int test_command_9_skip (void)
9382 str = getenv ("SKIP_TEST_COMMAND_9");
9383 if (str && strcmp (str, "1") == 0) return 1;
9384 str = getenv ("SKIP_TEST_COMMAND");
9385 if (str && strcmp (str, "1") == 0) return 1;
9389 static int test_command_9 (void)
9391 if (test_command_9_skip ()) {
9392 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_9");
9396 /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
9398 char device[] = "/dev/sda";
9401 r = guestfs_blockdev_setrw (g, device);
9408 r = guestfs_umount_all (g);
9415 r = guestfs_lvm_remove_all (g);
9420 char device[] = "/dev/sda";
9421 char lines_0[] = ",";
9428 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9433 char fstype[] = "ext2";
9434 char device[] = "/dev/sda1";
9437 r = guestfs_mkfs (g, fstype, device);
9442 char device[] = "/dev/sda1";
9443 char mountpoint[] = "/";
9446 r = guestfs_mount (g, device, mountpoint);
9450 /* TestOutput for command (9) */
9451 char expected[] = "Result10-1\nResult10-2\n";
9453 char remotefilename[] = "/test-command";
9456 r = guestfs_upload (g, "test-command", remotefilename);
9461 char path[] = "/test-command";
9464 r = guestfs_chmod (g, 493, path);
9469 char arguments_0[] = "/test-command";
9470 char arguments_1[] = "10";
9471 char *arguments[] = {
9478 r = guestfs_command (g, arguments);
9481 if (strcmp (r, expected) != 0) {
9482 fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
9490 static int test_command_10_skip (void)
9494 str = getenv ("SKIP_TEST_COMMAND_10");
9495 if (str && strcmp (str, "1") == 0) return 1;
9496 str = getenv ("SKIP_TEST_COMMAND");
9497 if (str && strcmp (str, "1") == 0) return 1;
9501 static int test_command_10 (void)
9503 if (test_command_10_skip ()) {
9504 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_10");
9508 /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
9510 char device[] = "/dev/sda";
9513 r = guestfs_blockdev_setrw (g, device);
9520 r = guestfs_umount_all (g);
9527 r = guestfs_lvm_remove_all (g);
9532 char device[] = "/dev/sda";
9533 char lines_0[] = ",";
9540 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9545 char fstype[] = "ext2";
9546 char device[] = "/dev/sda1";
9549 r = guestfs_mkfs (g, fstype, device);
9554 char device[] = "/dev/sda1";
9555 char mountpoint[] = "/";
9558 r = guestfs_mount (g, device, mountpoint);
9562 /* TestOutput for command (10) */
9563 char expected[] = "Result11-1\nResult11-2";
9565 char remotefilename[] = "/test-command";
9568 r = guestfs_upload (g, "test-command", remotefilename);
9573 char path[] = "/test-command";
9576 r = guestfs_chmod (g, 493, path);
9581 char arguments_0[] = "/test-command";
9582 char arguments_1[] = "11";
9583 char *arguments[] = {
9590 r = guestfs_command (g, arguments);
9593 if (strcmp (r, expected) != 0) {
9594 fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
9602 static int test_command_11_skip (void)
9606 str = getenv ("SKIP_TEST_COMMAND_11");
9607 if (str && strcmp (str, "1") == 0) return 1;
9608 str = getenv ("SKIP_TEST_COMMAND");
9609 if (str && strcmp (str, "1") == 0) return 1;
9613 static int test_command_11 (void)
9615 if (test_command_11_skip ()) {
9616 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_11");
9620 /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
9622 char device[] = "/dev/sda";
9625 r = guestfs_blockdev_setrw (g, device);
9632 r = guestfs_umount_all (g);
9639 r = guestfs_lvm_remove_all (g);
9644 char device[] = "/dev/sda";
9645 char lines_0[] = ",";
9652 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9657 char fstype[] = "ext2";
9658 char device[] = "/dev/sda1";
9661 r = guestfs_mkfs (g, fstype, device);
9666 char device[] = "/dev/sda1";
9667 char mountpoint[] = "/";
9670 r = guestfs_mount (g, device, mountpoint);
9674 /* TestLastFail for command (11) */
9676 char remotefilename[] = "/test-command";
9679 r = guestfs_upload (g, "test-command", remotefilename);
9684 char path[] = "/test-command";
9687 r = guestfs_chmod (g, 493, path);
9692 char arguments_0[] = "/test-command";
9693 char *arguments[] = {
9699 r = guestfs_command (g, arguments);
9707 static int test_file_0_skip (void)
9711 str = getenv ("SKIP_TEST_FILE_0");
9712 if (str && strcmp (str, "1") == 0) return 1;
9713 str = getenv ("SKIP_TEST_FILE");
9714 if (str && strcmp (str, "1") == 0) return 1;
9718 static int test_file_0 (void)
9720 if (test_file_0_skip ()) {
9721 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_0");
9725 /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
9727 char device[] = "/dev/sda";
9730 r = guestfs_blockdev_setrw (g, device);
9737 r = guestfs_umount_all (g);
9744 r = guestfs_lvm_remove_all (g);
9749 char device[] = "/dev/sda";
9750 char lines_0[] = ",";
9757 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9762 char fstype[] = "ext2";
9763 char device[] = "/dev/sda1";
9766 r = guestfs_mkfs (g, fstype, device);
9771 char device[] = "/dev/sda1";
9772 char mountpoint[] = "/";
9775 r = guestfs_mount (g, device, mountpoint);
9779 /* TestOutput for file (0) */
9780 char expected[] = "empty";
9782 char path[] = "/new";
9785 r = guestfs_touch (g, path);
9790 char path[] = "/new";
9793 r = guestfs_file (g, path);
9796 if (strcmp (r, expected) != 0) {
9797 fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
9805 static int test_file_1_skip (void)
9809 str = getenv ("SKIP_TEST_FILE_1");
9810 if (str && strcmp (str, "1") == 0) return 1;
9811 str = getenv ("SKIP_TEST_FILE");
9812 if (str && strcmp (str, "1") == 0) return 1;
9816 static int test_file_1 (void)
9818 if (test_file_1_skip ()) {
9819 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_1");
9823 /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
9825 char device[] = "/dev/sda";
9828 r = guestfs_blockdev_setrw (g, device);
9835 r = guestfs_umount_all (g);
9842 r = guestfs_lvm_remove_all (g);
9847 char device[] = "/dev/sda";
9848 char lines_0[] = ",";
9855 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9860 char fstype[] = "ext2";
9861 char device[] = "/dev/sda1";
9864 r = guestfs_mkfs (g, fstype, device);
9869 char device[] = "/dev/sda1";
9870 char mountpoint[] = "/";
9873 r = guestfs_mount (g, device, mountpoint);
9877 /* TestOutput for file (1) */
9878 char expected[] = "ASCII text";
9880 char path[] = "/new";
9881 char content[] = "some content\n";
9884 r = guestfs_write_file (g, path, content, 0);
9889 char path[] = "/new";
9892 r = guestfs_file (g, path);
9895 if (strcmp (r, expected) != 0) {
9896 fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
9904 static int test_file_2_skip (void)
9908 str = getenv ("SKIP_TEST_FILE_2");
9909 if (str && strcmp (str, "1") == 0) return 1;
9910 str = getenv ("SKIP_TEST_FILE");
9911 if (str && strcmp (str, "1") == 0) return 1;
9915 static int test_file_2 (void)
9917 if (test_file_2_skip ()) {
9918 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_2");
9922 /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
9924 char device[] = "/dev/sda";
9927 r = guestfs_blockdev_setrw (g, device);
9934 r = guestfs_umount_all (g);
9941 r = guestfs_lvm_remove_all (g);
9946 char device[] = "/dev/sda";
9947 char lines_0[] = ",";
9954 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9959 char fstype[] = "ext2";
9960 char device[] = "/dev/sda1";
9963 r = guestfs_mkfs (g, fstype, device);
9968 char device[] = "/dev/sda1";
9969 char mountpoint[] = "/";
9972 r = guestfs_mount (g, device, mountpoint);
9976 /* TestLastFail for file (2) */
9978 char path[] = "/nofile";
9981 r = guestfs_file (g, path);
9989 static int test_umount_all_0_skip (void)
9993 str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
9994 if (str && strcmp (str, "1") == 0) return 1;
9995 str = getenv ("SKIP_TEST_UMOUNT_ALL");
9996 if (str && strcmp (str, "1") == 0) return 1;
10000 static int test_umount_all_0 (void)
10002 if (test_umount_all_0_skip ()) {
10003 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_0");
10007 /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
10009 char device[] = "/dev/sda";
10011 suppress_error = 0;
10012 r = guestfs_blockdev_setrw (g, device);
10018 suppress_error = 0;
10019 r = guestfs_umount_all (g);
10025 suppress_error = 0;
10026 r = guestfs_lvm_remove_all (g);
10031 char device[] = "/dev/sda";
10032 char lines_0[] = ",";
10038 suppress_error = 0;
10039 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10044 char fstype[] = "ext2";
10045 char device[] = "/dev/sda1";
10047 suppress_error = 0;
10048 r = guestfs_mkfs (g, fstype, device);
10053 char device[] = "/dev/sda1";
10054 char mountpoint[] = "/";
10056 suppress_error = 0;
10057 r = guestfs_mount (g, device, mountpoint);
10061 /* TestOutputList for umount_all (0) */
10064 suppress_error = 0;
10065 r = guestfs_umount_all (g);
10072 suppress_error = 0;
10073 r = guestfs_mounts (g);
10076 if (r[0] != NULL) {
10077 fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
10081 for (i = 0; r[i] != NULL; ++i)
10088 static int test_umount_all_1_skip (void)
10092 str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
10093 if (str && strcmp (str, "1") == 0) return 1;
10094 str = getenv ("SKIP_TEST_UMOUNT_ALL");
10095 if (str && strcmp (str, "1") == 0) return 1;
10099 static int test_umount_all_1 (void)
10101 if (test_umount_all_1_skip ()) {
10102 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_1");
10106 /* InitNone|InitEmpty for test_umount_all_1 */
10108 char device[] = "/dev/sda";
10110 suppress_error = 0;
10111 r = guestfs_blockdev_setrw (g, device);
10117 suppress_error = 0;
10118 r = guestfs_umount_all (g);
10124 suppress_error = 0;
10125 r = guestfs_lvm_remove_all (g);
10129 /* TestOutputList for umount_all (1) */
10131 char device[] = "/dev/sda";
10132 char lines_0[] = ",10";
10133 char lines_1[] = ",20";
10134 char lines_2[] = ",";
10142 suppress_error = 0;
10143 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10148 char fstype[] = "ext2";
10149 char device[] = "/dev/sda1";
10151 suppress_error = 0;
10152 r = guestfs_mkfs (g, fstype, device);
10157 char fstype[] = "ext2";
10158 char device[] = "/dev/sda2";
10160 suppress_error = 0;
10161 r = guestfs_mkfs (g, fstype, device);
10166 char fstype[] = "ext2";
10167 char device[] = "/dev/sda3";
10169 suppress_error = 0;
10170 r = guestfs_mkfs (g, fstype, device);
10175 char device[] = "/dev/sda1";
10176 char mountpoint[] = "/";
10178 suppress_error = 0;
10179 r = guestfs_mount (g, device, mountpoint);
10184 char path[] = "/mp1";
10186 suppress_error = 0;
10187 r = guestfs_mkdir (g, path);
10192 char device[] = "/dev/sda2";
10193 char mountpoint[] = "/mp1";
10195 suppress_error = 0;
10196 r = guestfs_mount (g, device, mountpoint);
10201 char path[] = "/mp1/mp2";
10203 suppress_error = 0;
10204 r = guestfs_mkdir (g, path);
10209 char device[] = "/dev/sda3";
10210 char mountpoint[] = "/mp1/mp2";
10212 suppress_error = 0;
10213 r = guestfs_mount (g, device, mountpoint);
10218 char path[] = "/mp1/mp2/mp3";
10220 suppress_error = 0;
10221 r = guestfs_mkdir (g, path);
10227 suppress_error = 0;
10228 r = guestfs_umount_all (g);
10235 suppress_error = 0;
10236 r = guestfs_mounts (g);
10239 if (r[0] != NULL) {
10240 fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
10244 for (i = 0; r[i] != NULL; ++i)
10251 static int test_mounts_0_skip (void)
10255 str = getenv ("SKIP_TEST_MOUNTS_0");
10256 if (str && strcmp (str, "1") == 0) return 1;
10257 str = getenv ("SKIP_TEST_MOUNTS");
10258 if (str && strcmp (str, "1") == 0) return 1;
10262 static int test_mounts_0 (void)
10264 if (test_mounts_0_skip ()) {
10265 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mounts_0");
10269 /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
10271 char device[] = "/dev/sda";
10273 suppress_error = 0;
10274 r = guestfs_blockdev_setrw (g, device);
10280 suppress_error = 0;
10281 r = guestfs_umount_all (g);
10287 suppress_error = 0;
10288 r = guestfs_lvm_remove_all (g);
10293 char device[] = "/dev/sda";
10294 char lines_0[] = ",";
10300 suppress_error = 0;
10301 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10306 char fstype[] = "ext2";
10307 char device[] = "/dev/sda1";
10309 suppress_error = 0;
10310 r = guestfs_mkfs (g, fstype, device);
10315 char device[] = "/dev/sda1";
10316 char mountpoint[] = "/";
10318 suppress_error = 0;
10319 r = guestfs_mount (g, device, mountpoint);
10323 /* TestOutputListOfDevices for mounts (0) */
10327 suppress_error = 0;
10328 r = guestfs_mounts (g);
10332 fprintf (stderr, "test_mounts_0: short list returned from command\n");
10337 char expected[] = "/dev/sda1";
10339 if (strcmp (r[0], expected) != 0) {
10340 fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10344 if (r[1] != NULL) {
10345 fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
10349 for (i = 0; r[i] != NULL; ++i)
10356 static int test_umount_0_skip (void)
10360 str = getenv ("SKIP_TEST_UMOUNT_0");
10361 if (str && strcmp (str, "1") == 0) return 1;
10362 str = getenv ("SKIP_TEST_UMOUNT");
10363 if (str && strcmp (str, "1") == 0) return 1;
10367 static int test_umount_0 (void)
10369 if (test_umount_0_skip ()) {
10370 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_0");
10374 /* InitNone|InitEmpty for test_umount_0 */
10376 char device[] = "/dev/sda";
10378 suppress_error = 0;
10379 r = guestfs_blockdev_setrw (g, device);
10385 suppress_error = 0;
10386 r = guestfs_umount_all (g);
10392 suppress_error = 0;
10393 r = guestfs_lvm_remove_all (g);
10397 /* TestOutputListOfDevices for umount (0) */
10399 char device[] = "/dev/sda";
10400 char lines_0[] = ",";
10406 suppress_error = 0;
10407 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10412 char fstype[] = "ext2";
10413 char device[] = "/dev/sda1";
10415 suppress_error = 0;
10416 r = guestfs_mkfs (g, fstype, device);
10421 char device[] = "/dev/sda1";
10422 char mountpoint[] = "/";
10424 suppress_error = 0;
10425 r = guestfs_mount (g, device, mountpoint);
10432 suppress_error = 0;
10433 r = guestfs_mounts (g);
10437 fprintf (stderr, "test_umount_0: short list returned from command\n");
10442 char expected[] = "/dev/sda1";
10444 if (strcmp (r[0], expected) != 0) {
10445 fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10449 if (r[1] != NULL) {
10450 fprintf (stderr, "test_umount_0: extra elements returned from command\n");
10454 for (i = 0; r[i] != NULL; ++i)
10461 static int test_umount_1_skip (void)
10465 str = getenv ("SKIP_TEST_UMOUNT_1");
10466 if (str && strcmp (str, "1") == 0) return 1;
10467 str = getenv ("SKIP_TEST_UMOUNT");
10468 if (str && strcmp (str, "1") == 0) return 1;
10472 static int test_umount_1 (void)
10474 if (test_umount_1_skip ()) {
10475 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_1");
10479 /* InitNone|InitEmpty for test_umount_1 */
10481 char device[] = "/dev/sda";
10483 suppress_error = 0;
10484 r = guestfs_blockdev_setrw (g, device);
10490 suppress_error = 0;
10491 r = guestfs_umount_all (g);
10497 suppress_error = 0;
10498 r = guestfs_lvm_remove_all (g);
10502 /* TestOutputList for umount (1) */
10504 char device[] = "/dev/sda";
10505 char lines_0[] = ",";
10511 suppress_error = 0;
10512 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10517 char fstype[] = "ext2";
10518 char device[] = "/dev/sda1";
10520 suppress_error = 0;
10521 r = guestfs_mkfs (g, fstype, device);
10526 char device[] = "/dev/sda1";
10527 char mountpoint[] = "/";
10529 suppress_error = 0;
10530 r = guestfs_mount (g, device, mountpoint);
10535 char pathordevice[] = "/";
10537 suppress_error = 0;
10538 r = guestfs_umount (g, pathordevice);
10545 suppress_error = 0;
10546 r = guestfs_mounts (g);
10549 if (r[0] != NULL) {
10550 fprintf (stderr, "test_umount_1: extra elements returned from command\n");
10554 for (i = 0; r[i] != NULL; ++i)
10561 static int test_write_file_0_skip (void)
10565 str = getenv ("SKIP_TEST_WRITE_FILE_0");
10566 if (str && strcmp (str, "1") == 0) return 1;
10567 str = getenv ("SKIP_TEST_WRITE_FILE");
10568 if (str && strcmp (str, "1") == 0) return 1;
10572 static int test_write_file_0 (void)
10574 if (test_write_file_0_skip ()) {
10575 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_0");
10579 /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
10581 char device[] = "/dev/sda";
10583 suppress_error = 0;
10584 r = guestfs_blockdev_setrw (g, device);
10590 suppress_error = 0;
10591 r = guestfs_umount_all (g);
10597 suppress_error = 0;
10598 r = guestfs_lvm_remove_all (g);
10603 char device[] = "/dev/sda";
10604 char lines_0[] = ",";
10610 suppress_error = 0;
10611 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10616 char fstype[] = "ext2";
10617 char device[] = "/dev/sda1";
10619 suppress_error = 0;
10620 r = guestfs_mkfs (g, fstype, device);
10625 char device[] = "/dev/sda1";
10626 char mountpoint[] = "/";
10628 suppress_error = 0;
10629 r = guestfs_mount (g, device, mountpoint);
10633 /* TestOutput for write_file (0) */
10634 char expected[] = "new file contents";
10636 char path[] = "/new";
10637 char content[] = "new file contents";
10639 suppress_error = 0;
10640 r = guestfs_write_file (g, path, content, 0);
10645 char path[] = "/new";
10647 suppress_error = 0;
10648 r = guestfs_cat (g, path);
10651 if (strcmp (r, expected) != 0) {
10652 fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
10660 static int test_write_file_1_skip (void)
10664 str = getenv ("SKIP_TEST_WRITE_FILE_1");
10665 if (str && strcmp (str, "1") == 0) return 1;
10666 str = getenv ("SKIP_TEST_WRITE_FILE");
10667 if (str && strcmp (str, "1") == 0) return 1;
10671 static int test_write_file_1 (void)
10673 if (test_write_file_1_skip ()) {
10674 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_1");
10678 /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
10680 char device[] = "/dev/sda";
10682 suppress_error = 0;
10683 r = guestfs_blockdev_setrw (g, device);
10689 suppress_error = 0;
10690 r = guestfs_umount_all (g);
10696 suppress_error = 0;
10697 r = guestfs_lvm_remove_all (g);
10702 char device[] = "/dev/sda";
10703 char lines_0[] = ",";
10709 suppress_error = 0;
10710 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10715 char fstype[] = "ext2";
10716 char device[] = "/dev/sda1";
10718 suppress_error = 0;
10719 r = guestfs_mkfs (g, fstype, device);
10724 char device[] = "/dev/sda1";
10725 char mountpoint[] = "/";
10727 suppress_error = 0;
10728 r = guestfs_mount (g, device, mountpoint);
10732 /* TestOutput for write_file (1) */
10733 char expected[] = "\nnew file contents\n";
10735 char path[] = "/new";
10736 char content[] = "\nnew file contents\n";
10738 suppress_error = 0;
10739 r = guestfs_write_file (g, path, content, 0);
10744 char path[] = "/new";
10746 suppress_error = 0;
10747 r = guestfs_cat (g, path);
10750 if (strcmp (r, expected) != 0) {
10751 fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
10759 static int test_write_file_2_skip (void)
10763 str = getenv ("SKIP_TEST_WRITE_FILE_2");
10764 if (str && strcmp (str, "1") == 0) return 1;
10765 str = getenv ("SKIP_TEST_WRITE_FILE");
10766 if (str && strcmp (str, "1") == 0) return 1;
10770 static int test_write_file_2 (void)
10772 if (test_write_file_2_skip ()) {
10773 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_2");
10777 /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
10779 char device[] = "/dev/sda";
10781 suppress_error = 0;
10782 r = guestfs_blockdev_setrw (g, device);
10788 suppress_error = 0;
10789 r = guestfs_umount_all (g);
10795 suppress_error = 0;
10796 r = guestfs_lvm_remove_all (g);
10801 char device[] = "/dev/sda";
10802 char lines_0[] = ",";
10808 suppress_error = 0;
10809 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10814 char fstype[] = "ext2";
10815 char device[] = "/dev/sda1";
10817 suppress_error = 0;
10818 r = guestfs_mkfs (g, fstype, device);
10823 char device[] = "/dev/sda1";
10824 char mountpoint[] = "/";
10826 suppress_error = 0;
10827 r = guestfs_mount (g, device, mountpoint);
10831 /* TestOutput for write_file (2) */
10832 char expected[] = "\n\n";
10834 char path[] = "/new";
10835 char content[] = "\n\n";
10837 suppress_error = 0;
10838 r = guestfs_write_file (g, path, content, 0);
10843 char path[] = "/new";
10845 suppress_error = 0;
10846 r = guestfs_cat (g, path);
10849 if (strcmp (r, expected) != 0) {
10850 fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
10858 static int test_write_file_3_skip (void)
10862 str = getenv ("SKIP_TEST_WRITE_FILE_3");
10863 if (str && strcmp (str, "1") == 0) return 1;
10864 str = getenv ("SKIP_TEST_WRITE_FILE");
10865 if (str && strcmp (str, "1") == 0) return 1;
10869 static int test_write_file_3 (void)
10871 if (test_write_file_3_skip ()) {
10872 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_3");
10876 /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
10878 char device[] = "/dev/sda";
10880 suppress_error = 0;
10881 r = guestfs_blockdev_setrw (g, device);
10887 suppress_error = 0;
10888 r = guestfs_umount_all (g);
10894 suppress_error = 0;
10895 r = guestfs_lvm_remove_all (g);
10900 char device[] = "/dev/sda";
10901 char lines_0[] = ",";
10907 suppress_error = 0;
10908 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10913 char fstype[] = "ext2";
10914 char device[] = "/dev/sda1";
10916 suppress_error = 0;
10917 r = guestfs_mkfs (g, fstype, device);
10922 char device[] = "/dev/sda1";
10923 char mountpoint[] = "/";
10925 suppress_error = 0;
10926 r = guestfs_mount (g, device, mountpoint);
10930 /* TestOutput for write_file (3) */
10931 char expected[] = "";
10933 char path[] = "/new";
10934 char content[] = "";
10936 suppress_error = 0;
10937 r = guestfs_write_file (g, path, content, 0);
10942 char path[] = "/new";
10944 suppress_error = 0;
10945 r = guestfs_cat (g, path);
10948 if (strcmp (r, expected) != 0) {
10949 fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
10957 static int test_write_file_4_skip (void)
10961 str = getenv ("SKIP_TEST_WRITE_FILE_4");
10962 if (str && strcmp (str, "1") == 0) return 1;
10963 str = getenv ("SKIP_TEST_WRITE_FILE");
10964 if (str && strcmp (str, "1") == 0) return 1;
10968 static int test_write_file_4 (void)
10970 if (test_write_file_4_skip ()) {
10971 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_4");
10975 /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
10977 char device[] = "/dev/sda";
10979 suppress_error = 0;
10980 r = guestfs_blockdev_setrw (g, device);
10986 suppress_error = 0;
10987 r = guestfs_umount_all (g);
10993 suppress_error = 0;
10994 r = guestfs_lvm_remove_all (g);
10999 char device[] = "/dev/sda";
11000 char lines_0[] = ",";
11006 suppress_error = 0;
11007 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11012 char fstype[] = "ext2";
11013 char device[] = "/dev/sda1";
11015 suppress_error = 0;
11016 r = guestfs_mkfs (g, fstype, device);
11021 char device[] = "/dev/sda1";
11022 char mountpoint[] = "/";
11024 suppress_error = 0;
11025 r = guestfs_mount (g, device, mountpoint);
11029 /* TestOutput for write_file (4) */
11030 char expected[] = "\n\n\n";
11032 char path[] = "/new";
11033 char content[] = "\n\n\n";
11035 suppress_error = 0;
11036 r = guestfs_write_file (g, path, content, 0);
11041 char path[] = "/new";
11043 suppress_error = 0;
11044 r = guestfs_cat (g, path);
11047 if (strcmp (r, expected) != 0) {
11048 fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
11056 static int test_write_file_5_skip (void)
11060 str = getenv ("SKIP_TEST_WRITE_FILE_5");
11061 if (str && strcmp (str, "1") == 0) return 1;
11062 str = getenv ("SKIP_TEST_WRITE_FILE");
11063 if (str && strcmp (str, "1") == 0) return 1;
11067 static int test_write_file_5 (void)
11069 if (test_write_file_5_skip ()) {
11070 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_5");
11074 /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
11076 char device[] = "/dev/sda";
11078 suppress_error = 0;
11079 r = guestfs_blockdev_setrw (g, device);
11085 suppress_error = 0;
11086 r = guestfs_umount_all (g);
11092 suppress_error = 0;
11093 r = guestfs_lvm_remove_all (g);
11098 char device[] = "/dev/sda";
11099 char lines_0[] = ",";
11105 suppress_error = 0;
11106 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11111 char fstype[] = "ext2";
11112 char device[] = "/dev/sda1";
11114 suppress_error = 0;
11115 r = guestfs_mkfs (g, fstype, device);
11120 char device[] = "/dev/sda1";
11121 char mountpoint[] = "/";
11123 suppress_error = 0;
11124 r = guestfs_mount (g, device, mountpoint);
11128 /* TestOutput for write_file (5) */
11129 char expected[] = "\n";
11131 char path[] = "/new";
11132 char content[] = "\n";
11134 suppress_error = 0;
11135 r = guestfs_write_file (g, path, content, 0);
11140 char path[] = "/new";
11142 suppress_error = 0;
11143 r = guestfs_cat (g, path);
11146 if (strcmp (r, expected) != 0) {
11147 fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
11155 static int test_mkfs_0_skip (void)
11159 str = getenv ("SKIP_TEST_MKFS_0");
11160 if (str && strcmp (str, "1") == 0) return 1;
11161 str = getenv ("SKIP_TEST_MKFS");
11162 if (str && strcmp (str, "1") == 0) return 1;
11166 static int test_mkfs_0 (void)
11168 if (test_mkfs_0_skip ()) {
11169 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkfs_0");
11173 /* InitNone|InitEmpty for test_mkfs_0 */
11175 char device[] = "/dev/sda";
11177 suppress_error = 0;
11178 r = guestfs_blockdev_setrw (g, device);
11184 suppress_error = 0;
11185 r = guestfs_umount_all (g);
11191 suppress_error = 0;
11192 r = guestfs_lvm_remove_all (g);
11196 /* TestOutput for mkfs (0) */
11197 char expected[] = "new file contents";
11199 char device[] = "/dev/sda";
11200 char lines_0[] = ",";
11206 suppress_error = 0;
11207 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11212 char fstype[] = "ext2";
11213 char device[] = "/dev/sda1";
11215 suppress_error = 0;
11216 r = guestfs_mkfs (g, fstype, device);
11221 char device[] = "/dev/sda1";
11222 char mountpoint[] = "/";
11224 suppress_error = 0;
11225 r = guestfs_mount (g, device, mountpoint);
11230 char path[] = "/new";
11231 char content[] = "new file contents";
11233 suppress_error = 0;
11234 r = guestfs_write_file (g, path, content, 0);
11239 char path[] = "/new";
11241 suppress_error = 0;
11242 r = guestfs_cat (g, path);
11245 if (strcmp (r, expected) != 0) {
11246 fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
11254 static int test_lvcreate_0_skip (void)
11258 str = getenv ("SKIP_TEST_LVCREATE_0");
11259 if (str && strcmp (str, "1") == 0) return 1;
11260 str = getenv ("SKIP_TEST_LVCREATE");
11261 if (str && strcmp (str, "1") == 0) return 1;
11265 static int test_lvcreate_0 (void)
11267 if (test_lvcreate_0_skip ()) {
11268 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvcreate_0");
11272 /* InitNone|InitEmpty for test_lvcreate_0 */
11274 char device[] = "/dev/sda";
11276 suppress_error = 0;
11277 r = guestfs_blockdev_setrw (g, device);
11283 suppress_error = 0;
11284 r = guestfs_umount_all (g);
11290 suppress_error = 0;
11291 r = guestfs_lvm_remove_all (g);
11295 /* TestOutputList for lvcreate (0) */
11297 char device[] = "/dev/sda";
11298 char lines_0[] = ",10";
11299 char lines_1[] = ",20";
11300 char lines_2[] = ",";
11308 suppress_error = 0;
11309 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11314 char device[] = "/dev/sda1";
11316 suppress_error = 0;
11317 r = guestfs_pvcreate (g, device);
11322 char device[] = "/dev/sda2";
11324 suppress_error = 0;
11325 r = guestfs_pvcreate (g, device);
11330 char device[] = "/dev/sda3";
11332 suppress_error = 0;
11333 r = guestfs_pvcreate (g, device);
11338 char volgroup[] = "VG1";
11339 char physvols_0[] = "/dev/sda1";
11340 char physvols_1[] = "/dev/sda2";
11341 char *physvols[] = {
11347 suppress_error = 0;
11348 r = guestfs_vgcreate (g, volgroup, physvols);
11353 char volgroup[] = "VG2";
11354 char physvols_0[] = "/dev/sda3";
11355 char *physvols[] = {
11360 suppress_error = 0;
11361 r = guestfs_vgcreate (g, volgroup, physvols);
11366 char logvol[] = "LV1";
11367 char volgroup[] = "VG1";
11369 suppress_error = 0;
11370 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11375 char logvol[] = "LV2";
11376 char volgroup[] = "VG1";
11378 suppress_error = 0;
11379 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11384 char logvol[] = "LV3";
11385 char volgroup[] = "VG2";
11387 suppress_error = 0;
11388 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11393 char logvol[] = "LV4";
11394 char volgroup[] = "VG2";
11396 suppress_error = 0;
11397 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11402 char logvol[] = "LV5";
11403 char volgroup[] = "VG2";
11405 suppress_error = 0;
11406 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11413 suppress_error = 0;
11414 r = guestfs_lvs (g);
11418 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11423 char expected[] = "/dev/VG1/LV1";
11424 if (strcmp (r[0], expected) != 0) {
11425 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11430 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11435 char expected[] = "/dev/VG1/LV2";
11436 if (strcmp (r[1], expected) != 0) {
11437 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11442 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11447 char expected[] = "/dev/VG2/LV3";
11448 if (strcmp (r[2], expected) != 0) {
11449 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11454 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11459 char expected[] = "/dev/VG2/LV4";
11460 if (strcmp (r[3], expected) != 0) {
11461 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
11466 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11471 char expected[] = "/dev/VG2/LV5";
11472 if (strcmp (r[4], expected) != 0) {
11473 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
11477 if (r[5] != NULL) {
11478 fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
11482 for (i = 0; r[i] != NULL; ++i)
11489 static int test_vgcreate_0_skip (void)
11493 str = getenv ("SKIP_TEST_VGCREATE_0");
11494 if (str && strcmp (str, "1") == 0) return 1;
11495 str = getenv ("SKIP_TEST_VGCREATE");
11496 if (str && strcmp (str, "1") == 0) return 1;
11500 static int test_vgcreate_0 (void)
11502 if (test_vgcreate_0_skip ()) {
11503 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgcreate_0");
11507 /* InitNone|InitEmpty for test_vgcreate_0 */
11509 char device[] = "/dev/sda";
11511 suppress_error = 0;
11512 r = guestfs_blockdev_setrw (g, device);
11518 suppress_error = 0;
11519 r = guestfs_umount_all (g);
11525 suppress_error = 0;
11526 r = guestfs_lvm_remove_all (g);
11530 /* TestOutputList for vgcreate (0) */
11532 char device[] = "/dev/sda";
11533 char lines_0[] = ",10";
11534 char lines_1[] = ",20";
11535 char lines_2[] = ",";
11543 suppress_error = 0;
11544 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11549 char device[] = "/dev/sda1";
11551 suppress_error = 0;
11552 r = guestfs_pvcreate (g, device);
11557 char device[] = "/dev/sda2";
11559 suppress_error = 0;
11560 r = guestfs_pvcreate (g, device);
11565 char device[] = "/dev/sda3";
11567 suppress_error = 0;
11568 r = guestfs_pvcreate (g, device);
11573 char volgroup[] = "VG1";
11574 char physvols_0[] = "/dev/sda1";
11575 char physvols_1[] = "/dev/sda2";
11576 char *physvols[] = {
11582 suppress_error = 0;
11583 r = guestfs_vgcreate (g, volgroup, physvols);
11588 char volgroup[] = "VG2";
11589 char physvols_0[] = "/dev/sda3";
11590 char *physvols[] = {
11595 suppress_error = 0;
11596 r = guestfs_vgcreate (g, volgroup, physvols);
11603 suppress_error = 0;
11604 r = guestfs_vgs (g);
11608 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
11613 char expected[] = "VG1";
11614 if (strcmp (r[0], expected) != 0) {
11615 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11620 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
11625 char expected[] = "VG2";
11626 if (strcmp (r[1], expected) != 0) {
11627 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11631 if (r[2] != NULL) {
11632 fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
11636 for (i = 0; r[i] != NULL; ++i)
11643 static int test_pvcreate_0_skip (void)
11647 str = getenv ("SKIP_TEST_PVCREATE_0");
11648 if (str && strcmp (str, "1") == 0) return 1;
11649 str = getenv ("SKIP_TEST_PVCREATE");
11650 if (str && strcmp (str, "1") == 0) return 1;
11654 static int test_pvcreate_0 (void)
11656 if (test_pvcreate_0_skip ()) {
11657 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvcreate_0");
11661 /* InitNone|InitEmpty for test_pvcreate_0 */
11663 char device[] = "/dev/sda";
11665 suppress_error = 0;
11666 r = guestfs_blockdev_setrw (g, device);
11672 suppress_error = 0;
11673 r = guestfs_umount_all (g);
11679 suppress_error = 0;
11680 r = guestfs_lvm_remove_all (g);
11684 /* TestOutputListOfDevices for pvcreate (0) */
11686 char device[] = "/dev/sda";
11687 char lines_0[] = ",10";
11688 char lines_1[] = ",20";
11689 char lines_2[] = ",";
11697 suppress_error = 0;
11698 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11703 char device[] = "/dev/sda1";
11705 suppress_error = 0;
11706 r = guestfs_pvcreate (g, device);
11711 char device[] = "/dev/sda2";
11713 suppress_error = 0;
11714 r = guestfs_pvcreate (g, device);
11719 char device[] = "/dev/sda3";
11721 suppress_error = 0;
11722 r = guestfs_pvcreate (g, device);
11729 suppress_error = 0;
11730 r = guestfs_pvs (g);
11734 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11739 char expected[] = "/dev/sda1";
11741 if (strcmp (r[0], expected) != 0) {
11742 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11747 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11752 char expected[] = "/dev/sda2";
11754 if (strcmp (r[1], expected) != 0) {
11755 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11760 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11765 char expected[] = "/dev/sda3";
11767 if (strcmp (r[2], expected) != 0) {
11768 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11772 if (r[3] != NULL) {
11773 fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
11777 for (i = 0; r[i] != NULL; ++i)
11784 static int test_is_dir_0_skip (void)
11788 str = getenv ("SKIP_TEST_IS_DIR_0");
11789 if (str && strcmp (str, "1") == 0) return 1;
11790 str = getenv ("SKIP_TEST_IS_DIR");
11791 if (str && strcmp (str, "1") == 0) return 1;
11795 static int test_is_dir_0 (void)
11797 if (test_is_dir_0_skip ()) {
11798 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_0");
11802 /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
11804 char device[] = "/dev/sda";
11806 suppress_error = 0;
11807 r = guestfs_blockdev_setrw (g, device);
11813 suppress_error = 0;
11814 r = guestfs_umount_all (g);
11820 suppress_error = 0;
11821 r = guestfs_lvm_remove_all (g);
11826 char device[] = "/dev/sda";
11827 char lines_0[] = ",";
11833 suppress_error = 0;
11834 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11839 char fstype[] = "ext2";
11840 char device[] = "/dev/sda1";
11842 suppress_error = 0;
11843 r = guestfs_mkfs (g, fstype, device);
11848 char device[] = "/dev/sda1";
11849 char mountpoint[] = "/";
11851 suppress_error = 0;
11852 r = guestfs_mount (g, device, mountpoint);
11856 /* TestOutputFalse for is_dir (0) */
11858 char path[] = "/new";
11860 suppress_error = 0;
11861 r = guestfs_touch (g, path);
11866 char path[] = "/new";
11868 suppress_error = 0;
11869 r = guestfs_is_dir (g, path);
11873 fprintf (stderr, "test_is_dir_0: expected false, got true\n");
11880 static int test_is_dir_1_skip (void)
11884 str = getenv ("SKIP_TEST_IS_DIR_1");
11885 if (str && strcmp (str, "1") == 0) return 1;
11886 str = getenv ("SKIP_TEST_IS_DIR");
11887 if (str && strcmp (str, "1") == 0) return 1;
11891 static int test_is_dir_1 (void)
11893 if (test_is_dir_1_skip ()) {
11894 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_1");
11898 /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
11900 char device[] = "/dev/sda";
11902 suppress_error = 0;
11903 r = guestfs_blockdev_setrw (g, device);
11909 suppress_error = 0;
11910 r = guestfs_umount_all (g);
11916 suppress_error = 0;
11917 r = guestfs_lvm_remove_all (g);
11922 char device[] = "/dev/sda";
11923 char lines_0[] = ",";
11929 suppress_error = 0;
11930 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11935 char fstype[] = "ext2";
11936 char device[] = "/dev/sda1";
11938 suppress_error = 0;
11939 r = guestfs_mkfs (g, fstype, device);
11944 char device[] = "/dev/sda1";
11945 char mountpoint[] = "/";
11947 suppress_error = 0;
11948 r = guestfs_mount (g, device, mountpoint);
11952 /* TestOutputTrue for is_dir (1) */
11954 char path[] = "/new";
11956 suppress_error = 0;
11957 r = guestfs_mkdir (g, path);
11962 char path[] = "/new";
11964 suppress_error = 0;
11965 r = guestfs_is_dir (g, path);
11969 fprintf (stderr, "test_is_dir_1: expected true, got false\n");
11976 static int test_is_file_0_skip (void)
11980 str = getenv ("SKIP_TEST_IS_FILE_0");
11981 if (str && strcmp (str, "1") == 0) return 1;
11982 str = getenv ("SKIP_TEST_IS_FILE");
11983 if (str && strcmp (str, "1") == 0) return 1;
11987 static int test_is_file_0 (void)
11989 if (test_is_file_0_skip ()) {
11990 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_0");
11994 /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
11996 char device[] = "/dev/sda";
11998 suppress_error = 0;
11999 r = guestfs_blockdev_setrw (g, device);
12005 suppress_error = 0;
12006 r = guestfs_umount_all (g);
12012 suppress_error = 0;
12013 r = guestfs_lvm_remove_all (g);
12018 char device[] = "/dev/sda";
12019 char lines_0[] = ",";
12025 suppress_error = 0;
12026 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12031 char fstype[] = "ext2";
12032 char device[] = "/dev/sda1";
12034 suppress_error = 0;
12035 r = guestfs_mkfs (g, fstype, device);
12040 char device[] = "/dev/sda1";
12041 char mountpoint[] = "/";
12043 suppress_error = 0;
12044 r = guestfs_mount (g, device, mountpoint);
12048 /* TestOutputTrue for is_file (0) */
12050 char path[] = "/new";
12052 suppress_error = 0;
12053 r = guestfs_touch (g, path);
12058 char path[] = "/new";
12060 suppress_error = 0;
12061 r = guestfs_is_file (g, path);
12065 fprintf (stderr, "test_is_file_0: expected true, got false\n");
12072 static int test_is_file_1_skip (void)
12076 str = getenv ("SKIP_TEST_IS_FILE_1");
12077 if (str && strcmp (str, "1") == 0) return 1;
12078 str = getenv ("SKIP_TEST_IS_FILE");
12079 if (str && strcmp (str, "1") == 0) return 1;
12083 static int test_is_file_1 (void)
12085 if (test_is_file_1_skip ()) {
12086 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_1");
12090 /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
12092 char device[] = "/dev/sda";
12094 suppress_error = 0;
12095 r = guestfs_blockdev_setrw (g, device);
12101 suppress_error = 0;
12102 r = guestfs_umount_all (g);
12108 suppress_error = 0;
12109 r = guestfs_lvm_remove_all (g);
12114 char device[] = "/dev/sda";
12115 char lines_0[] = ",";
12121 suppress_error = 0;
12122 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12127 char fstype[] = "ext2";
12128 char device[] = "/dev/sda1";
12130 suppress_error = 0;
12131 r = guestfs_mkfs (g, fstype, device);
12136 char device[] = "/dev/sda1";
12137 char mountpoint[] = "/";
12139 suppress_error = 0;
12140 r = guestfs_mount (g, device, mountpoint);
12144 /* TestOutputFalse for is_file (1) */
12146 char path[] = "/new";
12148 suppress_error = 0;
12149 r = guestfs_mkdir (g, path);
12154 char path[] = "/new";
12156 suppress_error = 0;
12157 r = guestfs_is_file (g, path);
12161 fprintf (stderr, "test_is_file_1: expected false, got true\n");
12168 static int test_exists_0_skip (void)
12172 str = getenv ("SKIP_TEST_EXISTS_0");
12173 if (str && strcmp (str, "1") == 0) return 1;
12174 str = getenv ("SKIP_TEST_EXISTS");
12175 if (str && strcmp (str, "1") == 0) return 1;
12179 static int test_exists_0 (void)
12181 if (test_exists_0_skip ()) {
12182 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_0");
12186 /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
12188 char device[] = "/dev/sda";
12190 suppress_error = 0;
12191 r = guestfs_blockdev_setrw (g, device);
12197 suppress_error = 0;
12198 r = guestfs_umount_all (g);
12204 suppress_error = 0;
12205 r = guestfs_lvm_remove_all (g);
12210 char device[] = "/dev/sda";
12211 char lines_0[] = ",";
12217 suppress_error = 0;
12218 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12223 char fstype[] = "ext2";
12224 char device[] = "/dev/sda1";
12226 suppress_error = 0;
12227 r = guestfs_mkfs (g, fstype, device);
12232 char device[] = "/dev/sda1";
12233 char mountpoint[] = "/";
12235 suppress_error = 0;
12236 r = guestfs_mount (g, device, mountpoint);
12240 /* TestOutputTrue for exists (0) */
12242 char path[] = "/new";
12244 suppress_error = 0;
12245 r = guestfs_touch (g, path);
12250 char path[] = "/new";
12252 suppress_error = 0;
12253 r = guestfs_exists (g, path);
12257 fprintf (stderr, "test_exists_0: expected true, got false\n");
12264 static int test_exists_1_skip (void)
12268 str = getenv ("SKIP_TEST_EXISTS_1");
12269 if (str && strcmp (str, "1") == 0) return 1;
12270 str = getenv ("SKIP_TEST_EXISTS");
12271 if (str && strcmp (str, "1") == 0) return 1;
12275 static int test_exists_1 (void)
12277 if (test_exists_1_skip ()) {
12278 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_1");
12282 /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
12284 char device[] = "/dev/sda";
12286 suppress_error = 0;
12287 r = guestfs_blockdev_setrw (g, device);
12293 suppress_error = 0;
12294 r = guestfs_umount_all (g);
12300 suppress_error = 0;
12301 r = guestfs_lvm_remove_all (g);
12306 char device[] = "/dev/sda";
12307 char lines_0[] = ",";
12313 suppress_error = 0;
12314 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12319 char fstype[] = "ext2";
12320 char device[] = "/dev/sda1";
12322 suppress_error = 0;
12323 r = guestfs_mkfs (g, fstype, device);
12328 char device[] = "/dev/sda1";
12329 char mountpoint[] = "/";
12331 suppress_error = 0;
12332 r = guestfs_mount (g, device, mountpoint);
12336 /* TestOutputTrue for exists (1) */
12338 char path[] = "/new";
12340 suppress_error = 0;
12341 r = guestfs_mkdir (g, path);
12346 char path[] = "/new";
12348 suppress_error = 0;
12349 r = guestfs_exists (g, path);
12353 fprintf (stderr, "test_exists_1: expected true, got false\n");
12360 static int test_mkdir_p_0_skip (void)
12364 str = getenv ("SKIP_TEST_MKDIR_P_0");
12365 if (str && strcmp (str, "1") == 0) return 1;
12366 str = getenv ("SKIP_TEST_MKDIR_P");
12367 if (str && strcmp (str, "1") == 0) return 1;
12371 static int test_mkdir_p_0 (void)
12373 if (test_mkdir_p_0_skip ()) {
12374 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_0");
12378 /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
12380 char device[] = "/dev/sda";
12382 suppress_error = 0;
12383 r = guestfs_blockdev_setrw (g, device);
12389 suppress_error = 0;
12390 r = guestfs_umount_all (g);
12396 suppress_error = 0;
12397 r = guestfs_lvm_remove_all (g);
12402 char device[] = "/dev/sda";
12403 char lines_0[] = ",";
12409 suppress_error = 0;
12410 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12415 char fstype[] = "ext2";
12416 char device[] = "/dev/sda1";
12418 suppress_error = 0;
12419 r = guestfs_mkfs (g, fstype, device);
12424 char device[] = "/dev/sda1";
12425 char mountpoint[] = "/";
12427 suppress_error = 0;
12428 r = guestfs_mount (g, device, mountpoint);
12432 /* TestOutputTrue for mkdir_p (0) */
12434 char path[] = "/new/foo/bar";
12436 suppress_error = 0;
12437 r = guestfs_mkdir_p (g, path);
12442 char path[] = "/new/foo/bar";
12444 suppress_error = 0;
12445 r = guestfs_is_dir (g, path);
12449 fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
12456 static int test_mkdir_p_1_skip (void)
12460 str = getenv ("SKIP_TEST_MKDIR_P_1");
12461 if (str && strcmp (str, "1") == 0) return 1;
12462 str = getenv ("SKIP_TEST_MKDIR_P");
12463 if (str && strcmp (str, "1") == 0) return 1;
12467 static int test_mkdir_p_1 (void)
12469 if (test_mkdir_p_1_skip ()) {
12470 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_1");
12474 /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
12476 char device[] = "/dev/sda";
12478 suppress_error = 0;
12479 r = guestfs_blockdev_setrw (g, device);
12485 suppress_error = 0;
12486 r = guestfs_umount_all (g);
12492 suppress_error = 0;
12493 r = guestfs_lvm_remove_all (g);
12498 char device[] = "/dev/sda";
12499 char lines_0[] = ",";
12505 suppress_error = 0;
12506 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12511 char fstype[] = "ext2";
12512 char device[] = "/dev/sda1";
12514 suppress_error = 0;
12515 r = guestfs_mkfs (g, fstype, device);
12520 char device[] = "/dev/sda1";
12521 char mountpoint[] = "/";
12523 suppress_error = 0;
12524 r = guestfs_mount (g, device, mountpoint);
12528 /* TestOutputTrue for mkdir_p (1) */
12530 char path[] = "/new/foo/bar";
12532 suppress_error = 0;
12533 r = guestfs_mkdir_p (g, path);
12538 char path[] = "/new/foo";
12540 suppress_error = 0;
12541 r = guestfs_is_dir (g, path);
12545 fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
12552 static int test_mkdir_p_2_skip (void)
12556 str = getenv ("SKIP_TEST_MKDIR_P_2");
12557 if (str && strcmp (str, "1") == 0) return 1;
12558 str = getenv ("SKIP_TEST_MKDIR_P");
12559 if (str && strcmp (str, "1") == 0) return 1;
12563 static int test_mkdir_p_2 (void)
12565 if (test_mkdir_p_2_skip ()) {
12566 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_2");
12570 /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
12572 char device[] = "/dev/sda";
12574 suppress_error = 0;
12575 r = guestfs_blockdev_setrw (g, device);
12581 suppress_error = 0;
12582 r = guestfs_umount_all (g);
12588 suppress_error = 0;
12589 r = guestfs_lvm_remove_all (g);
12594 char device[] = "/dev/sda";
12595 char lines_0[] = ",";
12601 suppress_error = 0;
12602 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12607 char fstype[] = "ext2";
12608 char device[] = "/dev/sda1";
12610 suppress_error = 0;
12611 r = guestfs_mkfs (g, fstype, device);
12616 char device[] = "/dev/sda1";
12617 char mountpoint[] = "/";
12619 suppress_error = 0;
12620 r = guestfs_mount (g, device, mountpoint);
12624 /* TestOutputTrue for mkdir_p (2) */
12626 char path[] = "/new/foo/bar";
12628 suppress_error = 0;
12629 r = guestfs_mkdir_p (g, path);
12634 char path[] = "/new";
12636 suppress_error = 0;
12637 r = guestfs_is_dir (g, path);
12641 fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
12648 static int test_mkdir_p_3_skip (void)
12652 str = getenv ("SKIP_TEST_MKDIR_P_3");
12653 if (str && strcmp (str, "1") == 0) return 1;
12654 str = getenv ("SKIP_TEST_MKDIR_P");
12655 if (str && strcmp (str, "1") == 0) return 1;
12659 static int test_mkdir_p_3 (void)
12661 if (test_mkdir_p_3_skip ()) {
12662 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_3");
12666 /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
12668 char device[] = "/dev/sda";
12670 suppress_error = 0;
12671 r = guestfs_blockdev_setrw (g, device);
12677 suppress_error = 0;
12678 r = guestfs_umount_all (g);
12684 suppress_error = 0;
12685 r = guestfs_lvm_remove_all (g);
12690 char device[] = "/dev/sda";
12691 char lines_0[] = ",";
12697 suppress_error = 0;
12698 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12703 char fstype[] = "ext2";
12704 char device[] = "/dev/sda1";
12706 suppress_error = 0;
12707 r = guestfs_mkfs (g, fstype, device);
12712 char device[] = "/dev/sda1";
12713 char mountpoint[] = "/";
12715 suppress_error = 0;
12716 r = guestfs_mount (g, device, mountpoint);
12720 /* TestRun for mkdir_p (3) */
12722 char path[] = "/new";
12724 suppress_error = 0;
12725 r = guestfs_mkdir (g, path);
12730 char path[] = "/new";
12732 suppress_error = 0;
12733 r = guestfs_mkdir_p (g, path);
12740 static int test_mkdir_p_4_skip (void)
12744 str = getenv ("SKIP_TEST_MKDIR_P_4");
12745 if (str && strcmp (str, "1") == 0) return 1;
12746 str = getenv ("SKIP_TEST_MKDIR_P");
12747 if (str && strcmp (str, "1") == 0) return 1;
12751 static int test_mkdir_p_4 (void)
12753 if (test_mkdir_p_4_skip ()) {
12754 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_4");
12758 /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
12760 char device[] = "/dev/sda";
12762 suppress_error = 0;
12763 r = guestfs_blockdev_setrw (g, device);
12769 suppress_error = 0;
12770 r = guestfs_umount_all (g);
12776 suppress_error = 0;
12777 r = guestfs_lvm_remove_all (g);
12782 char device[] = "/dev/sda";
12783 char lines_0[] = ",";
12789 suppress_error = 0;
12790 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12795 char fstype[] = "ext2";
12796 char device[] = "/dev/sda1";
12798 suppress_error = 0;
12799 r = guestfs_mkfs (g, fstype, device);
12804 char device[] = "/dev/sda1";
12805 char mountpoint[] = "/";
12807 suppress_error = 0;
12808 r = guestfs_mount (g, device, mountpoint);
12812 /* TestLastFail for mkdir_p (4) */
12814 char path[] = "/new";
12816 suppress_error = 0;
12817 r = guestfs_touch (g, path);
12822 char path[] = "/new";
12824 suppress_error = 1;
12825 r = guestfs_mkdir_p (g, path);
12832 static int test_mkdir_0_skip (void)
12836 str = getenv ("SKIP_TEST_MKDIR_0");
12837 if (str && strcmp (str, "1") == 0) return 1;
12838 str = getenv ("SKIP_TEST_MKDIR");
12839 if (str && strcmp (str, "1") == 0) return 1;
12843 static int test_mkdir_0 (void)
12845 if (test_mkdir_0_skip ()) {
12846 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_0");
12850 /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
12852 char device[] = "/dev/sda";
12854 suppress_error = 0;
12855 r = guestfs_blockdev_setrw (g, device);
12861 suppress_error = 0;
12862 r = guestfs_umount_all (g);
12868 suppress_error = 0;
12869 r = guestfs_lvm_remove_all (g);
12874 char device[] = "/dev/sda";
12875 char lines_0[] = ",";
12881 suppress_error = 0;
12882 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12887 char fstype[] = "ext2";
12888 char device[] = "/dev/sda1";
12890 suppress_error = 0;
12891 r = guestfs_mkfs (g, fstype, device);
12896 char device[] = "/dev/sda1";
12897 char mountpoint[] = "/";
12899 suppress_error = 0;
12900 r = guestfs_mount (g, device, mountpoint);
12904 /* TestOutputTrue for mkdir (0) */
12906 char path[] = "/new";
12908 suppress_error = 0;
12909 r = guestfs_mkdir (g, path);
12914 char path[] = "/new";
12916 suppress_error = 0;
12917 r = guestfs_is_dir (g, path);
12921 fprintf (stderr, "test_mkdir_0: expected true, got false\n");
12928 static int test_mkdir_1_skip (void)
12932 str = getenv ("SKIP_TEST_MKDIR_1");
12933 if (str && strcmp (str, "1") == 0) return 1;
12934 str = getenv ("SKIP_TEST_MKDIR");
12935 if (str && strcmp (str, "1") == 0) return 1;
12939 static int test_mkdir_1 (void)
12941 if (test_mkdir_1_skip ()) {
12942 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_1");
12946 /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
12948 char device[] = "/dev/sda";
12950 suppress_error = 0;
12951 r = guestfs_blockdev_setrw (g, device);
12957 suppress_error = 0;
12958 r = guestfs_umount_all (g);
12964 suppress_error = 0;
12965 r = guestfs_lvm_remove_all (g);
12970 char device[] = "/dev/sda";
12971 char lines_0[] = ",";
12977 suppress_error = 0;
12978 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12983 char fstype[] = "ext2";
12984 char device[] = "/dev/sda1";
12986 suppress_error = 0;
12987 r = guestfs_mkfs (g, fstype, device);
12992 char device[] = "/dev/sda1";
12993 char mountpoint[] = "/";
12995 suppress_error = 0;
12996 r = guestfs_mount (g, device, mountpoint);
13000 /* TestLastFail for mkdir (1) */
13002 char path[] = "/new/foo/bar";
13004 suppress_error = 1;
13005 r = guestfs_mkdir (g, path);
13012 static int test_rm_rf_0_skip (void)
13016 str = getenv ("SKIP_TEST_RM_RF_0");
13017 if (str && strcmp (str, "1") == 0) return 1;
13018 str = getenv ("SKIP_TEST_RM_RF");
13019 if (str && strcmp (str, "1") == 0) return 1;
13023 static int test_rm_rf_0 (void)
13025 if (test_rm_rf_0_skip ()) {
13026 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_rf_0");
13030 /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
13032 char device[] = "/dev/sda";
13034 suppress_error = 0;
13035 r = guestfs_blockdev_setrw (g, device);
13041 suppress_error = 0;
13042 r = guestfs_umount_all (g);
13048 suppress_error = 0;
13049 r = guestfs_lvm_remove_all (g);
13054 char device[] = "/dev/sda";
13055 char lines_0[] = ",";
13061 suppress_error = 0;
13062 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13067 char fstype[] = "ext2";
13068 char device[] = "/dev/sda1";
13070 suppress_error = 0;
13071 r = guestfs_mkfs (g, fstype, device);
13076 char device[] = "/dev/sda1";
13077 char mountpoint[] = "/";
13079 suppress_error = 0;
13080 r = guestfs_mount (g, device, mountpoint);
13084 /* TestOutputFalse for rm_rf (0) */
13086 char path[] = "/new";
13088 suppress_error = 0;
13089 r = guestfs_mkdir (g, path);
13094 char path[] = "/new/foo";
13096 suppress_error = 0;
13097 r = guestfs_mkdir (g, path);
13102 char path[] = "/new/foo/bar";
13104 suppress_error = 0;
13105 r = guestfs_touch (g, path);
13110 char path[] = "/new";
13112 suppress_error = 0;
13113 r = guestfs_rm_rf (g, path);
13118 char path[] = "/new";
13120 suppress_error = 0;
13121 r = guestfs_exists (g, path);
13125 fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
13132 static int test_rmdir_0_skip (void)
13136 str = getenv ("SKIP_TEST_RMDIR_0");
13137 if (str && strcmp (str, "1") == 0) return 1;
13138 str = getenv ("SKIP_TEST_RMDIR");
13139 if (str && strcmp (str, "1") == 0) return 1;
13143 static int test_rmdir_0 (void)
13145 if (test_rmdir_0_skip ()) {
13146 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_0");
13150 /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
13152 char device[] = "/dev/sda";
13154 suppress_error = 0;
13155 r = guestfs_blockdev_setrw (g, device);
13161 suppress_error = 0;
13162 r = guestfs_umount_all (g);
13168 suppress_error = 0;
13169 r = guestfs_lvm_remove_all (g);
13174 char device[] = "/dev/sda";
13175 char lines_0[] = ",";
13181 suppress_error = 0;
13182 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13187 char fstype[] = "ext2";
13188 char device[] = "/dev/sda1";
13190 suppress_error = 0;
13191 r = guestfs_mkfs (g, fstype, device);
13196 char device[] = "/dev/sda1";
13197 char mountpoint[] = "/";
13199 suppress_error = 0;
13200 r = guestfs_mount (g, device, mountpoint);
13204 /* TestRun for rmdir (0) */
13206 char path[] = "/new";
13208 suppress_error = 0;
13209 r = guestfs_mkdir (g, path);
13214 char path[] = "/new";
13216 suppress_error = 0;
13217 r = guestfs_rmdir (g, path);
13224 static int test_rmdir_1_skip (void)
13228 str = getenv ("SKIP_TEST_RMDIR_1");
13229 if (str && strcmp (str, "1") == 0) return 1;
13230 str = getenv ("SKIP_TEST_RMDIR");
13231 if (str && strcmp (str, "1") == 0) return 1;
13235 static int test_rmdir_1 (void)
13237 if (test_rmdir_1_skip ()) {
13238 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_1");
13242 /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
13244 char device[] = "/dev/sda";
13246 suppress_error = 0;
13247 r = guestfs_blockdev_setrw (g, device);
13253 suppress_error = 0;
13254 r = guestfs_umount_all (g);
13260 suppress_error = 0;
13261 r = guestfs_lvm_remove_all (g);
13266 char device[] = "/dev/sda";
13267 char lines_0[] = ",";
13273 suppress_error = 0;
13274 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13279 char fstype[] = "ext2";
13280 char device[] = "/dev/sda1";
13282 suppress_error = 0;
13283 r = guestfs_mkfs (g, fstype, device);
13288 char device[] = "/dev/sda1";
13289 char mountpoint[] = "/";
13291 suppress_error = 0;
13292 r = guestfs_mount (g, device, mountpoint);
13296 /* TestLastFail for rmdir (1) */
13298 char path[] = "/new";
13300 suppress_error = 1;
13301 r = guestfs_rmdir (g, path);
13308 static int test_rmdir_2_skip (void)
13312 str = getenv ("SKIP_TEST_RMDIR_2");
13313 if (str && strcmp (str, "1") == 0) return 1;
13314 str = getenv ("SKIP_TEST_RMDIR");
13315 if (str && strcmp (str, "1") == 0) return 1;
13319 static int test_rmdir_2 (void)
13321 if (test_rmdir_2_skip ()) {
13322 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_2");
13326 /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
13328 char device[] = "/dev/sda";
13330 suppress_error = 0;
13331 r = guestfs_blockdev_setrw (g, device);
13337 suppress_error = 0;
13338 r = guestfs_umount_all (g);
13344 suppress_error = 0;
13345 r = guestfs_lvm_remove_all (g);
13350 char device[] = "/dev/sda";
13351 char lines_0[] = ",";
13357 suppress_error = 0;
13358 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13363 char fstype[] = "ext2";
13364 char device[] = "/dev/sda1";
13366 suppress_error = 0;
13367 r = guestfs_mkfs (g, fstype, device);
13372 char device[] = "/dev/sda1";
13373 char mountpoint[] = "/";
13375 suppress_error = 0;
13376 r = guestfs_mount (g, device, mountpoint);
13380 /* TestLastFail for rmdir (2) */
13382 char path[] = "/new";
13384 suppress_error = 0;
13385 r = guestfs_touch (g, path);
13390 char path[] = "/new";
13392 suppress_error = 1;
13393 r = guestfs_rmdir (g, path);
13400 static int test_rm_0_skip (void)
13404 str = getenv ("SKIP_TEST_RM_0");
13405 if (str && strcmp (str, "1") == 0) return 1;
13406 str = getenv ("SKIP_TEST_RM");
13407 if (str && strcmp (str, "1") == 0) return 1;
13411 static int test_rm_0 (void)
13413 if (test_rm_0_skip ()) {
13414 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_0");
13418 /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
13420 char device[] = "/dev/sda";
13422 suppress_error = 0;
13423 r = guestfs_blockdev_setrw (g, device);
13429 suppress_error = 0;
13430 r = guestfs_umount_all (g);
13436 suppress_error = 0;
13437 r = guestfs_lvm_remove_all (g);
13442 char device[] = "/dev/sda";
13443 char lines_0[] = ",";
13449 suppress_error = 0;
13450 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13455 char fstype[] = "ext2";
13456 char device[] = "/dev/sda1";
13458 suppress_error = 0;
13459 r = guestfs_mkfs (g, fstype, device);
13464 char device[] = "/dev/sda1";
13465 char mountpoint[] = "/";
13467 suppress_error = 0;
13468 r = guestfs_mount (g, device, mountpoint);
13472 /* TestRun for rm (0) */
13474 char path[] = "/new";
13476 suppress_error = 0;
13477 r = guestfs_touch (g, path);
13482 char path[] = "/new";
13484 suppress_error = 0;
13485 r = guestfs_rm (g, path);
13492 static int test_rm_1_skip (void)
13496 str = getenv ("SKIP_TEST_RM_1");
13497 if (str && strcmp (str, "1") == 0) return 1;
13498 str = getenv ("SKIP_TEST_RM");
13499 if (str && strcmp (str, "1") == 0) return 1;
13503 static int test_rm_1 (void)
13505 if (test_rm_1_skip ()) {
13506 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_1");
13510 /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
13512 char device[] = "/dev/sda";
13514 suppress_error = 0;
13515 r = guestfs_blockdev_setrw (g, device);
13521 suppress_error = 0;
13522 r = guestfs_umount_all (g);
13528 suppress_error = 0;
13529 r = guestfs_lvm_remove_all (g);
13534 char device[] = "/dev/sda";
13535 char lines_0[] = ",";
13541 suppress_error = 0;
13542 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13547 char fstype[] = "ext2";
13548 char device[] = "/dev/sda1";
13550 suppress_error = 0;
13551 r = guestfs_mkfs (g, fstype, device);
13556 char device[] = "/dev/sda1";
13557 char mountpoint[] = "/";
13559 suppress_error = 0;
13560 r = guestfs_mount (g, device, mountpoint);
13564 /* TestLastFail for rm (1) */
13566 char path[] = "/new";
13568 suppress_error = 1;
13569 r = guestfs_rm (g, path);
13576 static int test_rm_2_skip (void)
13580 str = getenv ("SKIP_TEST_RM_2");
13581 if (str && strcmp (str, "1") == 0) return 1;
13582 str = getenv ("SKIP_TEST_RM");
13583 if (str && strcmp (str, "1") == 0) return 1;
13587 static int test_rm_2 (void)
13589 if (test_rm_2_skip ()) {
13590 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_2");
13594 /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
13596 char device[] = "/dev/sda";
13598 suppress_error = 0;
13599 r = guestfs_blockdev_setrw (g, device);
13605 suppress_error = 0;
13606 r = guestfs_umount_all (g);
13612 suppress_error = 0;
13613 r = guestfs_lvm_remove_all (g);
13618 char device[] = "/dev/sda";
13619 char lines_0[] = ",";
13625 suppress_error = 0;
13626 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13631 char fstype[] = "ext2";
13632 char device[] = "/dev/sda1";
13634 suppress_error = 0;
13635 r = guestfs_mkfs (g, fstype, device);
13640 char device[] = "/dev/sda1";
13641 char mountpoint[] = "/";
13643 suppress_error = 0;
13644 r = guestfs_mount (g, device, mountpoint);
13648 /* TestLastFail for rm (2) */
13650 char path[] = "/new";
13652 suppress_error = 0;
13653 r = guestfs_mkdir (g, path);
13658 char path[] = "/new";
13660 suppress_error = 1;
13661 r = guestfs_rm (g, path);
13668 static int test_read_lines_0_skip (void)
13672 str = getenv ("SKIP_TEST_READ_LINES_0");
13673 if (str && strcmp (str, "1") == 0) return 1;
13674 str = getenv ("SKIP_TEST_READ_LINES");
13675 if (str && strcmp (str, "1") == 0) return 1;
13679 static int test_read_lines_0 (void)
13681 if (test_read_lines_0_skip ()) {
13682 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_0");
13686 /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
13688 char device[] = "/dev/sda";
13690 suppress_error = 0;
13691 r = guestfs_blockdev_setrw (g, device);
13697 suppress_error = 0;
13698 r = guestfs_umount_all (g);
13704 suppress_error = 0;
13705 r = guestfs_lvm_remove_all (g);
13710 char device[] = "/dev/sda";
13711 char lines_0[] = ",";
13717 suppress_error = 0;
13718 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13723 char fstype[] = "ext2";
13724 char device[] = "/dev/sda1";
13726 suppress_error = 0;
13727 r = guestfs_mkfs (g, fstype, device);
13732 char device[] = "/dev/sda1";
13733 char mountpoint[] = "/";
13735 suppress_error = 0;
13736 r = guestfs_mount (g, device, mountpoint);
13740 /* TestOutputList for read_lines (0) */
13742 char path[] = "/new";
13743 char content[] = "line1\r\nline2\nline3";
13745 suppress_error = 0;
13746 r = guestfs_write_file (g, path, content, 0);
13751 char path[] = "/new";
13754 suppress_error = 0;
13755 r = guestfs_read_lines (g, path);
13759 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
13764 char expected[] = "line1";
13765 if (strcmp (r[0], expected) != 0) {
13766 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13771 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
13776 char expected[] = "line2";
13777 if (strcmp (r[1], expected) != 0) {
13778 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
13783 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
13788 char expected[] = "line3";
13789 if (strcmp (r[2], expected) != 0) {
13790 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
13794 if (r[3] != NULL) {
13795 fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
13799 for (i = 0; r[i] != NULL; ++i)
13806 static int test_read_lines_1_skip (void)
13810 str = getenv ("SKIP_TEST_READ_LINES_1");
13811 if (str && strcmp (str, "1") == 0) return 1;
13812 str = getenv ("SKIP_TEST_READ_LINES");
13813 if (str && strcmp (str, "1") == 0) return 1;
13817 static int test_read_lines_1 (void)
13819 if (test_read_lines_1_skip ()) {
13820 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_1");
13824 /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
13826 char device[] = "/dev/sda";
13828 suppress_error = 0;
13829 r = guestfs_blockdev_setrw (g, device);
13835 suppress_error = 0;
13836 r = guestfs_umount_all (g);
13842 suppress_error = 0;
13843 r = guestfs_lvm_remove_all (g);
13848 char device[] = "/dev/sda";
13849 char lines_0[] = ",";
13855 suppress_error = 0;
13856 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13861 char fstype[] = "ext2";
13862 char device[] = "/dev/sda1";
13864 suppress_error = 0;
13865 r = guestfs_mkfs (g, fstype, device);
13870 char device[] = "/dev/sda1";
13871 char mountpoint[] = "/";
13873 suppress_error = 0;
13874 r = guestfs_mount (g, device, mountpoint);
13878 /* TestOutputList for read_lines (1) */
13880 char path[] = "/new";
13881 char content[] = "";
13883 suppress_error = 0;
13884 r = guestfs_write_file (g, path, content, 0);
13889 char path[] = "/new";
13892 suppress_error = 0;
13893 r = guestfs_read_lines (g, path);
13896 if (r[0] != NULL) {
13897 fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
13901 for (i = 0; r[i] != NULL; ++i)
13908 static int test_lvs_0_skip (void)
13912 str = getenv ("SKIP_TEST_LVS_0");
13913 if (str && strcmp (str, "1") == 0) return 1;
13914 str = getenv ("SKIP_TEST_LVS");
13915 if (str && strcmp (str, "1") == 0) return 1;
13919 static int test_lvs_0 (void)
13921 if (test_lvs_0_skip ()) {
13922 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_0");
13926 /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
13928 char device[] = "/dev/sda";
13930 suppress_error = 0;
13931 r = guestfs_blockdev_setrw (g, device);
13937 suppress_error = 0;
13938 r = guestfs_umount_all (g);
13944 suppress_error = 0;
13945 r = guestfs_lvm_remove_all (g);
13950 char device[] = "/dev/sda";
13951 char lines_0[] = ",";
13957 suppress_error = 0;
13958 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13963 char device[] = "/dev/sda1";
13965 suppress_error = 0;
13966 r = guestfs_pvcreate (g, device);
13971 char volgroup[] = "VG";
13972 char physvols_0[] = "/dev/sda1";
13973 char *physvols[] = {
13978 suppress_error = 0;
13979 r = guestfs_vgcreate (g, volgroup, physvols);
13984 char logvol[] = "LV";
13985 char volgroup[] = "VG";
13987 suppress_error = 0;
13988 r = guestfs_lvcreate (g, logvol, volgroup, 8);
13993 char fstype[] = "ext2";
13994 char device[] = "/dev/VG/LV";
13996 suppress_error = 0;
13997 r = guestfs_mkfs (g, fstype, device);
14002 char device[] = "/dev/VG/LV";
14003 char mountpoint[] = "/";
14005 suppress_error = 0;
14006 r = guestfs_mount (g, device, mountpoint);
14010 /* TestOutputList for lvs (0) */
14014 suppress_error = 0;
14015 r = guestfs_lvs (g);
14019 fprintf (stderr, "test_lvs_0: short list returned from command\n");
14024 char expected[] = "/dev/VG/LV";
14025 if (strcmp (r[0], expected) != 0) {
14026 fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14030 if (r[1] != NULL) {
14031 fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
14035 for (i = 0; r[i] != NULL; ++i)
14042 static int test_lvs_1_skip (void)
14046 str = getenv ("SKIP_TEST_LVS_1");
14047 if (str && strcmp (str, "1") == 0) return 1;
14048 str = getenv ("SKIP_TEST_LVS");
14049 if (str && strcmp (str, "1") == 0) return 1;
14053 static int test_lvs_1 (void)
14055 if (test_lvs_1_skip ()) {
14056 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_1");
14060 /* InitNone|InitEmpty for test_lvs_1 */
14062 char device[] = "/dev/sda";
14064 suppress_error = 0;
14065 r = guestfs_blockdev_setrw (g, device);
14071 suppress_error = 0;
14072 r = guestfs_umount_all (g);
14078 suppress_error = 0;
14079 r = guestfs_lvm_remove_all (g);
14083 /* TestOutputList for lvs (1) */
14085 char device[] = "/dev/sda";
14086 char lines_0[] = ",10";
14087 char lines_1[] = ",20";
14088 char lines_2[] = ",";
14096 suppress_error = 0;
14097 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14102 char device[] = "/dev/sda1";
14104 suppress_error = 0;
14105 r = guestfs_pvcreate (g, device);
14110 char device[] = "/dev/sda2";
14112 suppress_error = 0;
14113 r = guestfs_pvcreate (g, device);
14118 char device[] = "/dev/sda3";
14120 suppress_error = 0;
14121 r = guestfs_pvcreate (g, device);
14126 char volgroup[] = "VG1";
14127 char physvols_0[] = "/dev/sda1";
14128 char physvols_1[] = "/dev/sda2";
14129 char *physvols[] = {
14135 suppress_error = 0;
14136 r = guestfs_vgcreate (g, volgroup, physvols);
14141 char volgroup[] = "VG2";
14142 char physvols_0[] = "/dev/sda3";
14143 char *physvols[] = {
14148 suppress_error = 0;
14149 r = guestfs_vgcreate (g, volgroup, physvols);
14154 char logvol[] = "LV1";
14155 char volgroup[] = "VG1";
14157 suppress_error = 0;
14158 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14163 char logvol[] = "LV2";
14164 char volgroup[] = "VG1";
14166 suppress_error = 0;
14167 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14172 char logvol[] = "LV3";
14173 char volgroup[] = "VG2";
14175 suppress_error = 0;
14176 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14183 suppress_error = 0;
14184 r = guestfs_lvs (g);
14188 fprintf (stderr, "test_lvs_1: short list returned from command\n");
14193 char expected[] = "/dev/VG1/LV1";
14194 if (strcmp (r[0], expected) != 0) {
14195 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14200 fprintf (stderr, "test_lvs_1: short list returned from command\n");
14205 char expected[] = "/dev/VG1/LV2";
14206 if (strcmp (r[1], expected) != 0) {
14207 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14212 fprintf (stderr, "test_lvs_1: short list returned from command\n");
14217 char expected[] = "/dev/VG2/LV3";
14218 if (strcmp (r[2], expected) != 0) {
14219 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14223 if (r[3] != NULL) {
14224 fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
14228 for (i = 0; r[i] != NULL; ++i)
14235 static int test_vgs_0_skip (void)
14239 str = getenv ("SKIP_TEST_VGS_0");
14240 if (str && strcmp (str, "1") == 0) return 1;
14241 str = getenv ("SKIP_TEST_VGS");
14242 if (str && strcmp (str, "1") == 0) return 1;
14246 static int test_vgs_0 (void)
14248 if (test_vgs_0_skip ()) {
14249 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_0");
14253 /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
14255 char device[] = "/dev/sda";
14257 suppress_error = 0;
14258 r = guestfs_blockdev_setrw (g, device);
14264 suppress_error = 0;
14265 r = guestfs_umount_all (g);
14271 suppress_error = 0;
14272 r = guestfs_lvm_remove_all (g);
14277 char device[] = "/dev/sda";
14278 char lines_0[] = ",";
14284 suppress_error = 0;
14285 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14290 char device[] = "/dev/sda1";
14292 suppress_error = 0;
14293 r = guestfs_pvcreate (g, device);
14298 char volgroup[] = "VG";
14299 char physvols_0[] = "/dev/sda1";
14300 char *physvols[] = {
14305 suppress_error = 0;
14306 r = guestfs_vgcreate (g, volgroup, physvols);
14311 char logvol[] = "LV";
14312 char volgroup[] = "VG";
14314 suppress_error = 0;
14315 r = guestfs_lvcreate (g, logvol, volgroup, 8);
14320 char fstype[] = "ext2";
14321 char device[] = "/dev/VG/LV";
14323 suppress_error = 0;
14324 r = guestfs_mkfs (g, fstype, device);
14329 char device[] = "/dev/VG/LV";
14330 char mountpoint[] = "/";
14332 suppress_error = 0;
14333 r = guestfs_mount (g, device, mountpoint);
14337 /* TestOutputList for vgs (0) */
14341 suppress_error = 0;
14342 r = guestfs_vgs (g);
14346 fprintf (stderr, "test_vgs_0: short list returned from command\n");
14351 char expected[] = "VG";
14352 if (strcmp (r[0], expected) != 0) {
14353 fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14357 if (r[1] != NULL) {
14358 fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
14362 for (i = 0; r[i] != NULL; ++i)
14369 static int test_vgs_1_skip (void)
14373 str = getenv ("SKIP_TEST_VGS_1");
14374 if (str && strcmp (str, "1") == 0) return 1;
14375 str = getenv ("SKIP_TEST_VGS");
14376 if (str && strcmp (str, "1") == 0) return 1;
14380 static int test_vgs_1 (void)
14382 if (test_vgs_1_skip ()) {
14383 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_1");
14387 /* InitNone|InitEmpty for test_vgs_1 */
14389 char device[] = "/dev/sda";
14391 suppress_error = 0;
14392 r = guestfs_blockdev_setrw (g, device);
14398 suppress_error = 0;
14399 r = guestfs_umount_all (g);
14405 suppress_error = 0;
14406 r = guestfs_lvm_remove_all (g);
14410 /* TestOutputList for vgs (1) */
14412 char device[] = "/dev/sda";
14413 char lines_0[] = ",10";
14414 char lines_1[] = ",20";
14415 char lines_2[] = ",";
14423 suppress_error = 0;
14424 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14429 char device[] = "/dev/sda1";
14431 suppress_error = 0;
14432 r = guestfs_pvcreate (g, device);
14437 char device[] = "/dev/sda2";
14439 suppress_error = 0;
14440 r = guestfs_pvcreate (g, device);
14445 char device[] = "/dev/sda3";
14447 suppress_error = 0;
14448 r = guestfs_pvcreate (g, device);
14453 char volgroup[] = "VG1";
14454 char physvols_0[] = "/dev/sda1";
14455 char physvols_1[] = "/dev/sda2";
14456 char *physvols[] = {
14462 suppress_error = 0;
14463 r = guestfs_vgcreate (g, volgroup, physvols);
14468 char volgroup[] = "VG2";
14469 char physvols_0[] = "/dev/sda3";
14470 char *physvols[] = {
14475 suppress_error = 0;
14476 r = guestfs_vgcreate (g, volgroup, physvols);
14483 suppress_error = 0;
14484 r = guestfs_vgs (g);
14488 fprintf (stderr, "test_vgs_1: short list returned from command\n");
14493 char expected[] = "VG1";
14494 if (strcmp (r[0], expected) != 0) {
14495 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14500 fprintf (stderr, "test_vgs_1: short list returned from command\n");
14505 char expected[] = "VG2";
14506 if (strcmp (r[1], expected) != 0) {
14507 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14511 if (r[2] != NULL) {
14512 fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
14516 for (i = 0; r[i] != NULL; ++i)
14523 static int test_pvs_0_skip (void)
14527 str = getenv ("SKIP_TEST_PVS_0");
14528 if (str && strcmp (str, "1") == 0) return 1;
14529 str = getenv ("SKIP_TEST_PVS");
14530 if (str && strcmp (str, "1") == 0) return 1;
14534 static int test_pvs_0 (void)
14536 if (test_pvs_0_skip ()) {
14537 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_0");
14541 /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
14543 char device[] = "/dev/sda";
14545 suppress_error = 0;
14546 r = guestfs_blockdev_setrw (g, device);
14552 suppress_error = 0;
14553 r = guestfs_umount_all (g);
14559 suppress_error = 0;
14560 r = guestfs_lvm_remove_all (g);
14565 char device[] = "/dev/sda";
14566 char lines_0[] = ",";
14572 suppress_error = 0;
14573 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14578 char device[] = "/dev/sda1";
14580 suppress_error = 0;
14581 r = guestfs_pvcreate (g, device);
14586 char volgroup[] = "VG";
14587 char physvols_0[] = "/dev/sda1";
14588 char *physvols[] = {
14593 suppress_error = 0;
14594 r = guestfs_vgcreate (g, volgroup, physvols);
14599 char logvol[] = "LV";
14600 char volgroup[] = "VG";
14602 suppress_error = 0;
14603 r = guestfs_lvcreate (g, logvol, volgroup, 8);
14608 char fstype[] = "ext2";
14609 char device[] = "/dev/VG/LV";
14611 suppress_error = 0;
14612 r = guestfs_mkfs (g, fstype, device);
14617 char device[] = "/dev/VG/LV";
14618 char mountpoint[] = "/";
14620 suppress_error = 0;
14621 r = guestfs_mount (g, device, mountpoint);
14625 /* TestOutputListOfDevices for pvs (0) */
14629 suppress_error = 0;
14630 r = guestfs_pvs (g);
14634 fprintf (stderr, "test_pvs_0: short list returned from command\n");
14639 char expected[] = "/dev/sda1";
14641 if (strcmp (r[0], expected) != 0) {
14642 fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14646 if (r[1] != NULL) {
14647 fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
14651 for (i = 0; r[i] != NULL; ++i)
14658 static int test_pvs_1_skip (void)
14662 str = getenv ("SKIP_TEST_PVS_1");
14663 if (str && strcmp (str, "1") == 0) return 1;
14664 str = getenv ("SKIP_TEST_PVS");
14665 if (str && strcmp (str, "1") == 0) return 1;
14669 static int test_pvs_1 (void)
14671 if (test_pvs_1_skip ()) {
14672 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_1");
14676 /* InitNone|InitEmpty for test_pvs_1 */
14678 char device[] = "/dev/sda";
14680 suppress_error = 0;
14681 r = guestfs_blockdev_setrw (g, device);
14687 suppress_error = 0;
14688 r = guestfs_umount_all (g);
14694 suppress_error = 0;
14695 r = guestfs_lvm_remove_all (g);
14699 /* TestOutputListOfDevices for pvs (1) */
14701 char device[] = "/dev/sda";
14702 char lines_0[] = ",10";
14703 char lines_1[] = ",20";
14704 char lines_2[] = ",";
14712 suppress_error = 0;
14713 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14718 char device[] = "/dev/sda1";
14720 suppress_error = 0;
14721 r = guestfs_pvcreate (g, device);
14726 char device[] = "/dev/sda2";
14728 suppress_error = 0;
14729 r = guestfs_pvcreate (g, device);
14734 char device[] = "/dev/sda3";
14736 suppress_error = 0;
14737 r = guestfs_pvcreate (g, device);
14744 suppress_error = 0;
14745 r = guestfs_pvs (g);
14749 fprintf (stderr, "test_pvs_1: short list returned from command\n");
14754 char expected[] = "/dev/sda1";
14756 if (strcmp (r[0], expected) != 0) {
14757 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14762 fprintf (stderr, "test_pvs_1: short list returned from command\n");
14767 char expected[] = "/dev/sda2";
14769 if (strcmp (r[1], expected) != 0) {
14770 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14775 fprintf (stderr, "test_pvs_1: short list returned from command\n");
14780 char expected[] = "/dev/sda3";
14782 if (strcmp (r[2], expected) != 0) {
14783 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14787 if (r[3] != NULL) {
14788 fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
14792 for (i = 0; r[i] != NULL; ++i)
14799 static int test_list_partitions_0_skip (void)
14803 str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
14804 if (str && strcmp (str, "1") == 0) return 1;
14805 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
14806 if (str && strcmp (str, "1") == 0) return 1;
14810 static int test_list_partitions_0 (void)
14812 if (test_list_partitions_0_skip ()) {
14813 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_0");
14817 /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
14819 char device[] = "/dev/sda";
14821 suppress_error = 0;
14822 r = guestfs_blockdev_setrw (g, device);
14828 suppress_error = 0;
14829 r = guestfs_umount_all (g);
14835 suppress_error = 0;
14836 r = guestfs_lvm_remove_all (g);
14841 char device[] = "/dev/sda";
14842 char lines_0[] = ",";
14848 suppress_error = 0;
14849 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14854 char fstype[] = "ext2";
14855 char device[] = "/dev/sda1";
14857 suppress_error = 0;
14858 r = guestfs_mkfs (g, fstype, device);
14863 char device[] = "/dev/sda1";
14864 char mountpoint[] = "/";
14866 suppress_error = 0;
14867 r = guestfs_mount (g, device, mountpoint);
14871 /* TestOutputListOfDevices for list_partitions (0) */
14875 suppress_error = 0;
14876 r = guestfs_list_partitions (g);
14880 fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
14885 char expected[] = "/dev/sda1";
14887 if (strcmp (r[0], expected) != 0) {
14888 fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14892 if (r[1] != NULL) {
14893 fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
14897 for (i = 0; r[i] != NULL; ++i)
14904 static int test_list_partitions_1_skip (void)
14908 str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
14909 if (str && strcmp (str, "1") == 0) return 1;
14910 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
14911 if (str && strcmp (str, "1") == 0) return 1;
14915 static int test_list_partitions_1 (void)
14917 if (test_list_partitions_1_skip ()) {
14918 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_1");
14922 /* InitNone|InitEmpty for test_list_partitions_1 */
14924 char device[] = "/dev/sda";
14926 suppress_error = 0;
14927 r = guestfs_blockdev_setrw (g, device);
14933 suppress_error = 0;
14934 r = guestfs_umount_all (g);
14940 suppress_error = 0;
14941 r = guestfs_lvm_remove_all (g);
14945 /* TestOutputListOfDevices for list_partitions (1) */
14947 char device[] = "/dev/sda";
14948 char lines_0[] = ",10";
14949 char lines_1[] = ",20";
14950 char lines_2[] = ",";
14958 suppress_error = 0;
14959 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14966 suppress_error = 0;
14967 r = guestfs_list_partitions (g);
14971 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
14976 char expected[] = "/dev/sda1";
14978 if (strcmp (r[0], expected) != 0) {
14979 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14984 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
14989 char expected[] = "/dev/sda2";
14991 if (strcmp (r[1], expected) != 0) {
14992 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14997 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15002 char expected[] = "/dev/sda3";
15004 if (strcmp (r[2], expected) != 0) {
15005 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15009 if (r[3] != NULL) {
15010 fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
15014 for (i = 0; r[i] != NULL; ++i)
15021 static int test_list_devices_0_skip (void)
15025 str = getenv ("SKIP_TEST_LIST_DEVICES_0");
15026 if (str && strcmp (str, "1") == 0) return 1;
15027 str = getenv ("SKIP_TEST_LIST_DEVICES");
15028 if (str && strcmp (str, "1") == 0) return 1;
15032 static int test_list_devices_0 (void)
15034 if (test_list_devices_0_skip ()) {
15035 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_devices_0");
15039 /* InitNone|InitEmpty for test_list_devices_0 */
15041 char device[] = "/dev/sda";
15043 suppress_error = 0;
15044 r = guestfs_blockdev_setrw (g, device);
15050 suppress_error = 0;
15051 r = guestfs_umount_all (g);
15057 suppress_error = 0;
15058 r = guestfs_lvm_remove_all (g);
15062 /* TestOutputListOfDevices for list_devices (0) */
15066 suppress_error = 0;
15067 r = guestfs_list_devices (g);
15071 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15076 char expected[] = "/dev/sda";
15078 if (strcmp (r[0], expected) != 0) {
15079 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15084 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15089 char expected[] = "/dev/sdb";
15091 if (strcmp (r[1], expected) != 0) {
15092 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15097 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15102 char expected[] = "/dev/sdc";
15104 if (strcmp (r[2], expected) != 0) {
15105 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15110 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15115 char expected[] = "/dev/sdd";
15117 if (strcmp (r[3], expected) != 0) {
15118 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15122 if (r[4] != NULL) {
15123 fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
15127 for (i = 0; r[i] != NULL; ++i)
15134 static int test_ls_0_skip (void)
15138 str = getenv ("SKIP_TEST_LS_0");
15139 if (str && strcmp (str, "1") == 0) return 1;
15140 str = getenv ("SKIP_TEST_LS");
15141 if (str && strcmp (str, "1") == 0) return 1;
15145 static int test_ls_0 (void)
15147 if (test_ls_0_skip ()) {
15148 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ls_0");
15152 /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
15154 char device[] = "/dev/sda";
15156 suppress_error = 0;
15157 r = guestfs_blockdev_setrw (g, device);
15163 suppress_error = 0;
15164 r = guestfs_umount_all (g);
15170 suppress_error = 0;
15171 r = guestfs_lvm_remove_all (g);
15176 char device[] = "/dev/sda";
15177 char lines_0[] = ",";
15183 suppress_error = 0;
15184 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15189 char fstype[] = "ext2";
15190 char device[] = "/dev/sda1";
15192 suppress_error = 0;
15193 r = guestfs_mkfs (g, fstype, device);
15198 char device[] = "/dev/sda1";
15199 char mountpoint[] = "/";
15201 suppress_error = 0;
15202 r = guestfs_mount (g, device, mountpoint);
15206 /* TestOutputList for ls (0) */
15208 char path[] = "/new";
15210 suppress_error = 0;
15211 r = guestfs_touch (g, path);
15216 char path[] = "/newer";
15218 suppress_error = 0;
15219 r = guestfs_touch (g, path);
15224 char path[] = "/newest";
15226 suppress_error = 0;
15227 r = guestfs_touch (g, path);
15232 char directory[] = "/";
15235 suppress_error = 0;
15236 r = guestfs_ls (g, directory);
15240 fprintf (stderr, "test_ls_0: short list returned from command\n");
15245 char expected[] = "lost+found";
15246 if (strcmp (r[0], expected) != 0) {
15247 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15252 fprintf (stderr, "test_ls_0: short list returned from command\n");
15257 char expected[] = "new";
15258 if (strcmp (r[1], expected) != 0) {
15259 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15264 fprintf (stderr, "test_ls_0: short list returned from command\n");
15269 char expected[] = "newer";
15270 if (strcmp (r[2], expected) != 0) {
15271 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15276 fprintf (stderr, "test_ls_0: short list returned from command\n");
15281 char expected[] = "newest";
15282 if (strcmp (r[3], expected) != 0) {
15283 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15287 if (r[4] != NULL) {
15288 fprintf (stderr, "test_ls_0: extra elements returned from command\n");
15292 for (i = 0; r[i] != NULL; ++i)
15299 static int test_cat_0_skip (void)
15303 str = getenv ("SKIP_TEST_CAT_0");
15304 if (str && strcmp (str, "1") == 0) return 1;
15305 str = getenv ("SKIP_TEST_CAT");
15306 if (str && strcmp (str, "1") == 0) return 1;
15310 static int test_cat_0 (void)
15312 if (test_cat_0_skip ()) {
15313 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cat_0");
15317 /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
15319 char device[] = "/dev/sda";
15321 suppress_error = 0;
15322 r = guestfs_blockdev_setrw (g, device);
15328 suppress_error = 0;
15329 r = guestfs_umount_all (g);
15335 suppress_error = 0;
15336 r = guestfs_lvm_remove_all (g);
15341 char device[] = "/dev/sda";
15342 char lines_0[] = ",";
15348 suppress_error = 0;
15349 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15354 char fstype[] = "ext2";
15355 char device[] = "/dev/sda1";
15357 suppress_error = 0;
15358 r = guestfs_mkfs (g, fstype, device);
15363 char device[] = "/dev/sda1";
15364 char mountpoint[] = "/";
15366 suppress_error = 0;
15367 r = guestfs_mount (g, device, mountpoint);
15371 /* TestOutput for cat (0) */
15372 char expected[] = "new file contents";
15374 char path[] = "/new";
15375 char content[] = "new file contents";
15377 suppress_error = 0;
15378 r = guestfs_write_file (g, path, content, 0);
15383 char path[] = "/new";
15385 suppress_error = 0;
15386 r = guestfs_cat (g, path);
15389 if (strcmp (r, expected) != 0) {
15390 fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
15398 static int test_touch_0_skip (void)
15402 str = getenv ("SKIP_TEST_TOUCH_0");
15403 if (str && strcmp (str, "1") == 0) return 1;
15404 str = getenv ("SKIP_TEST_TOUCH");
15405 if (str && strcmp (str, "1") == 0) return 1;
15409 static int test_touch_0 (void)
15411 if (test_touch_0_skip ()) {
15412 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_touch_0");
15416 /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
15418 char device[] = "/dev/sda";
15420 suppress_error = 0;
15421 r = guestfs_blockdev_setrw (g, device);
15427 suppress_error = 0;
15428 r = guestfs_umount_all (g);
15434 suppress_error = 0;
15435 r = guestfs_lvm_remove_all (g);
15440 char device[] = "/dev/sda";
15441 char lines_0[] = ",";
15447 suppress_error = 0;
15448 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15453 char fstype[] = "ext2";
15454 char device[] = "/dev/sda1";
15456 suppress_error = 0;
15457 r = guestfs_mkfs (g, fstype, device);
15462 char device[] = "/dev/sda1";
15463 char mountpoint[] = "/";
15465 suppress_error = 0;
15466 r = guestfs_mount (g, device, mountpoint);
15470 /* TestOutputTrue for touch (0) */
15472 char path[] = "/new";
15474 suppress_error = 0;
15475 r = guestfs_touch (g, path);
15480 char path[] = "/new";
15482 suppress_error = 0;
15483 r = guestfs_exists (g, path);
15487 fprintf (stderr, "test_touch_0: expected true, got false\n");
15494 static int test_sync_0_skip (void)
15498 str = getenv ("SKIP_TEST_SYNC_0");
15499 if (str && strcmp (str, "1") == 0) return 1;
15500 str = getenv ("SKIP_TEST_SYNC");
15501 if (str && strcmp (str, "1") == 0) return 1;
15505 static int test_sync_0 (void)
15507 if (test_sync_0_skip ()) {
15508 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sync_0");
15512 /* InitNone|InitEmpty for test_sync_0 */
15514 char device[] = "/dev/sda";
15516 suppress_error = 0;
15517 r = guestfs_blockdev_setrw (g, device);
15523 suppress_error = 0;
15524 r = guestfs_umount_all (g);
15530 suppress_error = 0;
15531 r = guestfs_lvm_remove_all (g);
15535 /* TestRun for sync (0) */
15538 suppress_error = 0;
15539 r = guestfs_sync (g);
15546 static int test_mount_0_skip (void)
15550 str = getenv ("SKIP_TEST_MOUNT_0");
15551 if (str && strcmp (str, "1") == 0) return 1;
15552 str = getenv ("SKIP_TEST_MOUNT");
15553 if (str && strcmp (str, "1") == 0) return 1;
15557 static int test_mount_0 (void)
15559 if (test_mount_0_skip ()) {
15560 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_0");
15564 /* InitNone|InitEmpty for test_mount_0 */
15566 char device[] = "/dev/sda";
15568 suppress_error = 0;
15569 r = guestfs_blockdev_setrw (g, device);
15575 suppress_error = 0;
15576 r = guestfs_umount_all (g);
15582 suppress_error = 0;
15583 r = guestfs_lvm_remove_all (g);
15587 /* TestOutput for mount (0) */
15588 char expected[] = "new file contents";
15590 char device[] = "/dev/sda";
15591 char lines_0[] = ",";
15597 suppress_error = 0;
15598 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15603 char fstype[] = "ext2";
15604 char device[] = "/dev/sda1";
15606 suppress_error = 0;
15607 r = guestfs_mkfs (g, fstype, device);
15612 char device[] = "/dev/sda1";
15613 char mountpoint[] = "/";
15615 suppress_error = 0;
15616 r = guestfs_mount (g, device, mountpoint);
15621 char path[] = "/new";
15622 char content[] = "new file contents";
15624 suppress_error = 0;
15625 r = guestfs_write_file (g, path, content, 0);
15630 char path[] = "/new";
15632 suppress_error = 0;
15633 r = guestfs_cat (g, path);
15636 if (strcmp (r, expected) != 0) {
15637 fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
15645 int main (int argc, char *argv[])
15649 const char *filename;
15651 int nr_tests, test_num = 0;
15653 no_test_warnings ();
15655 g = guestfs_create ();
15657 printf ("guestfs_create FAILED\n");
15661 guestfs_set_error_handler (g, print_error, NULL);
15663 guestfs_set_path (g, "../appliance");
15665 filename = "test1.img";
15666 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
15671 if (lseek (fd, 524288000, SEEK_SET) == -1) {
15677 if (write (fd, &c, 1) == -1) {
15683 if (close (fd) == -1) {
15688 if (guestfs_add_drive (g, filename) == -1) {
15689 printf ("guestfs_add_drive %s FAILED\n", filename);
15693 filename = "test2.img";
15694 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
15699 if (lseek (fd, 52428800, SEEK_SET) == -1) {
15705 if (write (fd, &c, 1) == -1) {
15711 if (close (fd) == -1) {
15716 if (guestfs_add_drive (g, filename) == -1) {
15717 printf ("guestfs_add_drive %s FAILED\n", filename);
15721 filename = "test3.img";
15722 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
15727 if (lseek (fd, 10485760, SEEK_SET) == -1) {
15733 if (write (fd, &c, 1) == -1) {
15739 if (close (fd) == -1) {
15744 if (guestfs_add_drive (g, filename) == -1) {
15745 printf ("guestfs_add_drive %s FAILED\n", filename);
15749 if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
15750 printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
15754 if (guestfs_launch (g) == -1) {
15755 printf ("guestfs_launch FAILED\n");
15759 /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */
15762 if (guestfs_wait_ready (g) == -1) {
15763 printf ("guestfs_wait_ready FAILED\n");
15767 /* Cancel previous alarm. */
15773 printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
15774 if (test_ntfs_3g_probe_0 () == -1) {
15775 printf ("test_ntfs_3g_probe_0 FAILED\n");
15779 printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
15780 if (test_ntfs_3g_probe_1 () == -1) {
15781 printf ("test_ntfs_3g_probe_1 FAILED\n");
15785 printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
15786 if (test_sleep_0 () == -1) {
15787 printf ("test_sleep_0 FAILED\n");
15791 printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
15792 if (test_find_0 () == -1) {
15793 printf ("test_find_0 FAILED\n");
15797 printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
15798 if (test_find_1 () == -1) {
15799 printf ("test_find_1 FAILED\n");
15803 printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
15804 if (test_find_2 () == -1) {
15805 printf ("test_find_2 FAILED\n");
15809 printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
15810 if (test_lvresize_0 () == -1) {
15811 printf ("test_lvresize_0 FAILED\n");
15815 printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
15816 if (test_zerofree_0 () == -1) {
15817 printf ("test_zerofree_0 FAILED\n");
15821 printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
15822 if (test_hexdump_0 () == -1) {
15823 printf ("test_hexdump_0 FAILED\n");
15827 printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
15828 if (test_strings_e_0 () == -1) {
15829 printf ("test_strings_e_0 FAILED\n");
15833 printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
15834 if (test_strings_e_1 () == -1) {
15835 printf ("test_strings_e_1 FAILED\n");
15839 printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
15840 if (test_strings_0 () == -1) {
15841 printf ("test_strings_0 FAILED\n");
15845 printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
15846 if (test_strings_1 () == -1) {
15847 printf ("test_strings_1 FAILED\n");
15851 printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
15852 if (test_equal_0 () == -1) {
15853 printf ("test_equal_0 FAILED\n");
15857 printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
15858 if (test_equal_1 () == -1) {
15859 printf ("test_equal_1 FAILED\n");
15863 printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
15864 if (test_equal_2 () == -1) {
15865 printf ("test_equal_2 FAILED\n");
15869 printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
15870 if (test_ping_daemon_0 () == -1) {
15871 printf ("test_ping_daemon_0 FAILED\n");
15875 printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
15876 if (test_dmesg_0 () == -1) {
15877 printf ("test_dmesg_0 FAILED\n");
15881 printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
15882 if (test_drop_caches_0 () == -1) {
15883 printf ("test_drop_caches_0 FAILED\n");
15887 printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
15888 if (test_mv_0 () == -1) {
15889 printf ("test_mv_0 FAILED\n");
15893 printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
15894 if (test_mv_1 () == -1) {
15895 printf ("test_mv_1 FAILED\n");
15899 printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
15900 if (test_cp_a_0 () == -1) {
15901 printf ("test_cp_a_0 FAILED\n");
15905 printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
15906 if (test_cp_0 () == -1) {
15907 printf ("test_cp_0 FAILED\n");
15911 printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
15912 if (test_cp_1 () == -1) {
15913 printf ("test_cp_1 FAILED\n");
15917 printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
15918 if (test_cp_2 () == -1) {
15919 printf ("test_cp_2 FAILED\n");
15923 printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
15924 if (test_grub_install_0 () == -1) {
15925 printf ("test_grub_install_0 FAILED\n");
15929 printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
15930 if (test_zero_0 () == -1) {
15931 printf ("test_zero_0 FAILED\n");
15935 printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
15936 if (test_fsck_0 () == -1) {
15937 printf ("test_fsck_0 FAILED\n");
15941 printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
15942 if (test_fsck_1 () == -1) {
15943 printf ("test_fsck_1 FAILED\n");
15947 printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
15948 if (test_set_e2uuid_0 () == -1) {
15949 printf ("test_set_e2uuid_0 FAILED\n");
15953 printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
15954 if (test_set_e2uuid_1 () == -1) {
15955 printf ("test_set_e2uuid_1 FAILED\n");
15959 printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
15960 if (test_set_e2uuid_2 () == -1) {
15961 printf ("test_set_e2uuid_2 FAILED\n");
15965 printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
15966 if (test_set_e2uuid_3 () == -1) {
15967 printf ("test_set_e2uuid_3 FAILED\n");
15971 printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
15972 if (test_set_e2label_0 () == -1) {
15973 printf ("test_set_e2label_0 FAILED\n");
15977 printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
15978 if (test_pvremove_0 () == -1) {
15979 printf ("test_pvremove_0 FAILED\n");
15983 printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
15984 if (test_pvremove_1 () == -1) {
15985 printf ("test_pvremove_1 FAILED\n");
15989 printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
15990 if (test_pvremove_2 () == -1) {
15991 printf ("test_pvremove_2 FAILED\n");
15995 printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
15996 if (test_vgremove_0 () == -1) {
15997 printf ("test_vgremove_0 FAILED\n");
16001 printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
16002 if (test_vgremove_1 () == -1) {
16003 printf ("test_vgremove_1 FAILED\n");
16007 printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
16008 if (test_lvremove_0 () == -1) {
16009 printf ("test_lvremove_0 FAILED\n");
16013 printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
16014 if (test_lvremove_1 () == -1) {
16015 printf ("test_lvremove_1 FAILED\n");
16019 printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
16020 if (test_lvremove_2 () == -1) {
16021 printf ("test_lvremove_2 FAILED\n");
16025 printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
16026 if (test_mount_ro_0 () == -1) {
16027 printf ("test_mount_ro_0 FAILED\n");
16031 printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
16032 if (test_mount_ro_1 () == -1) {
16033 printf ("test_mount_ro_1 FAILED\n");
16037 printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
16038 if (test_tgz_in_0 () == -1) {
16039 printf ("test_tgz_in_0 FAILED\n");
16043 printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
16044 if (test_tar_in_0 () == -1) {
16045 printf ("test_tar_in_0 FAILED\n");
16049 printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
16050 if (test_checksum_0 () == -1) {
16051 printf ("test_checksum_0 FAILED\n");
16055 printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
16056 if (test_checksum_1 () == -1) {
16057 printf ("test_checksum_1 FAILED\n");
16061 printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
16062 if (test_checksum_2 () == -1) {
16063 printf ("test_checksum_2 FAILED\n");
16067 printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
16068 if (test_checksum_3 () == -1) {
16069 printf ("test_checksum_3 FAILED\n");
16073 printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
16074 if (test_checksum_4 () == -1) {
16075 printf ("test_checksum_4 FAILED\n");
16079 printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
16080 if (test_checksum_5 () == -1) {
16081 printf ("test_checksum_5 FAILED\n");
16085 printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
16086 if (test_checksum_6 () == -1) {
16087 printf ("test_checksum_6 FAILED\n");
16091 printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
16092 if (test_checksum_7 () == -1) {
16093 printf ("test_checksum_7 FAILED\n");
16097 printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
16098 if (test_checksum_8 () == -1) {
16099 printf ("test_checksum_8 FAILED\n");
16103 printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
16104 if (test_download_0 () == -1) {
16105 printf ("test_download_0 FAILED\n");
16109 printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
16110 if (test_upload_0 () == -1) {
16111 printf ("test_upload_0 FAILED\n");
16115 printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
16116 if (test_blockdev_rereadpt_0 () == -1) {
16117 printf ("test_blockdev_rereadpt_0 FAILED\n");
16121 printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
16122 if (test_blockdev_flushbufs_0 () == -1) {
16123 printf ("test_blockdev_flushbufs_0 FAILED\n");
16127 printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
16128 if (test_blockdev_getsize64_0 () == -1) {
16129 printf ("test_blockdev_getsize64_0 FAILED\n");
16133 printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
16134 if (test_blockdev_getsz_0 () == -1) {
16135 printf ("test_blockdev_getsz_0 FAILED\n");
16139 printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
16140 if (test_blockdev_getbsz_0 () == -1) {
16141 printf ("test_blockdev_getbsz_0 FAILED\n");
16145 printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
16146 if (test_blockdev_getss_0 () == -1) {
16147 printf ("test_blockdev_getss_0 FAILED\n");
16151 printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
16152 if (test_blockdev_getro_0 () == -1) {
16153 printf ("test_blockdev_getro_0 FAILED\n");
16157 printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
16158 if (test_blockdev_setrw_0 () == -1) {
16159 printf ("test_blockdev_setrw_0 FAILED\n");
16163 printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
16164 if (test_blockdev_setro_0 () == -1) {
16165 printf ("test_blockdev_setro_0 FAILED\n");
16169 printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
16170 if (test_statvfs_0 () == -1) {
16171 printf ("test_statvfs_0 FAILED\n");
16175 printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
16176 if (test_lstat_0 () == -1) {
16177 printf ("test_lstat_0 FAILED\n");
16181 printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
16182 if (test_stat_0 () == -1) {
16183 printf ("test_stat_0 FAILED\n");
16187 printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
16188 if (test_command_lines_0 () == -1) {
16189 printf ("test_command_lines_0 FAILED\n");
16193 printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
16194 if (test_command_lines_1 () == -1) {
16195 printf ("test_command_lines_1 FAILED\n");
16199 printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
16200 if (test_command_lines_2 () == -1) {
16201 printf ("test_command_lines_2 FAILED\n");
16205 printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
16206 if (test_command_lines_3 () == -1) {
16207 printf ("test_command_lines_3 FAILED\n");
16211 printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
16212 if (test_command_lines_4 () == -1) {
16213 printf ("test_command_lines_4 FAILED\n");
16217 printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
16218 if (test_command_lines_5 () == -1) {
16219 printf ("test_command_lines_5 FAILED\n");
16223 printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
16224 if (test_command_lines_6 () == -1) {
16225 printf ("test_command_lines_6 FAILED\n");
16229 printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
16230 if (test_command_lines_7 () == -1) {
16231 printf ("test_command_lines_7 FAILED\n");
16235 printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
16236 if (test_command_lines_8 () == -1) {
16237 printf ("test_command_lines_8 FAILED\n");
16241 printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
16242 if (test_command_lines_9 () == -1) {
16243 printf ("test_command_lines_9 FAILED\n");
16247 printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
16248 if (test_command_lines_10 () == -1) {
16249 printf ("test_command_lines_10 FAILED\n");
16253 printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
16254 if (test_command_0 () == -1) {
16255 printf ("test_command_0 FAILED\n");
16259 printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
16260 if (test_command_1 () == -1) {
16261 printf ("test_command_1 FAILED\n");
16265 printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
16266 if (test_command_2 () == -1) {
16267 printf ("test_command_2 FAILED\n");
16271 printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
16272 if (test_command_3 () == -1) {
16273 printf ("test_command_3 FAILED\n");
16277 printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
16278 if (test_command_4 () == -1) {
16279 printf ("test_command_4 FAILED\n");
16283 printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
16284 if (test_command_5 () == -1) {
16285 printf ("test_command_5 FAILED\n");
16289 printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
16290 if (test_command_6 () == -1) {
16291 printf ("test_command_6 FAILED\n");
16295 printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
16296 if (test_command_7 () == -1) {
16297 printf ("test_command_7 FAILED\n");
16301 printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
16302 if (test_command_8 () == -1) {
16303 printf ("test_command_8 FAILED\n");
16307 printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
16308 if (test_command_9 () == -1) {
16309 printf ("test_command_9 FAILED\n");
16313 printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
16314 if (test_command_10 () == -1) {
16315 printf ("test_command_10 FAILED\n");
16319 printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
16320 if (test_command_11 () == -1) {
16321 printf ("test_command_11 FAILED\n");
16325 printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
16326 if (test_file_0 () == -1) {
16327 printf ("test_file_0 FAILED\n");
16331 printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
16332 if (test_file_1 () == -1) {
16333 printf ("test_file_1 FAILED\n");
16337 printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
16338 if (test_file_2 () == -1) {
16339 printf ("test_file_2 FAILED\n");
16343 printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
16344 if (test_umount_all_0 () == -1) {
16345 printf ("test_umount_all_0 FAILED\n");
16349 printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
16350 if (test_umount_all_1 () == -1) {
16351 printf ("test_umount_all_1 FAILED\n");
16355 printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
16356 if (test_mounts_0 () == -1) {
16357 printf ("test_mounts_0 FAILED\n");
16361 printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
16362 if (test_umount_0 () == -1) {
16363 printf ("test_umount_0 FAILED\n");
16367 printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
16368 if (test_umount_1 () == -1) {
16369 printf ("test_umount_1 FAILED\n");
16373 printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
16374 if (test_write_file_0 () == -1) {
16375 printf ("test_write_file_0 FAILED\n");
16379 printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
16380 if (test_write_file_1 () == -1) {
16381 printf ("test_write_file_1 FAILED\n");
16385 printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
16386 if (test_write_file_2 () == -1) {
16387 printf ("test_write_file_2 FAILED\n");
16391 printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
16392 if (test_write_file_3 () == -1) {
16393 printf ("test_write_file_3 FAILED\n");
16397 printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
16398 if (test_write_file_4 () == -1) {
16399 printf ("test_write_file_4 FAILED\n");
16403 printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
16404 if (test_write_file_5 () == -1) {
16405 printf ("test_write_file_5 FAILED\n");
16409 printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
16410 if (test_mkfs_0 () == -1) {
16411 printf ("test_mkfs_0 FAILED\n");
16415 printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
16416 if (test_lvcreate_0 () == -1) {
16417 printf ("test_lvcreate_0 FAILED\n");
16421 printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
16422 if (test_vgcreate_0 () == -1) {
16423 printf ("test_vgcreate_0 FAILED\n");
16427 printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
16428 if (test_pvcreate_0 () == -1) {
16429 printf ("test_pvcreate_0 FAILED\n");
16433 printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
16434 if (test_is_dir_0 () == -1) {
16435 printf ("test_is_dir_0 FAILED\n");
16439 printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
16440 if (test_is_dir_1 () == -1) {
16441 printf ("test_is_dir_1 FAILED\n");
16445 printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
16446 if (test_is_file_0 () == -1) {
16447 printf ("test_is_file_0 FAILED\n");
16451 printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
16452 if (test_is_file_1 () == -1) {
16453 printf ("test_is_file_1 FAILED\n");
16457 printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
16458 if (test_exists_0 () == -1) {
16459 printf ("test_exists_0 FAILED\n");
16463 printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
16464 if (test_exists_1 () == -1) {
16465 printf ("test_exists_1 FAILED\n");
16469 printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
16470 if (test_mkdir_p_0 () == -1) {
16471 printf ("test_mkdir_p_0 FAILED\n");
16475 printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
16476 if (test_mkdir_p_1 () == -1) {
16477 printf ("test_mkdir_p_1 FAILED\n");
16481 printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
16482 if (test_mkdir_p_2 () == -1) {
16483 printf ("test_mkdir_p_2 FAILED\n");
16487 printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
16488 if (test_mkdir_p_3 () == -1) {
16489 printf ("test_mkdir_p_3 FAILED\n");
16493 printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
16494 if (test_mkdir_p_4 () == -1) {
16495 printf ("test_mkdir_p_4 FAILED\n");
16499 printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
16500 if (test_mkdir_0 () == -1) {
16501 printf ("test_mkdir_0 FAILED\n");
16505 printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
16506 if (test_mkdir_1 () == -1) {
16507 printf ("test_mkdir_1 FAILED\n");
16511 printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
16512 if (test_rm_rf_0 () == -1) {
16513 printf ("test_rm_rf_0 FAILED\n");
16517 printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
16518 if (test_rmdir_0 () == -1) {
16519 printf ("test_rmdir_0 FAILED\n");
16523 printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
16524 if (test_rmdir_1 () == -1) {
16525 printf ("test_rmdir_1 FAILED\n");
16529 printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
16530 if (test_rmdir_2 () == -1) {
16531 printf ("test_rmdir_2 FAILED\n");
16535 printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
16536 if (test_rm_0 () == -1) {
16537 printf ("test_rm_0 FAILED\n");
16541 printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
16542 if (test_rm_1 () == -1) {
16543 printf ("test_rm_1 FAILED\n");
16547 printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
16548 if (test_rm_2 () == -1) {
16549 printf ("test_rm_2 FAILED\n");
16553 printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
16554 if (test_read_lines_0 () == -1) {
16555 printf ("test_read_lines_0 FAILED\n");
16559 printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
16560 if (test_read_lines_1 () == -1) {
16561 printf ("test_read_lines_1 FAILED\n");
16565 printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
16566 if (test_lvs_0 () == -1) {
16567 printf ("test_lvs_0 FAILED\n");
16571 printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
16572 if (test_lvs_1 () == -1) {
16573 printf ("test_lvs_1 FAILED\n");
16577 printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
16578 if (test_vgs_0 () == -1) {
16579 printf ("test_vgs_0 FAILED\n");
16583 printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
16584 if (test_vgs_1 () == -1) {
16585 printf ("test_vgs_1 FAILED\n");
16589 printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
16590 if (test_pvs_0 () == -1) {
16591 printf ("test_pvs_0 FAILED\n");
16595 printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
16596 if (test_pvs_1 () == -1) {
16597 printf ("test_pvs_1 FAILED\n");
16601 printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
16602 if (test_list_partitions_0 () == -1) {
16603 printf ("test_list_partitions_0 FAILED\n");
16607 printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
16608 if (test_list_partitions_1 () == -1) {
16609 printf ("test_list_partitions_1 FAILED\n");
16613 printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
16614 if (test_list_devices_0 () == -1) {
16615 printf ("test_list_devices_0 FAILED\n");
16619 printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
16620 if (test_ls_0 () == -1) {
16621 printf ("test_ls_0 FAILED\n");
16625 printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
16626 if (test_cat_0 () == -1) {
16627 printf ("test_cat_0 FAILED\n");
16631 printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
16632 if (test_touch_0 () == -1) {
16633 printf ("test_touch_0 FAILED\n");
16637 printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
16638 if (test_sync_0 () == -1) {
16639 printf ("test_sync_0 FAILED\n");
16643 printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
16644 if (test_mount_0 () == -1) {
16645 printf ("test_mount_0 FAILED\n");
16650 unlink ("test1.img");
16651 unlink ("test2.img");
16652 unlink ("test3.img");
16655 printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);