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");
153 static int test_ntfs_3g_probe_0_skip (void)
157 str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0");
158 if (str && strcmp (str, "1") == 0) return 1;
159 str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
160 if (str && strcmp (str, "1") == 0) return 1;
164 static int test_ntfs_3g_probe_0 (void)
166 if (test_ntfs_3g_probe_0_skip ()) {
167 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ntfs_3g_probe_0");
171 /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
173 char device[] = "/dev/sda";
176 r = guestfs_blockdev_setrw (g, device);
183 r = guestfs_umount_all (g);
190 r = guestfs_lvm_remove_all (g);
194 /* TestOutputInt for ntfs_3g_probe (0) */
196 char device[] = "/dev/sda";
197 char lines_0[] = ",";
204 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
209 char fstype[] = "ntfs";
210 char device[] = "/dev/sda1";
213 r = guestfs_mkfs (g, fstype, device);
218 char device[] = "/dev/sda1";
221 r = guestfs_ntfs_3g_probe (g, 1, device);
225 fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n", (int) r);
232 static int test_ntfs_3g_probe_1_skip (void)
236 str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
237 if (str && strcmp (str, "1") == 0) return 1;
238 str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
239 if (str && strcmp (str, "1") == 0) return 1;
243 static int test_ntfs_3g_probe_1 (void)
245 if (test_ntfs_3g_probe_1_skip ()) {
246 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ntfs_3g_probe_1");
250 /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
252 char device[] = "/dev/sda";
255 r = guestfs_blockdev_setrw (g, device);
262 r = guestfs_umount_all (g);
269 r = guestfs_lvm_remove_all (g);
273 /* TestOutputInt for ntfs_3g_probe (1) */
275 char device[] = "/dev/sda";
276 char lines_0[] = ",";
283 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
288 char fstype[] = "ext2";
289 char device[] = "/dev/sda1";
292 r = guestfs_mkfs (g, fstype, device);
297 char device[] = "/dev/sda1";
300 r = guestfs_ntfs_3g_probe (g, 1, device);
304 fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n", (int) r);
311 static int test_sleep_0_skip (void)
315 str = getenv ("SKIP_TEST_SLEEP_0");
316 if (str && strcmp (str, "1") == 0) return 1;
317 str = getenv ("SKIP_TEST_SLEEP");
318 if (str && strcmp (str, "1") == 0) return 1;
322 static int test_sleep_0 (void)
324 if (test_sleep_0_skip ()) {
325 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sleep_0");
329 /* InitNone|InitEmpty for test_sleep_0 */
331 char device[] = "/dev/sda";
334 r = guestfs_blockdev_setrw (g, device);
341 r = guestfs_umount_all (g);
348 r = guestfs_lvm_remove_all (g);
352 /* TestRun for sleep (0) */
356 r = guestfs_sleep (g, 1);
363 static int test_find_0_skip (void)
367 str = getenv ("SKIP_TEST_FIND_0");
368 if (str && strcmp (str, "1") == 0) return 1;
369 str = getenv ("SKIP_TEST_FIND");
370 if (str && strcmp (str, "1") == 0) return 1;
374 static int test_find_0 (void)
376 if (test_find_0_skip ()) {
377 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_0");
381 /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
383 char device[] = "/dev/sda";
386 r = guestfs_blockdev_setrw (g, device);
393 r = guestfs_umount_all (g);
400 r = guestfs_lvm_remove_all (g);
405 char device[] = "/dev/sda";
406 char lines_0[] = ",";
413 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
418 char fstype[] = "ext2";
419 char device[] = "/dev/sda1";
422 r = guestfs_mkfs (g, fstype, device);
427 char device[] = "/dev/sda1";
428 char mountpoint[] = "/";
431 r = guestfs_mount (g, device, mountpoint);
435 /* TestOutputList for find (0) */
437 char directory[] = "/";
441 r = guestfs_find (g, directory);
445 fprintf (stderr, "test_find_0: short list returned from command\n");
450 char expected[] = "lost+found";
451 if (strcmp (r[0], expected) != 0) {
452 fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
457 fprintf (stderr, "test_find_0: extra elements returned from command\n");
461 for (i = 0; r[i] != NULL; ++i)
468 static int test_find_1_skip (void)
472 str = getenv ("SKIP_TEST_FIND_1");
473 if (str && strcmp (str, "1") == 0) return 1;
474 str = getenv ("SKIP_TEST_FIND");
475 if (str && strcmp (str, "1") == 0) return 1;
479 static int test_find_1 (void)
481 if (test_find_1_skip ()) {
482 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_1");
486 /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
488 char device[] = "/dev/sda";
491 r = guestfs_blockdev_setrw (g, device);
498 r = guestfs_umount_all (g);
505 r = guestfs_lvm_remove_all (g);
510 char device[] = "/dev/sda";
511 char lines_0[] = ",";
518 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
523 char fstype[] = "ext2";
524 char device[] = "/dev/sda1";
527 r = guestfs_mkfs (g, fstype, device);
532 char device[] = "/dev/sda1";
533 char mountpoint[] = "/";
536 r = guestfs_mount (g, device, mountpoint);
540 /* TestOutputList for find (1) */
545 r = guestfs_touch (g, path);
553 r = guestfs_mkdir (g, path);
558 char path[] = "/b/c";
561 r = guestfs_touch (g, path);
566 char directory[] = "/";
570 r = guestfs_find (g, directory);
574 fprintf (stderr, "test_find_1: short list returned from command\n");
579 char expected[] = "a";
580 if (strcmp (r[0], expected) != 0) {
581 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
586 fprintf (stderr, "test_find_1: short list returned from command\n");
591 char expected[] = "b";
592 if (strcmp (r[1], expected) != 0) {
593 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
598 fprintf (stderr, "test_find_1: short list returned from command\n");
603 char expected[] = "b/c";
604 if (strcmp (r[2], expected) != 0) {
605 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
610 fprintf (stderr, "test_find_1: short list returned from command\n");
615 char expected[] = "lost+found";
616 if (strcmp (r[3], expected) != 0) {
617 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
622 fprintf (stderr, "test_find_1: extra elements returned from command\n");
626 for (i = 0; r[i] != NULL; ++i)
633 static int test_find_2_skip (void)
637 str = getenv ("SKIP_TEST_FIND_2");
638 if (str && strcmp (str, "1") == 0) return 1;
639 str = getenv ("SKIP_TEST_FIND");
640 if (str && strcmp (str, "1") == 0) return 1;
644 static int test_find_2 (void)
646 if (test_find_2_skip ()) {
647 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_2");
651 /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
653 char device[] = "/dev/sda";
656 r = guestfs_blockdev_setrw (g, device);
663 r = guestfs_umount_all (g);
670 r = guestfs_lvm_remove_all (g);
675 char device[] = "/dev/sda";
676 char lines_0[] = ",";
683 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
688 char fstype[] = "ext2";
689 char device[] = "/dev/sda1";
692 r = guestfs_mkfs (g, fstype, device);
697 char device[] = "/dev/sda1";
698 char mountpoint[] = "/";
701 r = guestfs_mount (g, device, mountpoint);
705 /* TestOutputList for find (2) */
707 char path[] = "/a/b/c";
710 r = guestfs_mkdir_p (g, path);
715 char path[] = "/a/b/c/d";
718 r = guestfs_touch (g, path);
723 char directory[] = "/a/b/";
727 r = guestfs_find (g, directory);
731 fprintf (stderr, "test_find_2: short list returned from command\n");
736 char expected[] = "c";
737 if (strcmp (r[0], expected) != 0) {
738 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
743 fprintf (stderr, "test_find_2: short list returned from command\n");
748 char expected[] = "c/d";
749 if (strcmp (r[1], expected) != 0) {
750 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
755 fprintf (stderr, "test_find_2: extra elements returned from command\n");
759 for (i = 0; r[i] != NULL; ++i)
766 static int test_lvresize_0_skip (void)
770 str = getenv ("SKIP_TEST_LVRESIZE_0");
771 if (str && strcmp (str, "1") == 0) return 1;
772 str = getenv ("SKIP_TEST_LVRESIZE");
773 if (str && strcmp (str, "1") == 0) return 1;
777 static int test_lvresize_0 (void)
779 if (test_lvresize_0_skip ()) {
780 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvresize_0");
784 /* InitNone|InitEmpty for test_lvresize_0 */
786 char device[] = "/dev/sda";
789 r = guestfs_blockdev_setrw (g, device);
796 r = guestfs_umount_all (g);
803 r = guestfs_lvm_remove_all (g);
807 /* TestOutput for lvresize (0) */
808 char expected[] = "test content";
810 char device[] = "/dev/sda";
811 char lines_0[] = ",";
818 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
823 char device[] = "/dev/sda1";
826 r = guestfs_pvcreate (g, device);
831 char volgroup[] = "VG";
832 char physvols_0[] = "/dev/sda1";
839 r = guestfs_vgcreate (g, volgroup, physvols);
844 char logvol[] = "LV";
845 char volgroup[] = "VG";
848 r = guestfs_lvcreate (g, logvol, volgroup, 10);
853 char fstype[] = "ext2";
854 char device[] = "/dev/VG/LV";
857 r = guestfs_mkfs (g, fstype, device);
862 char device[] = "/dev/VG/LV";
863 char mountpoint[] = "/";
866 r = guestfs_mount (g, device, mountpoint);
871 char path[] = "/new";
872 char content[] = "test content";
875 r = guestfs_write_file (g, path, content, 0);
880 char pathordevice[] = "/";
883 r = guestfs_umount (g, pathordevice);
888 char device[] = "/dev/VG/LV";
891 r = guestfs_lvresize (g, device, 20);
896 char device[] = "/dev/VG/LV";
899 r = guestfs_e2fsck_f (g, device);
904 char device[] = "/dev/VG/LV";
907 r = guestfs_resize2fs (g, device);
912 char device[] = "/dev/VG/LV";
913 char mountpoint[] = "/";
916 r = guestfs_mount (g, device, mountpoint);
921 char path[] = "/new";
924 r = guestfs_cat (g, path);
927 if (strcmp (r, expected) != 0) {
928 fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
936 static int test_zerofree_0_skip (void)
940 str = getenv ("SKIP_TEST_ZEROFREE_0");
941 if (str && strcmp (str, "1") == 0) return 1;
942 str = getenv ("SKIP_TEST_ZEROFREE");
943 if (str && strcmp (str, "1") == 0) return 1;
947 static int test_zerofree_0 (void)
949 if (test_zerofree_0_skip ()) {
950 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zerofree_0");
954 /* InitNone|InitEmpty for test_zerofree_0 */
956 char device[] = "/dev/sda";
959 r = guestfs_blockdev_setrw (g, device);
966 r = guestfs_umount_all (g);
973 r = guestfs_lvm_remove_all (g);
977 /* TestOutput for zerofree (0) */
978 char expected[] = "test file";
980 char device[] = "/dev/sda";
981 char lines_0[] = ",";
988 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
993 char fstype[] = "ext3";
994 char device[] = "/dev/sda1";
997 r = guestfs_mkfs (g, fstype, device);
1002 char device[] = "/dev/sda1";
1003 char mountpoint[] = "/";
1006 r = guestfs_mount (g, device, mountpoint);
1011 char path[] = "/new";
1012 char content[] = "test file";
1015 r = guestfs_write_file (g, path, content, 0);
1020 char pathordevice[] = "/dev/sda1";
1023 r = guestfs_umount (g, pathordevice);
1028 char device[] = "/dev/sda1";
1031 r = guestfs_zerofree (g, device);
1036 char device[] = "/dev/sda1";
1037 char mountpoint[] = "/";
1040 r = guestfs_mount (g, device, mountpoint);
1045 char path[] = "/new";
1048 r = guestfs_cat (g, path);
1051 if (strcmp (r, expected) != 0) {
1052 fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
1060 static int test_hexdump_0_skip (void)
1064 str = getenv ("SKIP_TEST_HEXDUMP_0");
1065 if (str && strcmp (str, "1") == 0) return 1;
1066 str = getenv ("SKIP_TEST_HEXDUMP");
1067 if (str && strcmp (str, "1") == 0) return 1;
1071 static int test_hexdump_0 (void)
1073 if (test_hexdump_0_skip ()) {
1074 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_hexdump_0");
1078 /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
1080 char device[] = "/dev/sda";
1083 r = guestfs_blockdev_setrw (g, device);
1090 r = guestfs_umount_all (g);
1097 r = guestfs_lvm_remove_all (g);
1102 char device[] = "/dev/sda";
1103 char lines_0[] = ",";
1110 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1115 char fstype[] = "ext2";
1116 char device[] = "/dev/sda1";
1119 r = guestfs_mkfs (g, fstype, device);
1124 char device[] = "/dev/sda1";
1125 char mountpoint[] = "/";
1128 r = guestfs_mount (g, device, mountpoint);
1132 /* TestOutput for hexdump (0) */
1133 char expected[] = "00000000 68 65 6c 6c 6f 0a 77 6f 72 6c 64 0a |hello.world.|\n0000000c\n";
1135 char path[] = "/new";
1136 char content[] = "hello\nworld\n";
1139 r = guestfs_write_file (g, path, content, 12);
1144 char path[] = "/new";
1147 r = guestfs_hexdump (g, path);
1150 if (strcmp (r, expected) != 0) {
1151 fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
1159 static int test_strings_e_0_skip (void)
1163 str = getenv ("SKIP_TEST_STRINGS_E_0");
1164 if (str && strcmp (str, "1") == 0) return 1;
1165 str = getenv ("SKIP_TEST_STRINGS_E");
1166 if (str && strcmp (str, "1") == 0) return 1;
1170 static int test_strings_e_0 (void)
1172 if (test_strings_e_0_skip ()) {
1173 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_0");
1177 /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
1179 char device[] = "/dev/sda";
1182 r = guestfs_blockdev_setrw (g, device);
1189 r = guestfs_umount_all (g);
1196 r = guestfs_lvm_remove_all (g);
1201 char device[] = "/dev/sda";
1202 char lines_0[] = ",";
1209 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1214 char fstype[] = "ext2";
1215 char device[] = "/dev/sda1";
1218 r = guestfs_mkfs (g, fstype, device);
1223 char device[] = "/dev/sda1";
1224 char mountpoint[] = "/";
1227 r = guestfs_mount (g, device, mountpoint);
1231 /* TestOutputList for strings_e (0) */
1233 char path[] = "/new";
1234 char content[] = "hello\nworld\n";
1237 r = guestfs_write_file (g, path, content, 0);
1242 char encoding[] = "b";
1243 char path[] = "/new";
1247 r = guestfs_strings_e (g, encoding, path);
1251 fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
1255 for (i = 0; r[i] != NULL; ++i)
1262 static int test_strings_e_1_skip (void)
1266 str = getenv ("SKIP_TEST_STRINGS_E_1");
1267 if (str && strcmp (str, "1") == 0) return 1;
1268 str = getenv ("SKIP_TEST_STRINGS_E");
1269 if (str && strcmp (str, "1") == 0) return 1;
1273 static int test_strings_e_1 (void)
1275 if (test_strings_e_1_skip ()) {
1276 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_1");
1280 printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
1284 static int test_strings_0_skip (void)
1288 str = getenv ("SKIP_TEST_STRINGS_0");
1289 if (str && strcmp (str, "1") == 0) return 1;
1290 str = getenv ("SKIP_TEST_STRINGS");
1291 if (str && strcmp (str, "1") == 0) return 1;
1295 static int test_strings_0 (void)
1297 if (test_strings_0_skip ()) {
1298 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_0");
1302 /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
1304 char device[] = "/dev/sda";
1307 r = guestfs_blockdev_setrw (g, device);
1314 r = guestfs_umount_all (g);
1321 r = guestfs_lvm_remove_all (g);
1326 char device[] = "/dev/sda";
1327 char lines_0[] = ",";
1334 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1339 char fstype[] = "ext2";
1340 char device[] = "/dev/sda1";
1343 r = guestfs_mkfs (g, fstype, device);
1348 char device[] = "/dev/sda1";
1349 char mountpoint[] = "/";
1352 r = guestfs_mount (g, device, mountpoint);
1356 /* TestOutputList for strings (0) */
1358 char path[] = "/new";
1359 char content[] = "hello\nworld\n";
1362 r = guestfs_write_file (g, path, content, 0);
1367 char path[] = "/new";
1371 r = guestfs_strings (g, path);
1375 fprintf (stderr, "test_strings_0: short list returned from command\n");
1380 char expected[] = "hello";
1381 if (strcmp (r[0], expected) != 0) {
1382 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1387 fprintf (stderr, "test_strings_0: short list returned from command\n");
1392 char expected[] = "world";
1393 if (strcmp (r[1], expected) != 0) {
1394 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1399 fprintf (stderr, "test_strings_0: extra elements returned from command\n");
1403 for (i = 0; r[i] != NULL; ++i)
1410 static int test_strings_1_skip (void)
1414 str = getenv ("SKIP_TEST_STRINGS_1");
1415 if (str && strcmp (str, "1") == 0) return 1;
1416 str = getenv ("SKIP_TEST_STRINGS");
1417 if (str && strcmp (str, "1") == 0) return 1;
1421 static int test_strings_1 (void)
1423 if (test_strings_1_skip ()) {
1424 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_1");
1428 /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
1430 char device[] = "/dev/sda";
1433 r = guestfs_blockdev_setrw (g, device);
1440 r = guestfs_umount_all (g);
1447 r = guestfs_lvm_remove_all (g);
1452 char device[] = "/dev/sda";
1453 char lines_0[] = ",";
1460 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1465 char fstype[] = "ext2";
1466 char device[] = "/dev/sda1";
1469 r = guestfs_mkfs (g, fstype, device);
1474 char device[] = "/dev/sda1";
1475 char mountpoint[] = "/";
1478 r = guestfs_mount (g, device, mountpoint);
1482 /* TestOutputList for strings (1) */
1484 char path[] = "/new";
1487 r = guestfs_touch (g, path);
1492 char path[] = "/new";
1496 r = guestfs_strings (g, path);
1500 fprintf (stderr, "test_strings_1: extra elements returned from command\n");
1504 for (i = 0; r[i] != NULL; ++i)
1511 static int test_equal_0_skip (void)
1515 str = getenv ("SKIP_TEST_EQUAL_0");
1516 if (str && strcmp (str, "1") == 0) return 1;
1517 str = getenv ("SKIP_TEST_EQUAL");
1518 if (str && strcmp (str, "1") == 0) return 1;
1522 static int test_equal_0 (void)
1524 if (test_equal_0_skip ()) {
1525 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_0");
1529 /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
1531 char device[] = "/dev/sda";
1534 r = guestfs_blockdev_setrw (g, device);
1541 r = guestfs_umount_all (g);
1548 r = guestfs_lvm_remove_all (g);
1553 char device[] = "/dev/sda";
1554 char lines_0[] = ",";
1561 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1566 char fstype[] = "ext2";
1567 char device[] = "/dev/sda1";
1570 r = guestfs_mkfs (g, fstype, device);
1575 char device[] = "/dev/sda1";
1576 char mountpoint[] = "/";
1579 r = guestfs_mount (g, device, mountpoint);
1583 /* TestOutputTrue for equal (0) */
1585 char path[] = "/file1";
1586 char content[] = "contents of a file";
1589 r = guestfs_write_file (g, path, content, 0);
1594 char src[] = "/file1";
1595 char dest[] = "/file2";
1598 r = guestfs_cp (g, src, dest);
1603 char file1[] = "/file1";
1604 char file2[] = "/file2";
1607 r = guestfs_equal (g, file1, file2);
1611 fprintf (stderr, "test_equal_0: expected true, got false\n");
1618 static int test_equal_1_skip (void)
1622 str = getenv ("SKIP_TEST_EQUAL_1");
1623 if (str && strcmp (str, "1") == 0) return 1;
1624 str = getenv ("SKIP_TEST_EQUAL");
1625 if (str && strcmp (str, "1") == 0) return 1;
1629 static int test_equal_1 (void)
1631 if (test_equal_1_skip ()) {
1632 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_1");
1636 /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
1638 char device[] = "/dev/sda";
1641 r = guestfs_blockdev_setrw (g, device);
1648 r = guestfs_umount_all (g);
1655 r = guestfs_lvm_remove_all (g);
1660 char device[] = "/dev/sda";
1661 char lines_0[] = ",";
1668 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1673 char fstype[] = "ext2";
1674 char device[] = "/dev/sda1";
1677 r = guestfs_mkfs (g, fstype, device);
1682 char device[] = "/dev/sda1";
1683 char mountpoint[] = "/";
1686 r = guestfs_mount (g, device, mountpoint);
1690 /* TestOutputFalse for equal (1) */
1692 char path[] = "/file1";
1693 char content[] = "contents of a file";
1696 r = guestfs_write_file (g, path, content, 0);
1701 char path[] = "/file2";
1702 char content[] = "contents of another file";
1705 r = guestfs_write_file (g, path, content, 0);
1710 char file1[] = "/file1";
1711 char file2[] = "/file2";
1714 r = guestfs_equal (g, file1, file2);
1718 fprintf (stderr, "test_equal_1: expected false, got true\n");
1725 static int test_equal_2_skip (void)
1729 str = getenv ("SKIP_TEST_EQUAL_2");
1730 if (str && strcmp (str, "1") == 0) return 1;
1731 str = getenv ("SKIP_TEST_EQUAL");
1732 if (str && strcmp (str, "1") == 0) return 1;
1736 static int test_equal_2 (void)
1738 if (test_equal_2_skip ()) {
1739 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_2");
1743 /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
1745 char device[] = "/dev/sda";
1748 r = guestfs_blockdev_setrw (g, device);
1755 r = guestfs_umount_all (g);
1762 r = guestfs_lvm_remove_all (g);
1767 char device[] = "/dev/sda";
1768 char lines_0[] = ",";
1775 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1780 char fstype[] = "ext2";
1781 char device[] = "/dev/sda1";
1784 r = guestfs_mkfs (g, fstype, device);
1789 char device[] = "/dev/sda1";
1790 char mountpoint[] = "/";
1793 r = guestfs_mount (g, device, mountpoint);
1797 /* TestLastFail for equal (2) */
1799 char file1[] = "/file1";
1800 char file2[] = "/file2";
1803 r = guestfs_equal (g, file1, file2);
1810 static int test_ping_daemon_0_skip (void)
1814 str = getenv ("SKIP_TEST_PING_DAEMON_0");
1815 if (str && strcmp (str, "1") == 0) return 1;
1816 str = getenv ("SKIP_TEST_PING_DAEMON");
1817 if (str && strcmp (str, "1") == 0) return 1;
1821 static int test_ping_daemon_0 (void)
1823 if (test_ping_daemon_0_skip ()) {
1824 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ping_daemon_0");
1828 /* InitNone|InitEmpty for test_ping_daemon_0 */
1830 char device[] = "/dev/sda";
1833 r = guestfs_blockdev_setrw (g, device);
1840 r = guestfs_umount_all (g);
1847 r = guestfs_lvm_remove_all (g);
1851 /* TestRun for ping_daemon (0) */
1855 r = guestfs_ping_daemon (g);
1862 static int test_dmesg_0_skip (void)
1866 str = getenv ("SKIP_TEST_DMESG_0");
1867 if (str && strcmp (str, "1") == 0) return 1;
1868 str = getenv ("SKIP_TEST_DMESG");
1869 if (str && strcmp (str, "1") == 0) return 1;
1873 static int test_dmesg_0 (void)
1875 if (test_dmesg_0_skip ()) {
1876 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_dmesg_0");
1880 /* InitNone|InitEmpty for test_dmesg_0 */
1882 char device[] = "/dev/sda";
1885 r = guestfs_blockdev_setrw (g, device);
1892 r = guestfs_umount_all (g);
1899 r = guestfs_lvm_remove_all (g);
1903 /* TestRun for dmesg (0) */
1907 r = guestfs_dmesg (g);
1915 static int test_drop_caches_0_skip (void)
1919 str = getenv ("SKIP_TEST_DROP_CACHES_0");
1920 if (str && strcmp (str, "1") == 0) return 1;
1921 str = getenv ("SKIP_TEST_DROP_CACHES");
1922 if (str && strcmp (str, "1") == 0) return 1;
1926 static int test_drop_caches_0 (void)
1928 if (test_drop_caches_0_skip ()) {
1929 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_drop_caches_0");
1933 /* InitNone|InitEmpty for test_drop_caches_0 */
1935 char device[] = "/dev/sda";
1938 r = guestfs_blockdev_setrw (g, device);
1945 r = guestfs_umount_all (g);
1952 r = guestfs_lvm_remove_all (g);
1956 /* TestRun for drop_caches (0) */
1960 r = guestfs_drop_caches (g, 3);
1967 static int test_mv_0_skip (void)
1971 str = getenv ("SKIP_TEST_MV_0");
1972 if (str && strcmp (str, "1") == 0) return 1;
1973 str = getenv ("SKIP_TEST_MV");
1974 if (str && strcmp (str, "1") == 0) return 1;
1978 static int test_mv_0 (void)
1980 if (test_mv_0_skip ()) {
1981 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_0");
1985 /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
1987 char device[] = "/dev/sda";
1990 r = guestfs_blockdev_setrw (g, device);
1997 r = guestfs_umount_all (g);
2004 r = guestfs_lvm_remove_all (g);
2009 char device[] = "/dev/sda";
2010 char lines_0[] = ",";
2017 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2022 char fstype[] = "ext2";
2023 char device[] = "/dev/sda1";
2026 r = guestfs_mkfs (g, fstype, device);
2031 char device[] = "/dev/sda1";
2032 char mountpoint[] = "/";
2035 r = guestfs_mount (g, device, mountpoint);
2039 /* TestOutput for mv (0) */
2040 char expected[] = "file content";
2042 char path[] = "/old";
2043 char content[] = "file content";
2046 r = guestfs_write_file (g, path, content, 0);
2051 char src[] = "/old";
2052 char dest[] = "/new";
2055 r = guestfs_mv (g, src, dest);
2060 char path[] = "/new";
2063 r = guestfs_cat (g, path);
2066 if (strcmp (r, expected) != 0) {
2067 fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
2075 static int test_mv_1_skip (void)
2079 str = getenv ("SKIP_TEST_MV_1");
2080 if (str && strcmp (str, "1") == 0) return 1;
2081 str = getenv ("SKIP_TEST_MV");
2082 if (str && strcmp (str, "1") == 0) return 1;
2086 static int test_mv_1 (void)
2088 if (test_mv_1_skip ()) {
2089 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_1");
2093 /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
2095 char device[] = "/dev/sda";
2098 r = guestfs_blockdev_setrw (g, device);
2105 r = guestfs_umount_all (g);
2112 r = guestfs_lvm_remove_all (g);
2117 char device[] = "/dev/sda";
2118 char lines_0[] = ",";
2125 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2130 char fstype[] = "ext2";
2131 char device[] = "/dev/sda1";
2134 r = guestfs_mkfs (g, fstype, device);
2139 char device[] = "/dev/sda1";
2140 char mountpoint[] = "/";
2143 r = guestfs_mount (g, device, mountpoint);
2147 /* TestOutputFalse for mv (1) */
2149 char path[] = "/old";
2150 char content[] = "file content";
2153 r = guestfs_write_file (g, path, content, 0);
2158 char src[] = "/old";
2159 char dest[] = "/new";
2162 r = guestfs_mv (g, src, dest);
2167 char path[] = "/old";
2170 r = guestfs_is_file (g, path);
2174 fprintf (stderr, "test_mv_1: expected false, got true\n");
2181 static int test_cp_a_0_skip (void)
2185 str = getenv ("SKIP_TEST_CP_A_0");
2186 if (str && strcmp (str, "1") == 0) return 1;
2187 str = getenv ("SKIP_TEST_CP_A");
2188 if (str && strcmp (str, "1") == 0) return 1;
2192 static int test_cp_a_0 (void)
2194 if (test_cp_a_0_skip ()) {
2195 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_a_0");
2199 /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
2201 char device[] = "/dev/sda";
2204 r = guestfs_blockdev_setrw (g, device);
2211 r = guestfs_umount_all (g);
2218 r = guestfs_lvm_remove_all (g);
2223 char device[] = "/dev/sda";
2224 char lines_0[] = ",";
2231 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2236 char fstype[] = "ext2";
2237 char device[] = "/dev/sda1";
2240 r = guestfs_mkfs (g, fstype, device);
2245 char device[] = "/dev/sda1";
2246 char mountpoint[] = "/";
2249 r = guestfs_mount (g, device, mountpoint);
2253 /* TestOutput for cp_a (0) */
2254 char expected[] = "file content";
2256 char path[] = "/olddir";
2259 r = guestfs_mkdir (g, path);
2264 char path[] = "/newdir";
2267 r = guestfs_mkdir (g, path);
2272 char path[] = "/olddir/file";
2273 char content[] = "file content";
2276 r = guestfs_write_file (g, path, content, 0);
2281 char src[] = "/olddir";
2282 char dest[] = "/newdir";
2285 r = guestfs_cp_a (g, src, dest);
2290 char path[] = "/newdir/olddir/file";
2293 r = guestfs_cat (g, path);
2296 if (strcmp (r, expected) != 0) {
2297 fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
2305 static int test_cp_0_skip (void)
2309 str = getenv ("SKIP_TEST_CP_0");
2310 if (str && strcmp (str, "1") == 0) return 1;
2311 str = getenv ("SKIP_TEST_CP");
2312 if (str && strcmp (str, "1") == 0) return 1;
2316 static int test_cp_0 (void)
2318 if (test_cp_0_skip ()) {
2319 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_0");
2323 /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
2325 char device[] = "/dev/sda";
2328 r = guestfs_blockdev_setrw (g, device);
2335 r = guestfs_umount_all (g);
2342 r = guestfs_lvm_remove_all (g);
2347 char device[] = "/dev/sda";
2348 char lines_0[] = ",";
2355 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2360 char fstype[] = "ext2";
2361 char device[] = "/dev/sda1";
2364 r = guestfs_mkfs (g, fstype, device);
2369 char device[] = "/dev/sda1";
2370 char mountpoint[] = "/";
2373 r = guestfs_mount (g, device, mountpoint);
2377 /* TestOutput for cp (0) */
2378 char expected[] = "file content";
2380 char path[] = "/old";
2381 char content[] = "file content";
2384 r = guestfs_write_file (g, path, content, 0);
2389 char src[] = "/old";
2390 char dest[] = "/new";
2393 r = guestfs_cp (g, src, dest);
2398 char path[] = "/new";
2401 r = guestfs_cat (g, path);
2404 if (strcmp (r, expected) != 0) {
2405 fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
2413 static int test_cp_1_skip (void)
2417 str = getenv ("SKIP_TEST_CP_1");
2418 if (str && strcmp (str, "1") == 0) return 1;
2419 str = getenv ("SKIP_TEST_CP");
2420 if (str && strcmp (str, "1") == 0) return 1;
2424 static int test_cp_1 (void)
2426 if (test_cp_1_skip ()) {
2427 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_1");
2431 /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
2433 char device[] = "/dev/sda";
2436 r = guestfs_blockdev_setrw (g, device);
2443 r = guestfs_umount_all (g);
2450 r = guestfs_lvm_remove_all (g);
2455 char device[] = "/dev/sda";
2456 char lines_0[] = ",";
2463 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2468 char fstype[] = "ext2";
2469 char device[] = "/dev/sda1";
2472 r = guestfs_mkfs (g, fstype, device);
2477 char device[] = "/dev/sda1";
2478 char mountpoint[] = "/";
2481 r = guestfs_mount (g, device, mountpoint);
2485 /* TestOutputTrue for cp (1) */
2487 char path[] = "/old";
2488 char content[] = "file content";
2491 r = guestfs_write_file (g, path, content, 0);
2496 char src[] = "/old";
2497 char dest[] = "/new";
2500 r = guestfs_cp (g, src, dest);
2505 char path[] = "/old";
2508 r = guestfs_is_file (g, path);
2512 fprintf (stderr, "test_cp_1: expected true, got false\n");
2519 static int test_cp_2_skip (void)
2523 str = getenv ("SKIP_TEST_CP_2");
2524 if (str && strcmp (str, "1") == 0) return 1;
2525 str = getenv ("SKIP_TEST_CP");
2526 if (str && strcmp (str, "1") == 0) return 1;
2530 static int test_cp_2 (void)
2532 if (test_cp_2_skip ()) {
2533 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_2");
2537 /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
2539 char device[] = "/dev/sda";
2542 r = guestfs_blockdev_setrw (g, device);
2549 r = guestfs_umount_all (g);
2556 r = guestfs_lvm_remove_all (g);
2561 char device[] = "/dev/sda";
2562 char lines_0[] = ",";
2569 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2574 char fstype[] = "ext2";
2575 char device[] = "/dev/sda1";
2578 r = guestfs_mkfs (g, fstype, device);
2583 char device[] = "/dev/sda1";
2584 char mountpoint[] = "/";
2587 r = guestfs_mount (g, device, mountpoint);
2591 /* TestOutput for cp (2) */
2592 char expected[] = "file content";
2594 char path[] = "/old";
2595 char content[] = "file content";
2598 r = guestfs_write_file (g, path, content, 0);
2603 char path[] = "/dir";
2606 r = guestfs_mkdir (g, path);
2611 char src[] = "/old";
2612 char dest[] = "/dir/new";
2615 r = guestfs_cp (g, src, dest);
2620 char path[] = "/dir/new";
2623 r = guestfs_cat (g, path);
2626 if (strcmp (r, expected) != 0) {
2627 fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
2635 static int test_grub_install_0_skip (void)
2639 str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
2640 if (str && strcmp (str, "1") == 0) return 1;
2641 str = getenv ("SKIP_TEST_GRUB_INSTALL");
2642 if (str && strcmp (str, "1") == 0) return 1;
2646 static int test_grub_install_0 (void)
2648 if (test_grub_install_0_skip ()) {
2649 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_grub_install_0");
2653 /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
2655 char device[] = "/dev/sda";
2658 r = guestfs_blockdev_setrw (g, device);
2665 r = guestfs_umount_all (g);
2672 r = guestfs_lvm_remove_all (g);
2677 char device[] = "/dev/sda";
2678 char lines_0[] = ",";
2685 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2690 char fstype[] = "ext2";
2691 char device[] = "/dev/sda1";
2694 r = guestfs_mkfs (g, fstype, device);
2699 char device[] = "/dev/sda1";
2700 char mountpoint[] = "/";
2703 r = guestfs_mount (g, device, mountpoint);
2707 /* TestOutputTrue for grub_install (0) */
2710 char device[] = "/dev/sda1";
2713 r = guestfs_grub_install (g, root, device);
2718 char path[] = "/boot";
2721 r = guestfs_is_dir (g, path);
2725 fprintf (stderr, "test_grub_install_0: expected true, got false\n");
2732 static int test_zero_0_skip (void)
2736 str = getenv ("SKIP_TEST_ZERO_0");
2737 if (str && strcmp (str, "1") == 0) return 1;
2738 str = getenv ("SKIP_TEST_ZERO");
2739 if (str && strcmp (str, "1") == 0) return 1;
2743 static int test_zero_0 (void)
2745 if (test_zero_0_skip ()) {
2746 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zero_0");
2750 /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
2752 char device[] = "/dev/sda";
2755 r = guestfs_blockdev_setrw (g, device);
2762 r = guestfs_umount_all (g);
2769 r = guestfs_lvm_remove_all (g);
2774 char device[] = "/dev/sda";
2775 char lines_0[] = ",";
2782 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2787 char fstype[] = "ext2";
2788 char device[] = "/dev/sda1";
2791 r = guestfs_mkfs (g, fstype, device);
2796 char device[] = "/dev/sda1";
2797 char mountpoint[] = "/";
2800 r = guestfs_mount (g, device, mountpoint);
2804 /* TestOutput for zero (0) */
2805 char expected[] = "data";
2807 char pathordevice[] = "/dev/sda1";
2810 r = guestfs_umount (g, pathordevice);
2815 char device[] = "/dev/sda1";
2818 r = guestfs_zero (g, device);
2823 char path[] = "/dev/sda1";
2826 r = guestfs_file (g, path);
2829 if (strcmp (r, expected) != 0) {
2830 fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
2838 static int test_fsck_0_skip (void)
2842 str = getenv ("SKIP_TEST_FSCK_0");
2843 if (str && strcmp (str, "1") == 0) return 1;
2844 str = getenv ("SKIP_TEST_FSCK");
2845 if (str && strcmp (str, "1") == 0) return 1;
2849 static int test_fsck_0 (void)
2851 if (test_fsck_0_skip ()) {
2852 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_0");
2856 /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
2858 char device[] = "/dev/sda";
2861 r = guestfs_blockdev_setrw (g, device);
2868 r = guestfs_umount_all (g);
2875 r = guestfs_lvm_remove_all (g);
2880 char device[] = "/dev/sda";
2881 char lines_0[] = ",";
2888 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2893 char fstype[] = "ext2";
2894 char device[] = "/dev/sda1";
2897 r = guestfs_mkfs (g, fstype, device);
2902 char device[] = "/dev/sda1";
2903 char mountpoint[] = "/";
2906 r = guestfs_mount (g, device, mountpoint);
2910 /* TestOutputInt for fsck (0) */
2912 char pathordevice[] = "/dev/sda1";
2915 r = guestfs_umount (g, pathordevice);
2920 char fstype[] = "ext2";
2921 char device[] = "/dev/sda1";
2924 r = guestfs_fsck (g, fstype, device);
2928 fprintf (stderr, "test_fsck_0: expected 0 but got %d\n", (int) r);
2935 static int test_fsck_1_skip (void)
2939 str = getenv ("SKIP_TEST_FSCK_1");
2940 if (str && strcmp (str, "1") == 0) return 1;
2941 str = getenv ("SKIP_TEST_FSCK");
2942 if (str && strcmp (str, "1") == 0) return 1;
2946 static int test_fsck_1 (void)
2948 if (test_fsck_1_skip ()) {
2949 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_1");
2953 /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
2955 char device[] = "/dev/sda";
2958 r = guestfs_blockdev_setrw (g, device);
2965 r = guestfs_umount_all (g);
2972 r = guestfs_lvm_remove_all (g);
2977 char device[] = "/dev/sda";
2978 char lines_0[] = ",";
2985 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2990 char fstype[] = "ext2";
2991 char device[] = "/dev/sda1";
2994 r = guestfs_mkfs (g, fstype, device);
2999 char device[] = "/dev/sda1";
3000 char mountpoint[] = "/";
3003 r = guestfs_mount (g, device, mountpoint);
3007 /* TestOutputInt for fsck (1) */
3009 char pathordevice[] = "/dev/sda1";
3012 r = guestfs_umount (g, pathordevice);
3017 char device[] = "/dev/sda1";
3020 r = guestfs_zero (g, device);
3025 char fstype[] = "ext2";
3026 char device[] = "/dev/sda1";
3029 r = guestfs_fsck (g, fstype, device);
3033 fprintf (stderr, "test_fsck_1: expected 8 but got %d\n", (int) r);
3040 static int test_set_e2uuid_0_skip (void)
3044 str = getenv ("SKIP_TEST_SET_E2UUID_0");
3045 if (str && strcmp (str, "1") == 0) return 1;
3046 str = getenv ("SKIP_TEST_SET_E2UUID");
3047 if (str && strcmp (str, "1") == 0) return 1;
3051 static int test_set_e2uuid_0 (void)
3053 if (test_set_e2uuid_0_skip ()) {
3054 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_0");
3058 /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
3060 char device[] = "/dev/sda";
3063 r = guestfs_blockdev_setrw (g, device);
3070 r = guestfs_umount_all (g);
3077 r = guestfs_lvm_remove_all (g);
3082 char device[] = "/dev/sda";
3083 char lines_0[] = ",";
3090 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3095 char fstype[] = "ext2";
3096 char device[] = "/dev/sda1";
3099 r = guestfs_mkfs (g, fstype, device);
3104 char device[] = "/dev/sda1";
3105 char mountpoint[] = "/";
3108 r = guestfs_mount (g, device, mountpoint);
3112 /* TestOutput for set_e2uuid (0) */
3113 char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3115 char device[] = "/dev/sda1";
3116 char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3119 r = guestfs_set_e2uuid (g, device, uuid);
3124 char device[] = "/dev/sda1";
3127 r = guestfs_get_e2uuid (g, device);
3130 if (strcmp (r, expected) != 0) {
3131 fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
3139 static int test_set_e2uuid_1_skip (void)
3143 str = getenv ("SKIP_TEST_SET_E2UUID_1");
3144 if (str && strcmp (str, "1") == 0) return 1;
3145 str = getenv ("SKIP_TEST_SET_E2UUID");
3146 if (str && strcmp (str, "1") == 0) return 1;
3150 static int test_set_e2uuid_1 (void)
3152 if (test_set_e2uuid_1_skip ()) {
3153 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_1");
3157 /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
3159 char device[] = "/dev/sda";
3162 r = guestfs_blockdev_setrw (g, device);
3169 r = guestfs_umount_all (g);
3176 r = guestfs_lvm_remove_all (g);
3181 char device[] = "/dev/sda";
3182 char lines_0[] = ",";
3189 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3194 char fstype[] = "ext2";
3195 char device[] = "/dev/sda1";
3198 r = guestfs_mkfs (g, fstype, device);
3203 char device[] = "/dev/sda1";
3204 char mountpoint[] = "/";
3207 r = guestfs_mount (g, device, mountpoint);
3211 /* TestOutput for set_e2uuid (1) */
3212 char expected[] = "";
3214 char device[] = "/dev/sda1";
3215 char uuid[] = "clear";
3218 r = guestfs_set_e2uuid (g, device, uuid);
3223 char device[] = "/dev/sda1";
3226 r = guestfs_get_e2uuid (g, device);
3229 if (strcmp (r, expected) != 0) {
3230 fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
3238 static int test_set_e2uuid_2_skip (void)
3242 str = getenv ("SKIP_TEST_SET_E2UUID_2");
3243 if (str && strcmp (str, "1") == 0) return 1;
3244 str = getenv ("SKIP_TEST_SET_E2UUID");
3245 if (str && strcmp (str, "1") == 0) return 1;
3249 static int test_set_e2uuid_2 (void)
3251 if (test_set_e2uuid_2_skip ()) {
3252 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_2");
3256 /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
3258 char device[] = "/dev/sda";
3261 r = guestfs_blockdev_setrw (g, device);
3268 r = guestfs_umount_all (g);
3275 r = guestfs_lvm_remove_all (g);
3280 char device[] = "/dev/sda";
3281 char lines_0[] = ",";
3288 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3293 char fstype[] = "ext2";
3294 char device[] = "/dev/sda1";
3297 r = guestfs_mkfs (g, fstype, device);
3302 char device[] = "/dev/sda1";
3303 char mountpoint[] = "/";
3306 r = guestfs_mount (g, device, mountpoint);
3310 /* TestRun for set_e2uuid (2) */
3312 char device[] = "/dev/sda1";
3313 char uuid[] = "random";
3316 r = guestfs_set_e2uuid (g, device, uuid);
3323 static int test_set_e2uuid_3_skip (void)
3327 str = getenv ("SKIP_TEST_SET_E2UUID_3");
3328 if (str && strcmp (str, "1") == 0) return 1;
3329 str = getenv ("SKIP_TEST_SET_E2UUID");
3330 if (str && strcmp (str, "1") == 0) return 1;
3334 static int test_set_e2uuid_3 (void)
3336 if (test_set_e2uuid_3_skip ()) {
3337 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_3");
3341 /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
3343 char device[] = "/dev/sda";
3346 r = guestfs_blockdev_setrw (g, device);
3353 r = guestfs_umount_all (g);
3360 r = guestfs_lvm_remove_all (g);
3365 char device[] = "/dev/sda";
3366 char lines_0[] = ",";
3373 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3378 char fstype[] = "ext2";
3379 char device[] = "/dev/sda1";
3382 r = guestfs_mkfs (g, fstype, device);
3387 char device[] = "/dev/sda1";
3388 char mountpoint[] = "/";
3391 r = guestfs_mount (g, device, mountpoint);
3395 /* TestRun for set_e2uuid (3) */
3397 char device[] = "/dev/sda1";
3398 char uuid[] = "time";
3401 r = guestfs_set_e2uuid (g, device, uuid);
3408 static int test_set_e2label_0_skip (void)
3412 str = getenv ("SKIP_TEST_SET_E2LABEL_0");
3413 if (str && strcmp (str, "1") == 0) return 1;
3414 str = getenv ("SKIP_TEST_SET_E2LABEL");
3415 if (str && strcmp (str, "1") == 0) return 1;
3419 static int test_set_e2label_0 (void)
3421 if (test_set_e2label_0_skip ()) {
3422 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2label_0");
3426 /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
3428 char device[] = "/dev/sda";
3431 r = guestfs_blockdev_setrw (g, device);
3438 r = guestfs_umount_all (g);
3445 r = guestfs_lvm_remove_all (g);
3450 char device[] = "/dev/sda";
3451 char lines_0[] = ",";
3458 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3463 char fstype[] = "ext2";
3464 char device[] = "/dev/sda1";
3467 r = guestfs_mkfs (g, fstype, device);
3472 char device[] = "/dev/sda1";
3473 char mountpoint[] = "/";
3476 r = guestfs_mount (g, device, mountpoint);
3480 /* TestOutput for set_e2label (0) */
3481 char expected[] = "testlabel";
3483 char device[] = "/dev/sda1";
3484 char label[] = "testlabel";
3487 r = guestfs_set_e2label (g, device, label);
3492 char device[] = "/dev/sda1";
3495 r = guestfs_get_e2label (g, device);
3498 if (strcmp (r, expected) != 0) {
3499 fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
3507 static int test_pvremove_0_skip (void)
3511 str = getenv ("SKIP_TEST_PVREMOVE_0");
3512 if (str && strcmp (str, "1") == 0) return 1;
3513 str = getenv ("SKIP_TEST_PVREMOVE");
3514 if (str && strcmp (str, "1") == 0) return 1;
3518 static int test_pvremove_0 (void)
3520 if (test_pvremove_0_skip ()) {
3521 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_0");
3525 /* InitNone|InitEmpty for test_pvremove_0 */
3527 char device[] = "/dev/sda";
3530 r = guestfs_blockdev_setrw (g, device);
3537 r = guestfs_umount_all (g);
3544 r = guestfs_lvm_remove_all (g);
3548 /* TestOutputListOfDevices for pvremove (0) */
3550 char device[] = "/dev/sda";
3551 char lines_0[] = ",";
3558 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3563 char device[] = "/dev/sda1";
3566 r = guestfs_pvcreate (g, device);
3571 char volgroup[] = "VG";
3572 char physvols_0[] = "/dev/sda1";
3573 char *physvols[] = {
3579 r = guestfs_vgcreate (g, volgroup, physvols);
3584 char logvol[] = "LV1";
3585 char volgroup[] = "VG";
3588 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3593 char logvol[] = "LV2";
3594 char volgroup[] = "VG";
3597 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3602 char vgname[] = "VG";
3605 r = guestfs_vgremove (g, vgname);
3610 char device[] = "/dev/sda1";
3613 r = guestfs_pvremove (g, device);
3621 r = guestfs_lvs (g);
3625 fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
3629 for (i = 0; r[i] != NULL; ++i)
3636 static int test_pvremove_1_skip (void)
3640 str = getenv ("SKIP_TEST_PVREMOVE_1");
3641 if (str && strcmp (str, "1") == 0) return 1;
3642 str = getenv ("SKIP_TEST_PVREMOVE");
3643 if (str && strcmp (str, "1") == 0) return 1;
3647 static int test_pvremove_1 (void)
3649 if (test_pvremove_1_skip ()) {
3650 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_1");
3654 /* InitNone|InitEmpty for test_pvremove_1 */
3656 char device[] = "/dev/sda";
3659 r = guestfs_blockdev_setrw (g, device);
3666 r = guestfs_umount_all (g);
3673 r = guestfs_lvm_remove_all (g);
3677 /* TestOutputListOfDevices for pvremove (1) */
3679 char device[] = "/dev/sda";
3680 char lines_0[] = ",";
3687 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3692 char device[] = "/dev/sda1";
3695 r = guestfs_pvcreate (g, device);
3700 char volgroup[] = "VG";
3701 char physvols_0[] = "/dev/sda1";
3702 char *physvols[] = {
3708 r = guestfs_vgcreate (g, volgroup, physvols);
3713 char logvol[] = "LV1";
3714 char volgroup[] = "VG";
3717 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3722 char logvol[] = "LV2";
3723 char volgroup[] = "VG";
3726 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3731 char vgname[] = "VG";
3734 r = guestfs_vgremove (g, vgname);
3739 char device[] = "/dev/sda1";
3742 r = guestfs_pvremove (g, device);
3750 r = guestfs_vgs (g);
3754 fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
3758 for (i = 0; r[i] != NULL; ++i)
3765 static int test_pvremove_2_skip (void)
3769 str = getenv ("SKIP_TEST_PVREMOVE_2");
3770 if (str && strcmp (str, "1") == 0) return 1;
3771 str = getenv ("SKIP_TEST_PVREMOVE");
3772 if (str && strcmp (str, "1") == 0) return 1;
3776 static int test_pvremove_2 (void)
3778 if (test_pvremove_2_skip ()) {
3779 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_2");
3783 /* InitNone|InitEmpty for test_pvremove_2 */
3785 char device[] = "/dev/sda";
3788 r = guestfs_blockdev_setrw (g, device);
3795 r = guestfs_umount_all (g);
3802 r = guestfs_lvm_remove_all (g);
3806 /* TestOutputListOfDevices for pvremove (2) */
3808 char device[] = "/dev/sda";
3809 char lines_0[] = ",";
3816 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3821 char device[] = "/dev/sda1";
3824 r = guestfs_pvcreate (g, device);
3829 char volgroup[] = "VG";
3830 char physvols_0[] = "/dev/sda1";
3831 char *physvols[] = {
3837 r = guestfs_vgcreate (g, volgroup, physvols);
3842 char logvol[] = "LV1";
3843 char volgroup[] = "VG";
3846 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3851 char logvol[] = "LV2";
3852 char volgroup[] = "VG";
3855 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3860 char vgname[] = "VG";
3863 r = guestfs_vgremove (g, vgname);
3868 char device[] = "/dev/sda1";
3871 r = guestfs_pvremove (g, device);
3879 r = guestfs_pvs (g);
3883 fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
3887 for (i = 0; r[i] != NULL; ++i)
3894 static int test_vgremove_0_skip (void)
3898 str = getenv ("SKIP_TEST_VGREMOVE_0");
3899 if (str && strcmp (str, "1") == 0) return 1;
3900 str = getenv ("SKIP_TEST_VGREMOVE");
3901 if (str && strcmp (str, "1") == 0) return 1;
3905 static int test_vgremove_0 (void)
3907 if (test_vgremove_0_skip ()) {
3908 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_0");
3912 /* InitNone|InitEmpty for test_vgremove_0 */
3914 char device[] = "/dev/sda";
3917 r = guestfs_blockdev_setrw (g, device);
3924 r = guestfs_umount_all (g);
3931 r = guestfs_lvm_remove_all (g);
3935 /* TestOutputList for vgremove (0) */
3937 char device[] = "/dev/sda";
3938 char lines_0[] = ",";
3945 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3950 char device[] = "/dev/sda1";
3953 r = guestfs_pvcreate (g, device);
3958 char volgroup[] = "VG";
3959 char physvols_0[] = "/dev/sda1";
3960 char *physvols[] = {
3966 r = guestfs_vgcreate (g, volgroup, physvols);
3971 char logvol[] = "LV1";
3972 char volgroup[] = "VG";
3975 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3980 char logvol[] = "LV2";
3981 char volgroup[] = "VG";
3984 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3989 char vgname[] = "VG";
3992 r = guestfs_vgremove (g, vgname);
4000 r = guestfs_lvs (g);
4004 fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
4008 for (i = 0; r[i] != NULL; ++i)
4015 static int test_vgremove_1_skip (void)
4019 str = getenv ("SKIP_TEST_VGREMOVE_1");
4020 if (str && strcmp (str, "1") == 0) return 1;
4021 str = getenv ("SKIP_TEST_VGREMOVE");
4022 if (str && strcmp (str, "1") == 0) return 1;
4026 static int test_vgremove_1 (void)
4028 if (test_vgremove_1_skip ()) {
4029 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_1");
4033 /* InitNone|InitEmpty for test_vgremove_1 */
4035 char device[] = "/dev/sda";
4038 r = guestfs_blockdev_setrw (g, device);
4045 r = guestfs_umount_all (g);
4052 r = guestfs_lvm_remove_all (g);
4056 /* TestOutputList for vgremove (1) */
4058 char device[] = "/dev/sda";
4059 char lines_0[] = ",";
4066 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4071 char device[] = "/dev/sda1";
4074 r = guestfs_pvcreate (g, device);
4079 char volgroup[] = "VG";
4080 char physvols_0[] = "/dev/sda1";
4081 char *physvols[] = {
4087 r = guestfs_vgcreate (g, volgroup, physvols);
4092 char logvol[] = "LV1";
4093 char volgroup[] = "VG";
4096 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4101 char logvol[] = "LV2";
4102 char volgroup[] = "VG";
4105 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4110 char vgname[] = "VG";
4113 r = guestfs_vgremove (g, vgname);
4121 r = guestfs_vgs (g);
4125 fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
4129 for (i = 0; r[i] != NULL; ++i)
4136 static int test_lvremove_0_skip (void)
4140 str = getenv ("SKIP_TEST_LVREMOVE_0");
4141 if (str && strcmp (str, "1") == 0) return 1;
4142 str = getenv ("SKIP_TEST_LVREMOVE");
4143 if (str && strcmp (str, "1") == 0) return 1;
4147 static int test_lvremove_0 (void)
4149 if (test_lvremove_0_skip ()) {
4150 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_0");
4154 /* InitNone|InitEmpty for test_lvremove_0 */
4156 char device[] = "/dev/sda";
4159 r = guestfs_blockdev_setrw (g, device);
4166 r = guestfs_umount_all (g);
4173 r = guestfs_lvm_remove_all (g);
4177 /* TestOutputList for lvremove (0) */
4179 char device[] = "/dev/sda";
4180 char lines_0[] = ",";
4187 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4192 char device[] = "/dev/sda1";
4195 r = guestfs_pvcreate (g, device);
4200 char volgroup[] = "VG";
4201 char physvols_0[] = "/dev/sda1";
4202 char *physvols[] = {
4208 r = guestfs_vgcreate (g, volgroup, physvols);
4213 char logvol[] = "LV1";
4214 char volgroup[] = "VG";
4217 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4222 char logvol[] = "LV2";
4223 char volgroup[] = "VG";
4226 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4231 char device[] = "/dev/VG/LV1";
4234 r = guestfs_lvremove (g, device);
4242 r = guestfs_lvs (g);
4246 fprintf (stderr, "test_lvremove_0: short list returned from command\n");
4251 char expected[] = "/dev/VG/LV2";
4252 if (strcmp (r[0], expected) != 0) {
4253 fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4258 fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
4262 for (i = 0; r[i] != NULL; ++i)
4269 static int test_lvremove_1_skip (void)
4273 str = getenv ("SKIP_TEST_LVREMOVE_1");
4274 if (str && strcmp (str, "1") == 0) return 1;
4275 str = getenv ("SKIP_TEST_LVREMOVE");
4276 if (str && strcmp (str, "1") == 0) return 1;
4280 static int test_lvremove_1 (void)
4282 if (test_lvremove_1_skip ()) {
4283 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_1");
4287 /* InitNone|InitEmpty for test_lvremove_1 */
4289 char device[] = "/dev/sda";
4292 r = guestfs_blockdev_setrw (g, device);
4299 r = guestfs_umount_all (g);
4306 r = guestfs_lvm_remove_all (g);
4310 /* TestOutputList for lvremove (1) */
4312 char device[] = "/dev/sda";
4313 char lines_0[] = ",";
4320 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4325 char device[] = "/dev/sda1";
4328 r = guestfs_pvcreate (g, device);
4333 char volgroup[] = "VG";
4334 char physvols_0[] = "/dev/sda1";
4335 char *physvols[] = {
4341 r = guestfs_vgcreate (g, volgroup, physvols);
4346 char logvol[] = "LV1";
4347 char volgroup[] = "VG";
4350 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4355 char logvol[] = "LV2";
4356 char volgroup[] = "VG";
4359 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4364 char device[] = "/dev/VG";
4367 r = guestfs_lvremove (g, device);
4375 r = guestfs_lvs (g);
4379 fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
4383 for (i = 0; r[i] != NULL; ++i)
4390 static int test_lvremove_2_skip (void)
4394 str = getenv ("SKIP_TEST_LVREMOVE_2");
4395 if (str && strcmp (str, "1") == 0) return 1;
4396 str = getenv ("SKIP_TEST_LVREMOVE");
4397 if (str && strcmp (str, "1") == 0) return 1;
4401 static int test_lvremove_2 (void)
4403 if (test_lvremove_2_skip ()) {
4404 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_2");
4408 /* InitNone|InitEmpty for test_lvremove_2 */
4410 char device[] = "/dev/sda";
4413 r = guestfs_blockdev_setrw (g, device);
4420 r = guestfs_umount_all (g);
4427 r = guestfs_lvm_remove_all (g);
4431 /* TestOutputList for lvremove (2) */
4433 char device[] = "/dev/sda";
4434 char lines_0[] = ",";
4441 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4446 char device[] = "/dev/sda1";
4449 r = guestfs_pvcreate (g, device);
4454 char volgroup[] = "VG";
4455 char physvols_0[] = "/dev/sda1";
4456 char *physvols[] = {
4462 r = guestfs_vgcreate (g, volgroup, physvols);
4467 char logvol[] = "LV1";
4468 char volgroup[] = "VG";
4471 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4476 char logvol[] = "LV2";
4477 char volgroup[] = "VG";
4480 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4485 char device[] = "/dev/VG";
4488 r = guestfs_lvremove (g, device);
4496 r = guestfs_vgs (g);
4500 fprintf (stderr, "test_lvremove_2: short list returned from command\n");
4505 char expected[] = "VG";
4506 if (strcmp (r[0], expected) != 0) {
4507 fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4512 fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
4516 for (i = 0; r[i] != NULL; ++i)
4523 static int test_mount_ro_0_skip (void)
4527 str = getenv ("SKIP_TEST_MOUNT_RO_0");
4528 if (str && strcmp (str, "1") == 0) return 1;
4529 str = getenv ("SKIP_TEST_MOUNT_RO");
4530 if (str && strcmp (str, "1") == 0) return 1;
4534 static int test_mount_ro_0 (void)
4536 if (test_mount_ro_0_skip ()) {
4537 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_0");
4541 /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
4543 char device[] = "/dev/sda";
4546 r = guestfs_blockdev_setrw (g, device);
4553 r = guestfs_umount_all (g);
4560 r = guestfs_lvm_remove_all (g);
4565 char device[] = "/dev/sda";
4566 char lines_0[] = ",";
4573 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4578 char fstype[] = "ext2";
4579 char device[] = "/dev/sda1";
4582 r = guestfs_mkfs (g, fstype, device);
4587 char device[] = "/dev/sda1";
4588 char mountpoint[] = "/";
4591 r = guestfs_mount (g, device, mountpoint);
4595 /* TestLastFail for mount_ro (0) */
4597 char pathordevice[] = "/";
4600 r = guestfs_umount (g, pathordevice);
4605 char device[] = "/dev/sda1";
4606 char mountpoint[] = "/";
4609 r = guestfs_mount_ro (g, device, mountpoint);
4614 char path[] = "/new";
4617 r = guestfs_touch (g, path);
4624 static int test_mount_ro_1_skip (void)
4628 str = getenv ("SKIP_TEST_MOUNT_RO_1");
4629 if (str && strcmp (str, "1") == 0) return 1;
4630 str = getenv ("SKIP_TEST_MOUNT_RO");
4631 if (str && strcmp (str, "1") == 0) return 1;
4635 static int test_mount_ro_1 (void)
4637 if (test_mount_ro_1_skip ()) {
4638 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_1");
4642 /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
4644 char device[] = "/dev/sda";
4647 r = guestfs_blockdev_setrw (g, device);
4654 r = guestfs_umount_all (g);
4661 r = guestfs_lvm_remove_all (g);
4666 char device[] = "/dev/sda";
4667 char lines_0[] = ",";
4674 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4679 char fstype[] = "ext2";
4680 char device[] = "/dev/sda1";
4683 r = guestfs_mkfs (g, fstype, device);
4688 char device[] = "/dev/sda1";
4689 char mountpoint[] = "/";
4692 r = guestfs_mount (g, device, mountpoint);
4696 /* TestOutput for mount_ro (1) */
4697 char expected[] = "data";
4699 char path[] = "/new";
4700 char content[] = "data";
4703 r = guestfs_write_file (g, path, content, 0);
4708 char pathordevice[] = "/";
4711 r = guestfs_umount (g, pathordevice);
4716 char device[] = "/dev/sda1";
4717 char mountpoint[] = "/";
4720 r = guestfs_mount_ro (g, device, mountpoint);
4725 char path[] = "/new";
4728 r = guestfs_cat (g, path);
4731 if (strcmp (r, expected) != 0) {
4732 fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
4740 static int test_tgz_in_0_skip (void)
4744 str = getenv ("SKIP_TEST_TGZ_IN_0");
4745 if (str && strcmp (str, "1") == 0) return 1;
4746 str = getenv ("SKIP_TEST_TGZ_IN");
4747 if (str && strcmp (str, "1") == 0) return 1;
4751 static int test_tgz_in_0 (void)
4753 if (test_tgz_in_0_skip ()) {
4754 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tgz_in_0");
4758 /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
4760 char device[] = "/dev/sda";
4763 r = guestfs_blockdev_setrw (g, device);
4770 r = guestfs_umount_all (g);
4777 r = guestfs_lvm_remove_all (g);
4782 char device[] = "/dev/sda";
4783 char lines_0[] = ",";
4790 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4795 char fstype[] = "ext2";
4796 char device[] = "/dev/sda1";
4799 r = guestfs_mkfs (g, fstype, device);
4804 char device[] = "/dev/sda1";
4805 char mountpoint[] = "/";
4808 r = guestfs_mount (g, device, mountpoint);
4812 /* TestOutput for tgz_in (0) */
4813 char expected[] = "hello\n";
4815 char directory[] = "/";
4818 r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
4823 char path[] = "/hello";
4826 r = guestfs_cat (g, path);
4829 if (strcmp (r, expected) != 0) {
4830 fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
4838 static int test_tar_in_0_skip (void)
4842 str = getenv ("SKIP_TEST_TAR_IN_0");
4843 if (str && strcmp (str, "1") == 0) return 1;
4844 str = getenv ("SKIP_TEST_TAR_IN");
4845 if (str && strcmp (str, "1") == 0) return 1;
4849 static int test_tar_in_0 (void)
4851 if (test_tar_in_0_skip ()) {
4852 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tar_in_0");
4856 /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
4858 char device[] = "/dev/sda";
4861 r = guestfs_blockdev_setrw (g, device);
4868 r = guestfs_umount_all (g);
4875 r = guestfs_lvm_remove_all (g);
4880 char device[] = "/dev/sda";
4881 char lines_0[] = ",";
4888 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4893 char fstype[] = "ext2";
4894 char device[] = "/dev/sda1";
4897 r = guestfs_mkfs (g, fstype, device);
4902 char device[] = "/dev/sda1";
4903 char mountpoint[] = "/";
4906 r = guestfs_mount (g, device, mountpoint);
4910 /* TestOutput for tar_in (0) */
4911 char expected[] = "hello\n";
4913 char directory[] = "/";
4916 r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
4921 char path[] = "/hello";
4924 r = guestfs_cat (g, path);
4927 if (strcmp (r, expected) != 0) {
4928 fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
4936 static int test_checksum_0_skip (void)
4940 str = getenv ("SKIP_TEST_CHECKSUM_0");
4941 if (str && strcmp (str, "1") == 0) return 1;
4942 str = getenv ("SKIP_TEST_CHECKSUM");
4943 if (str && strcmp (str, "1") == 0) return 1;
4947 static int test_checksum_0 (void)
4949 if (test_checksum_0_skip ()) {
4950 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_0");
4954 /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
4956 char device[] = "/dev/sda";
4959 r = guestfs_blockdev_setrw (g, device);
4966 r = guestfs_umount_all (g);
4973 r = guestfs_lvm_remove_all (g);
4978 char device[] = "/dev/sda";
4979 char lines_0[] = ",";
4986 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4991 char fstype[] = "ext2";
4992 char device[] = "/dev/sda1";
4995 r = guestfs_mkfs (g, fstype, device);
5000 char device[] = "/dev/sda1";
5001 char mountpoint[] = "/";
5004 r = guestfs_mount (g, device, mountpoint);
5008 /* TestOutput for checksum (0) */
5009 char expected[] = "935282863";
5011 char path[] = "/new";
5012 char content[] = "test\n";
5015 r = guestfs_write_file (g, path, content, 0);
5020 char csumtype[] = "crc";
5021 char path[] = "/new";
5024 r = guestfs_checksum (g, csumtype, path);
5027 if (strcmp (r, expected) != 0) {
5028 fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
5036 static int test_checksum_1_skip (void)
5040 str = getenv ("SKIP_TEST_CHECKSUM_1");
5041 if (str && strcmp (str, "1") == 0) return 1;
5042 str = getenv ("SKIP_TEST_CHECKSUM");
5043 if (str && strcmp (str, "1") == 0) return 1;
5047 static int test_checksum_1 (void)
5049 if (test_checksum_1_skip ()) {
5050 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_1");
5054 /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
5056 char device[] = "/dev/sda";
5059 r = guestfs_blockdev_setrw (g, device);
5066 r = guestfs_umount_all (g);
5073 r = guestfs_lvm_remove_all (g);
5078 char device[] = "/dev/sda";
5079 char lines_0[] = ",";
5086 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5091 char fstype[] = "ext2";
5092 char device[] = "/dev/sda1";
5095 r = guestfs_mkfs (g, fstype, device);
5100 char device[] = "/dev/sda1";
5101 char mountpoint[] = "/";
5104 r = guestfs_mount (g, device, mountpoint);
5108 /* TestLastFail for checksum (1) */
5110 char csumtype[] = "crc";
5111 char path[] = "/new";
5114 r = guestfs_checksum (g, csumtype, path);
5122 static int test_checksum_2_skip (void)
5126 str = getenv ("SKIP_TEST_CHECKSUM_2");
5127 if (str && strcmp (str, "1") == 0) return 1;
5128 str = getenv ("SKIP_TEST_CHECKSUM");
5129 if (str && strcmp (str, "1") == 0) return 1;
5133 static int test_checksum_2 (void)
5135 if (test_checksum_2_skip ()) {
5136 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_2");
5140 /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
5142 char device[] = "/dev/sda";
5145 r = guestfs_blockdev_setrw (g, device);
5152 r = guestfs_umount_all (g);
5159 r = guestfs_lvm_remove_all (g);
5164 char device[] = "/dev/sda";
5165 char lines_0[] = ",";
5172 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5177 char fstype[] = "ext2";
5178 char device[] = "/dev/sda1";
5181 r = guestfs_mkfs (g, fstype, device);
5186 char device[] = "/dev/sda1";
5187 char mountpoint[] = "/";
5190 r = guestfs_mount (g, device, mountpoint);
5194 /* TestOutput for checksum (2) */
5195 char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
5197 char path[] = "/new";
5198 char content[] = "test\n";
5201 r = guestfs_write_file (g, path, content, 0);
5206 char csumtype[] = "md5";
5207 char path[] = "/new";
5210 r = guestfs_checksum (g, csumtype, path);
5213 if (strcmp (r, expected) != 0) {
5214 fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
5222 static int test_checksum_3_skip (void)
5226 str = getenv ("SKIP_TEST_CHECKSUM_3");
5227 if (str && strcmp (str, "1") == 0) return 1;
5228 str = getenv ("SKIP_TEST_CHECKSUM");
5229 if (str && strcmp (str, "1") == 0) return 1;
5233 static int test_checksum_3 (void)
5235 if (test_checksum_3_skip ()) {
5236 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_3");
5240 /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
5242 char device[] = "/dev/sda";
5245 r = guestfs_blockdev_setrw (g, device);
5252 r = guestfs_umount_all (g);
5259 r = guestfs_lvm_remove_all (g);
5264 char device[] = "/dev/sda";
5265 char lines_0[] = ",";
5272 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5277 char fstype[] = "ext2";
5278 char device[] = "/dev/sda1";
5281 r = guestfs_mkfs (g, fstype, device);
5286 char device[] = "/dev/sda1";
5287 char mountpoint[] = "/";
5290 r = guestfs_mount (g, device, mountpoint);
5294 /* TestOutput for checksum (3) */
5295 char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
5297 char path[] = "/new";
5298 char content[] = "test\n";
5301 r = guestfs_write_file (g, path, content, 0);
5306 char csumtype[] = "sha1";
5307 char path[] = "/new";
5310 r = guestfs_checksum (g, csumtype, path);
5313 if (strcmp (r, expected) != 0) {
5314 fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
5322 static int test_checksum_4_skip (void)
5326 str = getenv ("SKIP_TEST_CHECKSUM_4");
5327 if (str && strcmp (str, "1") == 0) return 1;
5328 str = getenv ("SKIP_TEST_CHECKSUM");
5329 if (str && strcmp (str, "1") == 0) return 1;
5333 static int test_checksum_4 (void)
5335 if (test_checksum_4_skip ()) {
5336 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_4");
5340 /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
5342 char device[] = "/dev/sda";
5345 r = guestfs_blockdev_setrw (g, device);
5352 r = guestfs_umount_all (g);
5359 r = guestfs_lvm_remove_all (g);
5364 char device[] = "/dev/sda";
5365 char lines_0[] = ",";
5372 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5377 char fstype[] = "ext2";
5378 char device[] = "/dev/sda1";
5381 r = guestfs_mkfs (g, fstype, device);
5386 char device[] = "/dev/sda1";
5387 char mountpoint[] = "/";
5390 r = guestfs_mount (g, device, mountpoint);
5394 /* TestOutput for checksum (4) */
5395 char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
5397 char path[] = "/new";
5398 char content[] = "test\n";
5401 r = guestfs_write_file (g, path, content, 0);
5406 char csumtype[] = "sha224";
5407 char path[] = "/new";
5410 r = guestfs_checksum (g, csumtype, path);
5413 if (strcmp (r, expected) != 0) {
5414 fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
5422 static int test_checksum_5_skip (void)
5426 str = getenv ("SKIP_TEST_CHECKSUM_5");
5427 if (str && strcmp (str, "1") == 0) return 1;
5428 str = getenv ("SKIP_TEST_CHECKSUM");
5429 if (str && strcmp (str, "1") == 0) return 1;
5433 static int test_checksum_5 (void)
5435 if (test_checksum_5_skip ()) {
5436 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_5");
5440 /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
5442 char device[] = "/dev/sda";
5445 r = guestfs_blockdev_setrw (g, device);
5452 r = guestfs_umount_all (g);
5459 r = guestfs_lvm_remove_all (g);
5464 char device[] = "/dev/sda";
5465 char lines_0[] = ",";
5472 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5477 char fstype[] = "ext2";
5478 char device[] = "/dev/sda1";
5481 r = guestfs_mkfs (g, fstype, device);
5486 char device[] = "/dev/sda1";
5487 char mountpoint[] = "/";
5490 r = guestfs_mount (g, device, mountpoint);
5494 /* TestOutput for checksum (5) */
5495 char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
5497 char path[] = "/new";
5498 char content[] = "test\n";
5501 r = guestfs_write_file (g, path, content, 0);
5506 char csumtype[] = "sha256";
5507 char path[] = "/new";
5510 r = guestfs_checksum (g, csumtype, path);
5513 if (strcmp (r, expected) != 0) {
5514 fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
5522 static int test_checksum_6_skip (void)
5526 str = getenv ("SKIP_TEST_CHECKSUM_6");
5527 if (str && strcmp (str, "1") == 0) return 1;
5528 str = getenv ("SKIP_TEST_CHECKSUM");
5529 if (str && strcmp (str, "1") == 0) return 1;
5533 static int test_checksum_6 (void)
5535 if (test_checksum_6_skip ()) {
5536 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_6");
5540 /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
5542 char device[] = "/dev/sda";
5545 r = guestfs_blockdev_setrw (g, device);
5552 r = guestfs_umount_all (g);
5559 r = guestfs_lvm_remove_all (g);
5564 char device[] = "/dev/sda";
5565 char lines_0[] = ",";
5572 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5577 char fstype[] = "ext2";
5578 char device[] = "/dev/sda1";
5581 r = guestfs_mkfs (g, fstype, device);
5586 char device[] = "/dev/sda1";
5587 char mountpoint[] = "/";
5590 r = guestfs_mount (g, device, mountpoint);
5594 /* TestOutput for checksum (6) */
5595 char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
5597 char path[] = "/new";
5598 char content[] = "test\n";
5601 r = guestfs_write_file (g, path, content, 0);
5606 char csumtype[] = "sha384";
5607 char path[] = "/new";
5610 r = guestfs_checksum (g, csumtype, path);
5613 if (strcmp (r, expected) != 0) {
5614 fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
5622 static int test_checksum_7_skip (void)
5626 str = getenv ("SKIP_TEST_CHECKSUM_7");
5627 if (str && strcmp (str, "1") == 0) return 1;
5628 str = getenv ("SKIP_TEST_CHECKSUM");
5629 if (str && strcmp (str, "1") == 0) return 1;
5633 static int test_checksum_7 (void)
5635 if (test_checksum_7_skip ()) {
5636 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_7");
5640 /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
5642 char device[] = "/dev/sda";
5645 r = guestfs_blockdev_setrw (g, device);
5652 r = guestfs_umount_all (g);
5659 r = guestfs_lvm_remove_all (g);
5664 char device[] = "/dev/sda";
5665 char lines_0[] = ",";
5672 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5677 char fstype[] = "ext2";
5678 char device[] = "/dev/sda1";
5681 r = guestfs_mkfs (g, fstype, device);
5686 char device[] = "/dev/sda1";
5687 char mountpoint[] = "/";
5690 r = guestfs_mount (g, device, mountpoint);
5694 /* TestOutput for checksum (7) */
5695 char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
5697 char path[] = "/new";
5698 char content[] = "test\n";
5701 r = guestfs_write_file (g, path, content, 0);
5706 char csumtype[] = "sha512";
5707 char path[] = "/new";
5710 r = guestfs_checksum (g, csumtype, path);
5713 if (strcmp (r, expected) != 0) {
5714 fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
5722 static int test_checksum_8_skip (void)
5726 str = getenv ("SKIP_TEST_CHECKSUM_8");
5727 if (str && strcmp (str, "1") == 0) return 1;
5728 str = getenv ("SKIP_TEST_CHECKSUM");
5729 if (str && strcmp (str, "1") == 0) return 1;
5733 static int test_checksum_8 (void)
5735 if (test_checksum_8_skip ()) {
5736 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_8");
5740 /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
5742 char device[] = "/dev/sda";
5745 r = guestfs_blockdev_setrw (g, device);
5752 r = guestfs_umount_all (g);
5759 r = guestfs_lvm_remove_all (g);
5764 char device[] = "/dev/sda";
5765 char lines_0[] = ",";
5772 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5777 char fstype[] = "ext2";
5778 char device[] = "/dev/sda1";
5781 r = guestfs_mkfs (g, fstype, device);
5786 char device[] = "/dev/sda1";
5787 char mountpoint[] = "/";
5790 r = guestfs_mount (g, device, mountpoint);
5794 /* TestOutput for checksum (8) */
5795 char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
5797 char options[] = "ro";
5798 char vfstype[] = "squashfs";
5799 char device[] = "/dev/sdd";
5800 char mountpoint[] = "/";
5803 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
5808 char csumtype[] = "md5";
5809 char path[] = "/known-3";
5812 r = guestfs_checksum (g, csumtype, path);
5815 if (strcmp (r, expected) != 0) {
5816 fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
5824 static int test_download_0_skip (void)
5828 str = getenv ("SKIP_TEST_DOWNLOAD_0");
5829 if (str && strcmp (str, "1") == 0) return 1;
5830 str = getenv ("SKIP_TEST_DOWNLOAD");
5831 if (str && strcmp (str, "1") == 0) return 1;
5835 static int test_download_0 (void)
5837 if (test_download_0_skip ()) {
5838 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_download_0");
5842 /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
5844 char device[] = "/dev/sda";
5847 r = guestfs_blockdev_setrw (g, device);
5854 r = guestfs_umount_all (g);
5861 r = guestfs_lvm_remove_all (g);
5866 char device[] = "/dev/sda";
5867 char lines_0[] = ",";
5874 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5879 char fstype[] = "ext2";
5880 char device[] = "/dev/sda1";
5883 r = guestfs_mkfs (g, fstype, device);
5888 char device[] = "/dev/sda1";
5889 char mountpoint[] = "/";
5892 r = guestfs_mount (g, device, mountpoint);
5896 /* TestOutput for download (0) */
5897 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
5899 char remotefilename[] = "/COPYING.LIB";
5902 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
5907 char remotefilename[] = "/COPYING.LIB";
5910 r = guestfs_download (g, remotefilename, "testdownload.tmp");
5915 char remotefilename[] = "/upload";
5918 r = guestfs_upload (g, "testdownload.tmp", remotefilename);
5923 char csumtype[] = "md5";
5924 char path[] = "/upload";
5927 r = guestfs_checksum (g, csumtype, path);
5930 if (strcmp (r, expected) != 0) {
5931 fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
5939 static int test_upload_0_skip (void)
5943 str = getenv ("SKIP_TEST_UPLOAD_0");
5944 if (str && strcmp (str, "1") == 0) return 1;
5945 str = getenv ("SKIP_TEST_UPLOAD");
5946 if (str && strcmp (str, "1") == 0) return 1;
5950 static int test_upload_0 (void)
5952 if (test_upload_0_skip ()) {
5953 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_upload_0");
5957 /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
5959 char device[] = "/dev/sda";
5962 r = guestfs_blockdev_setrw (g, device);
5969 r = guestfs_umount_all (g);
5976 r = guestfs_lvm_remove_all (g);
5981 char device[] = "/dev/sda";
5982 char lines_0[] = ",";
5989 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5994 char fstype[] = "ext2";
5995 char device[] = "/dev/sda1";
5998 r = guestfs_mkfs (g, fstype, device);
6003 char device[] = "/dev/sda1";
6004 char mountpoint[] = "/";
6007 r = guestfs_mount (g, device, mountpoint);
6011 /* TestOutput for upload (0) */
6012 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
6014 char remotefilename[] = "/COPYING.LIB";
6017 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
6022 char csumtype[] = "md5";
6023 char path[] = "/COPYING.LIB";
6026 r = guestfs_checksum (g, csumtype, path);
6029 if (strcmp (r, expected) != 0) {
6030 fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
6038 static int test_blockdev_rereadpt_0_skip (void)
6042 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
6043 if (str && strcmp (str, "1") == 0) return 1;
6044 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
6045 if (str && strcmp (str, "1") == 0) return 1;
6049 static int test_blockdev_rereadpt_0 (void)
6051 if (test_blockdev_rereadpt_0_skip ()) {
6052 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_rereadpt_0");
6056 /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
6058 char device[] = "/dev/sda";
6061 r = guestfs_blockdev_setrw (g, device);
6068 r = guestfs_umount_all (g);
6075 r = guestfs_lvm_remove_all (g);
6079 /* TestRun for blockdev_rereadpt (0) */
6081 char device[] = "/dev/sda";
6084 r = guestfs_blockdev_rereadpt (g, device);
6091 static int test_blockdev_flushbufs_0_skip (void)
6095 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
6096 if (str && strcmp (str, "1") == 0) return 1;
6097 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
6098 if (str && strcmp (str, "1") == 0) return 1;
6102 static int test_blockdev_flushbufs_0 (void)
6104 if (test_blockdev_flushbufs_0_skip ()) {
6105 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_flushbufs_0");
6109 /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
6111 char device[] = "/dev/sda";
6114 r = guestfs_blockdev_setrw (g, device);
6121 r = guestfs_umount_all (g);
6128 r = guestfs_lvm_remove_all (g);
6132 /* TestRun for blockdev_flushbufs (0) */
6134 char device[] = "/dev/sda";
6137 r = guestfs_blockdev_flushbufs (g, device);
6144 static int test_blockdev_getsize64_0_skip (void)
6148 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
6149 if (str && strcmp (str, "1") == 0) return 1;
6150 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
6151 if (str && strcmp (str, "1") == 0) return 1;
6155 static int test_blockdev_getsize64_0 (void)
6157 if (test_blockdev_getsize64_0_skip ()) {
6158 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsize64_0");
6162 /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
6164 char device[] = "/dev/sda";
6167 r = guestfs_blockdev_setrw (g, device);
6174 r = guestfs_umount_all (g);
6181 r = guestfs_lvm_remove_all (g);
6185 /* TestOutputInt for blockdev_getsize64 (0) */
6187 char device[] = "/dev/sda";
6190 r = guestfs_blockdev_getsize64 (g, device);
6193 if (r != 524288000) {
6194 fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n", (int) r);
6201 static int test_blockdev_getsz_0_skip (void)
6205 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
6206 if (str && strcmp (str, "1") == 0) return 1;
6207 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
6208 if (str && strcmp (str, "1") == 0) return 1;
6212 static int test_blockdev_getsz_0 (void)
6214 if (test_blockdev_getsz_0_skip ()) {
6215 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsz_0");
6219 /* InitNone|InitEmpty for test_blockdev_getsz_0 */
6221 char device[] = "/dev/sda";
6224 r = guestfs_blockdev_setrw (g, device);
6231 r = guestfs_umount_all (g);
6238 r = guestfs_lvm_remove_all (g);
6242 /* TestOutputInt for blockdev_getsz (0) */
6244 char device[] = "/dev/sda";
6247 r = guestfs_blockdev_getsz (g, device);
6251 fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n", (int) r);
6258 static int test_blockdev_getbsz_0_skip (void)
6262 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
6263 if (str && strcmp (str, "1") == 0) return 1;
6264 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
6265 if (str && strcmp (str, "1") == 0) return 1;
6269 static int test_blockdev_getbsz_0 (void)
6271 if (test_blockdev_getbsz_0_skip ()) {
6272 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getbsz_0");
6276 /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
6278 char device[] = "/dev/sda";
6281 r = guestfs_blockdev_setrw (g, device);
6288 r = guestfs_umount_all (g);
6295 r = guestfs_lvm_remove_all (g);
6299 /* TestOutputInt for blockdev_getbsz (0) */
6301 char device[] = "/dev/sda";
6304 r = guestfs_blockdev_getbsz (g, device);
6308 fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n", (int) r);
6315 static int test_blockdev_getss_0_skip (void)
6319 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
6320 if (str && strcmp (str, "1") == 0) return 1;
6321 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
6322 if (str && strcmp (str, "1") == 0) return 1;
6326 static int test_blockdev_getss_0 (void)
6328 if (test_blockdev_getss_0_skip ()) {
6329 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getss_0");
6333 /* InitNone|InitEmpty for test_blockdev_getss_0 */
6335 char device[] = "/dev/sda";
6338 r = guestfs_blockdev_setrw (g, device);
6345 r = guestfs_umount_all (g);
6352 r = guestfs_lvm_remove_all (g);
6356 /* TestOutputInt for blockdev_getss (0) */
6358 char device[] = "/dev/sda";
6361 r = guestfs_blockdev_getss (g, device);
6365 fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n", (int) r);
6372 static int test_blockdev_getro_0_skip (void)
6376 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
6377 if (str && strcmp (str, "1") == 0) return 1;
6378 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
6379 if (str && strcmp (str, "1") == 0) return 1;
6383 static int test_blockdev_getro_0 (void)
6385 if (test_blockdev_getro_0_skip ()) {
6386 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getro_0");
6390 /* InitNone|InitEmpty for test_blockdev_getro_0 */
6392 char device[] = "/dev/sda";
6395 r = guestfs_blockdev_setrw (g, device);
6402 r = guestfs_umount_all (g);
6409 r = guestfs_lvm_remove_all (g);
6413 /* TestOutputTrue for blockdev_getro (0) */
6415 char device[] = "/dev/sda";
6418 r = guestfs_blockdev_setro (g, device);
6423 char device[] = "/dev/sda";
6426 r = guestfs_blockdev_getro (g, device);
6430 fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
6437 static int test_blockdev_setrw_0_skip (void)
6441 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
6442 if (str && strcmp (str, "1") == 0) return 1;
6443 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
6444 if (str && strcmp (str, "1") == 0) return 1;
6448 static int test_blockdev_setrw_0 (void)
6450 if (test_blockdev_setrw_0_skip ()) {
6451 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setrw_0");
6455 /* InitNone|InitEmpty for test_blockdev_setrw_0 */
6457 char device[] = "/dev/sda";
6460 r = guestfs_blockdev_setrw (g, device);
6467 r = guestfs_umount_all (g);
6474 r = guestfs_lvm_remove_all (g);
6478 /* TestOutputFalse for blockdev_setrw (0) */
6480 char device[] = "/dev/sda";
6483 r = guestfs_blockdev_setrw (g, device);
6488 char device[] = "/dev/sda";
6491 r = guestfs_blockdev_getro (g, device);
6495 fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
6502 static int test_blockdev_setro_0_skip (void)
6506 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
6507 if (str && strcmp (str, "1") == 0) return 1;
6508 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
6509 if (str && strcmp (str, "1") == 0) return 1;
6513 static int test_blockdev_setro_0 (void)
6515 if (test_blockdev_setro_0_skip ()) {
6516 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setro_0");
6520 /* InitNone|InitEmpty for test_blockdev_setro_0 */
6522 char device[] = "/dev/sda";
6525 r = guestfs_blockdev_setrw (g, device);
6532 r = guestfs_umount_all (g);
6539 r = guestfs_lvm_remove_all (g);
6543 /* TestOutputTrue for blockdev_setro (0) */
6545 char device[] = "/dev/sda";
6548 r = guestfs_blockdev_setro (g, device);
6553 char device[] = "/dev/sda";
6556 r = guestfs_blockdev_getro (g, device);
6560 fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
6567 static int test_statvfs_0_skip (void)
6571 str = getenv ("SKIP_TEST_STATVFS_0");
6572 if (str && strcmp (str, "1") == 0) return 1;
6573 str = getenv ("SKIP_TEST_STATVFS");
6574 if (str && strcmp (str, "1") == 0) return 1;
6578 static int test_statvfs_0 (void)
6580 if (test_statvfs_0_skip ()) {
6581 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_statvfs_0");
6585 /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
6587 char device[] = "/dev/sda";
6590 r = guestfs_blockdev_setrw (g, device);
6597 r = guestfs_umount_all (g);
6604 r = guestfs_lvm_remove_all (g);
6609 char device[] = "/dev/sda";
6610 char lines_0[] = ",";
6617 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6622 char fstype[] = "ext2";
6623 char device[] = "/dev/sda1";
6626 r = guestfs_mkfs (g, fstype, device);
6631 char device[] = "/dev/sda1";
6632 char mountpoint[] = "/";
6635 r = guestfs_mount (g, device, mountpoint);
6639 /* TestOutputStruct for statvfs (0) */
6642 struct guestfs_statvfs *r;
6644 r = guestfs_statvfs (g, path);
6647 if (r->bfree != 487702) {
6648 fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
6652 if (r->blocks != 490020) {
6653 fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
6657 if (r->bsize != 1024) {
6658 fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
6667 static int test_lstat_0_skip (void)
6671 str = getenv ("SKIP_TEST_LSTAT_0");
6672 if (str && strcmp (str, "1") == 0) return 1;
6673 str = getenv ("SKIP_TEST_LSTAT");
6674 if (str && strcmp (str, "1") == 0) return 1;
6678 static int test_lstat_0 (void)
6680 if (test_lstat_0_skip ()) {
6681 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lstat_0");
6685 /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
6687 char device[] = "/dev/sda";
6690 r = guestfs_blockdev_setrw (g, device);
6697 r = guestfs_umount_all (g);
6704 r = guestfs_lvm_remove_all (g);
6709 char device[] = "/dev/sda";
6710 char lines_0[] = ",";
6717 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6722 char fstype[] = "ext2";
6723 char device[] = "/dev/sda1";
6726 r = guestfs_mkfs (g, fstype, device);
6731 char device[] = "/dev/sda1";
6732 char mountpoint[] = "/";
6735 r = guestfs_mount (g, device, mountpoint);
6739 /* TestOutputStruct for lstat (0) */
6741 char path[] = "/new";
6744 r = guestfs_touch (g, path);
6749 char path[] = "/new";
6750 struct guestfs_stat *r;
6752 r = guestfs_lstat (g, path);
6756 fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
6765 static int test_stat_0_skip (void)
6769 str = getenv ("SKIP_TEST_STAT_0");
6770 if (str && strcmp (str, "1") == 0) return 1;
6771 str = getenv ("SKIP_TEST_STAT");
6772 if (str && strcmp (str, "1") == 0) return 1;
6776 static int test_stat_0 (void)
6778 if (test_stat_0_skip ()) {
6779 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_stat_0");
6783 /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
6785 char device[] = "/dev/sda";
6788 r = guestfs_blockdev_setrw (g, device);
6795 r = guestfs_umount_all (g);
6802 r = guestfs_lvm_remove_all (g);
6807 char device[] = "/dev/sda";
6808 char lines_0[] = ",";
6815 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6820 char fstype[] = "ext2";
6821 char device[] = "/dev/sda1";
6824 r = guestfs_mkfs (g, fstype, device);
6829 char device[] = "/dev/sda1";
6830 char mountpoint[] = "/";
6833 r = guestfs_mount (g, device, mountpoint);
6837 /* TestOutputStruct for stat (0) */
6839 char path[] = "/new";
6842 r = guestfs_touch (g, path);
6847 char path[] = "/new";
6848 struct guestfs_stat *r;
6850 r = guestfs_stat (g, path);
6854 fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
6863 static int test_command_lines_0_skip (void)
6867 str = getenv ("SKIP_TEST_COMMAND_LINES_0");
6868 if (str && strcmp (str, "1") == 0) return 1;
6869 str = getenv ("SKIP_TEST_COMMAND_LINES");
6870 if (str && strcmp (str, "1") == 0) return 1;
6874 static int test_command_lines_0 (void)
6876 if (test_command_lines_0_skip ()) {
6877 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_0");
6881 /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
6883 char device[] = "/dev/sda";
6886 r = guestfs_blockdev_setrw (g, device);
6893 r = guestfs_umount_all (g);
6900 r = guestfs_lvm_remove_all (g);
6905 char device[] = "/dev/sda";
6906 char lines_0[] = ",";
6913 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6918 char fstype[] = "ext2";
6919 char device[] = "/dev/sda1";
6922 r = guestfs_mkfs (g, fstype, device);
6927 char device[] = "/dev/sda1";
6928 char mountpoint[] = "/";
6931 r = guestfs_mount (g, device, mountpoint);
6935 /* TestOutputList for command_lines (0) */
6937 char remotefilename[] = "/test-command";
6940 r = guestfs_upload (g, "test-command", remotefilename);
6945 char path[] = "/test-command";
6948 r = guestfs_chmod (g, 493, path);
6953 char arguments_0[] = "/test-command";
6954 char arguments_1[] = "1";
6955 char *arguments[] = {
6963 r = guestfs_command_lines (g, arguments);
6967 fprintf (stderr, "test_command_lines_0: short list returned from command\n");
6972 char expected[] = "Result1";
6973 if (strcmp (r[0], expected) != 0) {
6974 fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6979 fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
6983 for (i = 0; r[i] != NULL; ++i)
6990 static int test_command_lines_1_skip (void)
6994 str = getenv ("SKIP_TEST_COMMAND_LINES_1");
6995 if (str && strcmp (str, "1") == 0) return 1;
6996 str = getenv ("SKIP_TEST_COMMAND_LINES");
6997 if (str && strcmp (str, "1") == 0) return 1;
7001 static int test_command_lines_1 (void)
7003 if (test_command_lines_1_skip ()) {
7004 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_1");
7008 /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
7010 char device[] = "/dev/sda";
7013 r = guestfs_blockdev_setrw (g, device);
7020 r = guestfs_umount_all (g);
7027 r = guestfs_lvm_remove_all (g);
7032 char device[] = "/dev/sda";
7033 char lines_0[] = ",";
7040 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7045 char fstype[] = "ext2";
7046 char device[] = "/dev/sda1";
7049 r = guestfs_mkfs (g, fstype, device);
7054 char device[] = "/dev/sda1";
7055 char mountpoint[] = "/";
7058 r = guestfs_mount (g, device, mountpoint);
7062 /* TestOutputList for command_lines (1) */
7064 char remotefilename[] = "/test-command";
7067 r = guestfs_upload (g, "test-command", remotefilename);
7072 char path[] = "/test-command";
7075 r = guestfs_chmod (g, 493, path);
7080 char arguments_0[] = "/test-command";
7081 char arguments_1[] = "2";
7082 char *arguments[] = {
7090 r = guestfs_command_lines (g, arguments);
7094 fprintf (stderr, "test_command_lines_1: short list returned from command\n");
7099 char expected[] = "Result2";
7100 if (strcmp (r[0], expected) != 0) {
7101 fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7106 fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
7110 for (i = 0; r[i] != NULL; ++i)
7117 static int test_command_lines_2_skip (void)
7121 str = getenv ("SKIP_TEST_COMMAND_LINES_2");
7122 if (str && strcmp (str, "1") == 0) return 1;
7123 str = getenv ("SKIP_TEST_COMMAND_LINES");
7124 if (str && strcmp (str, "1") == 0) return 1;
7128 static int test_command_lines_2 (void)
7130 if (test_command_lines_2_skip ()) {
7131 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_2");
7135 /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
7137 char device[] = "/dev/sda";
7140 r = guestfs_blockdev_setrw (g, device);
7147 r = guestfs_umount_all (g);
7154 r = guestfs_lvm_remove_all (g);
7159 char device[] = "/dev/sda";
7160 char lines_0[] = ",";
7167 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7172 char fstype[] = "ext2";
7173 char device[] = "/dev/sda1";
7176 r = guestfs_mkfs (g, fstype, device);
7181 char device[] = "/dev/sda1";
7182 char mountpoint[] = "/";
7185 r = guestfs_mount (g, device, mountpoint);
7189 /* TestOutputList for command_lines (2) */
7191 char remotefilename[] = "/test-command";
7194 r = guestfs_upload (g, "test-command", remotefilename);
7199 char path[] = "/test-command";
7202 r = guestfs_chmod (g, 493, path);
7207 char arguments_0[] = "/test-command";
7208 char arguments_1[] = "3";
7209 char *arguments[] = {
7217 r = guestfs_command_lines (g, arguments);
7221 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7226 char expected[] = "";
7227 if (strcmp (r[0], expected) != 0) {
7228 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7233 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7238 char expected[] = "Result3";
7239 if (strcmp (r[1], expected) != 0) {
7240 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7245 fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
7249 for (i = 0; r[i] != NULL; ++i)
7256 static int test_command_lines_3_skip (void)
7260 str = getenv ("SKIP_TEST_COMMAND_LINES_3");
7261 if (str && strcmp (str, "1") == 0) return 1;
7262 str = getenv ("SKIP_TEST_COMMAND_LINES");
7263 if (str && strcmp (str, "1") == 0) return 1;
7267 static int test_command_lines_3 (void)
7269 if (test_command_lines_3_skip ()) {
7270 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_3");
7274 /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
7276 char device[] = "/dev/sda";
7279 r = guestfs_blockdev_setrw (g, device);
7286 r = guestfs_umount_all (g);
7293 r = guestfs_lvm_remove_all (g);
7298 char device[] = "/dev/sda";
7299 char lines_0[] = ",";
7306 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7311 char fstype[] = "ext2";
7312 char device[] = "/dev/sda1";
7315 r = guestfs_mkfs (g, fstype, device);
7320 char device[] = "/dev/sda1";
7321 char mountpoint[] = "/";
7324 r = guestfs_mount (g, device, mountpoint);
7328 /* TestOutputList for command_lines (3) */
7330 char remotefilename[] = "/test-command";
7333 r = guestfs_upload (g, "test-command", remotefilename);
7338 char path[] = "/test-command";
7341 r = guestfs_chmod (g, 493, path);
7346 char arguments_0[] = "/test-command";
7347 char arguments_1[] = "4";
7348 char *arguments[] = {
7356 r = guestfs_command_lines (g, arguments);
7360 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7365 char expected[] = "";
7366 if (strcmp (r[0], expected) != 0) {
7367 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7372 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7377 char expected[] = "Result4";
7378 if (strcmp (r[1], expected) != 0) {
7379 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7384 fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
7388 for (i = 0; r[i] != NULL; ++i)
7395 static int test_command_lines_4_skip (void)
7399 str = getenv ("SKIP_TEST_COMMAND_LINES_4");
7400 if (str && strcmp (str, "1") == 0) return 1;
7401 str = getenv ("SKIP_TEST_COMMAND_LINES");
7402 if (str && strcmp (str, "1") == 0) return 1;
7406 static int test_command_lines_4 (void)
7408 if (test_command_lines_4_skip ()) {
7409 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_4");
7413 /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
7415 char device[] = "/dev/sda";
7418 r = guestfs_blockdev_setrw (g, device);
7425 r = guestfs_umount_all (g);
7432 r = guestfs_lvm_remove_all (g);
7437 char device[] = "/dev/sda";
7438 char lines_0[] = ",";
7445 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7450 char fstype[] = "ext2";
7451 char device[] = "/dev/sda1";
7454 r = guestfs_mkfs (g, fstype, device);
7459 char device[] = "/dev/sda1";
7460 char mountpoint[] = "/";
7463 r = guestfs_mount (g, device, mountpoint);
7467 /* TestOutputList for command_lines (4) */
7469 char remotefilename[] = "/test-command";
7472 r = guestfs_upload (g, "test-command", remotefilename);
7477 char path[] = "/test-command";
7480 r = guestfs_chmod (g, 493, path);
7485 char arguments_0[] = "/test-command";
7486 char arguments_1[] = "5";
7487 char *arguments[] = {
7495 r = guestfs_command_lines (g, arguments);
7499 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7504 char expected[] = "";
7505 if (strcmp (r[0], expected) != 0) {
7506 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7511 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7516 char expected[] = "Result5";
7517 if (strcmp (r[1], expected) != 0) {
7518 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7523 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7528 char expected[] = "";
7529 if (strcmp (r[2], expected) != 0) {
7530 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
7535 fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
7539 for (i = 0; r[i] != NULL; ++i)
7546 static int test_command_lines_5_skip (void)
7550 str = getenv ("SKIP_TEST_COMMAND_LINES_5");
7551 if (str && strcmp (str, "1") == 0) return 1;
7552 str = getenv ("SKIP_TEST_COMMAND_LINES");
7553 if (str && strcmp (str, "1") == 0) return 1;
7557 static int test_command_lines_5 (void)
7559 if (test_command_lines_5_skip ()) {
7560 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_5");
7564 /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
7566 char device[] = "/dev/sda";
7569 r = guestfs_blockdev_setrw (g, device);
7576 r = guestfs_umount_all (g);
7583 r = guestfs_lvm_remove_all (g);
7588 char device[] = "/dev/sda";
7589 char lines_0[] = ",";
7596 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7601 char fstype[] = "ext2";
7602 char device[] = "/dev/sda1";
7605 r = guestfs_mkfs (g, fstype, device);
7610 char device[] = "/dev/sda1";
7611 char mountpoint[] = "/";
7614 r = guestfs_mount (g, device, mountpoint);
7618 /* TestOutputList for command_lines (5) */
7620 char remotefilename[] = "/test-command";
7623 r = guestfs_upload (g, "test-command", remotefilename);
7628 char path[] = "/test-command";
7631 r = guestfs_chmod (g, 493, path);
7636 char arguments_0[] = "/test-command";
7637 char arguments_1[] = "6";
7638 char *arguments[] = {
7646 r = guestfs_command_lines (g, arguments);
7650 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7655 char expected[] = "";
7656 if (strcmp (r[0], expected) != 0) {
7657 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7662 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7667 char expected[] = "";
7668 if (strcmp (r[1], expected) != 0) {
7669 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7674 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7679 char expected[] = "Result6";
7680 if (strcmp (r[2], expected) != 0) {
7681 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
7686 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7691 char expected[] = "";
7692 if (strcmp (r[3], expected) != 0) {
7693 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
7698 fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
7702 for (i = 0; r[i] != NULL; ++i)
7709 static int test_command_lines_6_skip (void)
7713 str = getenv ("SKIP_TEST_COMMAND_LINES_6");
7714 if (str && strcmp (str, "1") == 0) return 1;
7715 str = getenv ("SKIP_TEST_COMMAND_LINES");
7716 if (str && strcmp (str, "1") == 0) return 1;
7720 static int test_command_lines_6 (void)
7722 if (test_command_lines_6_skip ()) {
7723 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_6");
7727 /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
7729 char device[] = "/dev/sda";
7732 r = guestfs_blockdev_setrw (g, device);
7739 r = guestfs_umount_all (g);
7746 r = guestfs_lvm_remove_all (g);
7751 char device[] = "/dev/sda";
7752 char lines_0[] = ",";
7759 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7764 char fstype[] = "ext2";
7765 char device[] = "/dev/sda1";
7768 r = guestfs_mkfs (g, fstype, device);
7773 char device[] = "/dev/sda1";
7774 char mountpoint[] = "/";
7777 r = guestfs_mount (g, device, mountpoint);
7781 /* TestOutputList for command_lines (6) */
7783 char remotefilename[] = "/test-command";
7786 r = guestfs_upload (g, "test-command", remotefilename);
7791 char path[] = "/test-command";
7794 r = guestfs_chmod (g, 493, path);
7799 char arguments_0[] = "/test-command";
7800 char arguments_1[] = "7";
7801 char *arguments[] = {
7809 r = guestfs_command_lines (g, arguments);
7813 fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
7817 for (i = 0; r[i] != NULL; ++i)
7824 static int test_command_lines_7_skip (void)
7828 str = getenv ("SKIP_TEST_COMMAND_LINES_7");
7829 if (str && strcmp (str, "1") == 0) return 1;
7830 str = getenv ("SKIP_TEST_COMMAND_LINES");
7831 if (str && strcmp (str, "1") == 0) return 1;
7835 static int test_command_lines_7 (void)
7837 if (test_command_lines_7_skip ()) {
7838 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_7");
7842 /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
7844 char device[] = "/dev/sda";
7847 r = guestfs_blockdev_setrw (g, device);
7854 r = guestfs_umount_all (g);
7861 r = guestfs_lvm_remove_all (g);
7866 char device[] = "/dev/sda";
7867 char lines_0[] = ",";
7874 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7879 char fstype[] = "ext2";
7880 char device[] = "/dev/sda1";
7883 r = guestfs_mkfs (g, fstype, device);
7888 char device[] = "/dev/sda1";
7889 char mountpoint[] = "/";
7892 r = guestfs_mount (g, device, mountpoint);
7896 /* TestOutputList for command_lines (7) */
7898 char remotefilename[] = "/test-command";
7901 r = guestfs_upload (g, "test-command", remotefilename);
7906 char path[] = "/test-command";
7909 r = guestfs_chmod (g, 493, path);
7914 char arguments_0[] = "/test-command";
7915 char arguments_1[] = "8";
7916 char *arguments[] = {
7924 r = guestfs_command_lines (g, arguments);
7928 fprintf (stderr, "test_command_lines_7: short list returned from command\n");
7933 char expected[] = "";
7934 if (strcmp (r[0], expected) != 0) {
7935 fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7940 fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
7944 for (i = 0; r[i] != NULL; ++i)
7951 static int test_command_lines_8_skip (void)
7955 str = getenv ("SKIP_TEST_COMMAND_LINES_8");
7956 if (str && strcmp (str, "1") == 0) return 1;
7957 str = getenv ("SKIP_TEST_COMMAND_LINES");
7958 if (str && strcmp (str, "1") == 0) return 1;
7962 static int test_command_lines_8 (void)
7964 if (test_command_lines_8_skip ()) {
7965 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_8");
7969 /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
7971 char device[] = "/dev/sda";
7974 r = guestfs_blockdev_setrw (g, device);
7981 r = guestfs_umount_all (g);
7988 r = guestfs_lvm_remove_all (g);
7993 char device[] = "/dev/sda";
7994 char lines_0[] = ",";
8001 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8006 char fstype[] = "ext2";
8007 char device[] = "/dev/sda1";
8010 r = guestfs_mkfs (g, fstype, device);
8015 char device[] = "/dev/sda1";
8016 char mountpoint[] = "/";
8019 r = guestfs_mount (g, device, mountpoint);
8023 /* TestOutputList for command_lines (8) */
8025 char remotefilename[] = "/test-command";
8028 r = guestfs_upload (g, "test-command", remotefilename);
8033 char path[] = "/test-command";
8036 r = guestfs_chmod (g, 493, path);
8041 char arguments_0[] = "/test-command";
8042 char arguments_1[] = "9";
8043 char *arguments[] = {
8051 r = guestfs_command_lines (g, arguments);
8055 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8060 char expected[] = "";
8061 if (strcmp (r[0], expected) != 0) {
8062 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8067 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8072 char expected[] = "";
8073 if (strcmp (r[1], expected) != 0) {
8074 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8079 fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
8083 for (i = 0; r[i] != NULL; ++i)
8090 static int test_command_lines_9_skip (void)
8094 str = getenv ("SKIP_TEST_COMMAND_LINES_9");
8095 if (str && strcmp (str, "1") == 0) return 1;
8096 str = getenv ("SKIP_TEST_COMMAND_LINES");
8097 if (str && strcmp (str, "1") == 0) return 1;
8101 static int test_command_lines_9 (void)
8103 if (test_command_lines_9_skip ()) {
8104 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_9");
8108 /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
8110 char device[] = "/dev/sda";
8113 r = guestfs_blockdev_setrw (g, device);
8120 r = guestfs_umount_all (g);
8127 r = guestfs_lvm_remove_all (g);
8132 char device[] = "/dev/sda";
8133 char lines_0[] = ",";
8140 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8145 char fstype[] = "ext2";
8146 char device[] = "/dev/sda1";
8149 r = guestfs_mkfs (g, fstype, device);
8154 char device[] = "/dev/sda1";
8155 char mountpoint[] = "/";
8158 r = guestfs_mount (g, device, mountpoint);
8162 /* TestOutputList for command_lines (9) */
8164 char remotefilename[] = "/test-command";
8167 r = guestfs_upload (g, "test-command", remotefilename);
8172 char path[] = "/test-command";
8175 r = guestfs_chmod (g, 493, path);
8180 char arguments_0[] = "/test-command";
8181 char arguments_1[] = "10";
8182 char *arguments[] = {
8190 r = guestfs_command_lines (g, arguments);
8194 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8199 char expected[] = "Result10-1";
8200 if (strcmp (r[0], expected) != 0) {
8201 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8206 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8211 char expected[] = "Result10-2";
8212 if (strcmp (r[1], expected) != 0) {
8213 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8218 fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
8222 for (i = 0; r[i] != NULL; ++i)
8229 static int test_command_lines_10_skip (void)
8233 str = getenv ("SKIP_TEST_COMMAND_LINES_10");
8234 if (str && strcmp (str, "1") == 0) return 1;
8235 str = getenv ("SKIP_TEST_COMMAND_LINES");
8236 if (str && strcmp (str, "1") == 0) return 1;
8240 static int test_command_lines_10 (void)
8242 if (test_command_lines_10_skip ()) {
8243 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_10");
8247 /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
8249 char device[] = "/dev/sda";
8252 r = guestfs_blockdev_setrw (g, device);
8259 r = guestfs_umount_all (g);
8266 r = guestfs_lvm_remove_all (g);
8271 char device[] = "/dev/sda";
8272 char lines_0[] = ",";
8279 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8284 char fstype[] = "ext2";
8285 char device[] = "/dev/sda1";
8288 r = guestfs_mkfs (g, fstype, device);
8293 char device[] = "/dev/sda1";
8294 char mountpoint[] = "/";
8297 r = guestfs_mount (g, device, mountpoint);
8301 /* TestOutputList for command_lines (10) */
8303 char remotefilename[] = "/test-command";
8306 r = guestfs_upload (g, "test-command", remotefilename);
8311 char path[] = "/test-command";
8314 r = guestfs_chmod (g, 493, path);
8319 char arguments_0[] = "/test-command";
8320 char arguments_1[] = "11";
8321 char *arguments[] = {
8329 r = guestfs_command_lines (g, arguments);
8333 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8338 char expected[] = "Result11-1";
8339 if (strcmp (r[0], expected) != 0) {
8340 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8345 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8350 char expected[] = "Result11-2";
8351 if (strcmp (r[1], expected) != 0) {
8352 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8357 fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
8361 for (i = 0; r[i] != NULL; ++i)
8368 static int test_command_0_skip (void)
8372 str = getenv ("SKIP_TEST_COMMAND_0");
8373 if (str && strcmp (str, "1") == 0) return 1;
8374 str = getenv ("SKIP_TEST_COMMAND");
8375 if (str && strcmp (str, "1") == 0) return 1;
8379 static int test_command_0 (void)
8381 if (test_command_0_skip ()) {
8382 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_0");
8386 /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
8388 char device[] = "/dev/sda";
8391 r = guestfs_blockdev_setrw (g, device);
8398 r = guestfs_umount_all (g);
8405 r = guestfs_lvm_remove_all (g);
8410 char device[] = "/dev/sda";
8411 char lines_0[] = ",";
8418 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8423 char fstype[] = "ext2";
8424 char device[] = "/dev/sda1";
8427 r = guestfs_mkfs (g, fstype, device);
8432 char device[] = "/dev/sda1";
8433 char mountpoint[] = "/";
8436 r = guestfs_mount (g, device, mountpoint);
8440 /* TestOutput for command (0) */
8441 char expected[] = "Result1";
8443 char remotefilename[] = "/test-command";
8446 r = guestfs_upload (g, "test-command", remotefilename);
8451 char path[] = "/test-command";
8454 r = guestfs_chmod (g, 493, path);
8459 char arguments_0[] = "/test-command";
8460 char arguments_1[] = "1";
8461 char *arguments[] = {
8468 r = guestfs_command (g, arguments);
8471 if (strcmp (r, expected) != 0) {
8472 fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
8480 static int test_command_1_skip (void)
8484 str = getenv ("SKIP_TEST_COMMAND_1");
8485 if (str && strcmp (str, "1") == 0) return 1;
8486 str = getenv ("SKIP_TEST_COMMAND");
8487 if (str && strcmp (str, "1") == 0) return 1;
8491 static int test_command_1 (void)
8493 if (test_command_1_skip ()) {
8494 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_1");
8498 /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
8500 char device[] = "/dev/sda";
8503 r = guestfs_blockdev_setrw (g, device);
8510 r = guestfs_umount_all (g);
8517 r = guestfs_lvm_remove_all (g);
8522 char device[] = "/dev/sda";
8523 char lines_0[] = ",";
8530 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8535 char fstype[] = "ext2";
8536 char device[] = "/dev/sda1";
8539 r = guestfs_mkfs (g, fstype, device);
8544 char device[] = "/dev/sda1";
8545 char mountpoint[] = "/";
8548 r = guestfs_mount (g, device, mountpoint);
8552 /* TestOutput for command (1) */
8553 char expected[] = "Result2\n";
8555 char remotefilename[] = "/test-command";
8558 r = guestfs_upload (g, "test-command", remotefilename);
8563 char path[] = "/test-command";
8566 r = guestfs_chmod (g, 493, path);
8571 char arguments_0[] = "/test-command";
8572 char arguments_1[] = "2";
8573 char *arguments[] = {
8580 r = guestfs_command (g, arguments);
8583 if (strcmp (r, expected) != 0) {
8584 fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
8592 static int test_command_2_skip (void)
8596 str = getenv ("SKIP_TEST_COMMAND_2");
8597 if (str && strcmp (str, "1") == 0) return 1;
8598 str = getenv ("SKIP_TEST_COMMAND");
8599 if (str && strcmp (str, "1") == 0) return 1;
8603 static int test_command_2 (void)
8605 if (test_command_2_skip ()) {
8606 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_2");
8610 /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
8612 char device[] = "/dev/sda";
8615 r = guestfs_blockdev_setrw (g, device);
8622 r = guestfs_umount_all (g);
8629 r = guestfs_lvm_remove_all (g);
8634 char device[] = "/dev/sda";
8635 char lines_0[] = ",";
8642 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8647 char fstype[] = "ext2";
8648 char device[] = "/dev/sda1";
8651 r = guestfs_mkfs (g, fstype, device);
8656 char device[] = "/dev/sda1";
8657 char mountpoint[] = "/";
8660 r = guestfs_mount (g, device, mountpoint);
8664 /* TestOutput for command (2) */
8665 char expected[] = "\nResult3";
8667 char remotefilename[] = "/test-command";
8670 r = guestfs_upload (g, "test-command", remotefilename);
8675 char path[] = "/test-command";
8678 r = guestfs_chmod (g, 493, path);
8683 char arguments_0[] = "/test-command";
8684 char arguments_1[] = "3";
8685 char *arguments[] = {
8692 r = guestfs_command (g, arguments);
8695 if (strcmp (r, expected) != 0) {
8696 fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
8704 static int test_command_3_skip (void)
8708 str = getenv ("SKIP_TEST_COMMAND_3");
8709 if (str && strcmp (str, "1") == 0) return 1;
8710 str = getenv ("SKIP_TEST_COMMAND");
8711 if (str && strcmp (str, "1") == 0) return 1;
8715 static int test_command_3 (void)
8717 if (test_command_3_skip ()) {
8718 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_3");
8722 /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
8724 char device[] = "/dev/sda";
8727 r = guestfs_blockdev_setrw (g, device);
8734 r = guestfs_umount_all (g);
8741 r = guestfs_lvm_remove_all (g);
8746 char device[] = "/dev/sda";
8747 char lines_0[] = ",";
8754 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8759 char fstype[] = "ext2";
8760 char device[] = "/dev/sda1";
8763 r = guestfs_mkfs (g, fstype, device);
8768 char device[] = "/dev/sda1";
8769 char mountpoint[] = "/";
8772 r = guestfs_mount (g, device, mountpoint);
8776 /* TestOutput for command (3) */
8777 char expected[] = "\nResult4\n";
8779 char remotefilename[] = "/test-command";
8782 r = guestfs_upload (g, "test-command", remotefilename);
8787 char path[] = "/test-command";
8790 r = guestfs_chmod (g, 493, path);
8795 char arguments_0[] = "/test-command";
8796 char arguments_1[] = "4";
8797 char *arguments[] = {
8804 r = guestfs_command (g, arguments);
8807 if (strcmp (r, expected) != 0) {
8808 fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
8816 static int test_command_4_skip (void)
8820 str = getenv ("SKIP_TEST_COMMAND_4");
8821 if (str && strcmp (str, "1") == 0) return 1;
8822 str = getenv ("SKIP_TEST_COMMAND");
8823 if (str && strcmp (str, "1") == 0) return 1;
8827 static int test_command_4 (void)
8829 if (test_command_4_skip ()) {
8830 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_4");
8834 /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
8836 char device[] = "/dev/sda";
8839 r = guestfs_blockdev_setrw (g, device);
8846 r = guestfs_umount_all (g);
8853 r = guestfs_lvm_remove_all (g);
8858 char device[] = "/dev/sda";
8859 char lines_0[] = ",";
8866 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8871 char fstype[] = "ext2";
8872 char device[] = "/dev/sda1";
8875 r = guestfs_mkfs (g, fstype, device);
8880 char device[] = "/dev/sda1";
8881 char mountpoint[] = "/";
8884 r = guestfs_mount (g, device, mountpoint);
8888 /* TestOutput for command (4) */
8889 char expected[] = "\nResult5\n\n";
8891 char remotefilename[] = "/test-command";
8894 r = guestfs_upload (g, "test-command", remotefilename);
8899 char path[] = "/test-command";
8902 r = guestfs_chmod (g, 493, path);
8907 char arguments_0[] = "/test-command";
8908 char arguments_1[] = "5";
8909 char *arguments[] = {
8916 r = guestfs_command (g, arguments);
8919 if (strcmp (r, expected) != 0) {
8920 fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
8928 static int test_command_5_skip (void)
8932 str = getenv ("SKIP_TEST_COMMAND_5");
8933 if (str && strcmp (str, "1") == 0) return 1;
8934 str = getenv ("SKIP_TEST_COMMAND");
8935 if (str && strcmp (str, "1") == 0) return 1;
8939 static int test_command_5 (void)
8941 if (test_command_5_skip ()) {
8942 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_5");
8946 /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
8948 char device[] = "/dev/sda";
8951 r = guestfs_blockdev_setrw (g, device);
8958 r = guestfs_umount_all (g);
8965 r = guestfs_lvm_remove_all (g);
8970 char device[] = "/dev/sda";
8971 char lines_0[] = ",";
8978 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8983 char fstype[] = "ext2";
8984 char device[] = "/dev/sda1";
8987 r = guestfs_mkfs (g, fstype, device);
8992 char device[] = "/dev/sda1";
8993 char mountpoint[] = "/";
8996 r = guestfs_mount (g, device, mountpoint);
9000 /* TestOutput for command (5) */
9001 char expected[] = "\n\nResult6\n\n";
9003 char remotefilename[] = "/test-command";
9006 r = guestfs_upload (g, "test-command", remotefilename);
9011 char path[] = "/test-command";
9014 r = guestfs_chmod (g, 493, path);
9019 char arguments_0[] = "/test-command";
9020 char arguments_1[] = "6";
9021 char *arguments[] = {
9028 r = guestfs_command (g, arguments);
9031 if (strcmp (r, expected) != 0) {
9032 fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
9040 static int test_command_6_skip (void)
9044 str = getenv ("SKIP_TEST_COMMAND_6");
9045 if (str && strcmp (str, "1") == 0) return 1;
9046 str = getenv ("SKIP_TEST_COMMAND");
9047 if (str && strcmp (str, "1") == 0) return 1;
9051 static int test_command_6 (void)
9053 if (test_command_6_skip ()) {
9054 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_6");
9058 /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
9060 char device[] = "/dev/sda";
9063 r = guestfs_blockdev_setrw (g, device);
9070 r = guestfs_umount_all (g);
9077 r = guestfs_lvm_remove_all (g);
9082 char device[] = "/dev/sda";
9083 char lines_0[] = ",";
9090 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9095 char fstype[] = "ext2";
9096 char device[] = "/dev/sda1";
9099 r = guestfs_mkfs (g, fstype, device);
9104 char device[] = "/dev/sda1";
9105 char mountpoint[] = "/";
9108 r = guestfs_mount (g, device, mountpoint);
9112 /* TestOutput for command (6) */
9113 char expected[] = "";
9115 char remotefilename[] = "/test-command";
9118 r = guestfs_upload (g, "test-command", remotefilename);
9123 char path[] = "/test-command";
9126 r = guestfs_chmod (g, 493, path);
9131 char arguments_0[] = "/test-command";
9132 char arguments_1[] = "7";
9133 char *arguments[] = {
9140 r = guestfs_command (g, arguments);
9143 if (strcmp (r, expected) != 0) {
9144 fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
9152 static int test_command_7_skip (void)
9156 str = getenv ("SKIP_TEST_COMMAND_7");
9157 if (str && strcmp (str, "1") == 0) return 1;
9158 str = getenv ("SKIP_TEST_COMMAND");
9159 if (str && strcmp (str, "1") == 0) return 1;
9163 static int test_command_7 (void)
9165 if (test_command_7_skip ()) {
9166 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_7");
9170 /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
9172 char device[] = "/dev/sda";
9175 r = guestfs_blockdev_setrw (g, device);
9182 r = guestfs_umount_all (g);
9189 r = guestfs_lvm_remove_all (g);
9194 char device[] = "/dev/sda";
9195 char lines_0[] = ",";
9202 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9207 char fstype[] = "ext2";
9208 char device[] = "/dev/sda1";
9211 r = guestfs_mkfs (g, fstype, device);
9216 char device[] = "/dev/sda1";
9217 char mountpoint[] = "/";
9220 r = guestfs_mount (g, device, mountpoint);
9224 /* TestOutput for command (7) */
9225 char expected[] = "\n";
9227 char remotefilename[] = "/test-command";
9230 r = guestfs_upload (g, "test-command", remotefilename);
9235 char path[] = "/test-command";
9238 r = guestfs_chmod (g, 493, path);
9243 char arguments_0[] = "/test-command";
9244 char arguments_1[] = "8";
9245 char *arguments[] = {
9252 r = guestfs_command (g, arguments);
9255 if (strcmp (r, expected) != 0) {
9256 fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
9264 static int test_command_8_skip (void)
9268 str = getenv ("SKIP_TEST_COMMAND_8");
9269 if (str && strcmp (str, "1") == 0) return 1;
9270 str = getenv ("SKIP_TEST_COMMAND");
9271 if (str && strcmp (str, "1") == 0) return 1;
9275 static int test_command_8 (void)
9277 if (test_command_8_skip ()) {
9278 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_8");
9282 /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
9284 char device[] = "/dev/sda";
9287 r = guestfs_blockdev_setrw (g, device);
9294 r = guestfs_umount_all (g);
9301 r = guestfs_lvm_remove_all (g);
9306 char device[] = "/dev/sda";
9307 char lines_0[] = ",";
9314 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9319 char fstype[] = "ext2";
9320 char device[] = "/dev/sda1";
9323 r = guestfs_mkfs (g, fstype, device);
9328 char device[] = "/dev/sda1";
9329 char mountpoint[] = "/";
9332 r = guestfs_mount (g, device, mountpoint);
9336 /* TestOutput for command (8) */
9337 char expected[] = "\n\n";
9339 char remotefilename[] = "/test-command";
9342 r = guestfs_upload (g, "test-command", remotefilename);
9347 char path[] = "/test-command";
9350 r = guestfs_chmod (g, 493, path);
9355 char arguments_0[] = "/test-command";
9356 char arguments_1[] = "9";
9357 char *arguments[] = {
9364 r = guestfs_command (g, arguments);
9367 if (strcmp (r, expected) != 0) {
9368 fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
9376 static int test_command_9_skip (void)
9380 str = getenv ("SKIP_TEST_COMMAND_9");
9381 if (str && strcmp (str, "1") == 0) return 1;
9382 str = getenv ("SKIP_TEST_COMMAND");
9383 if (str && strcmp (str, "1") == 0) return 1;
9387 static int test_command_9 (void)
9389 if (test_command_9_skip ()) {
9390 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_9");
9394 /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
9396 char device[] = "/dev/sda";
9399 r = guestfs_blockdev_setrw (g, device);
9406 r = guestfs_umount_all (g);
9413 r = guestfs_lvm_remove_all (g);
9418 char device[] = "/dev/sda";
9419 char lines_0[] = ",";
9426 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9431 char fstype[] = "ext2";
9432 char device[] = "/dev/sda1";
9435 r = guestfs_mkfs (g, fstype, device);
9440 char device[] = "/dev/sda1";
9441 char mountpoint[] = "/";
9444 r = guestfs_mount (g, device, mountpoint);
9448 /* TestOutput for command (9) */
9449 char expected[] = "Result10-1\nResult10-2\n";
9451 char remotefilename[] = "/test-command";
9454 r = guestfs_upload (g, "test-command", remotefilename);
9459 char path[] = "/test-command";
9462 r = guestfs_chmod (g, 493, path);
9467 char arguments_0[] = "/test-command";
9468 char arguments_1[] = "10";
9469 char *arguments[] = {
9476 r = guestfs_command (g, arguments);
9479 if (strcmp (r, expected) != 0) {
9480 fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
9488 static int test_command_10_skip (void)
9492 str = getenv ("SKIP_TEST_COMMAND_10");
9493 if (str && strcmp (str, "1") == 0) return 1;
9494 str = getenv ("SKIP_TEST_COMMAND");
9495 if (str && strcmp (str, "1") == 0) return 1;
9499 static int test_command_10 (void)
9501 if (test_command_10_skip ()) {
9502 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_10");
9506 /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
9508 char device[] = "/dev/sda";
9511 r = guestfs_blockdev_setrw (g, device);
9518 r = guestfs_umount_all (g);
9525 r = guestfs_lvm_remove_all (g);
9530 char device[] = "/dev/sda";
9531 char lines_0[] = ",";
9538 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9543 char fstype[] = "ext2";
9544 char device[] = "/dev/sda1";
9547 r = guestfs_mkfs (g, fstype, device);
9552 char device[] = "/dev/sda1";
9553 char mountpoint[] = "/";
9556 r = guestfs_mount (g, device, mountpoint);
9560 /* TestOutput for command (10) */
9561 char expected[] = "Result11-1\nResult11-2";
9563 char remotefilename[] = "/test-command";
9566 r = guestfs_upload (g, "test-command", remotefilename);
9571 char path[] = "/test-command";
9574 r = guestfs_chmod (g, 493, path);
9579 char arguments_0[] = "/test-command";
9580 char arguments_1[] = "11";
9581 char *arguments[] = {
9588 r = guestfs_command (g, arguments);
9591 if (strcmp (r, expected) != 0) {
9592 fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
9600 static int test_command_11_skip (void)
9604 str = getenv ("SKIP_TEST_COMMAND_11");
9605 if (str && strcmp (str, "1") == 0) return 1;
9606 str = getenv ("SKIP_TEST_COMMAND");
9607 if (str && strcmp (str, "1") == 0) return 1;
9611 static int test_command_11 (void)
9613 if (test_command_11_skip ()) {
9614 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_11");
9618 /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
9620 char device[] = "/dev/sda";
9623 r = guestfs_blockdev_setrw (g, device);
9630 r = guestfs_umount_all (g);
9637 r = guestfs_lvm_remove_all (g);
9642 char device[] = "/dev/sda";
9643 char lines_0[] = ",";
9650 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9655 char fstype[] = "ext2";
9656 char device[] = "/dev/sda1";
9659 r = guestfs_mkfs (g, fstype, device);
9664 char device[] = "/dev/sda1";
9665 char mountpoint[] = "/";
9668 r = guestfs_mount (g, device, mountpoint);
9672 /* TestLastFail for command (11) */
9674 char remotefilename[] = "/test-command";
9677 r = guestfs_upload (g, "test-command", remotefilename);
9682 char path[] = "/test-command";
9685 r = guestfs_chmod (g, 493, path);
9690 char arguments_0[] = "/test-command";
9691 char *arguments[] = {
9697 r = guestfs_command (g, arguments);
9705 static int test_file_0_skip (void)
9709 str = getenv ("SKIP_TEST_FILE_0");
9710 if (str && strcmp (str, "1") == 0) return 1;
9711 str = getenv ("SKIP_TEST_FILE");
9712 if (str && strcmp (str, "1") == 0) return 1;
9716 static int test_file_0 (void)
9718 if (test_file_0_skip ()) {
9719 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_0");
9723 /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
9725 char device[] = "/dev/sda";
9728 r = guestfs_blockdev_setrw (g, device);
9735 r = guestfs_umount_all (g);
9742 r = guestfs_lvm_remove_all (g);
9747 char device[] = "/dev/sda";
9748 char lines_0[] = ",";
9755 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9760 char fstype[] = "ext2";
9761 char device[] = "/dev/sda1";
9764 r = guestfs_mkfs (g, fstype, device);
9769 char device[] = "/dev/sda1";
9770 char mountpoint[] = "/";
9773 r = guestfs_mount (g, device, mountpoint);
9777 /* TestOutput for file (0) */
9778 char expected[] = "empty";
9780 char path[] = "/new";
9783 r = guestfs_touch (g, path);
9788 char path[] = "/new";
9791 r = guestfs_file (g, path);
9794 if (strcmp (r, expected) != 0) {
9795 fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
9803 static int test_file_1_skip (void)
9807 str = getenv ("SKIP_TEST_FILE_1");
9808 if (str && strcmp (str, "1") == 0) return 1;
9809 str = getenv ("SKIP_TEST_FILE");
9810 if (str && strcmp (str, "1") == 0) return 1;
9814 static int test_file_1 (void)
9816 if (test_file_1_skip ()) {
9817 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_1");
9821 /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
9823 char device[] = "/dev/sda";
9826 r = guestfs_blockdev_setrw (g, device);
9833 r = guestfs_umount_all (g);
9840 r = guestfs_lvm_remove_all (g);
9845 char device[] = "/dev/sda";
9846 char lines_0[] = ",";
9853 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9858 char fstype[] = "ext2";
9859 char device[] = "/dev/sda1";
9862 r = guestfs_mkfs (g, fstype, device);
9867 char device[] = "/dev/sda1";
9868 char mountpoint[] = "/";
9871 r = guestfs_mount (g, device, mountpoint);
9875 /* TestOutput for file (1) */
9876 char expected[] = "ASCII text";
9878 char path[] = "/new";
9879 char content[] = "some content\n";
9882 r = guestfs_write_file (g, path, content, 0);
9887 char path[] = "/new";
9890 r = guestfs_file (g, path);
9893 if (strcmp (r, expected) != 0) {
9894 fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
9902 static int test_file_2_skip (void)
9906 str = getenv ("SKIP_TEST_FILE_2");
9907 if (str && strcmp (str, "1") == 0) return 1;
9908 str = getenv ("SKIP_TEST_FILE");
9909 if (str && strcmp (str, "1") == 0) return 1;
9913 static int test_file_2 (void)
9915 if (test_file_2_skip ()) {
9916 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_2");
9920 /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
9922 char device[] = "/dev/sda";
9925 r = guestfs_blockdev_setrw (g, device);
9932 r = guestfs_umount_all (g);
9939 r = guestfs_lvm_remove_all (g);
9944 char device[] = "/dev/sda";
9945 char lines_0[] = ",";
9952 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9957 char fstype[] = "ext2";
9958 char device[] = "/dev/sda1";
9961 r = guestfs_mkfs (g, fstype, device);
9966 char device[] = "/dev/sda1";
9967 char mountpoint[] = "/";
9970 r = guestfs_mount (g, device, mountpoint);
9974 /* TestLastFail for file (2) */
9976 char path[] = "/nofile";
9979 r = guestfs_file (g, path);
9987 static int test_umount_all_0_skip (void)
9991 str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
9992 if (str && strcmp (str, "1") == 0) return 1;
9993 str = getenv ("SKIP_TEST_UMOUNT_ALL");
9994 if (str && strcmp (str, "1") == 0) return 1;
9998 static int test_umount_all_0 (void)
10000 if (test_umount_all_0_skip ()) {
10001 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_0");
10005 /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
10007 char device[] = "/dev/sda";
10009 suppress_error = 0;
10010 r = guestfs_blockdev_setrw (g, device);
10016 suppress_error = 0;
10017 r = guestfs_umount_all (g);
10023 suppress_error = 0;
10024 r = guestfs_lvm_remove_all (g);
10029 char device[] = "/dev/sda";
10030 char lines_0[] = ",";
10036 suppress_error = 0;
10037 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10042 char fstype[] = "ext2";
10043 char device[] = "/dev/sda1";
10045 suppress_error = 0;
10046 r = guestfs_mkfs (g, fstype, device);
10051 char device[] = "/dev/sda1";
10052 char mountpoint[] = "/";
10054 suppress_error = 0;
10055 r = guestfs_mount (g, device, mountpoint);
10059 /* TestOutputList for umount_all (0) */
10062 suppress_error = 0;
10063 r = guestfs_umount_all (g);
10070 suppress_error = 0;
10071 r = guestfs_mounts (g);
10074 if (r[0] != NULL) {
10075 fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
10079 for (i = 0; r[i] != NULL; ++i)
10086 static int test_umount_all_1_skip (void)
10090 str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
10091 if (str && strcmp (str, "1") == 0) return 1;
10092 str = getenv ("SKIP_TEST_UMOUNT_ALL");
10093 if (str && strcmp (str, "1") == 0) return 1;
10097 static int test_umount_all_1 (void)
10099 if (test_umount_all_1_skip ()) {
10100 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_1");
10104 /* InitNone|InitEmpty for test_umount_all_1 */
10106 char device[] = "/dev/sda";
10108 suppress_error = 0;
10109 r = guestfs_blockdev_setrw (g, device);
10115 suppress_error = 0;
10116 r = guestfs_umount_all (g);
10122 suppress_error = 0;
10123 r = guestfs_lvm_remove_all (g);
10127 /* TestOutputList for umount_all (1) */
10129 char device[] = "/dev/sda";
10130 char lines_0[] = ",10";
10131 char lines_1[] = ",20";
10132 char lines_2[] = ",";
10140 suppress_error = 0;
10141 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10146 char fstype[] = "ext2";
10147 char device[] = "/dev/sda1";
10149 suppress_error = 0;
10150 r = guestfs_mkfs (g, fstype, device);
10155 char fstype[] = "ext2";
10156 char device[] = "/dev/sda2";
10158 suppress_error = 0;
10159 r = guestfs_mkfs (g, fstype, device);
10164 char fstype[] = "ext2";
10165 char device[] = "/dev/sda3";
10167 suppress_error = 0;
10168 r = guestfs_mkfs (g, fstype, device);
10173 char device[] = "/dev/sda1";
10174 char mountpoint[] = "/";
10176 suppress_error = 0;
10177 r = guestfs_mount (g, device, mountpoint);
10182 char path[] = "/mp1";
10184 suppress_error = 0;
10185 r = guestfs_mkdir (g, path);
10190 char device[] = "/dev/sda2";
10191 char mountpoint[] = "/mp1";
10193 suppress_error = 0;
10194 r = guestfs_mount (g, device, mountpoint);
10199 char path[] = "/mp1/mp2";
10201 suppress_error = 0;
10202 r = guestfs_mkdir (g, path);
10207 char device[] = "/dev/sda3";
10208 char mountpoint[] = "/mp1/mp2";
10210 suppress_error = 0;
10211 r = guestfs_mount (g, device, mountpoint);
10216 char path[] = "/mp1/mp2/mp3";
10218 suppress_error = 0;
10219 r = guestfs_mkdir (g, path);
10225 suppress_error = 0;
10226 r = guestfs_umount_all (g);
10233 suppress_error = 0;
10234 r = guestfs_mounts (g);
10237 if (r[0] != NULL) {
10238 fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
10242 for (i = 0; r[i] != NULL; ++i)
10249 static int test_mounts_0_skip (void)
10253 str = getenv ("SKIP_TEST_MOUNTS_0");
10254 if (str && strcmp (str, "1") == 0) return 1;
10255 str = getenv ("SKIP_TEST_MOUNTS");
10256 if (str && strcmp (str, "1") == 0) return 1;
10260 static int test_mounts_0 (void)
10262 if (test_mounts_0_skip ()) {
10263 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mounts_0");
10267 /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
10269 char device[] = "/dev/sda";
10271 suppress_error = 0;
10272 r = guestfs_blockdev_setrw (g, device);
10278 suppress_error = 0;
10279 r = guestfs_umount_all (g);
10285 suppress_error = 0;
10286 r = guestfs_lvm_remove_all (g);
10291 char device[] = "/dev/sda";
10292 char lines_0[] = ",";
10298 suppress_error = 0;
10299 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10304 char fstype[] = "ext2";
10305 char device[] = "/dev/sda1";
10307 suppress_error = 0;
10308 r = guestfs_mkfs (g, fstype, device);
10313 char device[] = "/dev/sda1";
10314 char mountpoint[] = "/";
10316 suppress_error = 0;
10317 r = guestfs_mount (g, device, mountpoint);
10321 /* TestOutputListOfDevices for mounts (0) */
10325 suppress_error = 0;
10326 r = guestfs_mounts (g);
10330 fprintf (stderr, "test_mounts_0: short list returned from command\n");
10335 char expected[] = "/dev/sda1";
10337 if (strcmp (r[0], expected) != 0) {
10338 fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10342 if (r[1] != NULL) {
10343 fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
10347 for (i = 0; r[i] != NULL; ++i)
10354 static int test_umount_0_skip (void)
10358 str = getenv ("SKIP_TEST_UMOUNT_0");
10359 if (str && strcmp (str, "1") == 0) return 1;
10360 str = getenv ("SKIP_TEST_UMOUNT");
10361 if (str && strcmp (str, "1") == 0) return 1;
10365 static int test_umount_0 (void)
10367 if (test_umount_0_skip ()) {
10368 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_0");
10372 /* InitNone|InitEmpty for test_umount_0 */
10374 char device[] = "/dev/sda";
10376 suppress_error = 0;
10377 r = guestfs_blockdev_setrw (g, device);
10383 suppress_error = 0;
10384 r = guestfs_umount_all (g);
10390 suppress_error = 0;
10391 r = guestfs_lvm_remove_all (g);
10395 /* TestOutputListOfDevices for umount (0) */
10397 char device[] = "/dev/sda";
10398 char lines_0[] = ",";
10404 suppress_error = 0;
10405 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10410 char fstype[] = "ext2";
10411 char device[] = "/dev/sda1";
10413 suppress_error = 0;
10414 r = guestfs_mkfs (g, fstype, device);
10419 char device[] = "/dev/sda1";
10420 char mountpoint[] = "/";
10422 suppress_error = 0;
10423 r = guestfs_mount (g, device, mountpoint);
10430 suppress_error = 0;
10431 r = guestfs_mounts (g);
10435 fprintf (stderr, "test_umount_0: short list returned from command\n");
10440 char expected[] = "/dev/sda1";
10442 if (strcmp (r[0], expected) != 0) {
10443 fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10447 if (r[1] != NULL) {
10448 fprintf (stderr, "test_umount_0: extra elements returned from command\n");
10452 for (i = 0; r[i] != NULL; ++i)
10459 static int test_umount_1_skip (void)
10463 str = getenv ("SKIP_TEST_UMOUNT_1");
10464 if (str && strcmp (str, "1") == 0) return 1;
10465 str = getenv ("SKIP_TEST_UMOUNT");
10466 if (str && strcmp (str, "1") == 0) return 1;
10470 static int test_umount_1 (void)
10472 if (test_umount_1_skip ()) {
10473 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_1");
10477 /* InitNone|InitEmpty for test_umount_1 */
10479 char device[] = "/dev/sda";
10481 suppress_error = 0;
10482 r = guestfs_blockdev_setrw (g, device);
10488 suppress_error = 0;
10489 r = guestfs_umount_all (g);
10495 suppress_error = 0;
10496 r = guestfs_lvm_remove_all (g);
10500 /* TestOutputList for umount (1) */
10502 char device[] = "/dev/sda";
10503 char lines_0[] = ",";
10509 suppress_error = 0;
10510 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10515 char fstype[] = "ext2";
10516 char device[] = "/dev/sda1";
10518 suppress_error = 0;
10519 r = guestfs_mkfs (g, fstype, device);
10524 char device[] = "/dev/sda1";
10525 char mountpoint[] = "/";
10527 suppress_error = 0;
10528 r = guestfs_mount (g, device, mountpoint);
10533 char pathordevice[] = "/";
10535 suppress_error = 0;
10536 r = guestfs_umount (g, pathordevice);
10543 suppress_error = 0;
10544 r = guestfs_mounts (g);
10547 if (r[0] != NULL) {
10548 fprintf (stderr, "test_umount_1: extra elements returned from command\n");
10552 for (i = 0; r[i] != NULL; ++i)
10559 static int test_write_file_0_skip (void)
10563 str = getenv ("SKIP_TEST_WRITE_FILE_0");
10564 if (str && strcmp (str, "1") == 0) return 1;
10565 str = getenv ("SKIP_TEST_WRITE_FILE");
10566 if (str && strcmp (str, "1") == 0) return 1;
10570 static int test_write_file_0 (void)
10572 if (test_write_file_0_skip ()) {
10573 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_0");
10577 /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
10579 char device[] = "/dev/sda";
10581 suppress_error = 0;
10582 r = guestfs_blockdev_setrw (g, device);
10588 suppress_error = 0;
10589 r = guestfs_umount_all (g);
10595 suppress_error = 0;
10596 r = guestfs_lvm_remove_all (g);
10601 char device[] = "/dev/sda";
10602 char lines_0[] = ",";
10608 suppress_error = 0;
10609 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10614 char fstype[] = "ext2";
10615 char device[] = "/dev/sda1";
10617 suppress_error = 0;
10618 r = guestfs_mkfs (g, fstype, device);
10623 char device[] = "/dev/sda1";
10624 char mountpoint[] = "/";
10626 suppress_error = 0;
10627 r = guestfs_mount (g, device, mountpoint);
10631 /* TestOutput for write_file (0) */
10632 char expected[] = "new file contents";
10634 char path[] = "/new";
10635 char content[] = "new file contents";
10637 suppress_error = 0;
10638 r = guestfs_write_file (g, path, content, 0);
10643 char path[] = "/new";
10645 suppress_error = 0;
10646 r = guestfs_cat (g, path);
10649 if (strcmp (r, expected) != 0) {
10650 fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
10658 static int test_write_file_1_skip (void)
10662 str = getenv ("SKIP_TEST_WRITE_FILE_1");
10663 if (str && strcmp (str, "1") == 0) return 1;
10664 str = getenv ("SKIP_TEST_WRITE_FILE");
10665 if (str && strcmp (str, "1") == 0) return 1;
10669 static int test_write_file_1 (void)
10671 if (test_write_file_1_skip ()) {
10672 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_1");
10676 /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
10678 char device[] = "/dev/sda";
10680 suppress_error = 0;
10681 r = guestfs_blockdev_setrw (g, device);
10687 suppress_error = 0;
10688 r = guestfs_umount_all (g);
10694 suppress_error = 0;
10695 r = guestfs_lvm_remove_all (g);
10700 char device[] = "/dev/sda";
10701 char lines_0[] = ",";
10707 suppress_error = 0;
10708 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10713 char fstype[] = "ext2";
10714 char device[] = "/dev/sda1";
10716 suppress_error = 0;
10717 r = guestfs_mkfs (g, fstype, device);
10722 char device[] = "/dev/sda1";
10723 char mountpoint[] = "/";
10725 suppress_error = 0;
10726 r = guestfs_mount (g, device, mountpoint);
10730 /* TestOutput for write_file (1) */
10731 char expected[] = "\nnew file contents\n";
10733 char path[] = "/new";
10734 char content[] = "\nnew file contents\n";
10736 suppress_error = 0;
10737 r = guestfs_write_file (g, path, content, 0);
10742 char path[] = "/new";
10744 suppress_error = 0;
10745 r = guestfs_cat (g, path);
10748 if (strcmp (r, expected) != 0) {
10749 fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
10757 static int test_write_file_2_skip (void)
10761 str = getenv ("SKIP_TEST_WRITE_FILE_2");
10762 if (str && strcmp (str, "1") == 0) return 1;
10763 str = getenv ("SKIP_TEST_WRITE_FILE");
10764 if (str && strcmp (str, "1") == 0) return 1;
10768 static int test_write_file_2 (void)
10770 if (test_write_file_2_skip ()) {
10771 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_2");
10775 /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
10777 char device[] = "/dev/sda";
10779 suppress_error = 0;
10780 r = guestfs_blockdev_setrw (g, device);
10786 suppress_error = 0;
10787 r = guestfs_umount_all (g);
10793 suppress_error = 0;
10794 r = guestfs_lvm_remove_all (g);
10799 char device[] = "/dev/sda";
10800 char lines_0[] = ",";
10806 suppress_error = 0;
10807 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10812 char fstype[] = "ext2";
10813 char device[] = "/dev/sda1";
10815 suppress_error = 0;
10816 r = guestfs_mkfs (g, fstype, device);
10821 char device[] = "/dev/sda1";
10822 char mountpoint[] = "/";
10824 suppress_error = 0;
10825 r = guestfs_mount (g, device, mountpoint);
10829 /* TestOutput for write_file (2) */
10830 char expected[] = "\n\n";
10832 char path[] = "/new";
10833 char content[] = "\n\n";
10835 suppress_error = 0;
10836 r = guestfs_write_file (g, path, content, 0);
10841 char path[] = "/new";
10843 suppress_error = 0;
10844 r = guestfs_cat (g, path);
10847 if (strcmp (r, expected) != 0) {
10848 fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
10856 static int test_write_file_3_skip (void)
10860 str = getenv ("SKIP_TEST_WRITE_FILE_3");
10861 if (str && strcmp (str, "1") == 0) return 1;
10862 str = getenv ("SKIP_TEST_WRITE_FILE");
10863 if (str && strcmp (str, "1") == 0) return 1;
10867 static int test_write_file_3 (void)
10869 if (test_write_file_3_skip ()) {
10870 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_3");
10874 /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
10876 char device[] = "/dev/sda";
10878 suppress_error = 0;
10879 r = guestfs_blockdev_setrw (g, device);
10885 suppress_error = 0;
10886 r = guestfs_umount_all (g);
10892 suppress_error = 0;
10893 r = guestfs_lvm_remove_all (g);
10898 char device[] = "/dev/sda";
10899 char lines_0[] = ",";
10905 suppress_error = 0;
10906 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10911 char fstype[] = "ext2";
10912 char device[] = "/dev/sda1";
10914 suppress_error = 0;
10915 r = guestfs_mkfs (g, fstype, device);
10920 char device[] = "/dev/sda1";
10921 char mountpoint[] = "/";
10923 suppress_error = 0;
10924 r = guestfs_mount (g, device, mountpoint);
10928 /* TestOutput for write_file (3) */
10929 char expected[] = "";
10931 char path[] = "/new";
10932 char content[] = "";
10934 suppress_error = 0;
10935 r = guestfs_write_file (g, path, content, 0);
10940 char path[] = "/new";
10942 suppress_error = 0;
10943 r = guestfs_cat (g, path);
10946 if (strcmp (r, expected) != 0) {
10947 fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
10955 static int test_write_file_4_skip (void)
10959 str = getenv ("SKIP_TEST_WRITE_FILE_4");
10960 if (str && strcmp (str, "1") == 0) return 1;
10961 str = getenv ("SKIP_TEST_WRITE_FILE");
10962 if (str && strcmp (str, "1") == 0) return 1;
10966 static int test_write_file_4 (void)
10968 if (test_write_file_4_skip ()) {
10969 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_4");
10973 /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
10975 char device[] = "/dev/sda";
10977 suppress_error = 0;
10978 r = guestfs_blockdev_setrw (g, device);
10984 suppress_error = 0;
10985 r = guestfs_umount_all (g);
10991 suppress_error = 0;
10992 r = guestfs_lvm_remove_all (g);
10997 char device[] = "/dev/sda";
10998 char lines_0[] = ",";
11004 suppress_error = 0;
11005 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11010 char fstype[] = "ext2";
11011 char device[] = "/dev/sda1";
11013 suppress_error = 0;
11014 r = guestfs_mkfs (g, fstype, device);
11019 char device[] = "/dev/sda1";
11020 char mountpoint[] = "/";
11022 suppress_error = 0;
11023 r = guestfs_mount (g, device, mountpoint);
11027 /* TestOutput for write_file (4) */
11028 char expected[] = "\n\n\n";
11030 char path[] = "/new";
11031 char content[] = "\n\n\n";
11033 suppress_error = 0;
11034 r = guestfs_write_file (g, path, content, 0);
11039 char path[] = "/new";
11041 suppress_error = 0;
11042 r = guestfs_cat (g, path);
11045 if (strcmp (r, expected) != 0) {
11046 fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
11054 static int test_write_file_5_skip (void)
11058 str = getenv ("SKIP_TEST_WRITE_FILE_5");
11059 if (str && strcmp (str, "1") == 0) return 1;
11060 str = getenv ("SKIP_TEST_WRITE_FILE");
11061 if (str && strcmp (str, "1") == 0) return 1;
11065 static int test_write_file_5 (void)
11067 if (test_write_file_5_skip ()) {
11068 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_5");
11072 /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
11074 char device[] = "/dev/sda";
11076 suppress_error = 0;
11077 r = guestfs_blockdev_setrw (g, device);
11083 suppress_error = 0;
11084 r = guestfs_umount_all (g);
11090 suppress_error = 0;
11091 r = guestfs_lvm_remove_all (g);
11096 char device[] = "/dev/sda";
11097 char lines_0[] = ",";
11103 suppress_error = 0;
11104 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11109 char fstype[] = "ext2";
11110 char device[] = "/dev/sda1";
11112 suppress_error = 0;
11113 r = guestfs_mkfs (g, fstype, device);
11118 char device[] = "/dev/sda1";
11119 char mountpoint[] = "/";
11121 suppress_error = 0;
11122 r = guestfs_mount (g, device, mountpoint);
11126 /* TestOutput for write_file (5) */
11127 char expected[] = "\n";
11129 char path[] = "/new";
11130 char content[] = "\n";
11132 suppress_error = 0;
11133 r = guestfs_write_file (g, path, content, 0);
11138 char path[] = "/new";
11140 suppress_error = 0;
11141 r = guestfs_cat (g, path);
11144 if (strcmp (r, expected) != 0) {
11145 fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
11153 static int test_mkfs_0_skip (void)
11157 str = getenv ("SKIP_TEST_MKFS_0");
11158 if (str && strcmp (str, "1") == 0) return 1;
11159 str = getenv ("SKIP_TEST_MKFS");
11160 if (str && strcmp (str, "1") == 0) return 1;
11164 static int test_mkfs_0 (void)
11166 if (test_mkfs_0_skip ()) {
11167 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkfs_0");
11171 /* InitNone|InitEmpty for test_mkfs_0 */
11173 char device[] = "/dev/sda";
11175 suppress_error = 0;
11176 r = guestfs_blockdev_setrw (g, device);
11182 suppress_error = 0;
11183 r = guestfs_umount_all (g);
11189 suppress_error = 0;
11190 r = guestfs_lvm_remove_all (g);
11194 /* TestOutput for mkfs (0) */
11195 char expected[] = "new file contents";
11197 char device[] = "/dev/sda";
11198 char lines_0[] = ",";
11204 suppress_error = 0;
11205 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11210 char fstype[] = "ext2";
11211 char device[] = "/dev/sda1";
11213 suppress_error = 0;
11214 r = guestfs_mkfs (g, fstype, device);
11219 char device[] = "/dev/sda1";
11220 char mountpoint[] = "/";
11222 suppress_error = 0;
11223 r = guestfs_mount (g, device, mountpoint);
11228 char path[] = "/new";
11229 char content[] = "new file contents";
11231 suppress_error = 0;
11232 r = guestfs_write_file (g, path, content, 0);
11237 char path[] = "/new";
11239 suppress_error = 0;
11240 r = guestfs_cat (g, path);
11243 if (strcmp (r, expected) != 0) {
11244 fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
11252 static int test_lvcreate_0_skip (void)
11256 str = getenv ("SKIP_TEST_LVCREATE_0");
11257 if (str && strcmp (str, "1") == 0) return 1;
11258 str = getenv ("SKIP_TEST_LVCREATE");
11259 if (str && strcmp (str, "1") == 0) return 1;
11263 static int test_lvcreate_0 (void)
11265 if (test_lvcreate_0_skip ()) {
11266 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvcreate_0");
11270 /* InitNone|InitEmpty for test_lvcreate_0 */
11272 char device[] = "/dev/sda";
11274 suppress_error = 0;
11275 r = guestfs_blockdev_setrw (g, device);
11281 suppress_error = 0;
11282 r = guestfs_umount_all (g);
11288 suppress_error = 0;
11289 r = guestfs_lvm_remove_all (g);
11293 /* TestOutputList for lvcreate (0) */
11295 char device[] = "/dev/sda";
11296 char lines_0[] = ",10";
11297 char lines_1[] = ",20";
11298 char lines_2[] = ",";
11306 suppress_error = 0;
11307 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11312 char device[] = "/dev/sda1";
11314 suppress_error = 0;
11315 r = guestfs_pvcreate (g, device);
11320 char device[] = "/dev/sda2";
11322 suppress_error = 0;
11323 r = guestfs_pvcreate (g, device);
11328 char device[] = "/dev/sda3";
11330 suppress_error = 0;
11331 r = guestfs_pvcreate (g, device);
11336 char volgroup[] = "VG1";
11337 char physvols_0[] = "/dev/sda1";
11338 char physvols_1[] = "/dev/sda2";
11339 char *physvols[] = {
11345 suppress_error = 0;
11346 r = guestfs_vgcreate (g, volgroup, physvols);
11351 char volgroup[] = "VG2";
11352 char physvols_0[] = "/dev/sda3";
11353 char *physvols[] = {
11358 suppress_error = 0;
11359 r = guestfs_vgcreate (g, volgroup, physvols);
11364 char logvol[] = "LV1";
11365 char volgroup[] = "VG1";
11367 suppress_error = 0;
11368 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11373 char logvol[] = "LV2";
11374 char volgroup[] = "VG1";
11376 suppress_error = 0;
11377 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11382 char logvol[] = "LV3";
11383 char volgroup[] = "VG2";
11385 suppress_error = 0;
11386 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11391 char logvol[] = "LV4";
11392 char volgroup[] = "VG2";
11394 suppress_error = 0;
11395 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11400 char logvol[] = "LV5";
11401 char volgroup[] = "VG2";
11403 suppress_error = 0;
11404 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11411 suppress_error = 0;
11412 r = guestfs_lvs (g);
11416 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11421 char expected[] = "/dev/VG1/LV1";
11422 if (strcmp (r[0], expected) != 0) {
11423 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11428 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11433 char expected[] = "/dev/VG1/LV2";
11434 if (strcmp (r[1], expected) != 0) {
11435 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11440 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11445 char expected[] = "/dev/VG2/LV3";
11446 if (strcmp (r[2], expected) != 0) {
11447 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11452 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11457 char expected[] = "/dev/VG2/LV4";
11458 if (strcmp (r[3], expected) != 0) {
11459 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
11464 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11469 char expected[] = "/dev/VG2/LV5";
11470 if (strcmp (r[4], expected) != 0) {
11471 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
11475 if (r[5] != NULL) {
11476 fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
11480 for (i = 0; r[i] != NULL; ++i)
11487 static int test_vgcreate_0_skip (void)
11491 str = getenv ("SKIP_TEST_VGCREATE_0");
11492 if (str && strcmp (str, "1") == 0) return 1;
11493 str = getenv ("SKIP_TEST_VGCREATE");
11494 if (str && strcmp (str, "1") == 0) return 1;
11498 static int test_vgcreate_0 (void)
11500 if (test_vgcreate_0_skip ()) {
11501 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgcreate_0");
11505 /* InitNone|InitEmpty for test_vgcreate_0 */
11507 char device[] = "/dev/sda";
11509 suppress_error = 0;
11510 r = guestfs_blockdev_setrw (g, device);
11516 suppress_error = 0;
11517 r = guestfs_umount_all (g);
11523 suppress_error = 0;
11524 r = guestfs_lvm_remove_all (g);
11528 /* TestOutputList for vgcreate (0) */
11530 char device[] = "/dev/sda";
11531 char lines_0[] = ",10";
11532 char lines_1[] = ",20";
11533 char lines_2[] = ",";
11541 suppress_error = 0;
11542 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11547 char device[] = "/dev/sda1";
11549 suppress_error = 0;
11550 r = guestfs_pvcreate (g, device);
11555 char device[] = "/dev/sda2";
11557 suppress_error = 0;
11558 r = guestfs_pvcreate (g, device);
11563 char device[] = "/dev/sda3";
11565 suppress_error = 0;
11566 r = guestfs_pvcreate (g, device);
11571 char volgroup[] = "VG1";
11572 char physvols_0[] = "/dev/sda1";
11573 char physvols_1[] = "/dev/sda2";
11574 char *physvols[] = {
11580 suppress_error = 0;
11581 r = guestfs_vgcreate (g, volgroup, physvols);
11586 char volgroup[] = "VG2";
11587 char physvols_0[] = "/dev/sda3";
11588 char *physvols[] = {
11593 suppress_error = 0;
11594 r = guestfs_vgcreate (g, volgroup, physvols);
11601 suppress_error = 0;
11602 r = guestfs_vgs (g);
11606 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
11611 char expected[] = "VG1";
11612 if (strcmp (r[0], expected) != 0) {
11613 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11618 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
11623 char expected[] = "VG2";
11624 if (strcmp (r[1], expected) != 0) {
11625 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11629 if (r[2] != NULL) {
11630 fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
11634 for (i = 0; r[i] != NULL; ++i)
11641 static int test_pvcreate_0_skip (void)
11645 str = getenv ("SKIP_TEST_PVCREATE_0");
11646 if (str && strcmp (str, "1") == 0) return 1;
11647 str = getenv ("SKIP_TEST_PVCREATE");
11648 if (str && strcmp (str, "1") == 0) return 1;
11652 static int test_pvcreate_0 (void)
11654 if (test_pvcreate_0_skip ()) {
11655 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvcreate_0");
11659 /* InitNone|InitEmpty for test_pvcreate_0 */
11661 char device[] = "/dev/sda";
11663 suppress_error = 0;
11664 r = guestfs_blockdev_setrw (g, device);
11670 suppress_error = 0;
11671 r = guestfs_umount_all (g);
11677 suppress_error = 0;
11678 r = guestfs_lvm_remove_all (g);
11682 /* TestOutputListOfDevices for pvcreate (0) */
11684 char device[] = "/dev/sda";
11685 char lines_0[] = ",10";
11686 char lines_1[] = ",20";
11687 char lines_2[] = ",";
11695 suppress_error = 0;
11696 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11701 char device[] = "/dev/sda1";
11703 suppress_error = 0;
11704 r = guestfs_pvcreate (g, device);
11709 char device[] = "/dev/sda2";
11711 suppress_error = 0;
11712 r = guestfs_pvcreate (g, device);
11717 char device[] = "/dev/sda3";
11719 suppress_error = 0;
11720 r = guestfs_pvcreate (g, device);
11727 suppress_error = 0;
11728 r = guestfs_pvs (g);
11732 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11737 char expected[] = "/dev/sda1";
11739 if (strcmp (r[0], expected) != 0) {
11740 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11745 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11750 char expected[] = "/dev/sda2";
11752 if (strcmp (r[1], expected) != 0) {
11753 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11758 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11763 char expected[] = "/dev/sda3";
11765 if (strcmp (r[2], expected) != 0) {
11766 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11770 if (r[3] != NULL) {
11771 fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
11775 for (i = 0; r[i] != NULL; ++i)
11782 static int test_is_dir_0_skip (void)
11786 str = getenv ("SKIP_TEST_IS_DIR_0");
11787 if (str && strcmp (str, "1") == 0) return 1;
11788 str = getenv ("SKIP_TEST_IS_DIR");
11789 if (str && strcmp (str, "1") == 0) return 1;
11793 static int test_is_dir_0 (void)
11795 if (test_is_dir_0_skip ()) {
11796 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_0");
11800 /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
11802 char device[] = "/dev/sda";
11804 suppress_error = 0;
11805 r = guestfs_blockdev_setrw (g, device);
11811 suppress_error = 0;
11812 r = guestfs_umount_all (g);
11818 suppress_error = 0;
11819 r = guestfs_lvm_remove_all (g);
11824 char device[] = "/dev/sda";
11825 char lines_0[] = ",";
11831 suppress_error = 0;
11832 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11837 char fstype[] = "ext2";
11838 char device[] = "/dev/sda1";
11840 suppress_error = 0;
11841 r = guestfs_mkfs (g, fstype, device);
11846 char device[] = "/dev/sda1";
11847 char mountpoint[] = "/";
11849 suppress_error = 0;
11850 r = guestfs_mount (g, device, mountpoint);
11854 /* TestOutputFalse for is_dir (0) */
11856 char path[] = "/new";
11858 suppress_error = 0;
11859 r = guestfs_touch (g, path);
11864 char path[] = "/new";
11866 suppress_error = 0;
11867 r = guestfs_is_dir (g, path);
11871 fprintf (stderr, "test_is_dir_0: expected false, got true\n");
11878 static int test_is_dir_1_skip (void)
11882 str = getenv ("SKIP_TEST_IS_DIR_1");
11883 if (str && strcmp (str, "1") == 0) return 1;
11884 str = getenv ("SKIP_TEST_IS_DIR");
11885 if (str && strcmp (str, "1") == 0) return 1;
11889 static int test_is_dir_1 (void)
11891 if (test_is_dir_1_skip ()) {
11892 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_1");
11896 /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
11898 char device[] = "/dev/sda";
11900 suppress_error = 0;
11901 r = guestfs_blockdev_setrw (g, device);
11907 suppress_error = 0;
11908 r = guestfs_umount_all (g);
11914 suppress_error = 0;
11915 r = guestfs_lvm_remove_all (g);
11920 char device[] = "/dev/sda";
11921 char lines_0[] = ",";
11927 suppress_error = 0;
11928 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11933 char fstype[] = "ext2";
11934 char device[] = "/dev/sda1";
11936 suppress_error = 0;
11937 r = guestfs_mkfs (g, fstype, device);
11942 char device[] = "/dev/sda1";
11943 char mountpoint[] = "/";
11945 suppress_error = 0;
11946 r = guestfs_mount (g, device, mountpoint);
11950 /* TestOutputTrue for is_dir (1) */
11952 char path[] = "/new";
11954 suppress_error = 0;
11955 r = guestfs_mkdir (g, path);
11960 char path[] = "/new";
11962 suppress_error = 0;
11963 r = guestfs_is_dir (g, path);
11967 fprintf (stderr, "test_is_dir_1: expected true, got false\n");
11974 static int test_is_file_0_skip (void)
11978 str = getenv ("SKIP_TEST_IS_FILE_0");
11979 if (str && strcmp (str, "1") == 0) return 1;
11980 str = getenv ("SKIP_TEST_IS_FILE");
11981 if (str && strcmp (str, "1") == 0) return 1;
11985 static int test_is_file_0 (void)
11987 if (test_is_file_0_skip ()) {
11988 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_0");
11992 /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
11994 char device[] = "/dev/sda";
11996 suppress_error = 0;
11997 r = guestfs_blockdev_setrw (g, device);
12003 suppress_error = 0;
12004 r = guestfs_umount_all (g);
12010 suppress_error = 0;
12011 r = guestfs_lvm_remove_all (g);
12016 char device[] = "/dev/sda";
12017 char lines_0[] = ",";
12023 suppress_error = 0;
12024 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12029 char fstype[] = "ext2";
12030 char device[] = "/dev/sda1";
12032 suppress_error = 0;
12033 r = guestfs_mkfs (g, fstype, device);
12038 char device[] = "/dev/sda1";
12039 char mountpoint[] = "/";
12041 suppress_error = 0;
12042 r = guestfs_mount (g, device, mountpoint);
12046 /* TestOutputTrue for is_file (0) */
12048 char path[] = "/new";
12050 suppress_error = 0;
12051 r = guestfs_touch (g, path);
12056 char path[] = "/new";
12058 suppress_error = 0;
12059 r = guestfs_is_file (g, path);
12063 fprintf (stderr, "test_is_file_0: expected true, got false\n");
12070 static int test_is_file_1_skip (void)
12074 str = getenv ("SKIP_TEST_IS_FILE_1");
12075 if (str && strcmp (str, "1") == 0) return 1;
12076 str = getenv ("SKIP_TEST_IS_FILE");
12077 if (str && strcmp (str, "1") == 0) return 1;
12081 static int test_is_file_1 (void)
12083 if (test_is_file_1_skip ()) {
12084 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_1");
12088 /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
12090 char device[] = "/dev/sda";
12092 suppress_error = 0;
12093 r = guestfs_blockdev_setrw (g, device);
12099 suppress_error = 0;
12100 r = guestfs_umount_all (g);
12106 suppress_error = 0;
12107 r = guestfs_lvm_remove_all (g);
12112 char device[] = "/dev/sda";
12113 char lines_0[] = ",";
12119 suppress_error = 0;
12120 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12125 char fstype[] = "ext2";
12126 char device[] = "/dev/sda1";
12128 suppress_error = 0;
12129 r = guestfs_mkfs (g, fstype, device);
12134 char device[] = "/dev/sda1";
12135 char mountpoint[] = "/";
12137 suppress_error = 0;
12138 r = guestfs_mount (g, device, mountpoint);
12142 /* TestOutputFalse for is_file (1) */
12144 char path[] = "/new";
12146 suppress_error = 0;
12147 r = guestfs_mkdir (g, path);
12152 char path[] = "/new";
12154 suppress_error = 0;
12155 r = guestfs_is_file (g, path);
12159 fprintf (stderr, "test_is_file_1: expected false, got true\n");
12166 static int test_exists_0_skip (void)
12170 str = getenv ("SKIP_TEST_EXISTS_0");
12171 if (str && strcmp (str, "1") == 0) return 1;
12172 str = getenv ("SKIP_TEST_EXISTS");
12173 if (str && strcmp (str, "1") == 0) return 1;
12177 static int test_exists_0 (void)
12179 if (test_exists_0_skip ()) {
12180 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_0");
12184 /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
12186 char device[] = "/dev/sda";
12188 suppress_error = 0;
12189 r = guestfs_blockdev_setrw (g, device);
12195 suppress_error = 0;
12196 r = guestfs_umount_all (g);
12202 suppress_error = 0;
12203 r = guestfs_lvm_remove_all (g);
12208 char device[] = "/dev/sda";
12209 char lines_0[] = ",";
12215 suppress_error = 0;
12216 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12221 char fstype[] = "ext2";
12222 char device[] = "/dev/sda1";
12224 suppress_error = 0;
12225 r = guestfs_mkfs (g, fstype, device);
12230 char device[] = "/dev/sda1";
12231 char mountpoint[] = "/";
12233 suppress_error = 0;
12234 r = guestfs_mount (g, device, mountpoint);
12238 /* TestOutputTrue for exists (0) */
12240 char path[] = "/new";
12242 suppress_error = 0;
12243 r = guestfs_touch (g, path);
12248 char path[] = "/new";
12250 suppress_error = 0;
12251 r = guestfs_exists (g, path);
12255 fprintf (stderr, "test_exists_0: expected true, got false\n");
12262 static int test_exists_1_skip (void)
12266 str = getenv ("SKIP_TEST_EXISTS_1");
12267 if (str && strcmp (str, "1") == 0) return 1;
12268 str = getenv ("SKIP_TEST_EXISTS");
12269 if (str && strcmp (str, "1") == 0) return 1;
12273 static int test_exists_1 (void)
12275 if (test_exists_1_skip ()) {
12276 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_1");
12280 /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
12282 char device[] = "/dev/sda";
12284 suppress_error = 0;
12285 r = guestfs_blockdev_setrw (g, device);
12291 suppress_error = 0;
12292 r = guestfs_umount_all (g);
12298 suppress_error = 0;
12299 r = guestfs_lvm_remove_all (g);
12304 char device[] = "/dev/sda";
12305 char lines_0[] = ",";
12311 suppress_error = 0;
12312 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12317 char fstype[] = "ext2";
12318 char device[] = "/dev/sda1";
12320 suppress_error = 0;
12321 r = guestfs_mkfs (g, fstype, device);
12326 char device[] = "/dev/sda1";
12327 char mountpoint[] = "/";
12329 suppress_error = 0;
12330 r = guestfs_mount (g, device, mountpoint);
12334 /* TestOutputTrue for exists (1) */
12336 char path[] = "/new";
12338 suppress_error = 0;
12339 r = guestfs_mkdir (g, path);
12344 char path[] = "/new";
12346 suppress_error = 0;
12347 r = guestfs_exists (g, path);
12351 fprintf (stderr, "test_exists_1: expected true, got false\n");
12358 static int test_mkdir_p_0_skip (void)
12362 str = getenv ("SKIP_TEST_MKDIR_P_0");
12363 if (str && strcmp (str, "1") == 0) return 1;
12364 str = getenv ("SKIP_TEST_MKDIR_P");
12365 if (str && strcmp (str, "1") == 0) return 1;
12369 static int test_mkdir_p_0 (void)
12371 if (test_mkdir_p_0_skip ()) {
12372 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_0");
12376 /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
12378 char device[] = "/dev/sda";
12380 suppress_error = 0;
12381 r = guestfs_blockdev_setrw (g, device);
12387 suppress_error = 0;
12388 r = guestfs_umount_all (g);
12394 suppress_error = 0;
12395 r = guestfs_lvm_remove_all (g);
12400 char device[] = "/dev/sda";
12401 char lines_0[] = ",";
12407 suppress_error = 0;
12408 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12413 char fstype[] = "ext2";
12414 char device[] = "/dev/sda1";
12416 suppress_error = 0;
12417 r = guestfs_mkfs (g, fstype, device);
12422 char device[] = "/dev/sda1";
12423 char mountpoint[] = "/";
12425 suppress_error = 0;
12426 r = guestfs_mount (g, device, mountpoint);
12430 /* TestOutputTrue for mkdir_p (0) */
12432 char path[] = "/new/foo/bar";
12434 suppress_error = 0;
12435 r = guestfs_mkdir_p (g, path);
12440 char path[] = "/new/foo/bar";
12442 suppress_error = 0;
12443 r = guestfs_is_dir (g, path);
12447 fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
12454 static int test_mkdir_p_1_skip (void)
12458 str = getenv ("SKIP_TEST_MKDIR_P_1");
12459 if (str && strcmp (str, "1") == 0) return 1;
12460 str = getenv ("SKIP_TEST_MKDIR_P");
12461 if (str && strcmp (str, "1") == 0) return 1;
12465 static int test_mkdir_p_1 (void)
12467 if (test_mkdir_p_1_skip ()) {
12468 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_1");
12472 /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
12474 char device[] = "/dev/sda";
12476 suppress_error = 0;
12477 r = guestfs_blockdev_setrw (g, device);
12483 suppress_error = 0;
12484 r = guestfs_umount_all (g);
12490 suppress_error = 0;
12491 r = guestfs_lvm_remove_all (g);
12496 char device[] = "/dev/sda";
12497 char lines_0[] = ",";
12503 suppress_error = 0;
12504 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12509 char fstype[] = "ext2";
12510 char device[] = "/dev/sda1";
12512 suppress_error = 0;
12513 r = guestfs_mkfs (g, fstype, device);
12518 char device[] = "/dev/sda1";
12519 char mountpoint[] = "/";
12521 suppress_error = 0;
12522 r = guestfs_mount (g, device, mountpoint);
12526 /* TestOutputTrue for mkdir_p (1) */
12528 char path[] = "/new/foo/bar";
12530 suppress_error = 0;
12531 r = guestfs_mkdir_p (g, path);
12536 char path[] = "/new/foo";
12538 suppress_error = 0;
12539 r = guestfs_is_dir (g, path);
12543 fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
12550 static int test_mkdir_p_2_skip (void)
12554 str = getenv ("SKIP_TEST_MKDIR_P_2");
12555 if (str && strcmp (str, "1") == 0) return 1;
12556 str = getenv ("SKIP_TEST_MKDIR_P");
12557 if (str && strcmp (str, "1") == 0) return 1;
12561 static int test_mkdir_p_2 (void)
12563 if (test_mkdir_p_2_skip ()) {
12564 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_2");
12568 /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
12570 char device[] = "/dev/sda";
12572 suppress_error = 0;
12573 r = guestfs_blockdev_setrw (g, device);
12579 suppress_error = 0;
12580 r = guestfs_umount_all (g);
12586 suppress_error = 0;
12587 r = guestfs_lvm_remove_all (g);
12592 char device[] = "/dev/sda";
12593 char lines_0[] = ",";
12599 suppress_error = 0;
12600 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12605 char fstype[] = "ext2";
12606 char device[] = "/dev/sda1";
12608 suppress_error = 0;
12609 r = guestfs_mkfs (g, fstype, device);
12614 char device[] = "/dev/sda1";
12615 char mountpoint[] = "/";
12617 suppress_error = 0;
12618 r = guestfs_mount (g, device, mountpoint);
12622 /* TestOutputTrue for mkdir_p (2) */
12624 char path[] = "/new/foo/bar";
12626 suppress_error = 0;
12627 r = guestfs_mkdir_p (g, path);
12632 char path[] = "/new";
12634 suppress_error = 0;
12635 r = guestfs_is_dir (g, path);
12639 fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
12646 static int test_mkdir_p_3_skip (void)
12650 str = getenv ("SKIP_TEST_MKDIR_P_3");
12651 if (str && strcmp (str, "1") == 0) return 1;
12652 str = getenv ("SKIP_TEST_MKDIR_P");
12653 if (str && strcmp (str, "1") == 0) return 1;
12657 static int test_mkdir_p_3 (void)
12659 if (test_mkdir_p_3_skip ()) {
12660 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_3");
12664 /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
12666 char device[] = "/dev/sda";
12668 suppress_error = 0;
12669 r = guestfs_blockdev_setrw (g, device);
12675 suppress_error = 0;
12676 r = guestfs_umount_all (g);
12682 suppress_error = 0;
12683 r = guestfs_lvm_remove_all (g);
12688 char device[] = "/dev/sda";
12689 char lines_0[] = ",";
12695 suppress_error = 0;
12696 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12701 char fstype[] = "ext2";
12702 char device[] = "/dev/sda1";
12704 suppress_error = 0;
12705 r = guestfs_mkfs (g, fstype, device);
12710 char device[] = "/dev/sda1";
12711 char mountpoint[] = "/";
12713 suppress_error = 0;
12714 r = guestfs_mount (g, device, mountpoint);
12718 /* TestRun for mkdir_p (3) */
12720 char path[] = "/new";
12722 suppress_error = 0;
12723 r = guestfs_mkdir (g, path);
12728 char path[] = "/new";
12730 suppress_error = 0;
12731 r = guestfs_mkdir_p (g, path);
12738 static int test_mkdir_p_4_skip (void)
12742 str = getenv ("SKIP_TEST_MKDIR_P_4");
12743 if (str && strcmp (str, "1") == 0) return 1;
12744 str = getenv ("SKIP_TEST_MKDIR_P");
12745 if (str && strcmp (str, "1") == 0) return 1;
12749 static int test_mkdir_p_4 (void)
12751 if (test_mkdir_p_4_skip ()) {
12752 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_4");
12756 /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
12758 char device[] = "/dev/sda";
12760 suppress_error = 0;
12761 r = guestfs_blockdev_setrw (g, device);
12767 suppress_error = 0;
12768 r = guestfs_umount_all (g);
12774 suppress_error = 0;
12775 r = guestfs_lvm_remove_all (g);
12780 char device[] = "/dev/sda";
12781 char lines_0[] = ",";
12787 suppress_error = 0;
12788 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12793 char fstype[] = "ext2";
12794 char device[] = "/dev/sda1";
12796 suppress_error = 0;
12797 r = guestfs_mkfs (g, fstype, device);
12802 char device[] = "/dev/sda1";
12803 char mountpoint[] = "/";
12805 suppress_error = 0;
12806 r = guestfs_mount (g, device, mountpoint);
12810 /* TestLastFail for mkdir_p (4) */
12812 char path[] = "/new";
12814 suppress_error = 0;
12815 r = guestfs_touch (g, path);
12820 char path[] = "/new";
12822 suppress_error = 1;
12823 r = guestfs_mkdir_p (g, path);
12830 static int test_mkdir_0_skip (void)
12834 str = getenv ("SKIP_TEST_MKDIR_0");
12835 if (str && strcmp (str, "1") == 0) return 1;
12836 str = getenv ("SKIP_TEST_MKDIR");
12837 if (str && strcmp (str, "1") == 0) return 1;
12841 static int test_mkdir_0 (void)
12843 if (test_mkdir_0_skip ()) {
12844 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_0");
12848 /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
12850 char device[] = "/dev/sda";
12852 suppress_error = 0;
12853 r = guestfs_blockdev_setrw (g, device);
12859 suppress_error = 0;
12860 r = guestfs_umount_all (g);
12866 suppress_error = 0;
12867 r = guestfs_lvm_remove_all (g);
12872 char device[] = "/dev/sda";
12873 char lines_0[] = ",";
12879 suppress_error = 0;
12880 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12885 char fstype[] = "ext2";
12886 char device[] = "/dev/sda1";
12888 suppress_error = 0;
12889 r = guestfs_mkfs (g, fstype, device);
12894 char device[] = "/dev/sda1";
12895 char mountpoint[] = "/";
12897 suppress_error = 0;
12898 r = guestfs_mount (g, device, mountpoint);
12902 /* TestOutputTrue for mkdir (0) */
12904 char path[] = "/new";
12906 suppress_error = 0;
12907 r = guestfs_mkdir (g, path);
12912 char path[] = "/new";
12914 suppress_error = 0;
12915 r = guestfs_is_dir (g, path);
12919 fprintf (stderr, "test_mkdir_0: expected true, got false\n");
12926 static int test_mkdir_1_skip (void)
12930 str = getenv ("SKIP_TEST_MKDIR_1");
12931 if (str && strcmp (str, "1") == 0) return 1;
12932 str = getenv ("SKIP_TEST_MKDIR");
12933 if (str && strcmp (str, "1") == 0) return 1;
12937 static int test_mkdir_1 (void)
12939 if (test_mkdir_1_skip ()) {
12940 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_1");
12944 /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
12946 char device[] = "/dev/sda";
12948 suppress_error = 0;
12949 r = guestfs_blockdev_setrw (g, device);
12955 suppress_error = 0;
12956 r = guestfs_umount_all (g);
12962 suppress_error = 0;
12963 r = guestfs_lvm_remove_all (g);
12968 char device[] = "/dev/sda";
12969 char lines_0[] = ",";
12975 suppress_error = 0;
12976 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12981 char fstype[] = "ext2";
12982 char device[] = "/dev/sda1";
12984 suppress_error = 0;
12985 r = guestfs_mkfs (g, fstype, device);
12990 char device[] = "/dev/sda1";
12991 char mountpoint[] = "/";
12993 suppress_error = 0;
12994 r = guestfs_mount (g, device, mountpoint);
12998 /* TestLastFail for mkdir (1) */
13000 char path[] = "/new/foo/bar";
13002 suppress_error = 1;
13003 r = guestfs_mkdir (g, path);
13010 static int test_rm_rf_0_skip (void)
13014 str = getenv ("SKIP_TEST_RM_RF_0");
13015 if (str && strcmp (str, "1") == 0) return 1;
13016 str = getenv ("SKIP_TEST_RM_RF");
13017 if (str && strcmp (str, "1") == 0) return 1;
13021 static int test_rm_rf_0 (void)
13023 if (test_rm_rf_0_skip ()) {
13024 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_rf_0");
13028 /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
13030 char device[] = "/dev/sda";
13032 suppress_error = 0;
13033 r = guestfs_blockdev_setrw (g, device);
13039 suppress_error = 0;
13040 r = guestfs_umount_all (g);
13046 suppress_error = 0;
13047 r = guestfs_lvm_remove_all (g);
13052 char device[] = "/dev/sda";
13053 char lines_0[] = ",";
13059 suppress_error = 0;
13060 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13065 char fstype[] = "ext2";
13066 char device[] = "/dev/sda1";
13068 suppress_error = 0;
13069 r = guestfs_mkfs (g, fstype, device);
13074 char device[] = "/dev/sda1";
13075 char mountpoint[] = "/";
13077 suppress_error = 0;
13078 r = guestfs_mount (g, device, mountpoint);
13082 /* TestOutputFalse for rm_rf (0) */
13084 char path[] = "/new";
13086 suppress_error = 0;
13087 r = guestfs_mkdir (g, path);
13092 char path[] = "/new/foo";
13094 suppress_error = 0;
13095 r = guestfs_mkdir (g, path);
13100 char path[] = "/new/foo/bar";
13102 suppress_error = 0;
13103 r = guestfs_touch (g, path);
13108 char path[] = "/new";
13110 suppress_error = 0;
13111 r = guestfs_rm_rf (g, path);
13116 char path[] = "/new";
13118 suppress_error = 0;
13119 r = guestfs_exists (g, path);
13123 fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
13130 static int test_rmdir_0_skip (void)
13134 str = getenv ("SKIP_TEST_RMDIR_0");
13135 if (str && strcmp (str, "1") == 0) return 1;
13136 str = getenv ("SKIP_TEST_RMDIR");
13137 if (str && strcmp (str, "1") == 0) return 1;
13141 static int test_rmdir_0 (void)
13143 if (test_rmdir_0_skip ()) {
13144 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_0");
13148 /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
13150 char device[] = "/dev/sda";
13152 suppress_error = 0;
13153 r = guestfs_blockdev_setrw (g, device);
13159 suppress_error = 0;
13160 r = guestfs_umount_all (g);
13166 suppress_error = 0;
13167 r = guestfs_lvm_remove_all (g);
13172 char device[] = "/dev/sda";
13173 char lines_0[] = ",";
13179 suppress_error = 0;
13180 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13185 char fstype[] = "ext2";
13186 char device[] = "/dev/sda1";
13188 suppress_error = 0;
13189 r = guestfs_mkfs (g, fstype, device);
13194 char device[] = "/dev/sda1";
13195 char mountpoint[] = "/";
13197 suppress_error = 0;
13198 r = guestfs_mount (g, device, mountpoint);
13202 /* TestRun for rmdir (0) */
13204 char path[] = "/new";
13206 suppress_error = 0;
13207 r = guestfs_mkdir (g, path);
13212 char path[] = "/new";
13214 suppress_error = 0;
13215 r = guestfs_rmdir (g, path);
13222 static int test_rmdir_1_skip (void)
13226 str = getenv ("SKIP_TEST_RMDIR_1");
13227 if (str && strcmp (str, "1") == 0) return 1;
13228 str = getenv ("SKIP_TEST_RMDIR");
13229 if (str && strcmp (str, "1") == 0) return 1;
13233 static int test_rmdir_1 (void)
13235 if (test_rmdir_1_skip ()) {
13236 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_1");
13240 /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
13242 char device[] = "/dev/sda";
13244 suppress_error = 0;
13245 r = guestfs_blockdev_setrw (g, device);
13251 suppress_error = 0;
13252 r = guestfs_umount_all (g);
13258 suppress_error = 0;
13259 r = guestfs_lvm_remove_all (g);
13264 char device[] = "/dev/sda";
13265 char lines_0[] = ",";
13271 suppress_error = 0;
13272 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13277 char fstype[] = "ext2";
13278 char device[] = "/dev/sda1";
13280 suppress_error = 0;
13281 r = guestfs_mkfs (g, fstype, device);
13286 char device[] = "/dev/sda1";
13287 char mountpoint[] = "/";
13289 suppress_error = 0;
13290 r = guestfs_mount (g, device, mountpoint);
13294 /* TestLastFail for rmdir (1) */
13296 char path[] = "/new";
13298 suppress_error = 1;
13299 r = guestfs_rmdir (g, path);
13306 static int test_rmdir_2_skip (void)
13310 str = getenv ("SKIP_TEST_RMDIR_2");
13311 if (str && strcmp (str, "1") == 0) return 1;
13312 str = getenv ("SKIP_TEST_RMDIR");
13313 if (str && strcmp (str, "1") == 0) return 1;
13317 static int test_rmdir_2 (void)
13319 if (test_rmdir_2_skip ()) {
13320 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_2");
13324 /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
13326 char device[] = "/dev/sda";
13328 suppress_error = 0;
13329 r = guestfs_blockdev_setrw (g, device);
13335 suppress_error = 0;
13336 r = guestfs_umount_all (g);
13342 suppress_error = 0;
13343 r = guestfs_lvm_remove_all (g);
13348 char device[] = "/dev/sda";
13349 char lines_0[] = ",";
13355 suppress_error = 0;
13356 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13361 char fstype[] = "ext2";
13362 char device[] = "/dev/sda1";
13364 suppress_error = 0;
13365 r = guestfs_mkfs (g, fstype, device);
13370 char device[] = "/dev/sda1";
13371 char mountpoint[] = "/";
13373 suppress_error = 0;
13374 r = guestfs_mount (g, device, mountpoint);
13378 /* TestLastFail for rmdir (2) */
13380 char path[] = "/new";
13382 suppress_error = 0;
13383 r = guestfs_touch (g, path);
13388 char path[] = "/new";
13390 suppress_error = 1;
13391 r = guestfs_rmdir (g, path);
13398 static int test_rm_0_skip (void)
13402 str = getenv ("SKIP_TEST_RM_0");
13403 if (str && strcmp (str, "1") == 0) return 1;
13404 str = getenv ("SKIP_TEST_RM");
13405 if (str && strcmp (str, "1") == 0) return 1;
13409 static int test_rm_0 (void)
13411 if (test_rm_0_skip ()) {
13412 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_0");
13416 /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
13418 char device[] = "/dev/sda";
13420 suppress_error = 0;
13421 r = guestfs_blockdev_setrw (g, device);
13427 suppress_error = 0;
13428 r = guestfs_umount_all (g);
13434 suppress_error = 0;
13435 r = guestfs_lvm_remove_all (g);
13440 char device[] = "/dev/sda";
13441 char lines_0[] = ",";
13447 suppress_error = 0;
13448 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13453 char fstype[] = "ext2";
13454 char device[] = "/dev/sda1";
13456 suppress_error = 0;
13457 r = guestfs_mkfs (g, fstype, device);
13462 char device[] = "/dev/sda1";
13463 char mountpoint[] = "/";
13465 suppress_error = 0;
13466 r = guestfs_mount (g, device, mountpoint);
13470 /* TestRun for rm (0) */
13472 char path[] = "/new";
13474 suppress_error = 0;
13475 r = guestfs_touch (g, path);
13480 char path[] = "/new";
13482 suppress_error = 0;
13483 r = guestfs_rm (g, path);
13490 static int test_rm_1_skip (void)
13494 str = getenv ("SKIP_TEST_RM_1");
13495 if (str && strcmp (str, "1") == 0) return 1;
13496 str = getenv ("SKIP_TEST_RM");
13497 if (str && strcmp (str, "1") == 0) return 1;
13501 static int test_rm_1 (void)
13503 if (test_rm_1_skip ()) {
13504 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_1");
13508 /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
13510 char device[] = "/dev/sda";
13512 suppress_error = 0;
13513 r = guestfs_blockdev_setrw (g, device);
13519 suppress_error = 0;
13520 r = guestfs_umount_all (g);
13526 suppress_error = 0;
13527 r = guestfs_lvm_remove_all (g);
13532 char device[] = "/dev/sda";
13533 char lines_0[] = ",";
13539 suppress_error = 0;
13540 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13545 char fstype[] = "ext2";
13546 char device[] = "/dev/sda1";
13548 suppress_error = 0;
13549 r = guestfs_mkfs (g, fstype, device);
13554 char device[] = "/dev/sda1";
13555 char mountpoint[] = "/";
13557 suppress_error = 0;
13558 r = guestfs_mount (g, device, mountpoint);
13562 /* TestLastFail for rm (1) */
13564 char path[] = "/new";
13566 suppress_error = 1;
13567 r = guestfs_rm (g, path);
13574 static int test_rm_2_skip (void)
13578 str = getenv ("SKIP_TEST_RM_2");
13579 if (str && strcmp (str, "1") == 0) return 1;
13580 str = getenv ("SKIP_TEST_RM");
13581 if (str && strcmp (str, "1") == 0) return 1;
13585 static int test_rm_2 (void)
13587 if (test_rm_2_skip ()) {
13588 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_2");
13592 /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
13594 char device[] = "/dev/sda";
13596 suppress_error = 0;
13597 r = guestfs_blockdev_setrw (g, device);
13603 suppress_error = 0;
13604 r = guestfs_umount_all (g);
13610 suppress_error = 0;
13611 r = guestfs_lvm_remove_all (g);
13616 char device[] = "/dev/sda";
13617 char lines_0[] = ",";
13623 suppress_error = 0;
13624 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13629 char fstype[] = "ext2";
13630 char device[] = "/dev/sda1";
13632 suppress_error = 0;
13633 r = guestfs_mkfs (g, fstype, device);
13638 char device[] = "/dev/sda1";
13639 char mountpoint[] = "/";
13641 suppress_error = 0;
13642 r = guestfs_mount (g, device, mountpoint);
13646 /* TestLastFail for rm (2) */
13648 char path[] = "/new";
13650 suppress_error = 0;
13651 r = guestfs_mkdir (g, path);
13656 char path[] = "/new";
13658 suppress_error = 1;
13659 r = guestfs_rm (g, path);
13666 static int test_read_lines_0_skip (void)
13670 str = getenv ("SKIP_TEST_READ_LINES_0");
13671 if (str && strcmp (str, "1") == 0) return 1;
13672 str = getenv ("SKIP_TEST_READ_LINES");
13673 if (str && strcmp (str, "1") == 0) return 1;
13677 static int test_read_lines_0 (void)
13679 if (test_read_lines_0_skip ()) {
13680 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_0");
13684 /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
13686 char device[] = "/dev/sda";
13688 suppress_error = 0;
13689 r = guestfs_blockdev_setrw (g, device);
13695 suppress_error = 0;
13696 r = guestfs_umount_all (g);
13702 suppress_error = 0;
13703 r = guestfs_lvm_remove_all (g);
13708 char device[] = "/dev/sda";
13709 char lines_0[] = ",";
13715 suppress_error = 0;
13716 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13721 char fstype[] = "ext2";
13722 char device[] = "/dev/sda1";
13724 suppress_error = 0;
13725 r = guestfs_mkfs (g, fstype, device);
13730 char device[] = "/dev/sda1";
13731 char mountpoint[] = "/";
13733 suppress_error = 0;
13734 r = guestfs_mount (g, device, mountpoint);
13738 /* TestOutputList for read_lines (0) */
13740 char path[] = "/new";
13741 char content[] = "line1\r\nline2\nline3";
13743 suppress_error = 0;
13744 r = guestfs_write_file (g, path, content, 0);
13749 char path[] = "/new";
13752 suppress_error = 0;
13753 r = guestfs_read_lines (g, path);
13757 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
13762 char expected[] = "line1";
13763 if (strcmp (r[0], expected) != 0) {
13764 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13769 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
13774 char expected[] = "line2";
13775 if (strcmp (r[1], expected) != 0) {
13776 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
13781 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
13786 char expected[] = "line3";
13787 if (strcmp (r[2], expected) != 0) {
13788 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
13792 if (r[3] != NULL) {
13793 fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
13797 for (i = 0; r[i] != NULL; ++i)
13804 static int test_read_lines_1_skip (void)
13808 str = getenv ("SKIP_TEST_READ_LINES_1");
13809 if (str && strcmp (str, "1") == 0) return 1;
13810 str = getenv ("SKIP_TEST_READ_LINES");
13811 if (str && strcmp (str, "1") == 0) return 1;
13815 static int test_read_lines_1 (void)
13817 if (test_read_lines_1_skip ()) {
13818 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_1");
13822 /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
13824 char device[] = "/dev/sda";
13826 suppress_error = 0;
13827 r = guestfs_blockdev_setrw (g, device);
13833 suppress_error = 0;
13834 r = guestfs_umount_all (g);
13840 suppress_error = 0;
13841 r = guestfs_lvm_remove_all (g);
13846 char device[] = "/dev/sda";
13847 char lines_0[] = ",";
13853 suppress_error = 0;
13854 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13859 char fstype[] = "ext2";
13860 char device[] = "/dev/sda1";
13862 suppress_error = 0;
13863 r = guestfs_mkfs (g, fstype, device);
13868 char device[] = "/dev/sda1";
13869 char mountpoint[] = "/";
13871 suppress_error = 0;
13872 r = guestfs_mount (g, device, mountpoint);
13876 /* TestOutputList for read_lines (1) */
13878 char path[] = "/new";
13879 char content[] = "";
13881 suppress_error = 0;
13882 r = guestfs_write_file (g, path, content, 0);
13887 char path[] = "/new";
13890 suppress_error = 0;
13891 r = guestfs_read_lines (g, path);
13894 if (r[0] != NULL) {
13895 fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
13899 for (i = 0; r[i] != NULL; ++i)
13906 static int test_lvs_0_skip (void)
13910 str = getenv ("SKIP_TEST_LVS_0");
13911 if (str && strcmp (str, "1") == 0) return 1;
13912 str = getenv ("SKIP_TEST_LVS");
13913 if (str && strcmp (str, "1") == 0) return 1;
13917 static int test_lvs_0 (void)
13919 if (test_lvs_0_skip ()) {
13920 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_0");
13924 /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
13926 char device[] = "/dev/sda";
13928 suppress_error = 0;
13929 r = guestfs_blockdev_setrw (g, device);
13935 suppress_error = 0;
13936 r = guestfs_umount_all (g);
13942 suppress_error = 0;
13943 r = guestfs_lvm_remove_all (g);
13948 char device[] = "/dev/sda";
13949 char lines_0[] = ",";
13955 suppress_error = 0;
13956 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13961 char device[] = "/dev/sda1";
13963 suppress_error = 0;
13964 r = guestfs_pvcreate (g, device);
13969 char volgroup[] = "VG";
13970 char physvols_0[] = "/dev/sda1";
13971 char *physvols[] = {
13976 suppress_error = 0;
13977 r = guestfs_vgcreate (g, volgroup, physvols);
13982 char logvol[] = "LV";
13983 char volgroup[] = "VG";
13985 suppress_error = 0;
13986 r = guestfs_lvcreate (g, logvol, volgroup, 8);
13991 char fstype[] = "ext2";
13992 char device[] = "/dev/VG/LV";
13994 suppress_error = 0;
13995 r = guestfs_mkfs (g, fstype, device);
14000 char device[] = "/dev/VG/LV";
14001 char mountpoint[] = "/";
14003 suppress_error = 0;
14004 r = guestfs_mount (g, device, mountpoint);
14008 /* TestOutputList for lvs (0) */
14012 suppress_error = 0;
14013 r = guestfs_lvs (g);
14017 fprintf (stderr, "test_lvs_0: short list returned from command\n");
14022 char expected[] = "/dev/VG/LV";
14023 if (strcmp (r[0], expected) != 0) {
14024 fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14028 if (r[1] != NULL) {
14029 fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
14033 for (i = 0; r[i] != NULL; ++i)
14040 static int test_lvs_1_skip (void)
14044 str = getenv ("SKIP_TEST_LVS_1");
14045 if (str && strcmp (str, "1") == 0) return 1;
14046 str = getenv ("SKIP_TEST_LVS");
14047 if (str && strcmp (str, "1") == 0) return 1;
14051 static int test_lvs_1 (void)
14053 if (test_lvs_1_skip ()) {
14054 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_1");
14058 /* InitNone|InitEmpty for test_lvs_1 */
14060 char device[] = "/dev/sda";
14062 suppress_error = 0;
14063 r = guestfs_blockdev_setrw (g, device);
14069 suppress_error = 0;
14070 r = guestfs_umount_all (g);
14076 suppress_error = 0;
14077 r = guestfs_lvm_remove_all (g);
14081 /* TestOutputList for lvs (1) */
14083 char device[] = "/dev/sda";
14084 char lines_0[] = ",10";
14085 char lines_1[] = ",20";
14086 char lines_2[] = ",";
14094 suppress_error = 0;
14095 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14100 char device[] = "/dev/sda1";
14102 suppress_error = 0;
14103 r = guestfs_pvcreate (g, device);
14108 char device[] = "/dev/sda2";
14110 suppress_error = 0;
14111 r = guestfs_pvcreate (g, device);
14116 char device[] = "/dev/sda3";
14118 suppress_error = 0;
14119 r = guestfs_pvcreate (g, device);
14124 char volgroup[] = "VG1";
14125 char physvols_0[] = "/dev/sda1";
14126 char physvols_1[] = "/dev/sda2";
14127 char *physvols[] = {
14133 suppress_error = 0;
14134 r = guestfs_vgcreate (g, volgroup, physvols);
14139 char volgroup[] = "VG2";
14140 char physvols_0[] = "/dev/sda3";
14141 char *physvols[] = {
14146 suppress_error = 0;
14147 r = guestfs_vgcreate (g, volgroup, physvols);
14152 char logvol[] = "LV1";
14153 char volgroup[] = "VG1";
14155 suppress_error = 0;
14156 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14161 char logvol[] = "LV2";
14162 char volgroup[] = "VG1";
14164 suppress_error = 0;
14165 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14170 char logvol[] = "LV3";
14171 char volgroup[] = "VG2";
14173 suppress_error = 0;
14174 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14181 suppress_error = 0;
14182 r = guestfs_lvs (g);
14186 fprintf (stderr, "test_lvs_1: short list returned from command\n");
14191 char expected[] = "/dev/VG1/LV1";
14192 if (strcmp (r[0], expected) != 0) {
14193 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14198 fprintf (stderr, "test_lvs_1: short list returned from command\n");
14203 char expected[] = "/dev/VG1/LV2";
14204 if (strcmp (r[1], expected) != 0) {
14205 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14210 fprintf (stderr, "test_lvs_1: short list returned from command\n");
14215 char expected[] = "/dev/VG2/LV3";
14216 if (strcmp (r[2], expected) != 0) {
14217 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14221 if (r[3] != NULL) {
14222 fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
14226 for (i = 0; r[i] != NULL; ++i)
14233 static int test_vgs_0_skip (void)
14237 str = getenv ("SKIP_TEST_VGS_0");
14238 if (str && strcmp (str, "1") == 0) return 1;
14239 str = getenv ("SKIP_TEST_VGS");
14240 if (str && strcmp (str, "1") == 0) return 1;
14244 static int test_vgs_0 (void)
14246 if (test_vgs_0_skip ()) {
14247 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_0");
14251 /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
14253 char device[] = "/dev/sda";
14255 suppress_error = 0;
14256 r = guestfs_blockdev_setrw (g, device);
14262 suppress_error = 0;
14263 r = guestfs_umount_all (g);
14269 suppress_error = 0;
14270 r = guestfs_lvm_remove_all (g);
14275 char device[] = "/dev/sda";
14276 char lines_0[] = ",";
14282 suppress_error = 0;
14283 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14288 char device[] = "/dev/sda1";
14290 suppress_error = 0;
14291 r = guestfs_pvcreate (g, device);
14296 char volgroup[] = "VG";
14297 char physvols_0[] = "/dev/sda1";
14298 char *physvols[] = {
14303 suppress_error = 0;
14304 r = guestfs_vgcreate (g, volgroup, physvols);
14309 char logvol[] = "LV";
14310 char volgroup[] = "VG";
14312 suppress_error = 0;
14313 r = guestfs_lvcreate (g, logvol, volgroup, 8);
14318 char fstype[] = "ext2";
14319 char device[] = "/dev/VG/LV";
14321 suppress_error = 0;
14322 r = guestfs_mkfs (g, fstype, device);
14327 char device[] = "/dev/VG/LV";
14328 char mountpoint[] = "/";
14330 suppress_error = 0;
14331 r = guestfs_mount (g, device, mountpoint);
14335 /* TestOutputList for vgs (0) */
14339 suppress_error = 0;
14340 r = guestfs_vgs (g);
14344 fprintf (stderr, "test_vgs_0: short list returned from command\n");
14349 char expected[] = "VG";
14350 if (strcmp (r[0], expected) != 0) {
14351 fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14355 if (r[1] != NULL) {
14356 fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
14360 for (i = 0; r[i] != NULL; ++i)
14367 static int test_vgs_1_skip (void)
14371 str = getenv ("SKIP_TEST_VGS_1");
14372 if (str && strcmp (str, "1") == 0) return 1;
14373 str = getenv ("SKIP_TEST_VGS");
14374 if (str && strcmp (str, "1") == 0) return 1;
14378 static int test_vgs_1 (void)
14380 if (test_vgs_1_skip ()) {
14381 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_1");
14385 /* InitNone|InitEmpty for test_vgs_1 */
14387 char device[] = "/dev/sda";
14389 suppress_error = 0;
14390 r = guestfs_blockdev_setrw (g, device);
14396 suppress_error = 0;
14397 r = guestfs_umount_all (g);
14403 suppress_error = 0;
14404 r = guestfs_lvm_remove_all (g);
14408 /* TestOutputList for vgs (1) */
14410 char device[] = "/dev/sda";
14411 char lines_0[] = ",10";
14412 char lines_1[] = ",20";
14413 char lines_2[] = ",";
14421 suppress_error = 0;
14422 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14427 char device[] = "/dev/sda1";
14429 suppress_error = 0;
14430 r = guestfs_pvcreate (g, device);
14435 char device[] = "/dev/sda2";
14437 suppress_error = 0;
14438 r = guestfs_pvcreate (g, device);
14443 char device[] = "/dev/sda3";
14445 suppress_error = 0;
14446 r = guestfs_pvcreate (g, device);
14451 char volgroup[] = "VG1";
14452 char physvols_0[] = "/dev/sda1";
14453 char physvols_1[] = "/dev/sda2";
14454 char *physvols[] = {
14460 suppress_error = 0;
14461 r = guestfs_vgcreate (g, volgroup, physvols);
14466 char volgroup[] = "VG2";
14467 char physvols_0[] = "/dev/sda3";
14468 char *physvols[] = {
14473 suppress_error = 0;
14474 r = guestfs_vgcreate (g, volgroup, physvols);
14481 suppress_error = 0;
14482 r = guestfs_vgs (g);
14486 fprintf (stderr, "test_vgs_1: short list returned from command\n");
14491 char expected[] = "VG1";
14492 if (strcmp (r[0], expected) != 0) {
14493 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14498 fprintf (stderr, "test_vgs_1: short list returned from command\n");
14503 char expected[] = "VG2";
14504 if (strcmp (r[1], expected) != 0) {
14505 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14509 if (r[2] != NULL) {
14510 fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
14514 for (i = 0; r[i] != NULL; ++i)
14521 static int test_pvs_0_skip (void)
14525 str = getenv ("SKIP_TEST_PVS_0");
14526 if (str && strcmp (str, "1") == 0) return 1;
14527 str = getenv ("SKIP_TEST_PVS");
14528 if (str && strcmp (str, "1") == 0) return 1;
14532 static int test_pvs_0 (void)
14534 if (test_pvs_0_skip ()) {
14535 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_0");
14539 /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
14541 char device[] = "/dev/sda";
14543 suppress_error = 0;
14544 r = guestfs_blockdev_setrw (g, device);
14550 suppress_error = 0;
14551 r = guestfs_umount_all (g);
14557 suppress_error = 0;
14558 r = guestfs_lvm_remove_all (g);
14563 char device[] = "/dev/sda";
14564 char lines_0[] = ",";
14570 suppress_error = 0;
14571 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14576 char device[] = "/dev/sda1";
14578 suppress_error = 0;
14579 r = guestfs_pvcreate (g, device);
14584 char volgroup[] = "VG";
14585 char physvols_0[] = "/dev/sda1";
14586 char *physvols[] = {
14591 suppress_error = 0;
14592 r = guestfs_vgcreate (g, volgroup, physvols);
14597 char logvol[] = "LV";
14598 char volgroup[] = "VG";
14600 suppress_error = 0;
14601 r = guestfs_lvcreate (g, logvol, volgroup, 8);
14606 char fstype[] = "ext2";
14607 char device[] = "/dev/VG/LV";
14609 suppress_error = 0;
14610 r = guestfs_mkfs (g, fstype, device);
14615 char device[] = "/dev/VG/LV";
14616 char mountpoint[] = "/";
14618 suppress_error = 0;
14619 r = guestfs_mount (g, device, mountpoint);
14623 /* TestOutputListOfDevices for pvs (0) */
14627 suppress_error = 0;
14628 r = guestfs_pvs (g);
14632 fprintf (stderr, "test_pvs_0: short list returned from command\n");
14637 char expected[] = "/dev/sda1";
14639 if (strcmp (r[0], expected) != 0) {
14640 fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14644 if (r[1] != NULL) {
14645 fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
14649 for (i = 0; r[i] != NULL; ++i)
14656 static int test_pvs_1_skip (void)
14660 str = getenv ("SKIP_TEST_PVS_1");
14661 if (str && strcmp (str, "1") == 0) return 1;
14662 str = getenv ("SKIP_TEST_PVS");
14663 if (str && strcmp (str, "1") == 0) return 1;
14667 static int test_pvs_1 (void)
14669 if (test_pvs_1_skip ()) {
14670 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_1");
14674 /* InitNone|InitEmpty for test_pvs_1 */
14676 char device[] = "/dev/sda";
14678 suppress_error = 0;
14679 r = guestfs_blockdev_setrw (g, device);
14685 suppress_error = 0;
14686 r = guestfs_umount_all (g);
14692 suppress_error = 0;
14693 r = guestfs_lvm_remove_all (g);
14697 /* TestOutputListOfDevices for pvs (1) */
14699 char device[] = "/dev/sda";
14700 char lines_0[] = ",10";
14701 char lines_1[] = ",20";
14702 char lines_2[] = ",";
14710 suppress_error = 0;
14711 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14716 char device[] = "/dev/sda1";
14718 suppress_error = 0;
14719 r = guestfs_pvcreate (g, device);
14724 char device[] = "/dev/sda2";
14726 suppress_error = 0;
14727 r = guestfs_pvcreate (g, device);
14732 char device[] = "/dev/sda3";
14734 suppress_error = 0;
14735 r = guestfs_pvcreate (g, device);
14742 suppress_error = 0;
14743 r = guestfs_pvs (g);
14747 fprintf (stderr, "test_pvs_1: short list returned from command\n");
14752 char expected[] = "/dev/sda1";
14754 if (strcmp (r[0], expected) != 0) {
14755 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14760 fprintf (stderr, "test_pvs_1: short list returned from command\n");
14765 char expected[] = "/dev/sda2";
14767 if (strcmp (r[1], expected) != 0) {
14768 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14773 fprintf (stderr, "test_pvs_1: short list returned from command\n");
14778 char expected[] = "/dev/sda3";
14780 if (strcmp (r[2], expected) != 0) {
14781 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14785 if (r[3] != NULL) {
14786 fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
14790 for (i = 0; r[i] != NULL; ++i)
14797 static int test_list_partitions_0_skip (void)
14801 str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
14802 if (str && strcmp (str, "1") == 0) return 1;
14803 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
14804 if (str && strcmp (str, "1") == 0) return 1;
14808 static int test_list_partitions_0 (void)
14810 if (test_list_partitions_0_skip ()) {
14811 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_0");
14815 /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
14817 char device[] = "/dev/sda";
14819 suppress_error = 0;
14820 r = guestfs_blockdev_setrw (g, device);
14826 suppress_error = 0;
14827 r = guestfs_umount_all (g);
14833 suppress_error = 0;
14834 r = guestfs_lvm_remove_all (g);
14839 char device[] = "/dev/sda";
14840 char lines_0[] = ",";
14846 suppress_error = 0;
14847 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14852 char fstype[] = "ext2";
14853 char device[] = "/dev/sda1";
14855 suppress_error = 0;
14856 r = guestfs_mkfs (g, fstype, device);
14861 char device[] = "/dev/sda1";
14862 char mountpoint[] = "/";
14864 suppress_error = 0;
14865 r = guestfs_mount (g, device, mountpoint);
14869 /* TestOutputListOfDevices for list_partitions (0) */
14873 suppress_error = 0;
14874 r = guestfs_list_partitions (g);
14878 fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
14883 char expected[] = "/dev/sda1";
14885 if (strcmp (r[0], expected) != 0) {
14886 fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14890 if (r[1] != NULL) {
14891 fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
14895 for (i = 0; r[i] != NULL; ++i)
14902 static int test_list_partitions_1_skip (void)
14906 str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
14907 if (str && strcmp (str, "1") == 0) return 1;
14908 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
14909 if (str && strcmp (str, "1") == 0) return 1;
14913 static int test_list_partitions_1 (void)
14915 if (test_list_partitions_1_skip ()) {
14916 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_1");
14920 /* InitNone|InitEmpty for test_list_partitions_1 */
14922 char device[] = "/dev/sda";
14924 suppress_error = 0;
14925 r = guestfs_blockdev_setrw (g, device);
14931 suppress_error = 0;
14932 r = guestfs_umount_all (g);
14938 suppress_error = 0;
14939 r = guestfs_lvm_remove_all (g);
14943 /* TestOutputListOfDevices for list_partitions (1) */
14945 char device[] = "/dev/sda";
14946 char lines_0[] = ",10";
14947 char lines_1[] = ",20";
14948 char lines_2[] = ",";
14956 suppress_error = 0;
14957 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14964 suppress_error = 0;
14965 r = guestfs_list_partitions (g);
14969 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
14974 char expected[] = "/dev/sda1";
14976 if (strcmp (r[0], expected) != 0) {
14977 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14982 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
14987 char expected[] = "/dev/sda2";
14989 if (strcmp (r[1], expected) != 0) {
14990 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14995 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15000 char expected[] = "/dev/sda3";
15002 if (strcmp (r[2], expected) != 0) {
15003 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15007 if (r[3] != NULL) {
15008 fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
15012 for (i = 0; r[i] != NULL; ++i)
15019 static int test_list_devices_0_skip (void)
15023 str = getenv ("SKIP_TEST_LIST_DEVICES_0");
15024 if (str && strcmp (str, "1") == 0) return 1;
15025 str = getenv ("SKIP_TEST_LIST_DEVICES");
15026 if (str && strcmp (str, "1") == 0) return 1;
15030 static int test_list_devices_0 (void)
15032 if (test_list_devices_0_skip ()) {
15033 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_devices_0");
15037 /* InitNone|InitEmpty for test_list_devices_0 */
15039 char device[] = "/dev/sda";
15041 suppress_error = 0;
15042 r = guestfs_blockdev_setrw (g, device);
15048 suppress_error = 0;
15049 r = guestfs_umount_all (g);
15055 suppress_error = 0;
15056 r = guestfs_lvm_remove_all (g);
15060 /* TestOutputListOfDevices for list_devices (0) */
15064 suppress_error = 0;
15065 r = guestfs_list_devices (g);
15069 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15074 char expected[] = "/dev/sda";
15076 if (strcmp (r[0], expected) != 0) {
15077 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15082 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15087 char expected[] = "/dev/sdb";
15089 if (strcmp (r[1], expected) != 0) {
15090 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15095 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15100 char expected[] = "/dev/sdc";
15102 if (strcmp (r[2], expected) != 0) {
15103 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15108 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15113 char expected[] = "/dev/sdd";
15115 if (strcmp (r[3], expected) != 0) {
15116 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15120 if (r[4] != NULL) {
15121 fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
15125 for (i = 0; r[i] != NULL; ++i)
15132 static int test_ls_0_skip (void)
15136 str = getenv ("SKIP_TEST_LS_0");
15137 if (str && strcmp (str, "1") == 0) return 1;
15138 str = getenv ("SKIP_TEST_LS");
15139 if (str && strcmp (str, "1") == 0) return 1;
15143 static int test_ls_0 (void)
15145 if (test_ls_0_skip ()) {
15146 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ls_0");
15150 /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
15152 char device[] = "/dev/sda";
15154 suppress_error = 0;
15155 r = guestfs_blockdev_setrw (g, device);
15161 suppress_error = 0;
15162 r = guestfs_umount_all (g);
15168 suppress_error = 0;
15169 r = guestfs_lvm_remove_all (g);
15174 char device[] = "/dev/sda";
15175 char lines_0[] = ",";
15181 suppress_error = 0;
15182 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15187 char fstype[] = "ext2";
15188 char device[] = "/dev/sda1";
15190 suppress_error = 0;
15191 r = guestfs_mkfs (g, fstype, device);
15196 char device[] = "/dev/sda1";
15197 char mountpoint[] = "/";
15199 suppress_error = 0;
15200 r = guestfs_mount (g, device, mountpoint);
15204 /* TestOutputList for ls (0) */
15206 char path[] = "/new";
15208 suppress_error = 0;
15209 r = guestfs_touch (g, path);
15214 char path[] = "/newer";
15216 suppress_error = 0;
15217 r = guestfs_touch (g, path);
15222 char path[] = "/newest";
15224 suppress_error = 0;
15225 r = guestfs_touch (g, path);
15230 char directory[] = "/";
15233 suppress_error = 0;
15234 r = guestfs_ls (g, directory);
15238 fprintf (stderr, "test_ls_0: short list returned from command\n");
15243 char expected[] = "lost+found";
15244 if (strcmp (r[0], expected) != 0) {
15245 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15250 fprintf (stderr, "test_ls_0: short list returned from command\n");
15255 char expected[] = "new";
15256 if (strcmp (r[1], expected) != 0) {
15257 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15262 fprintf (stderr, "test_ls_0: short list returned from command\n");
15267 char expected[] = "newer";
15268 if (strcmp (r[2], expected) != 0) {
15269 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15274 fprintf (stderr, "test_ls_0: short list returned from command\n");
15279 char expected[] = "newest";
15280 if (strcmp (r[3], expected) != 0) {
15281 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15285 if (r[4] != NULL) {
15286 fprintf (stderr, "test_ls_0: extra elements returned from command\n");
15290 for (i = 0; r[i] != NULL; ++i)
15297 static int test_cat_0_skip (void)
15301 str = getenv ("SKIP_TEST_CAT_0");
15302 if (str && strcmp (str, "1") == 0) return 1;
15303 str = getenv ("SKIP_TEST_CAT");
15304 if (str && strcmp (str, "1") == 0) return 1;
15308 static int test_cat_0 (void)
15310 if (test_cat_0_skip ()) {
15311 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cat_0");
15315 /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
15317 char device[] = "/dev/sda";
15319 suppress_error = 0;
15320 r = guestfs_blockdev_setrw (g, device);
15326 suppress_error = 0;
15327 r = guestfs_umount_all (g);
15333 suppress_error = 0;
15334 r = guestfs_lvm_remove_all (g);
15339 char device[] = "/dev/sda";
15340 char lines_0[] = ",";
15346 suppress_error = 0;
15347 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15352 char fstype[] = "ext2";
15353 char device[] = "/dev/sda1";
15355 suppress_error = 0;
15356 r = guestfs_mkfs (g, fstype, device);
15361 char device[] = "/dev/sda1";
15362 char mountpoint[] = "/";
15364 suppress_error = 0;
15365 r = guestfs_mount (g, device, mountpoint);
15369 /* TestOutput for cat (0) */
15370 char expected[] = "new file contents";
15372 char path[] = "/new";
15373 char content[] = "new file contents";
15375 suppress_error = 0;
15376 r = guestfs_write_file (g, path, content, 0);
15381 char path[] = "/new";
15383 suppress_error = 0;
15384 r = guestfs_cat (g, path);
15387 if (strcmp (r, expected) != 0) {
15388 fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
15396 static int test_touch_0_skip (void)
15400 str = getenv ("SKIP_TEST_TOUCH_0");
15401 if (str && strcmp (str, "1") == 0) return 1;
15402 str = getenv ("SKIP_TEST_TOUCH");
15403 if (str && strcmp (str, "1") == 0) return 1;
15407 static int test_touch_0 (void)
15409 if (test_touch_0_skip ()) {
15410 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_touch_0");
15414 /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
15416 char device[] = "/dev/sda";
15418 suppress_error = 0;
15419 r = guestfs_blockdev_setrw (g, device);
15425 suppress_error = 0;
15426 r = guestfs_umount_all (g);
15432 suppress_error = 0;
15433 r = guestfs_lvm_remove_all (g);
15438 char device[] = "/dev/sda";
15439 char lines_0[] = ",";
15445 suppress_error = 0;
15446 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15451 char fstype[] = "ext2";
15452 char device[] = "/dev/sda1";
15454 suppress_error = 0;
15455 r = guestfs_mkfs (g, fstype, device);
15460 char device[] = "/dev/sda1";
15461 char mountpoint[] = "/";
15463 suppress_error = 0;
15464 r = guestfs_mount (g, device, mountpoint);
15468 /* TestOutputTrue for touch (0) */
15470 char path[] = "/new";
15472 suppress_error = 0;
15473 r = guestfs_touch (g, path);
15478 char path[] = "/new";
15480 suppress_error = 0;
15481 r = guestfs_exists (g, path);
15485 fprintf (stderr, "test_touch_0: expected true, got false\n");
15492 static int test_sync_0_skip (void)
15496 str = getenv ("SKIP_TEST_SYNC_0");
15497 if (str && strcmp (str, "1") == 0) return 1;
15498 str = getenv ("SKIP_TEST_SYNC");
15499 if (str && strcmp (str, "1") == 0) return 1;
15503 static int test_sync_0 (void)
15505 if (test_sync_0_skip ()) {
15506 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sync_0");
15510 /* InitNone|InitEmpty for test_sync_0 */
15512 char device[] = "/dev/sda";
15514 suppress_error = 0;
15515 r = guestfs_blockdev_setrw (g, device);
15521 suppress_error = 0;
15522 r = guestfs_umount_all (g);
15528 suppress_error = 0;
15529 r = guestfs_lvm_remove_all (g);
15533 /* TestRun for sync (0) */
15536 suppress_error = 0;
15537 r = guestfs_sync (g);
15544 static int test_mount_0_skip (void)
15548 str = getenv ("SKIP_TEST_MOUNT_0");
15549 if (str && strcmp (str, "1") == 0) return 1;
15550 str = getenv ("SKIP_TEST_MOUNT");
15551 if (str && strcmp (str, "1") == 0) return 1;
15555 static int test_mount_0 (void)
15557 if (test_mount_0_skip ()) {
15558 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_0");
15562 /* InitNone|InitEmpty for test_mount_0 */
15564 char device[] = "/dev/sda";
15566 suppress_error = 0;
15567 r = guestfs_blockdev_setrw (g, device);
15573 suppress_error = 0;
15574 r = guestfs_umount_all (g);
15580 suppress_error = 0;
15581 r = guestfs_lvm_remove_all (g);
15585 /* TestOutput for mount (0) */
15586 char expected[] = "new file contents";
15588 char device[] = "/dev/sda";
15589 char lines_0[] = ",";
15595 suppress_error = 0;
15596 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15601 char fstype[] = "ext2";
15602 char device[] = "/dev/sda1";
15604 suppress_error = 0;
15605 r = guestfs_mkfs (g, fstype, device);
15610 char device[] = "/dev/sda1";
15611 char mountpoint[] = "/";
15613 suppress_error = 0;
15614 r = guestfs_mount (g, device, mountpoint);
15619 char path[] = "/new";
15620 char content[] = "new file contents";
15622 suppress_error = 0;
15623 r = guestfs_write_file (g, path, content, 0);
15628 char path[] = "/new";
15630 suppress_error = 0;
15631 r = guestfs_cat (g, path);
15634 if (strcmp (r, expected) != 0) {
15635 fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
15643 int main (int argc, char *argv[])
15647 const char *filename;
15649 int nr_tests, test_num = 0;
15651 no_test_warnings ();
15653 g = guestfs_create ();
15655 printf ("guestfs_create FAILED\n");
15659 guestfs_set_error_handler (g, print_error, NULL);
15661 guestfs_set_path (g, "../appliance");
15663 filename = "test1.img";
15664 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
15669 if (lseek (fd, 524288000, SEEK_SET) == -1) {
15675 if (write (fd, &c, 1) == -1) {
15681 if (close (fd) == -1) {
15686 if (guestfs_add_drive (g, filename) == -1) {
15687 printf ("guestfs_add_drive %s FAILED\n", filename);
15691 filename = "test2.img";
15692 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
15697 if (lseek (fd, 52428800, SEEK_SET) == -1) {
15703 if (write (fd, &c, 1) == -1) {
15709 if (close (fd) == -1) {
15714 if (guestfs_add_drive (g, filename) == -1) {
15715 printf ("guestfs_add_drive %s FAILED\n", filename);
15719 filename = "test3.img";
15720 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
15725 if (lseek (fd, 10485760, SEEK_SET) == -1) {
15731 if (write (fd, &c, 1) == -1) {
15737 if (close (fd) == -1) {
15742 if (guestfs_add_drive (g, filename) == -1) {
15743 printf ("guestfs_add_drive %s FAILED\n", filename);
15747 if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
15748 printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
15752 if (guestfs_launch (g) == -1) {
15753 printf ("guestfs_launch FAILED\n");
15757 /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */
15760 if (guestfs_wait_ready (g) == -1) {
15761 printf ("guestfs_wait_ready FAILED\n");
15765 /* Cancel previous alarm. */
15771 printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
15772 if (test_ntfs_3g_probe_0 () == -1) {
15773 printf ("test_ntfs_3g_probe_0 FAILED\n");
15777 printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
15778 if (test_ntfs_3g_probe_1 () == -1) {
15779 printf ("test_ntfs_3g_probe_1 FAILED\n");
15783 printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
15784 if (test_sleep_0 () == -1) {
15785 printf ("test_sleep_0 FAILED\n");
15789 printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
15790 if (test_find_0 () == -1) {
15791 printf ("test_find_0 FAILED\n");
15795 printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
15796 if (test_find_1 () == -1) {
15797 printf ("test_find_1 FAILED\n");
15801 printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
15802 if (test_find_2 () == -1) {
15803 printf ("test_find_2 FAILED\n");
15807 printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
15808 if (test_lvresize_0 () == -1) {
15809 printf ("test_lvresize_0 FAILED\n");
15813 printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
15814 if (test_zerofree_0 () == -1) {
15815 printf ("test_zerofree_0 FAILED\n");
15819 printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
15820 if (test_hexdump_0 () == -1) {
15821 printf ("test_hexdump_0 FAILED\n");
15825 printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
15826 if (test_strings_e_0 () == -1) {
15827 printf ("test_strings_e_0 FAILED\n");
15831 printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
15832 if (test_strings_e_1 () == -1) {
15833 printf ("test_strings_e_1 FAILED\n");
15837 printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
15838 if (test_strings_0 () == -1) {
15839 printf ("test_strings_0 FAILED\n");
15843 printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
15844 if (test_strings_1 () == -1) {
15845 printf ("test_strings_1 FAILED\n");
15849 printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
15850 if (test_equal_0 () == -1) {
15851 printf ("test_equal_0 FAILED\n");
15855 printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
15856 if (test_equal_1 () == -1) {
15857 printf ("test_equal_1 FAILED\n");
15861 printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
15862 if (test_equal_2 () == -1) {
15863 printf ("test_equal_2 FAILED\n");
15867 printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
15868 if (test_ping_daemon_0 () == -1) {
15869 printf ("test_ping_daemon_0 FAILED\n");
15873 printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
15874 if (test_dmesg_0 () == -1) {
15875 printf ("test_dmesg_0 FAILED\n");
15879 printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
15880 if (test_drop_caches_0 () == -1) {
15881 printf ("test_drop_caches_0 FAILED\n");
15885 printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
15886 if (test_mv_0 () == -1) {
15887 printf ("test_mv_0 FAILED\n");
15891 printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
15892 if (test_mv_1 () == -1) {
15893 printf ("test_mv_1 FAILED\n");
15897 printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
15898 if (test_cp_a_0 () == -1) {
15899 printf ("test_cp_a_0 FAILED\n");
15903 printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
15904 if (test_cp_0 () == -1) {
15905 printf ("test_cp_0 FAILED\n");
15909 printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
15910 if (test_cp_1 () == -1) {
15911 printf ("test_cp_1 FAILED\n");
15915 printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
15916 if (test_cp_2 () == -1) {
15917 printf ("test_cp_2 FAILED\n");
15921 printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
15922 if (test_grub_install_0 () == -1) {
15923 printf ("test_grub_install_0 FAILED\n");
15927 printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
15928 if (test_zero_0 () == -1) {
15929 printf ("test_zero_0 FAILED\n");
15933 printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
15934 if (test_fsck_0 () == -1) {
15935 printf ("test_fsck_0 FAILED\n");
15939 printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
15940 if (test_fsck_1 () == -1) {
15941 printf ("test_fsck_1 FAILED\n");
15945 printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
15946 if (test_set_e2uuid_0 () == -1) {
15947 printf ("test_set_e2uuid_0 FAILED\n");
15951 printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
15952 if (test_set_e2uuid_1 () == -1) {
15953 printf ("test_set_e2uuid_1 FAILED\n");
15957 printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
15958 if (test_set_e2uuid_2 () == -1) {
15959 printf ("test_set_e2uuid_2 FAILED\n");
15963 printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
15964 if (test_set_e2uuid_3 () == -1) {
15965 printf ("test_set_e2uuid_3 FAILED\n");
15969 printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
15970 if (test_set_e2label_0 () == -1) {
15971 printf ("test_set_e2label_0 FAILED\n");
15975 printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
15976 if (test_pvremove_0 () == -1) {
15977 printf ("test_pvremove_0 FAILED\n");
15981 printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
15982 if (test_pvremove_1 () == -1) {
15983 printf ("test_pvremove_1 FAILED\n");
15987 printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
15988 if (test_pvremove_2 () == -1) {
15989 printf ("test_pvremove_2 FAILED\n");
15993 printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
15994 if (test_vgremove_0 () == -1) {
15995 printf ("test_vgremove_0 FAILED\n");
15999 printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
16000 if (test_vgremove_1 () == -1) {
16001 printf ("test_vgremove_1 FAILED\n");
16005 printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
16006 if (test_lvremove_0 () == -1) {
16007 printf ("test_lvremove_0 FAILED\n");
16011 printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
16012 if (test_lvremove_1 () == -1) {
16013 printf ("test_lvremove_1 FAILED\n");
16017 printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
16018 if (test_lvremove_2 () == -1) {
16019 printf ("test_lvremove_2 FAILED\n");
16023 printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
16024 if (test_mount_ro_0 () == -1) {
16025 printf ("test_mount_ro_0 FAILED\n");
16029 printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
16030 if (test_mount_ro_1 () == -1) {
16031 printf ("test_mount_ro_1 FAILED\n");
16035 printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
16036 if (test_tgz_in_0 () == -1) {
16037 printf ("test_tgz_in_0 FAILED\n");
16041 printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
16042 if (test_tar_in_0 () == -1) {
16043 printf ("test_tar_in_0 FAILED\n");
16047 printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
16048 if (test_checksum_0 () == -1) {
16049 printf ("test_checksum_0 FAILED\n");
16053 printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
16054 if (test_checksum_1 () == -1) {
16055 printf ("test_checksum_1 FAILED\n");
16059 printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
16060 if (test_checksum_2 () == -1) {
16061 printf ("test_checksum_2 FAILED\n");
16065 printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
16066 if (test_checksum_3 () == -1) {
16067 printf ("test_checksum_3 FAILED\n");
16071 printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
16072 if (test_checksum_4 () == -1) {
16073 printf ("test_checksum_4 FAILED\n");
16077 printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
16078 if (test_checksum_5 () == -1) {
16079 printf ("test_checksum_5 FAILED\n");
16083 printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
16084 if (test_checksum_6 () == -1) {
16085 printf ("test_checksum_6 FAILED\n");
16089 printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
16090 if (test_checksum_7 () == -1) {
16091 printf ("test_checksum_7 FAILED\n");
16095 printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
16096 if (test_checksum_8 () == -1) {
16097 printf ("test_checksum_8 FAILED\n");
16101 printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
16102 if (test_download_0 () == -1) {
16103 printf ("test_download_0 FAILED\n");
16107 printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
16108 if (test_upload_0 () == -1) {
16109 printf ("test_upload_0 FAILED\n");
16113 printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
16114 if (test_blockdev_rereadpt_0 () == -1) {
16115 printf ("test_blockdev_rereadpt_0 FAILED\n");
16119 printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
16120 if (test_blockdev_flushbufs_0 () == -1) {
16121 printf ("test_blockdev_flushbufs_0 FAILED\n");
16125 printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
16126 if (test_blockdev_getsize64_0 () == -1) {
16127 printf ("test_blockdev_getsize64_0 FAILED\n");
16131 printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
16132 if (test_blockdev_getsz_0 () == -1) {
16133 printf ("test_blockdev_getsz_0 FAILED\n");
16137 printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
16138 if (test_blockdev_getbsz_0 () == -1) {
16139 printf ("test_blockdev_getbsz_0 FAILED\n");
16143 printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
16144 if (test_blockdev_getss_0 () == -1) {
16145 printf ("test_blockdev_getss_0 FAILED\n");
16149 printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
16150 if (test_blockdev_getro_0 () == -1) {
16151 printf ("test_blockdev_getro_0 FAILED\n");
16155 printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
16156 if (test_blockdev_setrw_0 () == -1) {
16157 printf ("test_blockdev_setrw_0 FAILED\n");
16161 printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
16162 if (test_blockdev_setro_0 () == -1) {
16163 printf ("test_blockdev_setro_0 FAILED\n");
16167 printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
16168 if (test_statvfs_0 () == -1) {
16169 printf ("test_statvfs_0 FAILED\n");
16173 printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
16174 if (test_lstat_0 () == -1) {
16175 printf ("test_lstat_0 FAILED\n");
16179 printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
16180 if (test_stat_0 () == -1) {
16181 printf ("test_stat_0 FAILED\n");
16185 printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
16186 if (test_command_lines_0 () == -1) {
16187 printf ("test_command_lines_0 FAILED\n");
16191 printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
16192 if (test_command_lines_1 () == -1) {
16193 printf ("test_command_lines_1 FAILED\n");
16197 printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
16198 if (test_command_lines_2 () == -1) {
16199 printf ("test_command_lines_2 FAILED\n");
16203 printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
16204 if (test_command_lines_3 () == -1) {
16205 printf ("test_command_lines_3 FAILED\n");
16209 printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
16210 if (test_command_lines_4 () == -1) {
16211 printf ("test_command_lines_4 FAILED\n");
16215 printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
16216 if (test_command_lines_5 () == -1) {
16217 printf ("test_command_lines_5 FAILED\n");
16221 printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
16222 if (test_command_lines_6 () == -1) {
16223 printf ("test_command_lines_6 FAILED\n");
16227 printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
16228 if (test_command_lines_7 () == -1) {
16229 printf ("test_command_lines_7 FAILED\n");
16233 printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
16234 if (test_command_lines_8 () == -1) {
16235 printf ("test_command_lines_8 FAILED\n");
16239 printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
16240 if (test_command_lines_9 () == -1) {
16241 printf ("test_command_lines_9 FAILED\n");
16245 printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
16246 if (test_command_lines_10 () == -1) {
16247 printf ("test_command_lines_10 FAILED\n");
16251 printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
16252 if (test_command_0 () == -1) {
16253 printf ("test_command_0 FAILED\n");
16257 printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
16258 if (test_command_1 () == -1) {
16259 printf ("test_command_1 FAILED\n");
16263 printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
16264 if (test_command_2 () == -1) {
16265 printf ("test_command_2 FAILED\n");
16269 printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
16270 if (test_command_3 () == -1) {
16271 printf ("test_command_3 FAILED\n");
16275 printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
16276 if (test_command_4 () == -1) {
16277 printf ("test_command_4 FAILED\n");
16281 printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
16282 if (test_command_5 () == -1) {
16283 printf ("test_command_5 FAILED\n");
16287 printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
16288 if (test_command_6 () == -1) {
16289 printf ("test_command_6 FAILED\n");
16293 printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
16294 if (test_command_7 () == -1) {
16295 printf ("test_command_7 FAILED\n");
16299 printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
16300 if (test_command_8 () == -1) {
16301 printf ("test_command_8 FAILED\n");
16305 printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
16306 if (test_command_9 () == -1) {
16307 printf ("test_command_9 FAILED\n");
16311 printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
16312 if (test_command_10 () == -1) {
16313 printf ("test_command_10 FAILED\n");
16317 printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
16318 if (test_command_11 () == -1) {
16319 printf ("test_command_11 FAILED\n");
16323 printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
16324 if (test_file_0 () == -1) {
16325 printf ("test_file_0 FAILED\n");
16329 printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
16330 if (test_file_1 () == -1) {
16331 printf ("test_file_1 FAILED\n");
16335 printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
16336 if (test_file_2 () == -1) {
16337 printf ("test_file_2 FAILED\n");
16341 printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
16342 if (test_umount_all_0 () == -1) {
16343 printf ("test_umount_all_0 FAILED\n");
16347 printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
16348 if (test_umount_all_1 () == -1) {
16349 printf ("test_umount_all_1 FAILED\n");
16353 printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
16354 if (test_mounts_0 () == -1) {
16355 printf ("test_mounts_0 FAILED\n");
16359 printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
16360 if (test_umount_0 () == -1) {
16361 printf ("test_umount_0 FAILED\n");
16365 printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
16366 if (test_umount_1 () == -1) {
16367 printf ("test_umount_1 FAILED\n");
16371 printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
16372 if (test_write_file_0 () == -1) {
16373 printf ("test_write_file_0 FAILED\n");
16377 printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
16378 if (test_write_file_1 () == -1) {
16379 printf ("test_write_file_1 FAILED\n");
16383 printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
16384 if (test_write_file_2 () == -1) {
16385 printf ("test_write_file_2 FAILED\n");
16389 printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
16390 if (test_write_file_3 () == -1) {
16391 printf ("test_write_file_3 FAILED\n");
16395 printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
16396 if (test_write_file_4 () == -1) {
16397 printf ("test_write_file_4 FAILED\n");
16401 printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
16402 if (test_write_file_5 () == -1) {
16403 printf ("test_write_file_5 FAILED\n");
16407 printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
16408 if (test_mkfs_0 () == -1) {
16409 printf ("test_mkfs_0 FAILED\n");
16413 printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
16414 if (test_lvcreate_0 () == -1) {
16415 printf ("test_lvcreate_0 FAILED\n");
16419 printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
16420 if (test_vgcreate_0 () == -1) {
16421 printf ("test_vgcreate_0 FAILED\n");
16425 printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
16426 if (test_pvcreate_0 () == -1) {
16427 printf ("test_pvcreate_0 FAILED\n");
16431 printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
16432 if (test_is_dir_0 () == -1) {
16433 printf ("test_is_dir_0 FAILED\n");
16437 printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
16438 if (test_is_dir_1 () == -1) {
16439 printf ("test_is_dir_1 FAILED\n");
16443 printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
16444 if (test_is_file_0 () == -1) {
16445 printf ("test_is_file_0 FAILED\n");
16449 printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
16450 if (test_is_file_1 () == -1) {
16451 printf ("test_is_file_1 FAILED\n");
16455 printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
16456 if (test_exists_0 () == -1) {
16457 printf ("test_exists_0 FAILED\n");
16461 printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
16462 if (test_exists_1 () == -1) {
16463 printf ("test_exists_1 FAILED\n");
16467 printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
16468 if (test_mkdir_p_0 () == -1) {
16469 printf ("test_mkdir_p_0 FAILED\n");
16473 printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
16474 if (test_mkdir_p_1 () == -1) {
16475 printf ("test_mkdir_p_1 FAILED\n");
16479 printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
16480 if (test_mkdir_p_2 () == -1) {
16481 printf ("test_mkdir_p_2 FAILED\n");
16485 printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
16486 if (test_mkdir_p_3 () == -1) {
16487 printf ("test_mkdir_p_3 FAILED\n");
16491 printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
16492 if (test_mkdir_p_4 () == -1) {
16493 printf ("test_mkdir_p_4 FAILED\n");
16497 printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
16498 if (test_mkdir_0 () == -1) {
16499 printf ("test_mkdir_0 FAILED\n");
16503 printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
16504 if (test_mkdir_1 () == -1) {
16505 printf ("test_mkdir_1 FAILED\n");
16509 printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
16510 if (test_rm_rf_0 () == -1) {
16511 printf ("test_rm_rf_0 FAILED\n");
16515 printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
16516 if (test_rmdir_0 () == -1) {
16517 printf ("test_rmdir_0 FAILED\n");
16521 printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
16522 if (test_rmdir_1 () == -1) {
16523 printf ("test_rmdir_1 FAILED\n");
16527 printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
16528 if (test_rmdir_2 () == -1) {
16529 printf ("test_rmdir_2 FAILED\n");
16533 printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
16534 if (test_rm_0 () == -1) {
16535 printf ("test_rm_0 FAILED\n");
16539 printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
16540 if (test_rm_1 () == -1) {
16541 printf ("test_rm_1 FAILED\n");
16545 printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
16546 if (test_rm_2 () == -1) {
16547 printf ("test_rm_2 FAILED\n");
16551 printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
16552 if (test_read_lines_0 () == -1) {
16553 printf ("test_read_lines_0 FAILED\n");
16557 printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
16558 if (test_read_lines_1 () == -1) {
16559 printf ("test_read_lines_1 FAILED\n");
16563 printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
16564 if (test_lvs_0 () == -1) {
16565 printf ("test_lvs_0 FAILED\n");
16569 printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
16570 if (test_lvs_1 () == -1) {
16571 printf ("test_lvs_1 FAILED\n");
16575 printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
16576 if (test_vgs_0 () == -1) {
16577 printf ("test_vgs_0 FAILED\n");
16581 printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
16582 if (test_vgs_1 () == -1) {
16583 printf ("test_vgs_1 FAILED\n");
16587 printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
16588 if (test_pvs_0 () == -1) {
16589 printf ("test_pvs_0 FAILED\n");
16593 printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
16594 if (test_pvs_1 () == -1) {
16595 printf ("test_pvs_1 FAILED\n");
16599 printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
16600 if (test_list_partitions_0 () == -1) {
16601 printf ("test_list_partitions_0 FAILED\n");
16605 printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
16606 if (test_list_partitions_1 () == -1) {
16607 printf ("test_list_partitions_1 FAILED\n");
16611 printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
16612 if (test_list_devices_0 () == -1) {
16613 printf ("test_list_devices_0 FAILED\n");
16617 printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
16618 if (test_ls_0 () == -1) {
16619 printf ("test_ls_0 FAILED\n");
16623 printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
16624 if (test_cat_0 () == -1) {
16625 printf ("test_cat_0 FAILED\n");
16629 printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
16630 if (test_touch_0 () == -1) {
16631 printf ("test_touch_0 FAILED\n");
16635 printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
16636 if (test_sync_0 () == -1) {
16637 printf ("test_sync_0 FAILED\n");
16641 printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
16642 if (test_mount_0 () == -1) {
16643 printf ("test_mount_0 FAILED\n");
16648 unlink ("test1.img");
16649 unlink ("test2.img");
16650 unlink ("test3.img");
16653 printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);