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 device[] = "/dev/sdd";
5798 char mountpoint[] = "/";
5801 r = guestfs_mount (g, device, mountpoint);
5806 char csumtype[] = "md5";
5807 char path[] = "/known-3";
5810 r = guestfs_checksum (g, csumtype, path);
5813 if (strcmp (r, expected) != 0) {
5814 fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
5822 static int test_download_0_skip (void)
5826 str = getenv ("SKIP_TEST_DOWNLOAD_0");
5827 if (str && strcmp (str, "1") == 0) return 1;
5828 str = getenv ("SKIP_TEST_DOWNLOAD");
5829 if (str && strcmp (str, "1") == 0) return 1;
5833 static int test_download_0 (void)
5835 if (test_download_0_skip ()) {
5836 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_download_0");
5840 /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
5842 char device[] = "/dev/sda";
5845 r = guestfs_blockdev_setrw (g, device);
5852 r = guestfs_umount_all (g);
5859 r = guestfs_lvm_remove_all (g);
5864 char device[] = "/dev/sda";
5865 char lines_0[] = ",";
5872 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5877 char fstype[] = "ext2";
5878 char device[] = "/dev/sda1";
5881 r = guestfs_mkfs (g, fstype, device);
5886 char device[] = "/dev/sda1";
5887 char mountpoint[] = "/";
5890 r = guestfs_mount (g, device, mountpoint);
5894 /* TestOutput for download (0) */
5895 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
5897 char remotefilename[] = "/COPYING.LIB";
5900 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
5905 char remotefilename[] = "/COPYING.LIB";
5908 r = guestfs_download (g, remotefilename, "testdownload.tmp");
5913 char remotefilename[] = "/upload";
5916 r = guestfs_upload (g, "testdownload.tmp", remotefilename);
5921 char csumtype[] = "md5";
5922 char path[] = "/upload";
5925 r = guestfs_checksum (g, csumtype, path);
5928 if (strcmp (r, expected) != 0) {
5929 fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
5937 static int test_upload_0_skip (void)
5941 str = getenv ("SKIP_TEST_UPLOAD_0");
5942 if (str && strcmp (str, "1") == 0) return 1;
5943 str = getenv ("SKIP_TEST_UPLOAD");
5944 if (str && strcmp (str, "1") == 0) return 1;
5948 static int test_upload_0 (void)
5950 if (test_upload_0_skip ()) {
5951 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_upload_0");
5955 /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
5957 char device[] = "/dev/sda";
5960 r = guestfs_blockdev_setrw (g, device);
5967 r = guestfs_umount_all (g);
5974 r = guestfs_lvm_remove_all (g);
5979 char device[] = "/dev/sda";
5980 char lines_0[] = ",";
5987 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5992 char fstype[] = "ext2";
5993 char device[] = "/dev/sda1";
5996 r = guestfs_mkfs (g, fstype, device);
6001 char device[] = "/dev/sda1";
6002 char mountpoint[] = "/";
6005 r = guestfs_mount (g, device, mountpoint);
6009 /* TestOutput for upload (0) */
6010 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
6012 char remotefilename[] = "/COPYING.LIB";
6015 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
6020 char csumtype[] = "md5";
6021 char path[] = "/COPYING.LIB";
6024 r = guestfs_checksum (g, csumtype, path);
6027 if (strcmp (r, expected) != 0) {
6028 fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
6036 static int test_blockdev_rereadpt_0_skip (void)
6040 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
6041 if (str && strcmp (str, "1") == 0) return 1;
6042 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
6043 if (str && strcmp (str, "1") == 0) return 1;
6047 static int test_blockdev_rereadpt_0 (void)
6049 if (test_blockdev_rereadpt_0_skip ()) {
6050 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_rereadpt_0");
6054 /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
6056 char device[] = "/dev/sda";
6059 r = guestfs_blockdev_setrw (g, device);
6066 r = guestfs_umount_all (g);
6073 r = guestfs_lvm_remove_all (g);
6077 /* TestRun for blockdev_rereadpt (0) */
6079 char device[] = "/dev/sda";
6082 r = guestfs_blockdev_rereadpt (g, device);
6089 static int test_blockdev_flushbufs_0_skip (void)
6093 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
6094 if (str && strcmp (str, "1") == 0) return 1;
6095 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
6096 if (str && strcmp (str, "1") == 0) return 1;
6100 static int test_blockdev_flushbufs_0 (void)
6102 if (test_blockdev_flushbufs_0_skip ()) {
6103 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_flushbufs_0");
6107 /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
6109 char device[] = "/dev/sda";
6112 r = guestfs_blockdev_setrw (g, device);
6119 r = guestfs_umount_all (g);
6126 r = guestfs_lvm_remove_all (g);
6130 /* TestRun for blockdev_flushbufs (0) */
6132 char device[] = "/dev/sda";
6135 r = guestfs_blockdev_flushbufs (g, device);
6142 static int test_blockdev_getsize64_0_skip (void)
6146 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
6147 if (str && strcmp (str, "1") == 0) return 1;
6148 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
6149 if (str && strcmp (str, "1") == 0) return 1;
6153 static int test_blockdev_getsize64_0 (void)
6155 if (test_blockdev_getsize64_0_skip ()) {
6156 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsize64_0");
6160 /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
6162 char device[] = "/dev/sda";
6165 r = guestfs_blockdev_setrw (g, device);
6172 r = guestfs_umount_all (g);
6179 r = guestfs_lvm_remove_all (g);
6183 /* TestOutputInt for blockdev_getsize64 (0) */
6185 char device[] = "/dev/sda";
6188 r = guestfs_blockdev_getsize64 (g, device);
6191 if (r != 524288000) {
6192 fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n", (int) r);
6199 static int test_blockdev_getsz_0_skip (void)
6203 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
6204 if (str && strcmp (str, "1") == 0) return 1;
6205 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
6206 if (str && strcmp (str, "1") == 0) return 1;
6210 static int test_blockdev_getsz_0 (void)
6212 if (test_blockdev_getsz_0_skip ()) {
6213 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsz_0");
6217 /* InitNone|InitEmpty for test_blockdev_getsz_0 */
6219 char device[] = "/dev/sda";
6222 r = guestfs_blockdev_setrw (g, device);
6229 r = guestfs_umount_all (g);
6236 r = guestfs_lvm_remove_all (g);
6240 /* TestOutputInt for blockdev_getsz (0) */
6242 char device[] = "/dev/sda";
6245 r = guestfs_blockdev_getsz (g, device);
6249 fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n", (int) r);
6256 static int test_blockdev_getbsz_0_skip (void)
6260 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
6261 if (str && strcmp (str, "1") == 0) return 1;
6262 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
6263 if (str && strcmp (str, "1") == 0) return 1;
6267 static int test_blockdev_getbsz_0 (void)
6269 if (test_blockdev_getbsz_0_skip ()) {
6270 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getbsz_0");
6274 /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
6276 char device[] = "/dev/sda";
6279 r = guestfs_blockdev_setrw (g, device);
6286 r = guestfs_umount_all (g);
6293 r = guestfs_lvm_remove_all (g);
6297 /* TestOutputInt for blockdev_getbsz (0) */
6299 char device[] = "/dev/sda";
6302 r = guestfs_blockdev_getbsz (g, device);
6306 fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n", (int) r);
6313 static int test_blockdev_getss_0_skip (void)
6317 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
6318 if (str && strcmp (str, "1") == 0) return 1;
6319 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
6320 if (str && strcmp (str, "1") == 0) return 1;
6324 static int test_blockdev_getss_0 (void)
6326 if (test_blockdev_getss_0_skip ()) {
6327 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getss_0");
6331 /* InitNone|InitEmpty for test_blockdev_getss_0 */
6333 char device[] = "/dev/sda";
6336 r = guestfs_blockdev_setrw (g, device);
6343 r = guestfs_umount_all (g);
6350 r = guestfs_lvm_remove_all (g);
6354 /* TestOutputInt for blockdev_getss (0) */
6356 char device[] = "/dev/sda";
6359 r = guestfs_blockdev_getss (g, device);
6363 fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n", (int) r);
6370 static int test_blockdev_getro_0_skip (void)
6374 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
6375 if (str && strcmp (str, "1") == 0) return 1;
6376 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
6377 if (str && strcmp (str, "1") == 0) return 1;
6381 static int test_blockdev_getro_0 (void)
6383 if (test_blockdev_getro_0_skip ()) {
6384 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getro_0");
6388 /* InitNone|InitEmpty for test_blockdev_getro_0 */
6390 char device[] = "/dev/sda";
6393 r = guestfs_blockdev_setrw (g, device);
6400 r = guestfs_umount_all (g);
6407 r = guestfs_lvm_remove_all (g);
6411 /* TestOutputTrue for blockdev_getro (0) */
6413 char device[] = "/dev/sda";
6416 r = guestfs_blockdev_setro (g, device);
6421 char device[] = "/dev/sda";
6424 r = guestfs_blockdev_getro (g, device);
6428 fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
6435 static int test_blockdev_setrw_0_skip (void)
6439 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
6440 if (str && strcmp (str, "1") == 0) return 1;
6441 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
6442 if (str && strcmp (str, "1") == 0) return 1;
6446 static int test_blockdev_setrw_0 (void)
6448 if (test_blockdev_setrw_0_skip ()) {
6449 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setrw_0");
6453 /* InitNone|InitEmpty for test_blockdev_setrw_0 */
6455 char device[] = "/dev/sda";
6458 r = guestfs_blockdev_setrw (g, device);
6465 r = guestfs_umount_all (g);
6472 r = guestfs_lvm_remove_all (g);
6476 /* TestOutputFalse for blockdev_setrw (0) */
6478 char device[] = "/dev/sda";
6481 r = guestfs_blockdev_setrw (g, device);
6486 char device[] = "/dev/sda";
6489 r = guestfs_blockdev_getro (g, device);
6493 fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
6500 static int test_blockdev_setro_0_skip (void)
6504 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
6505 if (str && strcmp (str, "1") == 0) return 1;
6506 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
6507 if (str && strcmp (str, "1") == 0) return 1;
6511 static int test_blockdev_setro_0 (void)
6513 if (test_blockdev_setro_0_skip ()) {
6514 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setro_0");
6518 /* InitNone|InitEmpty for test_blockdev_setro_0 */
6520 char device[] = "/dev/sda";
6523 r = guestfs_blockdev_setrw (g, device);
6530 r = guestfs_umount_all (g);
6537 r = guestfs_lvm_remove_all (g);
6541 /* TestOutputTrue for blockdev_setro (0) */
6543 char device[] = "/dev/sda";
6546 r = guestfs_blockdev_setro (g, device);
6551 char device[] = "/dev/sda";
6554 r = guestfs_blockdev_getro (g, device);
6558 fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
6565 static int test_statvfs_0_skip (void)
6569 str = getenv ("SKIP_TEST_STATVFS_0");
6570 if (str && strcmp (str, "1") == 0) return 1;
6571 str = getenv ("SKIP_TEST_STATVFS");
6572 if (str && strcmp (str, "1") == 0) return 1;
6576 static int test_statvfs_0 (void)
6578 if (test_statvfs_0_skip ()) {
6579 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_statvfs_0");
6583 /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
6585 char device[] = "/dev/sda";
6588 r = guestfs_blockdev_setrw (g, device);
6595 r = guestfs_umount_all (g);
6602 r = guestfs_lvm_remove_all (g);
6607 char device[] = "/dev/sda";
6608 char lines_0[] = ",";
6615 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6620 char fstype[] = "ext2";
6621 char device[] = "/dev/sda1";
6624 r = guestfs_mkfs (g, fstype, device);
6629 char device[] = "/dev/sda1";
6630 char mountpoint[] = "/";
6633 r = guestfs_mount (g, device, mountpoint);
6637 /* TestOutputStruct for statvfs (0) */
6640 struct guestfs_statvfs *r;
6642 r = guestfs_statvfs (g, path);
6645 if (r->bfree != 487702) {
6646 fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
6650 if (r->blocks != 490020) {
6651 fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
6655 if (r->bsize != 1024) {
6656 fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
6665 static int test_lstat_0_skip (void)
6669 str = getenv ("SKIP_TEST_LSTAT_0");
6670 if (str && strcmp (str, "1") == 0) return 1;
6671 str = getenv ("SKIP_TEST_LSTAT");
6672 if (str && strcmp (str, "1") == 0) return 1;
6676 static int test_lstat_0 (void)
6678 if (test_lstat_0_skip ()) {
6679 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lstat_0");
6683 /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
6685 char device[] = "/dev/sda";
6688 r = guestfs_blockdev_setrw (g, device);
6695 r = guestfs_umount_all (g);
6702 r = guestfs_lvm_remove_all (g);
6707 char device[] = "/dev/sda";
6708 char lines_0[] = ",";
6715 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6720 char fstype[] = "ext2";
6721 char device[] = "/dev/sda1";
6724 r = guestfs_mkfs (g, fstype, device);
6729 char device[] = "/dev/sda1";
6730 char mountpoint[] = "/";
6733 r = guestfs_mount (g, device, mountpoint);
6737 /* TestOutputStruct for lstat (0) */
6739 char path[] = "/new";
6742 r = guestfs_touch (g, path);
6747 char path[] = "/new";
6748 struct guestfs_stat *r;
6750 r = guestfs_lstat (g, path);
6754 fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
6763 static int test_stat_0_skip (void)
6767 str = getenv ("SKIP_TEST_STAT_0");
6768 if (str && strcmp (str, "1") == 0) return 1;
6769 str = getenv ("SKIP_TEST_STAT");
6770 if (str && strcmp (str, "1") == 0) return 1;
6774 static int test_stat_0 (void)
6776 if (test_stat_0_skip ()) {
6777 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_stat_0");
6781 /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
6783 char device[] = "/dev/sda";
6786 r = guestfs_blockdev_setrw (g, device);
6793 r = guestfs_umount_all (g);
6800 r = guestfs_lvm_remove_all (g);
6805 char device[] = "/dev/sda";
6806 char lines_0[] = ",";
6813 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6818 char fstype[] = "ext2";
6819 char device[] = "/dev/sda1";
6822 r = guestfs_mkfs (g, fstype, device);
6827 char device[] = "/dev/sda1";
6828 char mountpoint[] = "/";
6831 r = guestfs_mount (g, device, mountpoint);
6835 /* TestOutputStruct for stat (0) */
6837 char path[] = "/new";
6840 r = guestfs_touch (g, path);
6845 char path[] = "/new";
6846 struct guestfs_stat *r;
6848 r = guestfs_stat (g, path);
6852 fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
6861 static int test_command_lines_0_skip (void)
6865 str = getenv ("SKIP_TEST_COMMAND_LINES_0");
6866 if (str && strcmp (str, "1") == 0) return 1;
6867 str = getenv ("SKIP_TEST_COMMAND_LINES");
6868 if (str && strcmp (str, "1") == 0) return 1;
6872 static int test_command_lines_0 (void)
6874 if (test_command_lines_0_skip ()) {
6875 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_0");
6879 /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
6881 char device[] = "/dev/sda";
6884 r = guestfs_blockdev_setrw (g, device);
6891 r = guestfs_umount_all (g);
6898 r = guestfs_lvm_remove_all (g);
6903 char device[] = "/dev/sda";
6904 char lines_0[] = ",";
6911 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6916 char fstype[] = "ext2";
6917 char device[] = "/dev/sda1";
6920 r = guestfs_mkfs (g, fstype, device);
6925 char device[] = "/dev/sda1";
6926 char mountpoint[] = "/";
6929 r = guestfs_mount (g, device, mountpoint);
6933 /* TestOutputList for command_lines (0) */
6935 char remotefilename[] = "/test-command";
6938 r = guestfs_upload (g, "test-command", remotefilename);
6943 char path[] = "/test-command";
6946 r = guestfs_chmod (g, 493, path);
6951 char arguments_0[] = "/test-command";
6952 char arguments_1[] = "1";
6953 char *arguments[] = {
6961 r = guestfs_command_lines (g, arguments);
6965 fprintf (stderr, "test_command_lines_0: short list returned from command\n");
6970 char expected[] = "Result1";
6971 if (strcmp (r[0], expected) != 0) {
6972 fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6977 fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
6981 for (i = 0; r[i] != NULL; ++i)
6988 static int test_command_lines_1_skip (void)
6992 str = getenv ("SKIP_TEST_COMMAND_LINES_1");
6993 if (str && strcmp (str, "1") == 0) return 1;
6994 str = getenv ("SKIP_TEST_COMMAND_LINES");
6995 if (str && strcmp (str, "1") == 0) return 1;
6999 static int test_command_lines_1 (void)
7001 if (test_command_lines_1_skip ()) {
7002 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_1");
7006 /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
7008 char device[] = "/dev/sda";
7011 r = guestfs_blockdev_setrw (g, device);
7018 r = guestfs_umount_all (g);
7025 r = guestfs_lvm_remove_all (g);
7030 char device[] = "/dev/sda";
7031 char lines_0[] = ",";
7038 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7043 char fstype[] = "ext2";
7044 char device[] = "/dev/sda1";
7047 r = guestfs_mkfs (g, fstype, device);
7052 char device[] = "/dev/sda1";
7053 char mountpoint[] = "/";
7056 r = guestfs_mount (g, device, mountpoint);
7060 /* TestOutputList for command_lines (1) */
7062 char remotefilename[] = "/test-command";
7065 r = guestfs_upload (g, "test-command", remotefilename);
7070 char path[] = "/test-command";
7073 r = guestfs_chmod (g, 493, path);
7078 char arguments_0[] = "/test-command";
7079 char arguments_1[] = "2";
7080 char *arguments[] = {
7088 r = guestfs_command_lines (g, arguments);
7092 fprintf (stderr, "test_command_lines_1: short list returned from command\n");
7097 char expected[] = "Result2";
7098 if (strcmp (r[0], expected) != 0) {
7099 fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7104 fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
7108 for (i = 0; r[i] != NULL; ++i)
7115 static int test_command_lines_2_skip (void)
7119 str = getenv ("SKIP_TEST_COMMAND_LINES_2");
7120 if (str && strcmp (str, "1") == 0) return 1;
7121 str = getenv ("SKIP_TEST_COMMAND_LINES");
7122 if (str && strcmp (str, "1") == 0) return 1;
7126 static int test_command_lines_2 (void)
7128 if (test_command_lines_2_skip ()) {
7129 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_2");
7133 /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
7135 char device[] = "/dev/sda";
7138 r = guestfs_blockdev_setrw (g, device);
7145 r = guestfs_umount_all (g);
7152 r = guestfs_lvm_remove_all (g);
7157 char device[] = "/dev/sda";
7158 char lines_0[] = ",";
7165 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7170 char fstype[] = "ext2";
7171 char device[] = "/dev/sda1";
7174 r = guestfs_mkfs (g, fstype, device);
7179 char device[] = "/dev/sda1";
7180 char mountpoint[] = "/";
7183 r = guestfs_mount (g, device, mountpoint);
7187 /* TestOutputList for command_lines (2) */
7189 char remotefilename[] = "/test-command";
7192 r = guestfs_upload (g, "test-command", remotefilename);
7197 char path[] = "/test-command";
7200 r = guestfs_chmod (g, 493, path);
7205 char arguments_0[] = "/test-command";
7206 char arguments_1[] = "3";
7207 char *arguments[] = {
7215 r = guestfs_command_lines (g, arguments);
7219 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7224 char expected[] = "";
7225 if (strcmp (r[0], expected) != 0) {
7226 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7231 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7236 char expected[] = "Result3";
7237 if (strcmp (r[1], expected) != 0) {
7238 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7243 fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
7247 for (i = 0; r[i] != NULL; ++i)
7254 static int test_command_lines_3_skip (void)
7258 str = getenv ("SKIP_TEST_COMMAND_LINES_3");
7259 if (str && strcmp (str, "1") == 0) return 1;
7260 str = getenv ("SKIP_TEST_COMMAND_LINES");
7261 if (str && strcmp (str, "1") == 0) return 1;
7265 static int test_command_lines_3 (void)
7267 if (test_command_lines_3_skip ()) {
7268 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_3");
7272 /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
7274 char device[] = "/dev/sda";
7277 r = guestfs_blockdev_setrw (g, device);
7284 r = guestfs_umount_all (g);
7291 r = guestfs_lvm_remove_all (g);
7296 char device[] = "/dev/sda";
7297 char lines_0[] = ",";
7304 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7309 char fstype[] = "ext2";
7310 char device[] = "/dev/sda1";
7313 r = guestfs_mkfs (g, fstype, device);
7318 char device[] = "/dev/sda1";
7319 char mountpoint[] = "/";
7322 r = guestfs_mount (g, device, mountpoint);
7326 /* TestOutputList for command_lines (3) */
7328 char remotefilename[] = "/test-command";
7331 r = guestfs_upload (g, "test-command", remotefilename);
7336 char path[] = "/test-command";
7339 r = guestfs_chmod (g, 493, path);
7344 char arguments_0[] = "/test-command";
7345 char arguments_1[] = "4";
7346 char *arguments[] = {
7354 r = guestfs_command_lines (g, arguments);
7358 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7363 char expected[] = "";
7364 if (strcmp (r[0], expected) != 0) {
7365 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7370 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7375 char expected[] = "Result4";
7376 if (strcmp (r[1], expected) != 0) {
7377 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7382 fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
7386 for (i = 0; r[i] != NULL; ++i)
7393 static int test_command_lines_4_skip (void)
7397 str = getenv ("SKIP_TEST_COMMAND_LINES_4");
7398 if (str && strcmp (str, "1") == 0) return 1;
7399 str = getenv ("SKIP_TEST_COMMAND_LINES");
7400 if (str && strcmp (str, "1") == 0) return 1;
7404 static int test_command_lines_4 (void)
7406 if (test_command_lines_4_skip ()) {
7407 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_4");
7411 /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
7413 char device[] = "/dev/sda";
7416 r = guestfs_blockdev_setrw (g, device);
7423 r = guestfs_umount_all (g);
7430 r = guestfs_lvm_remove_all (g);
7435 char device[] = "/dev/sda";
7436 char lines_0[] = ",";
7443 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7448 char fstype[] = "ext2";
7449 char device[] = "/dev/sda1";
7452 r = guestfs_mkfs (g, fstype, device);
7457 char device[] = "/dev/sda1";
7458 char mountpoint[] = "/";
7461 r = guestfs_mount (g, device, mountpoint);
7465 /* TestOutputList for command_lines (4) */
7467 char remotefilename[] = "/test-command";
7470 r = guestfs_upload (g, "test-command", remotefilename);
7475 char path[] = "/test-command";
7478 r = guestfs_chmod (g, 493, path);
7483 char arguments_0[] = "/test-command";
7484 char arguments_1[] = "5";
7485 char *arguments[] = {
7493 r = guestfs_command_lines (g, arguments);
7497 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7502 char expected[] = "";
7503 if (strcmp (r[0], expected) != 0) {
7504 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7509 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7514 char expected[] = "Result5";
7515 if (strcmp (r[1], expected) != 0) {
7516 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7521 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7526 char expected[] = "";
7527 if (strcmp (r[2], expected) != 0) {
7528 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
7533 fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
7537 for (i = 0; r[i] != NULL; ++i)
7544 static int test_command_lines_5_skip (void)
7548 str = getenv ("SKIP_TEST_COMMAND_LINES_5");
7549 if (str && strcmp (str, "1") == 0) return 1;
7550 str = getenv ("SKIP_TEST_COMMAND_LINES");
7551 if (str && strcmp (str, "1") == 0) return 1;
7555 static int test_command_lines_5 (void)
7557 if (test_command_lines_5_skip ()) {
7558 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_5");
7562 /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
7564 char device[] = "/dev/sda";
7567 r = guestfs_blockdev_setrw (g, device);
7574 r = guestfs_umount_all (g);
7581 r = guestfs_lvm_remove_all (g);
7586 char device[] = "/dev/sda";
7587 char lines_0[] = ",";
7594 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7599 char fstype[] = "ext2";
7600 char device[] = "/dev/sda1";
7603 r = guestfs_mkfs (g, fstype, device);
7608 char device[] = "/dev/sda1";
7609 char mountpoint[] = "/";
7612 r = guestfs_mount (g, device, mountpoint);
7616 /* TestOutputList for command_lines (5) */
7618 char remotefilename[] = "/test-command";
7621 r = guestfs_upload (g, "test-command", remotefilename);
7626 char path[] = "/test-command";
7629 r = guestfs_chmod (g, 493, path);
7634 char arguments_0[] = "/test-command";
7635 char arguments_1[] = "6";
7636 char *arguments[] = {
7644 r = guestfs_command_lines (g, arguments);
7648 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7653 char expected[] = "";
7654 if (strcmp (r[0], expected) != 0) {
7655 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7660 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7665 char expected[] = "";
7666 if (strcmp (r[1], expected) != 0) {
7667 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7672 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7677 char expected[] = "Result6";
7678 if (strcmp (r[2], expected) != 0) {
7679 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
7684 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7689 char expected[] = "";
7690 if (strcmp (r[3], expected) != 0) {
7691 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
7696 fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
7700 for (i = 0; r[i] != NULL; ++i)
7707 static int test_command_lines_6_skip (void)
7711 str = getenv ("SKIP_TEST_COMMAND_LINES_6");
7712 if (str && strcmp (str, "1") == 0) return 1;
7713 str = getenv ("SKIP_TEST_COMMAND_LINES");
7714 if (str && strcmp (str, "1") == 0) return 1;
7718 static int test_command_lines_6 (void)
7720 if (test_command_lines_6_skip ()) {
7721 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_6");
7725 /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
7727 char device[] = "/dev/sda";
7730 r = guestfs_blockdev_setrw (g, device);
7737 r = guestfs_umount_all (g);
7744 r = guestfs_lvm_remove_all (g);
7749 char device[] = "/dev/sda";
7750 char lines_0[] = ",";
7757 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7762 char fstype[] = "ext2";
7763 char device[] = "/dev/sda1";
7766 r = guestfs_mkfs (g, fstype, device);
7771 char device[] = "/dev/sda1";
7772 char mountpoint[] = "/";
7775 r = guestfs_mount (g, device, mountpoint);
7779 /* TestOutputList for command_lines (6) */
7781 char remotefilename[] = "/test-command";
7784 r = guestfs_upload (g, "test-command", remotefilename);
7789 char path[] = "/test-command";
7792 r = guestfs_chmod (g, 493, path);
7797 char arguments_0[] = "/test-command";
7798 char arguments_1[] = "7";
7799 char *arguments[] = {
7807 r = guestfs_command_lines (g, arguments);
7811 fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
7815 for (i = 0; r[i] != NULL; ++i)
7822 static int test_command_lines_7_skip (void)
7826 str = getenv ("SKIP_TEST_COMMAND_LINES_7");
7827 if (str && strcmp (str, "1") == 0) return 1;
7828 str = getenv ("SKIP_TEST_COMMAND_LINES");
7829 if (str && strcmp (str, "1") == 0) return 1;
7833 static int test_command_lines_7 (void)
7835 if (test_command_lines_7_skip ()) {
7836 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_7");
7840 /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
7842 char device[] = "/dev/sda";
7845 r = guestfs_blockdev_setrw (g, device);
7852 r = guestfs_umount_all (g);
7859 r = guestfs_lvm_remove_all (g);
7864 char device[] = "/dev/sda";
7865 char lines_0[] = ",";
7872 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7877 char fstype[] = "ext2";
7878 char device[] = "/dev/sda1";
7881 r = guestfs_mkfs (g, fstype, device);
7886 char device[] = "/dev/sda1";
7887 char mountpoint[] = "/";
7890 r = guestfs_mount (g, device, mountpoint);
7894 /* TestOutputList for command_lines (7) */
7896 char remotefilename[] = "/test-command";
7899 r = guestfs_upload (g, "test-command", remotefilename);
7904 char path[] = "/test-command";
7907 r = guestfs_chmod (g, 493, path);
7912 char arguments_0[] = "/test-command";
7913 char arguments_1[] = "8";
7914 char *arguments[] = {
7922 r = guestfs_command_lines (g, arguments);
7926 fprintf (stderr, "test_command_lines_7: short list returned from command\n");
7931 char expected[] = "";
7932 if (strcmp (r[0], expected) != 0) {
7933 fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7938 fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
7942 for (i = 0; r[i] != NULL; ++i)
7949 static int test_command_lines_8_skip (void)
7953 str = getenv ("SKIP_TEST_COMMAND_LINES_8");
7954 if (str && strcmp (str, "1") == 0) return 1;
7955 str = getenv ("SKIP_TEST_COMMAND_LINES");
7956 if (str && strcmp (str, "1") == 0) return 1;
7960 static int test_command_lines_8 (void)
7962 if (test_command_lines_8_skip ()) {
7963 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_8");
7967 /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
7969 char device[] = "/dev/sda";
7972 r = guestfs_blockdev_setrw (g, device);
7979 r = guestfs_umount_all (g);
7986 r = guestfs_lvm_remove_all (g);
7991 char device[] = "/dev/sda";
7992 char lines_0[] = ",";
7999 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8004 char fstype[] = "ext2";
8005 char device[] = "/dev/sda1";
8008 r = guestfs_mkfs (g, fstype, device);
8013 char device[] = "/dev/sda1";
8014 char mountpoint[] = "/";
8017 r = guestfs_mount (g, device, mountpoint);
8021 /* TestOutputList for command_lines (8) */
8023 char remotefilename[] = "/test-command";
8026 r = guestfs_upload (g, "test-command", remotefilename);
8031 char path[] = "/test-command";
8034 r = guestfs_chmod (g, 493, path);
8039 char arguments_0[] = "/test-command";
8040 char arguments_1[] = "9";
8041 char *arguments[] = {
8049 r = guestfs_command_lines (g, arguments);
8053 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8058 char expected[] = "";
8059 if (strcmp (r[0], expected) != 0) {
8060 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8065 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8070 char expected[] = "";
8071 if (strcmp (r[1], expected) != 0) {
8072 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8077 fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
8081 for (i = 0; r[i] != NULL; ++i)
8088 static int test_command_lines_9_skip (void)
8092 str = getenv ("SKIP_TEST_COMMAND_LINES_9");
8093 if (str && strcmp (str, "1") == 0) return 1;
8094 str = getenv ("SKIP_TEST_COMMAND_LINES");
8095 if (str && strcmp (str, "1") == 0) return 1;
8099 static int test_command_lines_9 (void)
8101 if (test_command_lines_9_skip ()) {
8102 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_9");
8106 /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
8108 char device[] = "/dev/sda";
8111 r = guestfs_blockdev_setrw (g, device);
8118 r = guestfs_umount_all (g);
8125 r = guestfs_lvm_remove_all (g);
8130 char device[] = "/dev/sda";
8131 char lines_0[] = ",";
8138 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8143 char fstype[] = "ext2";
8144 char device[] = "/dev/sda1";
8147 r = guestfs_mkfs (g, fstype, device);
8152 char device[] = "/dev/sda1";
8153 char mountpoint[] = "/";
8156 r = guestfs_mount (g, device, mountpoint);
8160 /* TestOutputList for command_lines (9) */
8162 char remotefilename[] = "/test-command";
8165 r = guestfs_upload (g, "test-command", remotefilename);
8170 char path[] = "/test-command";
8173 r = guestfs_chmod (g, 493, path);
8178 char arguments_0[] = "/test-command";
8179 char arguments_1[] = "10";
8180 char *arguments[] = {
8188 r = guestfs_command_lines (g, arguments);
8192 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8197 char expected[] = "Result10-1";
8198 if (strcmp (r[0], expected) != 0) {
8199 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8204 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8209 char expected[] = "Result10-2";
8210 if (strcmp (r[1], expected) != 0) {
8211 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8216 fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
8220 for (i = 0; r[i] != NULL; ++i)
8227 static int test_command_lines_10_skip (void)
8231 str = getenv ("SKIP_TEST_COMMAND_LINES_10");
8232 if (str && strcmp (str, "1") == 0) return 1;
8233 str = getenv ("SKIP_TEST_COMMAND_LINES");
8234 if (str && strcmp (str, "1") == 0) return 1;
8238 static int test_command_lines_10 (void)
8240 if (test_command_lines_10_skip ()) {
8241 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_10");
8245 /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
8247 char device[] = "/dev/sda";
8250 r = guestfs_blockdev_setrw (g, device);
8257 r = guestfs_umount_all (g);
8264 r = guestfs_lvm_remove_all (g);
8269 char device[] = "/dev/sda";
8270 char lines_0[] = ",";
8277 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8282 char fstype[] = "ext2";
8283 char device[] = "/dev/sda1";
8286 r = guestfs_mkfs (g, fstype, device);
8291 char device[] = "/dev/sda1";
8292 char mountpoint[] = "/";
8295 r = guestfs_mount (g, device, mountpoint);
8299 /* TestOutputList for command_lines (10) */
8301 char remotefilename[] = "/test-command";
8304 r = guestfs_upload (g, "test-command", remotefilename);
8309 char path[] = "/test-command";
8312 r = guestfs_chmod (g, 493, path);
8317 char arguments_0[] = "/test-command";
8318 char arguments_1[] = "11";
8319 char *arguments[] = {
8327 r = guestfs_command_lines (g, arguments);
8331 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8336 char expected[] = "Result11-1";
8337 if (strcmp (r[0], expected) != 0) {
8338 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8343 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8348 char expected[] = "Result11-2";
8349 if (strcmp (r[1], expected) != 0) {
8350 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8355 fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
8359 for (i = 0; r[i] != NULL; ++i)
8366 static int test_command_0_skip (void)
8370 str = getenv ("SKIP_TEST_COMMAND_0");
8371 if (str && strcmp (str, "1") == 0) return 1;
8372 str = getenv ("SKIP_TEST_COMMAND");
8373 if (str && strcmp (str, "1") == 0) return 1;
8377 static int test_command_0 (void)
8379 if (test_command_0_skip ()) {
8380 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_0");
8384 /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
8386 char device[] = "/dev/sda";
8389 r = guestfs_blockdev_setrw (g, device);
8396 r = guestfs_umount_all (g);
8403 r = guestfs_lvm_remove_all (g);
8408 char device[] = "/dev/sda";
8409 char lines_0[] = ",";
8416 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8421 char fstype[] = "ext2";
8422 char device[] = "/dev/sda1";
8425 r = guestfs_mkfs (g, fstype, device);
8430 char device[] = "/dev/sda1";
8431 char mountpoint[] = "/";
8434 r = guestfs_mount (g, device, mountpoint);
8438 /* TestOutput for command (0) */
8439 char expected[] = "Result1";
8441 char remotefilename[] = "/test-command";
8444 r = guestfs_upload (g, "test-command", remotefilename);
8449 char path[] = "/test-command";
8452 r = guestfs_chmod (g, 493, path);
8457 char arguments_0[] = "/test-command";
8458 char arguments_1[] = "1";
8459 char *arguments[] = {
8466 r = guestfs_command (g, arguments);
8469 if (strcmp (r, expected) != 0) {
8470 fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
8478 static int test_command_1_skip (void)
8482 str = getenv ("SKIP_TEST_COMMAND_1");
8483 if (str && strcmp (str, "1") == 0) return 1;
8484 str = getenv ("SKIP_TEST_COMMAND");
8485 if (str && strcmp (str, "1") == 0) return 1;
8489 static int test_command_1 (void)
8491 if (test_command_1_skip ()) {
8492 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_1");
8496 /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
8498 char device[] = "/dev/sda";
8501 r = guestfs_blockdev_setrw (g, device);
8508 r = guestfs_umount_all (g);
8515 r = guestfs_lvm_remove_all (g);
8520 char device[] = "/dev/sda";
8521 char lines_0[] = ",";
8528 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8533 char fstype[] = "ext2";
8534 char device[] = "/dev/sda1";
8537 r = guestfs_mkfs (g, fstype, device);
8542 char device[] = "/dev/sda1";
8543 char mountpoint[] = "/";
8546 r = guestfs_mount (g, device, mountpoint);
8550 /* TestOutput for command (1) */
8551 char expected[] = "Result2\n";
8553 char remotefilename[] = "/test-command";
8556 r = guestfs_upload (g, "test-command", remotefilename);
8561 char path[] = "/test-command";
8564 r = guestfs_chmod (g, 493, path);
8569 char arguments_0[] = "/test-command";
8570 char arguments_1[] = "2";
8571 char *arguments[] = {
8578 r = guestfs_command (g, arguments);
8581 if (strcmp (r, expected) != 0) {
8582 fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
8590 static int test_command_2_skip (void)
8594 str = getenv ("SKIP_TEST_COMMAND_2");
8595 if (str && strcmp (str, "1") == 0) return 1;
8596 str = getenv ("SKIP_TEST_COMMAND");
8597 if (str && strcmp (str, "1") == 0) return 1;
8601 static int test_command_2 (void)
8603 if (test_command_2_skip ()) {
8604 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_2");
8608 /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
8610 char device[] = "/dev/sda";
8613 r = guestfs_blockdev_setrw (g, device);
8620 r = guestfs_umount_all (g);
8627 r = guestfs_lvm_remove_all (g);
8632 char device[] = "/dev/sda";
8633 char lines_0[] = ",";
8640 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8645 char fstype[] = "ext2";
8646 char device[] = "/dev/sda1";
8649 r = guestfs_mkfs (g, fstype, device);
8654 char device[] = "/dev/sda1";
8655 char mountpoint[] = "/";
8658 r = guestfs_mount (g, device, mountpoint);
8662 /* TestOutput for command (2) */
8663 char expected[] = "\nResult3";
8665 char remotefilename[] = "/test-command";
8668 r = guestfs_upload (g, "test-command", remotefilename);
8673 char path[] = "/test-command";
8676 r = guestfs_chmod (g, 493, path);
8681 char arguments_0[] = "/test-command";
8682 char arguments_1[] = "3";
8683 char *arguments[] = {
8690 r = guestfs_command (g, arguments);
8693 if (strcmp (r, expected) != 0) {
8694 fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
8702 static int test_command_3_skip (void)
8706 str = getenv ("SKIP_TEST_COMMAND_3");
8707 if (str && strcmp (str, "1") == 0) return 1;
8708 str = getenv ("SKIP_TEST_COMMAND");
8709 if (str && strcmp (str, "1") == 0) return 1;
8713 static int test_command_3 (void)
8715 if (test_command_3_skip ()) {
8716 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_3");
8720 /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
8722 char device[] = "/dev/sda";
8725 r = guestfs_blockdev_setrw (g, device);
8732 r = guestfs_umount_all (g);
8739 r = guestfs_lvm_remove_all (g);
8744 char device[] = "/dev/sda";
8745 char lines_0[] = ",";
8752 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8757 char fstype[] = "ext2";
8758 char device[] = "/dev/sda1";
8761 r = guestfs_mkfs (g, fstype, device);
8766 char device[] = "/dev/sda1";
8767 char mountpoint[] = "/";
8770 r = guestfs_mount (g, device, mountpoint);
8774 /* TestOutput for command (3) */
8775 char expected[] = "\nResult4\n";
8777 char remotefilename[] = "/test-command";
8780 r = guestfs_upload (g, "test-command", remotefilename);
8785 char path[] = "/test-command";
8788 r = guestfs_chmod (g, 493, path);
8793 char arguments_0[] = "/test-command";
8794 char arguments_1[] = "4";
8795 char *arguments[] = {
8802 r = guestfs_command (g, arguments);
8805 if (strcmp (r, expected) != 0) {
8806 fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
8814 static int test_command_4_skip (void)
8818 str = getenv ("SKIP_TEST_COMMAND_4");
8819 if (str && strcmp (str, "1") == 0) return 1;
8820 str = getenv ("SKIP_TEST_COMMAND");
8821 if (str && strcmp (str, "1") == 0) return 1;
8825 static int test_command_4 (void)
8827 if (test_command_4_skip ()) {
8828 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_4");
8832 /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
8834 char device[] = "/dev/sda";
8837 r = guestfs_blockdev_setrw (g, device);
8844 r = guestfs_umount_all (g);
8851 r = guestfs_lvm_remove_all (g);
8856 char device[] = "/dev/sda";
8857 char lines_0[] = ",";
8864 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8869 char fstype[] = "ext2";
8870 char device[] = "/dev/sda1";
8873 r = guestfs_mkfs (g, fstype, device);
8878 char device[] = "/dev/sda1";
8879 char mountpoint[] = "/";
8882 r = guestfs_mount (g, device, mountpoint);
8886 /* TestOutput for command (4) */
8887 char expected[] = "\nResult5\n\n";
8889 char remotefilename[] = "/test-command";
8892 r = guestfs_upload (g, "test-command", remotefilename);
8897 char path[] = "/test-command";
8900 r = guestfs_chmod (g, 493, path);
8905 char arguments_0[] = "/test-command";
8906 char arguments_1[] = "5";
8907 char *arguments[] = {
8914 r = guestfs_command (g, arguments);
8917 if (strcmp (r, expected) != 0) {
8918 fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
8926 static int test_command_5_skip (void)
8930 str = getenv ("SKIP_TEST_COMMAND_5");
8931 if (str && strcmp (str, "1") == 0) return 1;
8932 str = getenv ("SKIP_TEST_COMMAND");
8933 if (str && strcmp (str, "1") == 0) return 1;
8937 static int test_command_5 (void)
8939 if (test_command_5_skip ()) {
8940 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_5");
8944 /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
8946 char device[] = "/dev/sda";
8949 r = guestfs_blockdev_setrw (g, device);
8956 r = guestfs_umount_all (g);
8963 r = guestfs_lvm_remove_all (g);
8968 char device[] = "/dev/sda";
8969 char lines_0[] = ",";
8976 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8981 char fstype[] = "ext2";
8982 char device[] = "/dev/sda1";
8985 r = guestfs_mkfs (g, fstype, device);
8990 char device[] = "/dev/sda1";
8991 char mountpoint[] = "/";
8994 r = guestfs_mount (g, device, mountpoint);
8998 /* TestOutput for command (5) */
8999 char expected[] = "\n\nResult6\n\n";
9001 char remotefilename[] = "/test-command";
9004 r = guestfs_upload (g, "test-command", remotefilename);
9009 char path[] = "/test-command";
9012 r = guestfs_chmod (g, 493, path);
9017 char arguments_0[] = "/test-command";
9018 char arguments_1[] = "6";
9019 char *arguments[] = {
9026 r = guestfs_command (g, arguments);
9029 if (strcmp (r, expected) != 0) {
9030 fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
9038 static int test_command_6_skip (void)
9042 str = getenv ("SKIP_TEST_COMMAND_6");
9043 if (str && strcmp (str, "1") == 0) return 1;
9044 str = getenv ("SKIP_TEST_COMMAND");
9045 if (str && strcmp (str, "1") == 0) return 1;
9049 static int test_command_6 (void)
9051 if (test_command_6_skip ()) {
9052 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_6");
9056 /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
9058 char device[] = "/dev/sda";
9061 r = guestfs_blockdev_setrw (g, device);
9068 r = guestfs_umount_all (g);
9075 r = guestfs_lvm_remove_all (g);
9080 char device[] = "/dev/sda";
9081 char lines_0[] = ",";
9088 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9093 char fstype[] = "ext2";
9094 char device[] = "/dev/sda1";
9097 r = guestfs_mkfs (g, fstype, device);
9102 char device[] = "/dev/sda1";
9103 char mountpoint[] = "/";
9106 r = guestfs_mount (g, device, mountpoint);
9110 /* TestOutput for command (6) */
9111 char expected[] = "";
9113 char remotefilename[] = "/test-command";
9116 r = guestfs_upload (g, "test-command", remotefilename);
9121 char path[] = "/test-command";
9124 r = guestfs_chmod (g, 493, path);
9129 char arguments_0[] = "/test-command";
9130 char arguments_1[] = "7";
9131 char *arguments[] = {
9138 r = guestfs_command (g, arguments);
9141 if (strcmp (r, expected) != 0) {
9142 fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
9150 static int test_command_7_skip (void)
9154 str = getenv ("SKIP_TEST_COMMAND_7");
9155 if (str && strcmp (str, "1") == 0) return 1;
9156 str = getenv ("SKIP_TEST_COMMAND");
9157 if (str && strcmp (str, "1") == 0) return 1;
9161 static int test_command_7 (void)
9163 if (test_command_7_skip ()) {
9164 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_7");
9168 /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
9170 char device[] = "/dev/sda";
9173 r = guestfs_blockdev_setrw (g, device);
9180 r = guestfs_umount_all (g);
9187 r = guestfs_lvm_remove_all (g);
9192 char device[] = "/dev/sda";
9193 char lines_0[] = ",";
9200 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9205 char fstype[] = "ext2";
9206 char device[] = "/dev/sda1";
9209 r = guestfs_mkfs (g, fstype, device);
9214 char device[] = "/dev/sda1";
9215 char mountpoint[] = "/";
9218 r = guestfs_mount (g, device, mountpoint);
9222 /* TestOutput for command (7) */
9223 char expected[] = "\n";
9225 char remotefilename[] = "/test-command";
9228 r = guestfs_upload (g, "test-command", remotefilename);
9233 char path[] = "/test-command";
9236 r = guestfs_chmod (g, 493, path);
9241 char arguments_0[] = "/test-command";
9242 char arguments_1[] = "8";
9243 char *arguments[] = {
9250 r = guestfs_command (g, arguments);
9253 if (strcmp (r, expected) != 0) {
9254 fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
9262 static int test_command_8_skip (void)
9266 str = getenv ("SKIP_TEST_COMMAND_8");
9267 if (str && strcmp (str, "1") == 0) return 1;
9268 str = getenv ("SKIP_TEST_COMMAND");
9269 if (str && strcmp (str, "1") == 0) return 1;
9273 static int test_command_8 (void)
9275 if (test_command_8_skip ()) {
9276 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_8");
9280 /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
9282 char device[] = "/dev/sda";
9285 r = guestfs_blockdev_setrw (g, device);
9292 r = guestfs_umount_all (g);
9299 r = guestfs_lvm_remove_all (g);
9304 char device[] = "/dev/sda";
9305 char lines_0[] = ",";
9312 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9317 char fstype[] = "ext2";
9318 char device[] = "/dev/sda1";
9321 r = guestfs_mkfs (g, fstype, device);
9326 char device[] = "/dev/sda1";
9327 char mountpoint[] = "/";
9330 r = guestfs_mount (g, device, mountpoint);
9334 /* TestOutput for command (8) */
9335 char expected[] = "\n\n";
9337 char remotefilename[] = "/test-command";
9340 r = guestfs_upload (g, "test-command", remotefilename);
9345 char path[] = "/test-command";
9348 r = guestfs_chmod (g, 493, path);
9353 char arguments_0[] = "/test-command";
9354 char arguments_1[] = "9";
9355 char *arguments[] = {
9362 r = guestfs_command (g, arguments);
9365 if (strcmp (r, expected) != 0) {
9366 fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
9374 static int test_command_9_skip (void)
9378 str = getenv ("SKIP_TEST_COMMAND_9");
9379 if (str && strcmp (str, "1") == 0) return 1;
9380 str = getenv ("SKIP_TEST_COMMAND");
9381 if (str && strcmp (str, "1") == 0) return 1;
9385 static int test_command_9 (void)
9387 if (test_command_9_skip ()) {
9388 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_9");
9392 /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
9394 char device[] = "/dev/sda";
9397 r = guestfs_blockdev_setrw (g, device);
9404 r = guestfs_umount_all (g);
9411 r = guestfs_lvm_remove_all (g);
9416 char device[] = "/dev/sda";
9417 char lines_0[] = ",";
9424 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9429 char fstype[] = "ext2";
9430 char device[] = "/dev/sda1";
9433 r = guestfs_mkfs (g, fstype, device);
9438 char device[] = "/dev/sda1";
9439 char mountpoint[] = "/";
9442 r = guestfs_mount (g, device, mountpoint);
9446 /* TestOutput for command (9) */
9447 char expected[] = "Result10-1\nResult10-2\n";
9449 char remotefilename[] = "/test-command";
9452 r = guestfs_upload (g, "test-command", remotefilename);
9457 char path[] = "/test-command";
9460 r = guestfs_chmod (g, 493, path);
9465 char arguments_0[] = "/test-command";
9466 char arguments_1[] = "10";
9467 char *arguments[] = {
9474 r = guestfs_command (g, arguments);
9477 if (strcmp (r, expected) != 0) {
9478 fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
9486 static int test_command_10_skip (void)
9490 str = getenv ("SKIP_TEST_COMMAND_10");
9491 if (str && strcmp (str, "1") == 0) return 1;
9492 str = getenv ("SKIP_TEST_COMMAND");
9493 if (str && strcmp (str, "1") == 0) return 1;
9497 static int test_command_10 (void)
9499 if (test_command_10_skip ()) {
9500 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_10");
9504 /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
9506 char device[] = "/dev/sda";
9509 r = guestfs_blockdev_setrw (g, device);
9516 r = guestfs_umount_all (g);
9523 r = guestfs_lvm_remove_all (g);
9528 char device[] = "/dev/sda";
9529 char lines_0[] = ",";
9536 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9541 char fstype[] = "ext2";
9542 char device[] = "/dev/sda1";
9545 r = guestfs_mkfs (g, fstype, device);
9550 char device[] = "/dev/sda1";
9551 char mountpoint[] = "/";
9554 r = guestfs_mount (g, device, mountpoint);
9558 /* TestOutput for command (10) */
9559 char expected[] = "Result11-1\nResult11-2";
9561 char remotefilename[] = "/test-command";
9564 r = guestfs_upload (g, "test-command", remotefilename);
9569 char path[] = "/test-command";
9572 r = guestfs_chmod (g, 493, path);
9577 char arguments_0[] = "/test-command";
9578 char arguments_1[] = "11";
9579 char *arguments[] = {
9586 r = guestfs_command (g, arguments);
9589 if (strcmp (r, expected) != 0) {
9590 fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
9598 static int test_command_11_skip (void)
9602 str = getenv ("SKIP_TEST_COMMAND_11");
9603 if (str && strcmp (str, "1") == 0) return 1;
9604 str = getenv ("SKIP_TEST_COMMAND");
9605 if (str && strcmp (str, "1") == 0) return 1;
9609 static int test_command_11 (void)
9611 if (test_command_11_skip ()) {
9612 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_11");
9616 /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
9618 char device[] = "/dev/sda";
9621 r = guestfs_blockdev_setrw (g, device);
9628 r = guestfs_umount_all (g);
9635 r = guestfs_lvm_remove_all (g);
9640 char device[] = "/dev/sda";
9641 char lines_0[] = ",";
9648 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9653 char fstype[] = "ext2";
9654 char device[] = "/dev/sda1";
9657 r = guestfs_mkfs (g, fstype, device);
9662 char device[] = "/dev/sda1";
9663 char mountpoint[] = "/";
9666 r = guestfs_mount (g, device, mountpoint);
9670 /* TestLastFail for command (11) */
9672 char remotefilename[] = "/test-command";
9675 r = guestfs_upload (g, "test-command", remotefilename);
9680 char path[] = "/test-command";
9683 r = guestfs_chmod (g, 493, path);
9688 char arguments_0[] = "/test-command";
9689 char *arguments[] = {
9695 r = guestfs_command (g, arguments);
9703 static int test_file_0_skip (void)
9707 str = getenv ("SKIP_TEST_FILE_0");
9708 if (str && strcmp (str, "1") == 0) return 1;
9709 str = getenv ("SKIP_TEST_FILE");
9710 if (str && strcmp (str, "1") == 0) return 1;
9714 static int test_file_0 (void)
9716 if (test_file_0_skip ()) {
9717 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_0");
9721 /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
9723 char device[] = "/dev/sda";
9726 r = guestfs_blockdev_setrw (g, device);
9733 r = guestfs_umount_all (g);
9740 r = guestfs_lvm_remove_all (g);
9745 char device[] = "/dev/sda";
9746 char lines_0[] = ",";
9753 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9758 char fstype[] = "ext2";
9759 char device[] = "/dev/sda1";
9762 r = guestfs_mkfs (g, fstype, device);
9767 char device[] = "/dev/sda1";
9768 char mountpoint[] = "/";
9771 r = guestfs_mount (g, device, mountpoint);
9775 /* TestOutput for file (0) */
9776 char expected[] = "empty";
9778 char path[] = "/new";
9781 r = guestfs_touch (g, path);
9786 char path[] = "/new";
9789 r = guestfs_file (g, path);
9792 if (strcmp (r, expected) != 0) {
9793 fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
9801 static int test_file_1_skip (void)
9805 str = getenv ("SKIP_TEST_FILE_1");
9806 if (str && strcmp (str, "1") == 0) return 1;
9807 str = getenv ("SKIP_TEST_FILE");
9808 if (str && strcmp (str, "1") == 0) return 1;
9812 static int test_file_1 (void)
9814 if (test_file_1_skip ()) {
9815 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_1");
9819 /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
9821 char device[] = "/dev/sda";
9824 r = guestfs_blockdev_setrw (g, device);
9831 r = guestfs_umount_all (g);
9838 r = guestfs_lvm_remove_all (g);
9843 char device[] = "/dev/sda";
9844 char lines_0[] = ",";
9851 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9856 char fstype[] = "ext2";
9857 char device[] = "/dev/sda1";
9860 r = guestfs_mkfs (g, fstype, device);
9865 char device[] = "/dev/sda1";
9866 char mountpoint[] = "/";
9869 r = guestfs_mount (g, device, mountpoint);
9873 /* TestOutput for file (1) */
9874 char expected[] = "ASCII text";
9876 char path[] = "/new";
9877 char content[] = "some content\n";
9880 r = guestfs_write_file (g, path, content, 0);
9885 char path[] = "/new";
9888 r = guestfs_file (g, path);
9891 if (strcmp (r, expected) != 0) {
9892 fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
9900 static int test_file_2_skip (void)
9904 str = getenv ("SKIP_TEST_FILE_2");
9905 if (str && strcmp (str, "1") == 0) return 1;
9906 str = getenv ("SKIP_TEST_FILE");
9907 if (str && strcmp (str, "1") == 0) return 1;
9911 static int test_file_2 (void)
9913 if (test_file_2_skip ()) {
9914 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_2");
9918 /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
9920 char device[] = "/dev/sda";
9923 r = guestfs_blockdev_setrw (g, device);
9930 r = guestfs_umount_all (g);
9937 r = guestfs_lvm_remove_all (g);
9942 char device[] = "/dev/sda";
9943 char lines_0[] = ",";
9950 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9955 char fstype[] = "ext2";
9956 char device[] = "/dev/sda1";
9959 r = guestfs_mkfs (g, fstype, device);
9964 char device[] = "/dev/sda1";
9965 char mountpoint[] = "/";
9968 r = guestfs_mount (g, device, mountpoint);
9972 /* TestLastFail for file (2) */
9974 char path[] = "/nofile";
9977 r = guestfs_file (g, path);
9985 static int test_umount_all_0_skip (void)
9989 str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
9990 if (str && strcmp (str, "1") == 0) return 1;
9991 str = getenv ("SKIP_TEST_UMOUNT_ALL");
9992 if (str && strcmp (str, "1") == 0) return 1;
9996 static int test_umount_all_0 (void)
9998 if (test_umount_all_0_skip ()) {
9999 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_0");
10003 /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
10005 char device[] = "/dev/sda";
10007 suppress_error = 0;
10008 r = guestfs_blockdev_setrw (g, device);
10014 suppress_error = 0;
10015 r = guestfs_umount_all (g);
10021 suppress_error = 0;
10022 r = guestfs_lvm_remove_all (g);
10027 char device[] = "/dev/sda";
10028 char lines_0[] = ",";
10034 suppress_error = 0;
10035 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10040 char fstype[] = "ext2";
10041 char device[] = "/dev/sda1";
10043 suppress_error = 0;
10044 r = guestfs_mkfs (g, fstype, device);
10049 char device[] = "/dev/sda1";
10050 char mountpoint[] = "/";
10052 suppress_error = 0;
10053 r = guestfs_mount (g, device, mountpoint);
10057 /* TestOutputList for umount_all (0) */
10060 suppress_error = 0;
10061 r = guestfs_umount_all (g);
10068 suppress_error = 0;
10069 r = guestfs_mounts (g);
10072 if (r[0] != NULL) {
10073 fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
10077 for (i = 0; r[i] != NULL; ++i)
10084 static int test_umount_all_1_skip (void)
10088 str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
10089 if (str && strcmp (str, "1") == 0) return 1;
10090 str = getenv ("SKIP_TEST_UMOUNT_ALL");
10091 if (str && strcmp (str, "1") == 0) return 1;
10095 static int test_umount_all_1 (void)
10097 if (test_umount_all_1_skip ()) {
10098 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_1");
10102 /* InitNone|InitEmpty for test_umount_all_1 */
10104 char device[] = "/dev/sda";
10106 suppress_error = 0;
10107 r = guestfs_blockdev_setrw (g, device);
10113 suppress_error = 0;
10114 r = guestfs_umount_all (g);
10120 suppress_error = 0;
10121 r = guestfs_lvm_remove_all (g);
10125 /* TestOutputList for umount_all (1) */
10127 char device[] = "/dev/sda";
10128 char lines_0[] = ",10";
10129 char lines_1[] = ",20";
10130 char lines_2[] = ",";
10138 suppress_error = 0;
10139 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10144 char fstype[] = "ext2";
10145 char device[] = "/dev/sda1";
10147 suppress_error = 0;
10148 r = guestfs_mkfs (g, fstype, device);
10153 char fstype[] = "ext2";
10154 char device[] = "/dev/sda2";
10156 suppress_error = 0;
10157 r = guestfs_mkfs (g, fstype, device);
10162 char fstype[] = "ext2";
10163 char device[] = "/dev/sda3";
10165 suppress_error = 0;
10166 r = guestfs_mkfs (g, fstype, device);
10171 char device[] = "/dev/sda1";
10172 char mountpoint[] = "/";
10174 suppress_error = 0;
10175 r = guestfs_mount (g, device, mountpoint);
10180 char path[] = "/mp1";
10182 suppress_error = 0;
10183 r = guestfs_mkdir (g, path);
10188 char device[] = "/dev/sda2";
10189 char mountpoint[] = "/mp1";
10191 suppress_error = 0;
10192 r = guestfs_mount (g, device, mountpoint);
10197 char path[] = "/mp1/mp2";
10199 suppress_error = 0;
10200 r = guestfs_mkdir (g, path);
10205 char device[] = "/dev/sda3";
10206 char mountpoint[] = "/mp1/mp2";
10208 suppress_error = 0;
10209 r = guestfs_mount (g, device, mountpoint);
10214 char path[] = "/mp1/mp2/mp3";
10216 suppress_error = 0;
10217 r = guestfs_mkdir (g, path);
10223 suppress_error = 0;
10224 r = guestfs_umount_all (g);
10231 suppress_error = 0;
10232 r = guestfs_mounts (g);
10235 if (r[0] != NULL) {
10236 fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
10240 for (i = 0; r[i] != NULL; ++i)
10247 static int test_mounts_0_skip (void)
10251 str = getenv ("SKIP_TEST_MOUNTS_0");
10252 if (str && strcmp (str, "1") == 0) return 1;
10253 str = getenv ("SKIP_TEST_MOUNTS");
10254 if (str && strcmp (str, "1") == 0) return 1;
10258 static int test_mounts_0 (void)
10260 if (test_mounts_0_skip ()) {
10261 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mounts_0");
10265 /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
10267 char device[] = "/dev/sda";
10269 suppress_error = 0;
10270 r = guestfs_blockdev_setrw (g, device);
10276 suppress_error = 0;
10277 r = guestfs_umount_all (g);
10283 suppress_error = 0;
10284 r = guestfs_lvm_remove_all (g);
10289 char device[] = "/dev/sda";
10290 char lines_0[] = ",";
10296 suppress_error = 0;
10297 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10302 char fstype[] = "ext2";
10303 char device[] = "/dev/sda1";
10305 suppress_error = 0;
10306 r = guestfs_mkfs (g, fstype, device);
10311 char device[] = "/dev/sda1";
10312 char mountpoint[] = "/";
10314 suppress_error = 0;
10315 r = guestfs_mount (g, device, mountpoint);
10319 /* TestOutputListOfDevices for mounts (0) */
10323 suppress_error = 0;
10324 r = guestfs_mounts (g);
10328 fprintf (stderr, "test_mounts_0: short list returned from command\n");
10333 char expected[] = "/dev/sda1";
10335 if (strcmp (r[0], expected) != 0) {
10336 fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10340 if (r[1] != NULL) {
10341 fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
10345 for (i = 0; r[i] != NULL; ++i)
10352 static int test_umount_0_skip (void)
10356 str = getenv ("SKIP_TEST_UMOUNT_0");
10357 if (str && strcmp (str, "1") == 0) return 1;
10358 str = getenv ("SKIP_TEST_UMOUNT");
10359 if (str && strcmp (str, "1") == 0) return 1;
10363 static int test_umount_0 (void)
10365 if (test_umount_0_skip ()) {
10366 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_0");
10370 /* InitNone|InitEmpty for test_umount_0 */
10372 char device[] = "/dev/sda";
10374 suppress_error = 0;
10375 r = guestfs_blockdev_setrw (g, device);
10381 suppress_error = 0;
10382 r = guestfs_umount_all (g);
10388 suppress_error = 0;
10389 r = guestfs_lvm_remove_all (g);
10393 /* TestOutputListOfDevices for umount (0) */
10395 char device[] = "/dev/sda";
10396 char lines_0[] = ",";
10402 suppress_error = 0;
10403 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10408 char fstype[] = "ext2";
10409 char device[] = "/dev/sda1";
10411 suppress_error = 0;
10412 r = guestfs_mkfs (g, fstype, device);
10417 char device[] = "/dev/sda1";
10418 char mountpoint[] = "/";
10420 suppress_error = 0;
10421 r = guestfs_mount (g, device, mountpoint);
10428 suppress_error = 0;
10429 r = guestfs_mounts (g);
10433 fprintf (stderr, "test_umount_0: short list returned from command\n");
10438 char expected[] = "/dev/sda1";
10440 if (strcmp (r[0], expected) != 0) {
10441 fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10445 if (r[1] != NULL) {
10446 fprintf (stderr, "test_umount_0: extra elements returned from command\n");
10450 for (i = 0; r[i] != NULL; ++i)
10457 static int test_umount_1_skip (void)
10461 str = getenv ("SKIP_TEST_UMOUNT_1");
10462 if (str && strcmp (str, "1") == 0) return 1;
10463 str = getenv ("SKIP_TEST_UMOUNT");
10464 if (str && strcmp (str, "1") == 0) return 1;
10468 static int test_umount_1 (void)
10470 if (test_umount_1_skip ()) {
10471 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_1");
10475 /* InitNone|InitEmpty for test_umount_1 */
10477 char device[] = "/dev/sda";
10479 suppress_error = 0;
10480 r = guestfs_blockdev_setrw (g, device);
10486 suppress_error = 0;
10487 r = guestfs_umount_all (g);
10493 suppress_error = 0;
10494 r = guestfs_lvm_remove_all (g);
10498 /* TestOutputList for umount (1) */
10500 char device[] = "/dev/sda";
10501 char lines_0[] = ",";
10507 suppress_error = 0;
10508 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10513 char fstype[] = "ext2";
10514 char device[] = "/dev/sda1";
10516 suppress_error = 0;
10517 r = guestfs_mkfs (g, fstype, device);
10522 char device[] = "/dev/sda1";
10523 char mountpoint[] = "/";
10525 suppress_error = 0;
10526 r = guestfs_mount (g, device, mountpoint);
10531 char pathordevice[] = "/";
10533 suppress_error = 0;
10534 r = guestfs_umount (g, pathordevice);
10541 suppress_error = 0;
10542 r = guestfs_mounts (g);
10545 if (r[0] != NULL) {
10546 fprintf (stderr, "test_umount_1: extra elements returned from command\n");
10550 for (i = 0; r[i] != NULL; ++i)
10557 static int test_write_file_0_skip (void)
10561 str = getenv ("SKIP_TEST_WRITE_FILE_0");
10562 if (str && strcmp (str, "1") == 0) return 1;
10563 str = getenv ("SKIP_TEST_WRITE_FILE");
10564 if (str && strcmp (str, "1") == 0) return 1;
10568 static int test_write_file_0 (void)
10570 if (test_write_file_0_skip ()) {
10571 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_0");
10575 /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
10577 char device[] = "/dev/sda";
10579 suppress_error = 0;
10580 r = guestfs_blockdev_setrw (g, device);
10586 suppress_error = 0;
10587 r = guestfs_umount_all (g);
10593 suppress_error = 0;
10594 r = guestfs_lvm_remove_all (g);
10599 char device[] = "/dev/sda";
10600 char lines_0[] = ",";
10606 suppress_error = 0;
10607 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10612 char fstype[] = "ext2";
10613 char device[] = "/dev/sda1";
10615 suppress_error = 0;
10616 r = guestfs_mkfs (g, fstype, device);
10621 char device[] = "/dev/sda1";
10622 char mountpoint[] = "/";
10624 suppress_error = 0;
10625 r = guestfs_mount (g, device, mountpoint);
10629 /* TestOutput for write_file (0) */
10630 char expected[] = "new file contents";
10632 char path[] = "/new";
10633 char content[] = "new file contents";
10635 suppress_error = 0;
10636 r = guestfs_write_file (g, path, content, 0);
10641 char path[] = "/new";
10643 suppress_error = 0;
10644 r = guestfs_cat (g, path);
10647 if (strcmp (r, expected) != 0) {
10648 fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
10656 static int test_write_file_1_skip (void)
10660 str = getenv ("SKIP_TEST_WRITE_FILE_1");
10661 if (str && strcmp (str, "1") == 0) return 1;
10662 str = getenv ("SKIP_TEST_WRITE_FILE");
10663 if (str && strcmp (str, "1") == 0) return 1;
10667 static int test_write_file_1 (void)
10669 if (test_write_file_1_skip ()) {
10670 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_1");
10674 /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
10676 char device[] = "/dev/sda";
10678 suppress_error = 0;
10679 r = guestfs_blockdev_setrw (g, device);
10685 suppress_error = 0;
10686 r = guestfs_umount_all (g);
10692 suppress_error = 0;
10693 r = guestfs_lvm_remove_all (g);
10698 char device[] = "/dev/sda";
10699 char lines_0[] = ",";
10705 suppress_error = 0;
10706 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10711 char fstype[] = "ext2";
10712 char device[] = "/dev/sda1";
10714 suppress_error = 0;
10715 r = guestfs_mkfs (g, fstype, device);
10720 char device[] = "/dev/sda1";
10721 char mountpoint[] = "/";
10723 suppress_error = 0;
10724 r = guestfs_mount (g, device, mountpoint);
10728 /* TestOutput for write_file (1) */
10729 char expected[] = "\nnew file contents\n";
10731 char path[] = "/new";
10732 char content[] = "\nnew file contents\n";
10734 suppress_error = 0;
10735 r = guestfs_write_file (g, path, content, 0);
10740 char path[] = "/new";
10742 suppress_error = 0;
10743 r = guestfs_cat (g, path);
10746 if (strcmp (r, expected) != 0) {
10747 fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
10755 static int test_write_file_2_skip (void)
10759 str = getenv ("SKIP_TEST_WRITE_FILE_2");
10760 if (str && strcmp (str, "1") == 0) return 1;
10761 str = getenv ("SKIP_TEST_WRITE_FILE");
10762 if (str && strcmp (str, "1") == 0) return 1;
10766 static int test_write_file_2 (void)
10768 if (test_write_file_2_skip ()) {
10769 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_2");
10773 /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
10775 char device[] = "/dev/sda";
10777 suppress_error = 0;
10778 r = guestfs_blockdev_setrw (g, device);
10784 suppress_error = 0;
10785 r = guestfs_umount_all (g);
10791 suppress_error = 0;
10792 r = guestfs_lvm_remove_all (g);
10797 char device[] = "/dev/sda";
10798 char lines_0[] = ",";
10804 suppress_error = 0;
10805 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10810 char fstype[] = "ext2";
10811 char device[] = "/dev/sda1";
10813 suppress_error = 0;
10814 r = guestfs_mkfs (g, fstype, device);
10819 char device[] = "/dev/sda1";
10820 char mountpoint[] = "/";
10822 suppress_error = 0;
10823 r = guestfs_mount (g, device, mountpoint);
10827 /* TestOutput for write_file (2) */
10828 char expected[] = "\n\n";
10830 char path[] = "/new";
10831 char content[] = "\n\n";
10833 suppress_error = 0;
10834 r = guestfs_write_file (g, path, content, 0);
10839 char path[] = "/new";
10841 suppress_error = 0;
10842 r = guestfs_cat (g, path);
10845 if (strcmp (r, expected) != 0) {
10846 fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
10854 static int test_write_file_3_skip (void)
10858 str = getenv ("SKIP_TEST_WRITE_FILE_3");
10859 if (str && strcmp (str, "1") == 0) return 1;
10860 str = getenv ("SKIP_TEST_WRITE_FILE");
10861 if (str && strcmp (str, "1") == 0) return 1;
10865 static int test_write_file_3 (void)
10867 if (test_write_file_3_skip ()) {
10868 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_3");
10872 /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
10874 char device[] = "/dev/sda";
10876 suppress_error = 0;
10877 r = guestfs_blockdev_setrw (g, device);
10883 suppress_error = 0;
10884 r = guestfs_umount_all (g);
10890 suppress_error = 0;
10891 r = guestfs_lvm_remove_all (g);
10896 char device[] = "/dev/sda";
10897 char lines_0[] = ",";
10903 suppress_error = 0;
10904 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10909 char fstype[] = "ext2";
10910 char device[] = "/dev/sda1";
10912 suppress_error = 0;
10913 r = guestfs_mkfs (g, fstype, device);
10918 char device[] = "/dev/sda1";
10919 char mountpoint[] = "/";
10921 suppress_error = 0;
10922 r = guestfs_mount (g, device, mountpoint);
10926 /* TestOutput for write_file (3) */
10927 char expected[] = "";
10929 char path[] = "/new";
10930 char content[] = "";
10932 suppress_error = 0;
10933 r = guestfs_write_file (g, path, content, 0);
10938 char path[] = "/new";
10940 suppress_error = 0;
10941 r = guestfs_cat (g, path);
10944 if (strcmp (r, expected) != 0) {
10945 fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
10953 static int test_write_file_4_skip (void)
10957 str = getenv ("SKIP_TEST_WRITE_FILE_4");
10958 if (str && strcmp (str, "1") == 0) return 1;
10959 str = getenv ("SKIP_TEST_WRITE_FILE");
10960 if (str && strcmp (str, "1") == 0) return 1;
10964 static int test_write_file_4 (void)
10966 if (test_write_file_4_skip ()) {
10967 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_4");
10971 /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
10973 char device[] = "/dev/sda";
10975 suppress_error = 0;
10976 r = guestfs_blockdev_setrw (g, device);
10982 suppress_error = 0;
10983 r = guestfs_umount_all (g);
10989 suppress_error = 0;
10990 r = guestfs_lvm_remove_all (g);
10995 char device[] = "/dev/sda";
10996 char lines_0[] = ",";
11002 suppress_error = 0;
11003 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11008 char fstype[] = "ext2";
11009 char device[] = "/dev/sda1";
11011 suppress_error = 0;
11012 r = guestfs_mkfs (g, fstype, device);
11017 char device[] = "/dev/sda1";
11018 char mountpoint[] = "/";
11020 suppress_error = 0;
11021 r = guestfs_mount (g, device, mountpoint);
11025 /* TestOutput for write_file (4) */
11026 char expected[] = "\n\n\n";
11028 char path[] = "/new";
11029 char content[] = "\n\n\n";
11031 suppress_error = 0;
11032 r = guestfs_write_file (g, path, content, 0);
11037 char path[] = "/new";
11039 suppress_error = 0;
11040 r = guestfs_cat (g, path);
11043 if (strcmp (r, expected) != 0) {
11044 fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
11052 static int test_write_file_5_skip (void)
11056 str = getenv ("SKIP_TEST_WRITE_FILE_5");
11057 if (str && strcmp (str, "1") == 0) return 1;
11058 str = getenv ("SKIP_TEST_WRITE_FILE");
11059 if (str && strcmp (str, "1") == 0) return 1;
11063 static int test_write_file_5 (void)
11065 if (test_write_file_5_skip ()) {
11066 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_5");
11070 /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
11072 char device[] = "/dev/sda";
11074 suppress_error = 0;
11075 r = guestfs_blockdev_setrw (g, device);
11081 suppress_error = 0;
11082 r = guestfs_umount_all (g);
11088 suppress_error = 0;
11089 r = guestfs_lvm_remove_all (g);
11094 char device[] = "/dev/sda";
11095 char lines_0[] = ",";
11101 suppress_error = 0;
11102 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11107 char fstype[] = "ext2";
11108 char device[] = "/dev/sda1";
11110 suppress_error = 0;
11111 r = guestfs_mkfs (g, fstype, device);
11116 char device[] = "/dev/sda1";
11117 char mountpoint[] = "/";
11119 suppress_error = 0;
11120 r = guestfs_mount (g, device, mountpoint);
11124 /* TestOutput for write_file (5) */
11125 char expected[] = "\n";
11127 char path[] = "/new";
11128 char content[] = "\n";
11130 suppress_error = 0;
11131 r = guestfs_write_file (g, path, content, 0);
11136 char path[] = "/new";
11138 suppress_error = 0;
11139 r = guestfs_cat (g, path);
11142 if (strcmp (r, expected) != 0) {
11143 fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
11151 static int test_mkfs_0_skip (void)
11155 str = getenv ("SKIP_TEST_MKFS_0");
11156 if (str && strcmp (str, "1") == 0) return 1;
11157 str = getenv ("SKIP_TEST_MKFS");
11158 if (str && strcmp (str, "1") == 0) return 1;
11162 static int test_mkfs_0 (void)
11164 if (test_mkfs_0_skip ()) {
11165 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkfs_0");
11169 /* InitNone|InitEmpty for test_mkfs_0 */
11171 char device[] = "/dev/sda";
11173 suppress_error = 0;
11174 r = guestfs_blockdev_setrw (g, device);
11180 suppress_error = 0;
11181 r = guestfs_umount_all (g);
11187 suppress_error = 0;
11188 r = guestfs_lvm_remove_all (g);
11192 /* TestOutput for mkfs (0) */
11193 char expected[] = "new file contents";
11195 char device[] = "/dev/sda";
11196 char lines_0[] = ",";
11202 suppress_error = 0;
11203 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11208 char fstype[] = "ext2";
11209 char device[] = "/dev/sda1";
11211 suppress_error = 0;
11212 r = guestfs_mkfs (g, fstype, device);
11217 char device[] = "/dev/sda1";
11218 char mountpoint[] = "/";
11220 suppress_error = 0;
11221 r = guestfs_mount (g, device, mountpoint);
11226 char path[] = "/new";
11227 char content[] = "new file contents";
11229 suppress_error = 0;
11230 r = guestfs_write_file (g, path, content, 0);
11235 char path[] = "/new";
11237 suppress_error = 0;
11238 r = guestfs_cat (g, path);
11241 if (strcmp (r, expected) != 0) {
11242 fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
11250 static int test_lvcreate_0_skip (void)
11254 str = getenv ("SKIP_TEST_LVCREATE_0");
11255 if (str && strcmp (str, "1") == 0) return 1;
11256 str = getenv ("SKIP_TEST_LVCREATE");
11257 if (str && strcmp (str, "1") == 0) return 1;
11261 static int test_lvcreate_0 (void)
11263 if (test_lvcreate_0_skip ()) {
11264 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvcreate_0");
11268 /* InitNone|InitEmpty for test_lvcreate_0 */
11270 char device[] = "/dev/sda";
11272 suppress_error = 0;
11273 r = guestfs_blockdev_setrw (g, device);
11279 suppress_error = 0;
11280 r = guestfs_umount_all (g);
11286 suppress_error = 0;
11287 r = guestfs_lvm_remove_all (g);
11291 /* TestOutputList for lvcreate (0) */
11293 char device[] = "/dev/sda";
11294 char lines_0[] = ",10";
11295 char lines_1[] = ",20";
11296 char lines_2[] = ",";
11304 suppress_error = 0;
11305 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11310 char device[] = "/dev/sda1";
11312 suppress_error = 0;
11313 r = guestfs_pvcreate (g, device);
11318 char device[] = "/dev/sda2";
11320 suppress_error = 0;
11321 r = guestfs_pvcreate (g, device);
11326 char device[] = "/dev/sda3";
11328 suppress_error = 0;
11329 r = guestfs_pvcreate (g, device);
11334 char volgroup[] = "VG1";
11335 char physvols_0[] = "/dev/sda1";
11336 char physvols_1[] = "/dev/sda2";
11337 char *physvols[] = {
11343 suppress_error = 0;
11344 r = guestfs_vgcreate (g, volgroup, physvols);
11349 char volgroup[] = "VG2";
11350 char physvols_0[] = "/dev/sda3";
11351 char *physvols[] = {
11356 suppress_error = 0;
11357 r = guestfs_vgcreate (g, volgroup, physvols);
11362 char logvol[] = "LV1";
11363 char volgroup[] = "VG1";
11365 suppress_error = 0;
11366 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11371 char logvol[] = "LV2";
11372 char volgroup[] = "VG1";
11374 suppress_error = 0;
11375 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11380 char logvol[] = "LV3";
11381 char volgroup[] = "VG2";
11383 suppress_error = 0;
11384 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11389 char logvol[] = "LV4";
11390 char volgroup[] = "VG2";
11392 suppress_error = 0;
11393 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11398 char logvol[] = "LV5";
11399 char volgroup[] = "VG2";
11401 suppress_error = 0;
11402 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11409 suppress_error = 0;
11410 r = guestfs_lvs (g);
11414 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11419 char expected[] = "/dev/VG1/LV1";
11420 if (strcmp (r[0], expected) != 0) {
11421 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11426 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11431 char expected[] = "/dev/VG1/LV2";
11432 if (strcmp (r[1], expected) != 0) {
11433 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11438 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11443 char expected[] = "/dev/VG2/LV3";
11444 if (strcmp (r[2], expected) != 0) {
11445 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11450 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11455 char expected[] = "/dev/VG2/LV4";
11456 if (strcmp (r[3], expected) != 0) {
11457 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
11462 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11467 char expected[] = "/dev/VG2/LV5";
11468 if (strcmp (r[4], expected) != 0) {
11469 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
11473 if (r[5] != NULL) {
11474 fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
11478 for (i = 0; r[i] != NULL; ++i)
11485 static int test_vgcreate_0_skip (void)
11489 str = getenv ("SKIP_TEST_VGCREATE_0");
11490 if (str && strcmp (str, "1") == 0) return 1;
11491 str = getenv ("SKIP_TEST_VGCREATE");
11492 if (str && strcmp (str, "1") == 0) return 1;
11496 static int test_vgcreate_0 (void)
11498 if (test_vgcreate_0_skip ()) {
11499 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgcreate_0");
11503 /* InitNone|InitEmpty for test_vgcreate_0 */
11505 char device[] = "/dev/sda";
11507 suppress_error = 0;
11508 r = guestfs_blockdev_setrw (g, device);
11514 suppress_error = 0;
11515 r = guestfs_umount_all (g);
11521 suppress_error = 0;
11522 r = guestfs_lvm_remove_all (g);
11526 /* TestOutputList for vgcreate (0) */
11528 char device[] = "/dev/sda";
11529 char lines_0[] = ",10";
11530 char lines_1[] = ",20";
11531 char lines_2[] = ",";
11539 suppress_error = 0;
11540 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11545 char device[] = "/dev/sda1";
11547 suppress_error = 0;
11548 r = guestfs_pvcreate (g, device);
11553 char device[] = "/dev/sda2";
11555 suppress_error = 0;
11556 r = guestfs_pvcreate (g, device);
11561 char device[] = "/dev/sda3";
11563 suppress_error = 0;
11564 r = guestfs_pvcreate (g, device);
11569 char volgroup[] = "VG1";
11570 char physvols_0[] = "/dev/sda1";
11571 char physvols_1[] = "/dev/sda2";
11572 char *physvols[] = {
11578 suppress_error = 0;
11579 r = guestfs_vgcreate (g, volgroup, physvols);
11584 char volgroup[] = "VG2";
11585 char physvols_0[] = "/dev/sda3";
11586 char *physvols[] = {
11591 suppress_error = 0;
11592 r = guestfs_vgcreate (g, volgroup, physvols);
11599 suppress_error = 0;
11600 r = guestfs_vgs (g);
11604 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
11609 char expected[] = "VG1";
11610 if (strcmp (r[0], expected) != 0) {
11611 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11616 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
11621 char expected[] = "VG2";
11622 if (strcmp (r[1], expected) != 0) {
11623 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11627 if (r[2] != NULL) {
11628 fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
11632 for (i = 0; r[i] != NULL; ++i)
11639 static int test_pvcreate_0_skip (void)
11643 str = getenv ("SKIP_TEST_PVCREATE_0");
11644 if (str && strcmp (str, "1") == 0) return 1;
11645 str = getenv ("SKIP_TEST_PVCREATE");
11646 if (str && strcmp (str, "1") == 0) return 1;
11650 static int test_pvcreate_0 (void)
11652 if (test_pvcreate_0_skip ()) {
11653 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvcreate_0");
11657 /* InitNone|InitEmpty for test_pvcreate_0 */
11659 char device[] = "/dev/sda";
11661 suppress_error = 0;
11662 r = guestfs_blockdev_setrw (g, device);
11668 suppress_error = 0;
11669 r = guestfs_umount_all (g);
11675 suppress_error = 0;
11676 r = guestfs_lvm_remove_all (g);
11680 /* TestOutputListOfDevices for pvcreate (0) */
11682 char device[] = "/dev/sda";
11683 char lines_0[] = ",10";
11684 char lines_1[] = ",20";
11685 char lines_2[] = ",";
11693 suppress_error = 0;
11694 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11699 char device[] = "/dev/sda1";
11701 suppress_error = 0;
11702 r = guestfs_pvcreate (g, device);
11707 char device[] = "/dev/sda2";
11709 suppress_error = 0;
11710 r = guestfs_pvcreate (g, device);
11715 char device[] = "/dev/sda3";
11717 suppress_error = 0;
11718 r = guestfs_pvcreate (g, device);
11725 suppress_error = 0;
11726 r = guestfs_pvs (g);
11730 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11735 char expected[] = "/dev/sda1";
11737 if (strcmp (r[0], expected) != 0) {
11738 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11743 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11748 char expected[] = "/dev/sda2";
11750 if (strcmp (r[1], expected) != 0) {
11751 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11756 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11761 char expected[] = "/dev/sda3";
11763 if (strcmp (r[2], expected) != 0) {
11764 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11768 if (r[3] != NULL) {
11769 fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
11773 for (i = 0; r[i] != NULL; ++i)
11780 static int test_is_dir_0_skip (void)
11784 str = getenv ("SKIP_TEST_IS_DIR_0");
11785 if (str && strcmp (str, "1") == 0) return 1;
11786 str = getenv ("SKIP_TEST_IS_DIR");
11787 if (str && strcmp (str, "1") == 0) return 1;
11791 static int test_is_dir_0 (void)
11793 if (test_is_dir_0_skip ()) {
11794 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_0");
11798 /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
11800 char device[] = "/dev/sda";
11802 suppress_error = 0;
11803 r = guestfs_blockdev_setrw (g, device);
11809 suppress_error = 0;
11810 r = guestfs_umount_all (g);
11816 suppress_error = 0;
11817 r = guestfs_lvm_remove_all (g);
11822 char device[] = "/dev/sda";
11823 char lines_0[] = ",";
11829 suppress_error = 0;
11830 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11835 char fstype[] = "ext2";
11836 char device[] = "/dev/sda1";
11838 suppress_error = 0;
11839 r = guestfs_mkfs (g, fstype, device);
11844 char device[] = "/dev/sda1";
11845 char mountpoint[] = "/";
11847 suppress_error = 0;
11848 r = guestfs_mount (g, device, mountpoint);
11852 /* TestOutputFalse for is_dir (0) */
11854 char path[] = "/new";
11856 suppress_error = 0;
11857 r = guestfs_touch (g, path);
11862 char path[] = "/new";
11864 suppress_error = 0;
11865 r = guestfs_is_dir (g, path);
11869 fprintf (stderr, "test_is_dir_0: expected false, got true\n");
11876 static int test_is_dir_1_skip (void)
11880 str = getenv ("SKIP_TEST_IS_DIR_1");
11881 if (str && strcmp (str, "1") == 0) return 1;
11882 str = getenv ("SKIP_TEST_IS_DIR");
11883 if (str && strcmp (str, "1") == 0) return 1;
11887 static int test_is_dir_1 (void)
11889 if (test_is_dir_1_skip ()) {
11890 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_1");
11894 /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
11896 char device[] = "/dev/sda";
11898 suppress_error = 0;
11899 r = guestfs_blockdev_setrw (g, device);
11905 suppress_error = 0;
11906 r = guestfs_umount_all (g);
11912 suppress_error = 0;
11913 r = guestfs_lvm_remove_all (g);
11918 char device[] = "/dev/sda";
11919 char lines_0[] = ",";
11925 suppress_error = 0;
11926 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11931 char fstype[] = "ext2";
11932 char device[] = "/dev/sda1";
11934 suppress_error = 0;
11935 r = guestfs_mkfs (g, fstype, device);
11940 char device[] = "/dev/sda1";
11941 char mountpoint[] = "/";
11943 suppress_error = 0;
11944 r = guestfs_mount (g, device, mountpoint);
11948 /* TestOutputTrue for is_dir (1) */
11950 char path[] = "/new";
11952 suppress_error = 0;
11953 r = guestfs_mkdir (g, path);
11958 char path[] = "/new";
11960 suppress_error = 0;
11961 r = guestfs_is_dir (g, path);
11965 fprintf (stderr, "test_is_dir_1: expected true, got false\n");
11972 static int test_is_file_0_skip (void)
11976 str = getenv ("SKIP_TEST_IS_FILE_0");
11977 if (str && strcmp (str, "1") == 0) return 1;
11978 str = getenv ("SKIP_TEST_IS_FILE");
11979 if (str && strcmp (str, "1") == 0) return 1;
11983 static int test_is_file_0 (void)
11985 if (test_is_file_0_skip ()) {
11986 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_0");
11990 /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
11992 char device[] = "/dev/sda";
11994 suppress_error = 0;
11995 r = guestfs_blockdev_setrw (g, device);
12001 suppress_error = 0;
12002 r = guestfs_umount_all (g);
12008 suppress_error = 0;
12009 r = guestfs_lvm_remove_all (g);
12014 char device[] = "/dev/sda";
12015 char lines_0[] = ",";
12021 suppress_error = 0;
12022 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12027 char fstype[] = "ext2";
12028 char device[] = "/dev/sda1";
12030 suppress_error = 0;
12031 r = guestfs_mkfs (g, fstype, device);
12036 char device[] = "/dev/sda1";
12037 char mountpoint[] = "/";
12039 suppress_error = 0;
12040 r = guestfs_mount (g, device, mountpoint);
12044 /* TestOutputTrue for is_file (0) */
12046 char path[] = "/new";
12048 suppress_error = 0;
12049 r = guestfs_touch (g, path);
12054 char path[] = "/new";
12056 suppress_error = 0;
12057 r = guestfs_is_file (g, path);
12061 fprintf (stderr, "test_is_file_0: expected true, got false\n");
12068 static int test_is_file_1_skip (void)
12072 str = getenv ("SKIP_TEST_IS_FILE_1");
12073 if (str && strcmp (str, "1") == 0) return 1;
12074 str = getenv ("SKIP_TEST_IS_FILE");
12075 if (str && strcmp (str, "1") == 0) return 1;
12079 static int test_is_file_1 (void)
12081 if (test_is_file_1_skip ()) {
12082 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_1");
12086 /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
12088 char device[] = "/dev/sda";
12090 suppress_error = 0;
12091 r = guestfs_blockdev_setrw (g, device);
12097 suppress_error = 0;
12098 r = guestfs_umount_all (g);
12104 suppress_error = 0;
12105 r = guestfs_lvm_remove_all (g);
12110 char device[] = "/dev/sda";
12111 char lines_0[] = ",";
12117 suppress_error = 0;
12118 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12123 char fstype[] = "ext2";
12124 char device[] = "/dev/sda1";
12126 suppress_error = 0;
12127 r = guestfs_mkfs (g, fstype, device);
12132 char device[] = "/dev/sda1";
12133 char mountpoint[] = "/";
12135 suppress_error = 0;
12136 r = guestfs_mount (g, device, mountpoint);
12140 /* TestOutputFalse for is_file (1) */
12142 char path[] = "/new";
12144 suppress_error = 0;
12145 r = guestfs_mkdir (g, path);
12150 char path[] = "/new";
12152 suppress_error = 0;
12153 r = guestfs_is_file (g, path);
12157 fprintf (stderr, "test_is_file_1: expected false, got true\n");
12164 static int test_exists_0_skip (void)
12168 str = getenv ("SKIP_TEST_EXISTS_0");
12169 if (str && strcmp (str, "1") == 0) return 1;
12170 str = getenv ("SKIP_TEST_EXISTS");
12171 if (str && strcmp (str, "1") == 0) return 1;
12175 static int test_exists_0 (void)
12177 if (test_exists_0_skip ()) {
12178 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_0");
12182 /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
12184 char device[] = "/dev/sda";
12186 suppress_error = 0;
12187 r = guestfs_blockdev_setrw (g, device);
12193 suppress_error = 0;
12194 r = guestfs_umount_all (g);
12200 suppress_error = 0;
12201 r = guestfs_lvm_remove_all (g);
12206 char device[] = "/dev/sda";
12207 char lines_0[] = ",";
12213 suppress_error = 0;
12214 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12219 char fstype[] = "ext2";
12220 char device[] = "/dev/sda1";
12222 suppress_error = 0;
12223 r = guestfs_mkfs (g, fstype, device);
12228 char device[] = "/dev/sda1";
12229 char mountpoint[] = "/";
12231 suppress_error = 0;
12232 r = guestfs_mount (g, device, mountpoint);
12236 /* TestOutputTrue for exists (0) */
12238 char path[] = "/new";
12240 suppress_error = 0;
12241 r = guestfs_touch (g, path);
12246 char path[] = "/new";
12248 suppress_error = 0;
12249 r = guestfs_exists (g, path);
12253 fprintf (stderr, "test_exists_0: expected true, got false\n");
12260 static int test_exists_1_skip (void)
12264 str = getenv ("SKIP_TEST_EXISTS_1");
12265 if (str && strcmp (str, "1") == 0) return 1;
12266 str = getenv ("SKIP_TEST_EXISTS");
12267 if (str && strcmp (str, "1") == 0) return 1;
12271 static int test_exists_1 (void)
12273 if (test_exists_1_skip ()) {
12274 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_1");
12278 /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
12280 char device[] = "/dev/sda";
12282 suppress_error = 0;
12283 r = guestfs_blockdev_setrw (g, device);
12289 suppress_error = 0;
12290 r = guestfs_umount_all (g);
12296 suppress_error = 0;
12297 r = guestfs_lvm_remove_all (g);
12302 char device[] = "/dev/sda";
12303 char lines_0[] = ",";
12309 suppress_error = 0;
12310 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12315 char fstype[] = "ext2";
12316 char device[] = "/dev/sda1";
12318 suppress_error = 0;
12319 r = guestfs_mkfs (g, fstype, device);
12324 char device[] = "/dev/sda1";
12325 char mountpoint[] = "/";
12327 suppress_error = 0;
12328 r = guestfs_mount (g, device, mountpoint);
12332 /* TestOutputTrue for exists (1) */
12334 char path[] = "/new";
12336 suppress_error = 0;
12337 r = guestfs_mkdir (g, path);
12342 char path[] = "/new";
12344 suppress_error = 0;
12345 r = guestfs_exists (g, path);
12349 fprintf (stderr, "test_exists_1: expected true, got false\n");
12356 static int test_mkdir_p_0_skip (void)
12360 str = getenv ("SKIP_TEST_MKDIR_P_0");
12361 if (str && strcmp (str, "1") == 0) return 1;
12362 str = getenv ("SKIP_TEST_MKDIR_P");
12363 if (str && strcmp (str, "1") == 0) return 1;
12367 static int test_mkdir_p_0 (void)
12369 if (test_mkdir_p_0_skip ()) {
12370 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_0");
12374 /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
12376 char device[] = "/dev/sda";
12378 suppress_error = 0;
12379 r = guestfs_blockdev_setrw (g, device);
12385 suppress_error = 0;
12386 r = guestfs_umount_all (g);
12392 suppress_error = 0;
12393 r = guestfs_lvm_remove_all (g);
12398 char device[] = "/dev/sda";
12399 char lines_0[] = ",";
12405 suppress_error = 0;
12406 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12411 char fstype[] = "ext2";
12412 char device[] = "/dev/sda1";
12414 suppress_error = 0;
12415 r = guestfs_mkfs (g, fstype, device);
12420 char device[] = "/dev/sda1";
12421 char mountpoint[] = "/";
12423 suppress_error = 0;
12424 r = guestfs_mount (g, device, mountpoint);
12428 /* TestOutputTrue for mkdir_p (0) */
12430 char path[] = "/new/foo/bar";
12432 suppress_error = 0;
12433 r = guestfs_mkdir_p (g, path);
12438 char path[] = "/new/foo/bar";
12440 suppress_error = 0;
12441 r = guestfs_is_dir (g, path);
12445 fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
12452 static int test_mkdir_p_1_skip (void)
12456 str = getenv ("SKIP_TEST_MKDIR_P_1");
12457 if (str && strcmp (str, "1") == 0) return 1;
12458 str = getenv ("SKIP_TEST_MKDIR_P");
12459 if (str && strcmp (str, "1") == 0) return 1;
12463 static int test_mkdir_p_1 (void)
12465 if (test_mkdir_p_1_skip ()) {
12466 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_1");
12470 /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
12472 char device[] = "/dev/sda";
12474 suppress_error = 0;
12475 r = guestfs_blockdev_setrw (g, device);
12481 suppress_error = 0;
12482 r = guestfs_umount_all (g);
12488 suppress_error = 0;
12489 r = guestfs_lvm_remove_all (g);
12494 char device[] = "/dev/sda";
12495 char lines_0[] = ",";
12501 suppress_error = 0;
12502 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12507 char fstype[] = "ext2";
12508 char device[] = "/dev/sda1";
12510 suppress_error = 0;
12511 r = guestfs_mkfs (g, fstype, device);
12516 char device[] = "/dev/sda1";
12517 char mountpoint[] = "/";
12519 suppress_error = 0;
12520 r = guestfs_mount (g, device, mountpoint);
12524 /* TestOutputTrue for mkdir_p (1) */
12526 char path[] = "/new/foo/bar";
12528 suppress_error = 0;
12529 r = guestfs_mkdir_p (g, path);
12534 char path[] = "/new/foo";
12536 suppress_error = 0;
12537 r = guestfs_is_dir (g, path);
12541 fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
12548 static int test_mkdir_p_2_skip (void)
12552 str = getenv ("SKIP_TEST_MKDIR_P_2");
12553 if (str && strcmp (str, "1") == 0) return 1;
12554 str = getenv ("SKIP_TEST_MKDIR_P");
12555 if (str && strcmp (str, "1") == 0) return 1;
12559 static int test_mkdir_p_2 (void)
12561 if (test_mkdir_p_2_skip ()) {
12562 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_2");
12566 /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
12568 char device[] = "/dev/sda";
12570 suppress_error = 0;
12571 r = guestfs_blockdev_setrw (g, device);
12577 suppress_error = 0;
12578 r = guestfs_umount_all (g);
12584 suppress_error = 0;
12585 r = guestfs_lvm_remove_all (g);
12590 char device[] = "/dev/sda";
12591 char lines_0[] = ",";
12597 suppress_error = 0;
12598 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12603 char fstype[] = "ext2";
12604 char device[] = "/dev/sda1";
12606 suppress_error = 0;
12607 r = guestfs_mkfs (g, fstype, device);
12612 char device[] = "/dev/sda1";
12613 char mountpoint[] = "/";
12615 suppress_error = 0;
12616 r = guestfs_mount (g, device, mountpoint);
12620 /* TestOutputTrue for mkdir_p (2) */
12622 char path[] = "/new/foo/bar";
12624 suppress_error = 0;
12625 r = guestfs_mkdir_p (g, path);
12630 char path[] = "/new";
12632 suppress_error = 0;
12633 r = guestfs_is_dir (g, path);
12637 fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
12644 static int test_mkdir_p_3_skip (void)
12648 str = getenv ("SKIP_TEST_MKDIR_P_3");
12649 if (str && strcmp (str, "1") == 0) return 1;
12650 str = getenv ("SKIP_TEST_MKDIR_P");
12651 if (str && strcmp (str, "1") == 0) return 1;
12655 static int test_mkdir_p_3 (void)
12657 if (test_mkdir_p_3_skip ()) {
12658 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_3");
12662 /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
12664 char device[] = "/dev/sda";
12666 suppress_error = 0;
12667 r = guestfs_blockdev_setrw (g, device);
12673 suppress_error = 0;
12674 r = guestfs_umount_all (g);
12680 suppress_error = 0;
12681 r = guestfs_lvm_remove_all (g);
12686 char device[] = "/dev/sda";
12687 char lines_0[] = ",";
12693 suppress_error = 0;
12694 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12699 char fstype[] = "ext2";
12700 char device[] = "/dev/sda1";
12702 suppress_error = 0;
12703 r = guestfs_mkfs (g, fstype, device);
12708 char device[] = "/dev/sda1";
12709 char mountpoint[] = "/";
12711 suppress_error = 0;
12712 r = guestfs_mount (g, device, mountpoint);
12716 /* TestRun for mkdir_p (3) */
12718 char path[] = "/new";
12720 suppress_error = 0;
12721 r = guestfs_mkdir (g, path);
12726 char path[] = "/new";
12728 suppress_error = 0;
12729 r = guestfs_mkdir_p (g, path);
12736 static int test_mkdir_p_4_skip (void)
12740 str = getenv ("SKIP_TEST_MKDIR_P_4");
12741 if (str && strcmp (str, "1") == 0) return 1;
12742 str = getenv ("SKIP_TEST_MKDIR_P");
12743 if (str && strcmp (str, "1") == 0) return 1;
12747 static int test_mkdir_p_4 (void)
12749 if (test_mkdir_p_4_skip ()) {
12750 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_4");
12754 /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
12756 char device[] = "/dev/sda";
12758 suppress_error = 0;
12759 r = guestfs_blockdev_setrw (g, device);
12765 suppress_error = 0;
12766 r = guestfs_umount_all (g);
12772 suppress_error = 0;
12773 r = guestfs_lvm_remove_all (g);
12778 char device[] = "/dev/sda";
12779 char lines_0[] = ",";
12785 suppress_error = 0;
12786 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12791 char fstype[] = "ext2";
12792 char device[] = "/dev/sda1";
12794 suppress_error = 0;
12795 r = guestfs_mkfs (g, fstype, device);
12800 char device[] = "/dev/sda1";
12801 char mountpoint[] = "/";
12803 suppress_error = 0;
12804 r = guestfs_mount (g, device, mountpoint);
12808 /* TestLastFail for mkdir_p (4) */
12810 char path[] = "/new";
12812 suppress_error = 0;
12813 r = guestfs_touch (g, path);
12818 char path[] = "/new";
12820 suppress_error = 1;
12821 r = guestfs_mkdir_p (g, path);
12828 static int test_mkdir_0_skip (void)
12832 str = getenv ("SKIP_TEST_MKDIR_0");
12833 if (str && strcmp (str, "1") == 0) return 1;
12834 str = getenv ("SKIP_TEST_MKDIR");
12835 if (str && strcmp (str, "1") == 0) return 1;
12839 static int test_mkdir_0 (void)
12841 if (test_mkdir_0_skip ()) {
12842 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_0");
12846 /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
12848 char device[] = "/dev/sda";
12850 suppress_error = 0;
12851 r = guestfs_blockdev_setrw (g, device);
12857 suppress_error = 0;
12858 r = guestfs_umount_all (g);
12864 suppress_error = 0;
12865 r = guestfs_lvm_remove_all (g);
12870 char device[] = "/dev/sda";
12871 char lines_0[] = ",";
12877 suppress_error = 0;
12878 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12883 char fstype[] = "ext2";
12884 char device[] = "/dev/sda1";
12886 suppress_error = 0;
12887 r = guestfs_mkfs (g, fstype, device);
12892 char device[] = "/dev/sda1";
12893 char mountpoint[] = "/";
12895 suppress_error = 0;
12896 r = guestfs_mount (g, device, mountpoint);
12900 /* TestOutputTrue for mkdir (0) */
12902 char path[] = "/new";
12904 suppress_error = 0;
12905 r = guestfs_mkdir (g, path);
12910 char path[] = "/new";
12912 suppress_error = 0;
12913 r = guestfs_is_dir (g, path);
12917 fprintf (stderr, "test_mkdir_0: expected true, got false\n");
12924 static int test_mkdir_1_skip (void)
12928 str = getenv ("SKIP_TEST_MKDIR_1");
12929 if (str && strcmp (str, "1") == 0) return 1;
12930 str = getenv ("SKIP_TEST_MKDIR");
12931 if (str && strcmp (str, "1") == 0) return 1;
12935 static int test_mkdir_1 (void)
12937 if (test_mkdir_1_skip ()) {
12938 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_1");
12942 /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
12944 char device[] = "/dev/sda";
12946 suppress_error = 0;
12947 r = guestfs_blockdev_setrw (g, device);
12953 suppress_error = 0;
12954 r = guestfs_umount_all (g);
12960 suppress_error = 0;
12961 r = guestfs_lvm_remove_all (g);
12966 char device[] = "/dev/sda";
12967 char lines_0[] = ",";
12973 suppress_error = 0;
12974 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12979 char fstype[] = "ext2";
12980 char device[] = "/dev/sda1";
12982 suppress_error = 0;
12983 r = guestfs_mkfs (g, fstype, device);
12988 char device[] = "/dev/sda1";
12989 char mountpoint[] = "/";
12991 suppress_error = 0;
12992 r = guestfs_mount (g, device, mountpoint);
12996 /* TestLastFail for mkdir (1) */
12998 char path[] = "/new/foo/bar";
13000 suppress_error = 1;
13001 r = guestfs_mkdir (g, path);
13008 static int test_rm_rf_0_skip (void)
13012 str = getenv ("SKIP_TEST_RM_RF_0");
13013 if (str && strcmp (str, "1") == 0) return 1;
13014 str = getenv ("SKIP_TEST_RM_RF");
13015 if (str && strcmp (str, "1") == 0) return 1;
13019 static int test_rm_rf_0 (void)
13021 if (test_rm_rf_0_skip ()) {
13022 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_rf_0");
13026 /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
13028 char device[] = "/dev/sda";
13030 suppress_error = 0;
13031 r = guestfs_blockdev_setrw (g, device);
13037 suppress_error = 0;
13038 r = guestfs_umount_all (g);
13044 suppress_error = 0;
13045 r = guestfs_lvm_remove_all (g);
13050 char device[] = "/dev/sda";
13051 char lines_0[] = ",";
13057 suppress_error = 0;
13058 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13063 char fstype[] = "ext2";
13064 char device[] = "/dev/sda1";
13066 suppress_error = 0;
13067 r = guestfs_mkfs (g, fstype, device);
13072 char device[] = "/dev/sda1";
13073 char mountpoint[] = "/";
13075 suppress_error = 0;
13076 r = guestfs_mount (g, device, mountpoint);
13080 /* TestOutputFalse for rm_rf (0) */
13082 char path[] = "/new";
13084 suppress_error = 0;
13085 r = guestfs_mkdir (g, path);
13090 char path[] = "/new/foo";
13092 suppress_error = 0;
13093 r = guestfs_mkdir (g, path);
13098 char path[] = "/new/foo/bar";
13100 suppress_error = 0;
13101 r = guestfs_touch (g, path);
13106 char path[] = "/new";
13108 suppress_error = 0;
13109 r = guestfs_rm_rf (g, path);
13114 char path[] = "/new";
13116 suppress_error = 0;
13117 r = guestfs_exists (g, path);
13121 fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
13128 static int test_rmdir_0_skip (void)
13132 str = getenv ("SKIP_TEST_RMDIR_0");
13133 if (str && strcmp (str, "1") == 0) return 1;
13134 str = getenv ("SKIP_TEST_RMDIR");
13135 if (str && strcmp (str, "1") == 0) return 1;
13139 static int test_rmdir_0 (void)
13141 if (test_rmdir_0_skip ()) {
13142 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_0");
13146 /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
13148 char device[] = "/dev/sda";
13150 suppress_error = 0;
13151 r = guestfs_blockdev_setrw (g, device);
13157 suppress_error = 0;
13158 r = guestfs_umount_all (g);
13164 suppress_error = 0;
13165 r = guestfs_lvm_remove_all (g);
13170 char device[] = "/dev/sda";
13171 char lines_0[] = ",";
13177 suppress_error = 0;
13178 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13183 char fstype[] = "ext2";
13184 char device[] = "/dev/sda1";
13186 suppress_error = 0;
13187 r = guestfs_mkfs (g, fstype, device);
13192 char device[] = "/dev/sda1";
13193 char mountpoint[] = "/";
13195 suppress_error = 0;
13196 r = guestfs_mount (g, device, mountpoint);
13200 /* TestRun for rmdir (0) */
13202 char path[] = "/new";
13204 suppress_error = 0;
13205 r = guestfs_mkdir (g, path);
13210 char path[] = "/new";
13212 suppress_error = 0;
13213 r = guestfs_rmdir (g, path);
13220 static int test_rmdir_1_skip (void)
13224 str = getenv ("SKIP_TEST_RMDIR_1");
13225 if (str && strcmp (str, "1") == 0) return 1;
13226 str = getenv ("SKIP_TEST_RMDIR");
13227 if (str && strcmp (str, "1") == 0) return 1;
13231 static int test_rmdir_1 (void)
13233 if (test_rmdir_1_skip ()) {
13234 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_1");
13238 /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
13240 char device[] = "/dev/sda";
13242 suppress_error = 0;
13243 r = guestfs_blockdev_setrw (g, device);
13249 suppress_error = 0;
13250 r = guestfs_umount_all (g);
13256 suppress_error = 0;
13257 r = guestfs_lvm_remove_all (g);
13262 char device[] = "/dev/sda";
13263 char lines_0[] = ",";
13269 suppress_error = 0;
13270 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13275 char fstype[] = "ext2";
13276 char device[] = "/dev/sda1";
13278 suppress_error = 0;
13279 r = guestfs_mkfs (g, fstype, device);
13284 char device[] = "/dev/sda1";
13285 char mountpoint[] = "/";
13287 suppress_error = 0;
13288 r = guestfs_mount (g, device, mountpoint);
13292 /* TestLastFail for rmdir (1) */
13294 char path[] = "/new";
13296 suppress_error = 1;
13297 r = guestfs_rmdir (g, path);
13304 static int test_rmdir_2_skip (void)
13308 str = getenv ("SKIP_TEST_RMDIR_2");
13309 if (str && strcmp (str, "1") == 0) return 1;
13310 str = getenv ("SKIP_TEST_RMDIR");
13311 if (str && strcmp (str, "1") == 0) return 1;
13315 static int test_rmdir_2 (void)
13317 if (test_rmdir_2_skip ()) {
13318 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_2");
13322 /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
13324 char device[] = "/dev/sda";
13326 suppress_error = 0;
13327 r = guestfs_blockdev_setrw (g, device);
13333 suppress_error = 0;
13334 r = guestfs_umount_all (g);
13340 suppress_error = 0;
13341 r = guestfs_lvm_remove_all (g);
13346 char device[] = "/dev/sda";
13347 char lines_0[] = ",";
13353 suppress_error = 0;
13354 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13359 char fstype[] = "ext2";
13360 char device[] = "/dev/sda1";
13362 suppress_error = 0;
13363 r = guestfs_mkfs (g, fstype, device);
13368 char device[] = "/dev/sda1";
13369 char mountpoint[] = "/";
13371 suppress_error = 0;
13372 r = guestfs_mount (g, device, mountpoint);
13376 /* TestLastFail for rmdir (2) */
13378 char path[] = "/new";
13380 suppress_error = 0;
13381 r = guestfs_touch (g, path);
13386 char path[] = "/new";
13388 suppress_error = 1;
13389 r = guestfs_rmdir (g, path);
13396 static int test_rm_0_skip (void)
13400 str = getenv ("SKIP_TEST_RM_0");
13401 if (str && strcmp (str, "1") == 0) return 1;
13402 str = getenv ("SKIP_TEST_RM");
13403 if (str && strcmp (str, "1") == 0) return 1;
13407 static int test_rm_0 (void)
13409 if (test_rm_0_skip ()) {
13410 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_0");
13414 /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
13416 char device[] = "/dev/sda";
13418 suppress_error = 0;
13419 r = guestfs_blockdev_setrw (g, device);
13425 suppress_error = 0;
13426 r = guestfs_umount_all (g);
13432 suppress_error = 0;
13433 r = guestfs_lvm_remove_all (g);
13438 char device[] = "/dev/sda";
13439 char lines_0[] = ",";
13445 suppress_error = 0;
13446 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13451 char fstype[] = "ext2";
13452 char device[] = "/dev/sda1";
13454 suppress_error = 0;
13455 r = guestfs_mkfs (g, fstype, device);
13460 char device[] = "/dev/sda1";
13461 char mountpoint[] = "/";
13463 suppress_error = 0;
13464 r = guestfs_mount (g, device, mountpoint);
13468 /* TestRun for rm (0) */
13470 char path[] = "/new";
13472 suppress_error = 0;
13473 r = guestfs_touch (g, path);
13478 char path[] = "/new";
13480 suppress_error = 0;
13481 r = guestfs_rm (g, path);
13488 static int test_rm_1_skip (void)
13492 str = getenv ("SKIP_TEST_RM_1");
13493 if (str && strcmp (str, "1") == 0) return 1;
13494 str = getenv ("SKIP_TEST_RM");
13495 if (str && strcmp (str, "1") == 0) return 1;
13499 static int test_rm_1 (void)
13501 if (test_rm_1_skip ()) {
13502 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_1");
13506 /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
13508 char device[] = "/dev/sda";
13510 suppress_error = 0;
13511 r = guestfs_blockdev_setrw (g, device);
13517 suppress_error = 0;
13518 r = guestfs_umount_all (g);
13524 suppress_error = 0;
13525 r = guestfs_lvm_remove_all (g);
13530 char device[] = "/dev/sda";
13531 char lines_0[] = ",";
13537 suppress_error = 0;
13538 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13543 char fstype[] = "ext2";
13544 char device[] = "/dev/sda1";
13546 suppress_error = 0;
13547 r = guestfs_mkfs (g, fstype, device);
13552 char device[] = "/dev/sda1";
13553 char mountpoint[] = "/";
13555 suppress_error = 0;
13556 r = guestfs_mount (g, device, mountpoint);
13560 /* TestLastFail for rm (1) */
13562 char path[] = "/new";
13564 suppress_error = 1;
13565 r = guestfs_rm (g, path);
13572 static int test_rm_2_skip (void)
13576 str = getenv ("SKIP_TEST_RM_2");
13577 if (str && strcmp (str, "1") == 0) return 1;
13578 str = getenv ("SKIP_TEST_RM");
13579 if (str && strcmp (str, "1") == 0) return 1;
13583 static int test_rm_2 (void)
13585 if (test_rm_2_skip ()) {
13586 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_2");
13590 /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
13592 char device[] = "/dev/sda";
13594 suppress_error = 0;
13595 r = guestfs_blockdev_setrw (g, device);
13601 suppress_error = 0;
13602 r = guestfs_umount_all (g);
13608 suppress_error = 0;
13609 r = guestfs_lvm_remove_all (g);
13614 char device[] = "/dev/sda";
13615 char lines_0[] = ",";
13621 suppress_error = 0;
13622 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13627 char fstype[] = "ext2";
13628 char device[] = "/dev/sda1";
13630 suppress_error = 0;
13631 r = guestfs_mkfs (g, fstype, device);
13636 char device[] = "/dev/sda1";
13637 char mountpoint[] = "/";
13639 suppress_error = 0;
13640 r = guestfs_mount (g, device, mountpoint);
13644 /* TestLastFail for rm (2) */
13646 char path[] = "/new";
13648 suppress_error = 0;
13649 r = guestfs_mkdir (g, path);
13654 char path[] = "/new";
13656 suppress_error = 1;
13657 r = guestfs_rm (g, path);
13664 static int test_read_lines_0_skip (void)
13668 str = getenv ("SKIP_TEST_READ_LINES_0");
13669 if (str && strcmp (str, "1") == 0) return 1;
13670 str = getenv ("SKIP_TEST_READ_LINES");
13671 if (str && strcmp (str, "1") == 0) return 1;
13675 static int test_read_lines_0 (void)
13677 if (test_read_lines_0_skip ()) {
13678 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_0");
13682 /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
13684 char device[] = "/dev/sda";
13686 suppress_error = 0;
13687 r = guestfs_blockdev_setrw (g, device);
13693 suppress_error = 0;
13694 r = guestfs_umount_all (g);
13700 suppress_error = 0;
13701 r = guestfs_lvm_remove_all (g);
13706 char device[] = "/dev/sda";
13707 char lines_0[] = ",";
13713 suppress_error = 0;
13714 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13719 char fstype[] = "ext2";
13720 char device[] = "/dev/sda1";
13722 suppress_error = 0;
13723 r = guestfs_mkfs (g, fstype, device);
13728 char device[] = "/dev/sda1";
13729 char mountpoint[] = "/";
13731 suppress_error = 0;
13732 r = guestfs_mount (g, device, mountpoint);
13736 /* TestOutputList for read_lines (0) */
13738 char path[] = "/new";
13739 char content[] = "line1\r\nline2\nline3";
13741 suppress_error = 0;
13742 r = guestfs_write_file (g, path, content, 0);
13747 char path[] = "/new";
13750 suppress_error = 0;
13751 r = guestfs_read_lines (g, path);
13755 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
13760 char expected[] = "line1";
13761 if (strcmp (r[0], expected) != 0) {
13762 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13767 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
13772 char expected[] = "line2";
13773 if (strcmp (r[1], expected) != 0) {
13774 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
13779 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
13784 char expected[] = "line3";
13785 if (strcmp (r[2], expected) != 0) {
13786 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
13790 if (r[3] != NULL) {
13791 fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
13795 for (i = 0; r[i] != NULL; ++i)
13802 static int test_read_lines_1_skip (void)
13806 str = getenv ("SKIP_TEST_READ_LINES_1");
13807 if (str && strcmp (str, "1") == 0) return 1;
13808 str = getenv ("SKIP_TEST_READ_LINES");
13809 if (str && strcmp (str, "1") == 0) return 1;
13813 static int test_read_lines_1 (void)
13815 if (test_read_lines_1_skip ()) {
13816 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_1");
13820 /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
13822 char device[] = "/dev/sda";
13824 suppress_error = 0;
13825 r = guestfs_blockdev_setrw (g, device);
13831 suppress_error = 0;
13832 r = guestfs_umount_all (g);
13838 suppress_error = 0;
13839 r = guestfs_lvm_remove_all (g);
13844 char device[] = "/dev/sda";
13845 char lines_0[] = ",";
13851 suppress_error = 0;
13852 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13857 char fstype[] = "ext2";
13858 char device[] = "/dev/sda1";
13860 suppress_error = 0;
13861 r = guestfs_mkfs (g, fstype, device);
13866 char device[] = "/dev/sda1";
13867 char mountpoint[] = "/";
13869 suppress_error = 0;
13870 r = guestfs_mount (g, device, mountpoint);
13874 /* TestOutputList for read_lines (1) */
13876 char path[] = "/new";
13877 char content[] = "";
13879 suppress_error = 0;
13880 r = guestfs_write_file (g, path, content, 0);
13885 char path[] = "/new";
13888 suppress_error = 0;
13889 r = guestfs_read_lines (g, path);
13892 if (r[0] != NULL) {
13893 fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
13897 for (i = 0; r[i] != NULL; ++i)
13904 static int test_lvs_0_skip (void)
13908 str = getenv ("SKIP_TEST_LVS_0");
13909 if (str && strcmp (str, "1") == 0) return 1;
13910 str = getenv ("SKIP_TEST_LVS");
13911 if (str && strcmp (str, "1") == 0) return 1;
13915 static int test_lvs_0 (void)
13917 if (test_lvs_0_skip ()) {
13918 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_0");
13922 /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
13924 char device[] = "/dev/sda";
13926 suppress_error = 0;
13927 r = guestfs_blockdev_setrw (g, device);
13933 suppress_error = 0;
13934 r = guestfs_umount_all (g);
13940 suppress_error = 0;
13941 r = guestfs_lvm_remove_all (g);
13946 char device[] = "/dev/sda";
13947 char lines_0[] = ",";
13953 suppress_error = 0;
13954 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13959 char device[] = "/dev/sda1";
13961 suppress_error = 0;
13962 r = guestfs_pvcreate (g, device);
13967 char volgroup[] = "VG";
13968 char physvols_0[] = "/dev/sda1";
13969 char *physvols[] = {
13974 suppress_error = 0;
13975 r = guestfs_vgcreate (g, volgroup, physvols);
13980 char logvol[] = "LV";
13981 char volgroup[] = "VG";
13983 suppress_error = 0;
13984 r = guestfs_lvcreate (g, logvol, volgroup, 8);
13989 char fstype[] = "ext2";
13990 char device[] = "/dev/VG/LV";
13992 suppress_error = 0;
13993 r = guestfs_mkfs (g, fstype, device);
13998 char device[] = "/dev/VG/LV";
13999 char mountpoint[] = "/";
14001 suppress_error = 0;
14002 r = guestfs_mount (g, device, mountpoint);
14006 /* TestOutputList for lvs (0) */
14010 suppress_error = 0;
14011 r = guestfs_lvs (g);
14015 fprintf (stderr, "test_lvs_0: short list returned from command\n");
14020 char expected[] = "/dev/VG/LV";
14021 if (strcmp (r[0], expected) != 0) {
14022 fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14026 if (r[1] != NULL) {
14027 fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
14031 for (i = 0; r[i] != NULL; ++i)
14038 static int test_lvs_1_skip (void)
14042 str = getenv ("SKIP_TEST_LVS_1");
14043 if (str && strcmp (str, "1") == 0) return 1;
14044 str = getenv ("SKIP_TEST_LVS");
14045 if (str && strcmp (str, "1") == 0) return 1;
14049 static int test_lvs_1 (void)
14051 if (test_lvs_1_skip ()) {
14052 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_1");
14056 /* InitNone|InitEmpty for test_lvs_1 */
14058 char device[] = "/dev/sda";
14060 suppress_error = 0;
14061 r = guestfs_blockdev_setrw (g, device);
14067 suppress_error = 0;
14068 r = guestfs_umount_all (g);
14074 suppress_error = 0;
14075 r = guestfs_lvm_remove_all (g);
14079 /* TestOutputList for lvs (1) */
14081 char device[] = "/dev/sda";
14082 char lines_0[] = ",10";
14083 char lines_1[] = ",20";
14084 char lines_2[] = ",";
14092 suppress_error = 0;
14093 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14098 char device[] = "/dev/sda1";
14100 suppress_error = 0;
14101 r = guestfs_pvcreate (g, device);
14106 char device[] = "/dev/sda2";
14108 suppress_error = 0;
14109 r = guestfs_pvcreate (g, device);
14114 char device[] = "/dev/sda3";
14116 suppress_error = 0;
14117 r = guestfs_pvcreate (g, device);
14122 char volgroup[] = "VG1";
14123 char physvols_0[] = "/dev/sda1";
14124 char physvols_1[] = "/dev/sda2";
14125 char *physvols[] = {
14131 suppress_error = 0;
14132 r = guestfs_vgcreate (g, volgroup, physvols);
14137 char volgroup[] = "VG2";
14138 char physvols_0[] = "/dev/sda3";
14139 char *physvols[] = {
14144 suppress_error = 0;
14145 r = guestfs_vgcreate (g, volgroup, physvols);
14150 char logvol[] = "LV1";
14151 char volgroup[] = "VG1";
14153 suppress_error = 0;
14154 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14159 char logvol[] = "LV2";
14160 char volgroup[] = "VG1";
14162 suppress_error = 0;
14163 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14168 char logvol[] = "LV3";
14169 char volgroup[] = "VG2";
14171 suppress_error = 0;
14172 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14179 suppress_error = 0;
14180 r = guestfs_lvs (g);
14184 fprintf (stderr, "test_lvs_1: short list returned from command\n");
14189 char expected[] = "/dev/VG1/LV1";
14190 if (strcmp (r[0], expected) != 0) {
14191 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14196 fprintf (stderr, "test_lvs_1: short list returned from command\n");
14201 char expected[] = "/dev/VG1/LV2";
14202 if (strcmp (r[1], expected) != 0) {
14203 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14208 fprintf (stderr, "test_lvs_1: short list returned from command\n");
14213 char expected[] = "/dev/VG2/LV3";
14214 if (strcmp (r[2], expected) != 0) {
14215 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14219 if (r[3] != NULL) {
14220 fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
14224 for (i = 0; r[i] != NULL; ++i)
14231 static int test_vgs_0_skip (void)
14235 str = getenv ("SKIP_TEST_VGS_0");
14236 if (str && strcmp (str, "1") == 0) return 1;
14237 str = getenv ("SKIP_TEST_VGS");
14238 if (str && strcmp (str, "1") == 0) return 1;
14242 static int test_vgs_0 (void)
14244 if (test_vgs_0_skip ()) {
14245 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_0");
14249 /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
14251 char device[] = "/dev/sda";
14253 suppress_error = 0;
14254 r = guestfs_blockdev_setrw (g, device);
14260 suppress_error = 0;
14261 r = guestfs_umount_all (g);
14267 suppress_error = 0;
14268 r = guestfs_lvm_remove_all (g);
14273 char device[] = "/dev/sda";
14274 char lines_0[] = ",";
14280 suppress_error = 0;
14281 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14286 char device[] = "/dev/sda1";
14288 suppress_error = 0;
14289 r = guestfs_pvcreate (g, device);
14294 char volgroup[] = "VG";
14295 char physvols_0[] = "/dev/sda1";
14296 char *physvols[] = {
14301 suppress_error = 0;
14302 r = guestfs_vgcreate (g, volgroup, physvols);
14307 char logvol[] = "LV";
14308 char volgroup[] = "VG";
14310 suppress_error = 0;
14311 r = guestfs_lvcreate (g, logvol, volgroup, 8);
14316 char fstype[] = "ext2";
14317 char device[] = "/dev/VG/LV";
14319 suppress_error = 0;
14320 r = guestfs_mkfs (g, fstype, device);
14325 char device[] = "/dev/VG/LV";
14326 char mountpoint[] = "/";
14328 suppress_error = 0;
14329 r = guestfs_mount (g, device, mountpoint);
14333 /* TestOutputList for vgs (0) */
14337 suppress_error = 0;
14338 r = guestfs_vgs (g);
14342 fprintf (stderr, "test_vgs_0: short list returned from command\n");
14347 char expected[] = "VG";
14348 if (strcmp (r[0], expected) != 0) {
14349 fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14353 if (r[1] != NULL) {
14354 fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
14358 for (i = 0; r[i] != NULL; ++i)
14365 static int test_vgs_1_skip (void)
14369 str = getenv ("SKIP_TEST_VGS_1");
14370 if (str && strcmp (str, "1") == 0) return 1;
14371 str = getenv ("SKIP_TEST_VGS");
14372 if (str && strcmp (str, "1") == 0) return 1;
14376 static int test_vgs_1 (void)
14378 if (test_vgs_1_skip ()) {
14379 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_1");
14383 /* InitNone|InitEmpty for test_vgs_1 */
14385 char device[] = "/dev/sda";
14387 suppress_error = 0;
14388 r = guestfs_blockdev_setrw (g, device);
14394 suppress_error = 0;
14395 r = guestfs_umount_all (g);
14401 suppress_error = 0;
14402 r = guestfs_lvm_remove_all (g);
14406 /* TestOutputList for vgs (1) */
14408 char device[] = "/dev/sda";
14409 char lines_0[] = ",10";
14410 char lines_1[] = ",20";
14411 char lines_2[] = ",";
14419 suppress_error = 0;
14420 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14425 char device[] = "/dev/sda1";
14427 suppress_error = 0;
14428 r = guestfs_pvcreate (g, device);
14433 char device[] = "/dev/sda2";
14435 suppress_error = 0;
14436 r = guestfs_pvcreate (g, device);
14441 char device[] = "/dev/sda3";
14443 suppress_error = 0;
14444 r = guestfs_pvcreate (g, device);
14449 char volgroup[] = "VG1";
14450 char physvols_0[] = "/dev/sda1";
14451 char physvols_1[] = "/dev/sda2";
14452 char *physvols[] = {
14458 suppress_error = 0;
14459 r = guestfs_vgcreate (g, volgroup, physvols);
14464 char volgroup[] = "VG2";
14465 char physvols_0[] = "/dev/sda3";
14466 char *physvols[] = {
14471 suppress_error = 0;
14472 r = guestfs_vgcreate (g, volgroup, physvols);
14479 suppress_error = 0;
14480 r = guestfs_vgs (g);
14484 fprintf (stderr, "test_vgs_1: short list returned from command\n");
14489 char expected[] = "VG1";
14490 if (strcmp (r[0], expected) != 0) {
14491 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14496 fprintf (stderr, "test_vgs_1: short list returned from command\n");
14501 char expected[] = "VG2";
14502 if (strcmp (r[1], expected) != 0) {
14503 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14507 if (r[2] != NULL) {
14508 fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
14512 for (i = 0; r[i] != NULL; ++i)
14519 static int test_pvs_0_skip (void)
14523 str = getenv ("SKIP_TEST_PVS_0");
14524 if (str && strcmp (str, "1") == 0) return 1;
14525 str = getenv ("SKIP_TEST_PVS");
14526 if (str && strcmp (str, "1") == 0) return 1;
14530 static int test_pvs_0 (void)
14532 if (test_pvs_0_skip ()) {
14533 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_0");
14537 /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
14539 char device[] = "/dev/sda";
14541 suppress_error = 0;
14542 r = guestfs_blockdev_setrw (g, device);
14548 suppress_error = 0;
14549 r = guestfs_umount_all (g);
14555 suppress_error = 0;
14556 r = guestfs_lvm_remove_all (g);
14561 char device[] = "/dev/sda";
14562 char lines_0[] = ",";
14568 suppress_error = 0;
14569 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14574 char device[] = "/dev/sda1";
14576 suppress_error = 0;
14577 r = guestfs_pvcreate (g, device);
14582 char volgroup[] = "VG";
14583 char physvols_0[] = "/dev/sda1";
14584 char *physvols[] = {
14589 suppress_error = 0;
14590 r = guestfs_vgcreate (g, volgroup, physvols);
14595 char logvol[] = "LV";
14596 char volgroup[] = "VG";
14598 suppress_error = 0;
14599 r = guestfs_lvcreate (g, logvol, volgroup, 8);
14604 char fstype[] = "ext2";
14605 char device[] = "/dev/VG/LV";
14607 suppress_error = 0;
14608 r = guestfs_mkfs (g, fstype, device);
14613 char device[] = "/dev/VG/LV";
14614 char mountpoint[] = "/";
14616 suppress_error = 0;
14617 r = guestfs_mount (g, device, mountpoint);
14621 /* TestOutputListOfDevices for pvs (0) */
14625 suppress_error = 0;
14626 r = guestfs_pvs (g);
14630 fprintf (stderr, "test_pvs_0: short list returned from command\n");
14635 char expected[] = "/dev/sda1";
14637 if (strcmp (r[0], expected) != 0) {
14638 fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14642 if (r[1] != NULL) {
14643 fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
14647 for (i = 0; r[i] != NULL; ++i)
14654 static int test_pvs_1_skip (void)
14658 str = getenv ("SKIP_TEST_PVS_1");
14659 if (str && strcmp (str, "1") == 0) return 1;
14660 str = getenv ("SKIP_TEST_PVS");
14661 if (str && strcmp (str, "1") == 0) return 1;
14665 static int test_pvs_1 (void)
14667 if (test_pvs_1_skip ()) {
14668 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_1");
14672 /* InitNone|InitEmpty for test_pvs_1 */
14674 char device[] = "/dev/sda";
14676 suppress_error = 0;
14677 r = guestfs_blockdev_setrw (g, device);
14683 suppress_error = 0;
14684 r = guestfs_umount_all (g);
14690 suppress_error = 0;
14691 r = guestfs_lvm_remove_all (g);
14695 /* TestOutputListOfDevices for pvs (1) */
14697 char device[] = "/dev/sda";
14698 char lines_0[] = ",10";
14699 char lines_1[] = ",20";
14700 char lines_2[] = ",";
14708 suppress_error = 0;
14709 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14714 char device[] = "/dev/sda1";
14716 suppress_error = 0;
14717 r = guestfs_pvcreate (g, device);
14722 char device[] = "/dev/sda2";
14724 suppress_error = 0;
14725 r = guestfs_pvcreate (g, device);
14730 char device[] = "/dev/sda3";
14732 suppress_error = 0;
14733 r = guestfs_pvcreate (g, device);
14740 suppress_error = 0;
14741 r = guestfs_pvs (g);
14745 fprintf (stderr, "test_pvs_1: short list returned from command\n");
14750 char expected[] = "/dev/sda1";
14752 if (strcmp (r[0], expected) != 0) {
14753 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14758 fprintf (stderr, "test_pvs_1: short list returned from command\n");
14763 char expected[] = "/dev/sda2";
14765 if (strcmp (r[1], expected) != 0) {
14766 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14771 fprintf (stderr, "test_pvs_1: short list returned from command\n");
14776 char expected[] = "/dev/sda3";
14778 if (strcmp (r[2], expected) != 0) {
14779 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14783 if (r[3] != NULL) {
14784 fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
14788 for (i = 0; r[i] != NULL; ++i)
14795 static int test_list_partitions_0_skip (void)
14799 str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
14800 if (str && strcmp (str, "1") == 0) return 1;
14801 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
14802 if (str && strcmp (str, "1") == 0) return 1;
14806 static int test_list_partitions_0 (void)
14808 if (test_list_partitions_0_skip ()) {
14809 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_0");
14813 /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
14815 char device[] = "/dev/sda";
14817 suppress_error = 0;
14818 r = guestfs_blockdev_setrw (g, device);
14824 suppress_error = 0;
14825 r = guestfs_umount_all (g);
14831 suppress_error = 0;
14832 r = guestfs_lvm_remove_all (g);
14837 char device[] = "/dev/sda";
14838 char lines_0[] = ",";
14844 suppress_error = 0;
14845 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14850 char fstype[] = "ext2";
14851 char device[] = "/dev/sda1";
14853 suppress_error = 0;
14854 r = guestfs_mkfs (g, fstype, device);
14859 char device[] = "/dev/sda1";
14860 char mountpoint[] = "/";
14862 suppress_error = 0;
14863 r = guestfs_mount (g, device, mountpoint);
14867 /* TestOutputListOfDevices for list_partitions (0) */
14871 suppress_error = 0;
14872 r = guestfs_list_partitions (g);
14876 fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
14881 char expected[] = "/dev/sda1";
14883 if (strcmp (r[0], expected) != 0) {
14884 fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14888 if (r[1] != NULL) {
14889 fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
14893 for (i = 0; r[i] != NULL; ++i)
14900 static int test_list_partitions_1_skip (void)
14904 str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
14905 if (str && strcmp (str, "1") == 0) return 1;
14906 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
14907 if (str && strcmp (str, "1") == 0) return 1;
14911 static int test_list_partitions_1 (void)
14913 if (test_list_partitions_1_skip ()) {
14914 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_1");
14918 /* InitNone|InitEmpty for test_list_partitions_1 */
14920 char device[] = "/dev/sda";
14922 suppress_error = 0;
14923 r = guestfs_blockdev_setrw (g, device);
14929 suppress_error = 0;
14930 r = guestfs_umount_all (g);
14936 suppress_error = 0;
14937 r = guestfs_lvm_remove_all (g);
14941 /* TestOutputListOfDevices for list_partitions (1) */
14943 char device[] = "/dev/sda";
14944 char lines_0[] = ",10";
14945 char lines_1[] = ",20";
14946 char lines_2[] = ",";
14954 suppress_error = 0;
14955 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14962 suppress_error = 0;
14963 r = guestfs_list_partitions (g);
14967 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
14972 char expected[] = "/dev/sda1";
14974 if (strcmp (r[0], expected) != 0) {
14975 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14980 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
14985 char expected[] = "/dev/sda2";
14987 if (strcmp (r[1], expected) != 0) {
14988 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14993 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
14998 char expected[] = "/dev/sda3";
15000 if (strcmp (r[2], expected) != 0) {
15001 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15005 if (r[3] != NULL) {
15006 fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
15010 for (i = 0; r[i] != NULL; ++i)
15017 static int test_list_devices_0_skip (void)
15021 str = getenv ("SKIP_TEST_LIST_DEVICES_0");
15022 if (str && strcmp (str, "1") == 0) return 1;
15023 str = getenv ("SKIP_TEST_LIST_DEVICES");
15024 if (str && strcmp (str, "1") == 0) return 1;
15028 static int test_list_devices_0 (void)
15030 if (test_list_devices_0_skip ()) {
15031 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_devices_0");
15035 /* InitNone|InitEmpty for test_list_devices_0 */
15037 char device[] = "/dev/sda";
15039 suppress_error = 0;
15040 r = guestfs_blockdev_setrw (g, device);
15046 suppress_error = 0;
15047 r = guestfs_umount_all (g);
15053 suppress_error = 0;
15054 r = guestfs_lvm_remove_all (g);
15058 /* TestOutputListOfDevices for list_devices (0) */
15062 suppress_error = 0;
15063 r = guestfs_list_devices (g);
15067 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15072 char expected[] = "/dev/sda";
15074 if (strcmp (r[0], expected) != 0) {
15075 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15080 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15085 char expected[] = "/dev/sdb";
15087 if (strcmp (r[1], expected) != 0) {
15088 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15093 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15098 char expected[] = "/dev/sdc";
15100 if (strcmp (r[2], expected) != 0) {
15101 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15106 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15111 char expected[] = "/dev/sdd";
15113 if (strcmp (r[3], expected) != 0) {
15114 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15118 if (r[4] != NULL) {
15119 fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
15123 for (i = 0; r[i] != NULL; ++i)
15130 static int test_ls_0_skip (void)
15134 str = getenv ("SKIP_TEST_LS_0");
15135 if (str && strcmp (str, "1") == 0) return 1;
15136 str = getenv ("SKIP_TEST_LS");
15137 if (str && strcmp (str, "1") == 0) return 1;
15141 static int test_ls_0 (void)
15143 if (test_ls_0_skip ()) {
15144 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ls_0");
15148 /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
15150 char device[] = "/dev/sda";
15152 suppress_error = 0;
15153 r = guestfs_blockdev_setrw (g, device);
15159 suppress_error = 0;
15160 r = guestfs_umount_all (g);
15166 suppress_error = 0;
15167 r = guestfs_lvm_remove_all (g);
15172 char device[] = "/dev/sda";
15173 char lines_0[] = ",";
15179 suppress_error = 0;
15180 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15185 char fstype[] = "ext2";
15186 char device[] = "/dev/sda1";
15188 suppress_error = 0;
15189 r = guestfs_mkfs (g, fstype, device);
15194 char device[] = "/dev/sda1";
15195 char mountpoint[] = "/";
15197 suppress_error = 0;
15198 r = guestfs_mount (g, device, mountpoint);
15202 /* TestOutputList for ls (0) */
15204 char path[] = "/new";
15206 suppress_error = 0;
15207 r = guestfs_touch (g, path);
15212 char path[] = "/newer";
15214 suppress_error = 0;
15215 r = guestfs_touch (g, path);
15220 char path[] = "/newest";
15222 suppress_error = 0;
15223 r = guestfs_touch (g, path);
15228 char directory[] = "/";
15231 suppress_error = 0;
15232 r = guestfs_ls (g, directory);
15236 fprintf (stderr, "test_ls_0: short list returned from command\n");
15241 char expected[] = "lost+found";
15242 if (strcmp (r[0], expected) != 0) {
15243 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15248 fprintf (stderr, "test_ls_0: short list returned from command\n");
15253 char expected[] = "new";
15254 if (strcmp (r[1], expected) != 0) {
15255 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15260 fprintf (stderr, "test_ls_0: short list returned from command\n");
15265 char expected[] = "newer";
15266 if (strcmp (r[2], expected) != 0) {
15267 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15272 fprintf (stderr, "test_ls_0: short list returned from command\n");
15277 char expected[] = "newest";
15278 if (strcmp (r[3], expected) != 0) {
15279 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15283 if (r[4] != NULL) {
15284 fprintf (stderr, "test_ls_0: extra elements returned from command\n");
15288 for (i = 0; r[i] != NULL; ++i)
15295 static int test_cat_0_skip (void)
15299 str = getenv ("SKIP_TEST_CAT_0");
15300 if (str && strcmp (str, "1") == 0) return 1;
15301 str = getenv ("SKIP_TEST_CAT");
15302 if (str && strcmp (str, "1") == 0) return 1;
15306 static int test_cat_0 (void)
15308 if (test_cat_0_skip ()) {
15309 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cat_0");
15313 /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
15315 char device[] = "/dev/sda";
15317 suppress_error = 0;
15318 r = guestfs_blockdev_setrw (g, device);
15324 suppress_error = 0;
15325 r = guestfs_umount_all (g);
15331 suppress_error = 0;
15332 r = guestfs_lvm_remove_all (g);
15337 char device[] = "/dev/sda";
15338 char lines_0[] = ",";
15344 suppress_error = 0;
15345 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15350 char fstype[] = "ext2";
15351 char device[] = "/dev/sda1";
15353 suppress_error = 0;
15354 r = guestfs_mkfs (g, fstype, device);
15359 char device[] = "/dev/sda1";
15360 char mountpoint[] = "/";
15362 suppress_error = 0;
15363 r = guestfs_mount (g, device, mountpoint);
15367 /* TestOutput for cat (0) */
15368 char expected[] = "new file contents";
15370 char path[] = "/new";
15371 char content[] = "new file contents";
15373 suppress_error = 0;
15374 r = guestfs_write_file (g, path, content, 0);
15379 char path[] = "/new";
15381 suppress_error = 0;
15382 r = guestfs_cat (g, path);
15385 if (strcmp (r, expected) != 0) {
15386 fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
15394 static int test_touch_0_skip (void)
15398 str = getenv ("SKIP_TEST_TOUCH_0");
15399 if (str && strcmp (str, "1") == 0) return 1;
15400 str = getenv ("SKIP_TEST_TOUCH");
15401 if (str && strcmp (str, "1") == 0) return 1;
15405 static int test_touch_0 (void)
15407 if (test_touch_0_skip ()) {
15408 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_touch_0");
15412 /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
15414 char device[] = "/dev/sda";
15416 suppress_error = 0;
15417 r = guestfs_blockdev_setrw (g, device);
15423 suppress_error = 0;
15424 r = guestfs_umount_all (g);
15430 suppress_error = 0;
15431 r = guestfs_lvm_remove_all (g);
15436 char device[] = "/dev/sda";
15437 char lines_0[] = ",";
15443 suppress_error = 0;
15444 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15449 char fstype[] = "ext2";
15450 char device[] = "/dev/sda1";
15452 suppress_error = 0;
15453 r = guestfs_mkfs (g, fstype, device);
15458 char device[] = "/dev/sda1";
15459 char mountpoint[] = "/";
15461 suppress_error = 0;
15462 r = guestfs_mount (g, device, mountpoint);
15466 /* TestOutputTrue for touch (0) */
15468 char path[] = "/new";
15470 suppress_error = 0;
15471 r = guestfs_touch (g, path);
15476 char path[] = "/new";
15478 suppress_error = 0;
15479 r = guestfs_exists (g, path);
15483 fprintf (stderr, "test_touch_0: expected true, got false\n");
15490 static int test_sync_0_skip (void)
15494 str = getenv ("SKIP_TEST_SYNC_0");
15495 if (str && strcmp (str, "1") == 0) return 1;
15496 str = getenv ("SKIP_TEST_SYNC");
15497 if (str && strcmp (str, "1") == 0) return 1;
15501 static int test_sync_0 (void)
15503 if (test_sync_0_skip ()) {
15504 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sync_0");
15508 /* InitNone|InitEmpty for test_sync_0 */
15510 char device[] = "/dev/sda";
15512 suppress_error = 0;
15513 r = guestfs_blockdev_setrw (g, device);
15519 suppress_error = 0;
15520 r = guestfs_umount_all (g);
15526 suppress_error = 0;
15527 r = guestfs_lvm_remove_all (g);
15531 /* TestRun for sync (0) */
15534 suppress_error = 0;
15535 r = guestfs_sync (g);
15542 static int test_mount_0_skip (void)
15546 str = getenv ("SKIP_TEST_MOUNT_0");
15547 if (str && strcmp (str, "1") == 0) return 1;
15548 str = getenv ("SKIP_TEST_MOUNT");
15549 if (str && strcmp (str, "1") == 0) return 1;
15553 static int test_mount_0 (void)
15555 if (test_mount_0_skip ()) {
15556 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_0");
15560 /* InitNone|InitEmpty for test_mount_0 */
15562 char device[] = "/dev/sda";
15564 suppress_error = 0;
15565 r = guestfs_blockdev_setrw (g, device);
15571 suppress_error = 0;
15572 r = guestfs_umount_all (g);
15578 suppress_error = 0;
15579 r = guestfs_lvm_remove_all (g);
15583 /* TestOutput for mount (0) */
15584 char expected[] = "new file contents";
15586 char device[] = "/dev/sda";
15587 char lines_0[] = ",";
15593 suppress_error = 0;
15594 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15599 char fstype[] = "ext2";
15600 char device[] = "/dev/sda1";
15602 suppress_error = 0;
15603 r = guestfs_mkfs (g, fstype, device);
15608 char device[] = "/dev/sda1";
15609 char mountpoint[] = "/";
15611 suppress_error = 0;
15612 r = guestfs_mount (g, device, mountpoint);
15617 char path[] = "/new";
15618 char content[] = "new file contents";
15620 suppress_error = 0;
15621 r = guestfs_write_file (g, path, content, 0);
15626 char path[] = "/new";
15628 suppress_error = 0;
15629 r = guestfs_cat (g, path);
15632 if (strcmp (r, expected) != 0) {
15633 fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
15641 int main (int argc, char *argv[])
15645 const char *filename;
15647 int nr_tests, test_num = 0;
15649 no_test_warnings ();
15651 g = guestfs_create ();
15653 printf ("guestfs_create FAILED\n");
15657 guestfs_set_error_handler (g, print_error, NULL);
15659 guestfs_set_path (g, "../appliance");
15661 filename = "test1.img";
15662 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
15667 if (lseek (fd, 524288000, SEEK_SET) == -1) {
15673 if (write (fd, &c, 1) == -1) {
15679 if (close (fd) == -1) {
15684 if (guestfs_add_drive (g, filename) == -1) {
15685 printf ("guestfs_add_drive %s FAILED\n", filename);
15689 filename = "test2.img";
15690 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
15695 if (lseek (fd, 52428800, SEEK_SET) == -1) {
15701 if (write (fd, &c, 1) == -1) {
15707 if (close (fd) == -1) {
15712 if (guestfs_add_drive (g, filename) == -1) {
15713 printf ("guestfs_add_drive %s FAILED\n", filename);
15717 filename = "test3.img";
15718 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
15723 if (lseek (fd, 10485760, SEEK_SET) == -1) {
15729 if (write (fd, &c, 1) == -1) {
15735 if (close (fd) == -1) {
15740 if (guestfs_add_drive (g, filename) == -1) {
15741 printf ("guestfs_add_drive %s FAILED\n", filename);
15745 if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
15746 printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
15750 if (guestfs_launch (g) == -1) {
15751 printf ("guestfs_launch FAILED\n");
15754 if (guestfs_wait_ready (g) == -1) {
15755 printf ("guestfs_wait_ready FAILED\n");
15762 printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
15763 if (test_ntfs_3g_probe_0 () == -1) {
15764 printf ("test_ntfs_3g_probe_0 FAILED\n");
15768 printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
15769 if (test_ntfs_3g_probe_1 () == -1) {
15770 printf ("test_ntfs_3g_probe_1 FAILED\n");
15774 printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
15775 if (test_sleep_0 () == -1) {
15776 printf ("test_sleep_0 FAILED\n");
15780 printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
15781 if (test_find_0 () == -1) {
15782 printf ("test_find_0 FAILED\n");
15786 printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
15787 if (test_find_1 () == -1) {
15788 printf ("test_find_1 FAILED\n");
15792 printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
15793 if (test_find_2 () == -1) {
15794 printf ("test_find_2 FAILED\n");
15798 printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
15799 if (test_lvresize_0 () == -1) {
15800 printf ("test_lvresize_0 FAILED\n");
15804 printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
15805 if (test_zerofree_0 () == -1) {
15806 printf ("test_zerofree_0 FAILED\n");
15810 printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
15811 if (test_hexdump_0 () == -1) {
15812 printf ("test_hexdump_0 FAILED\n");
15816 printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
15817 if (test_strings_e_0 () == -1) {
15818 printf ("test_strings_e_0 FAILED\n");
15822 printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
15823 if (test_strings_e_1 () == -1) {
15824 printf ("test_strings_e_1 FAILED\n");
15828 printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
15829 if (test_strings_0 () == -1) {
15830 printf ("test_strings_0 FAILED\n");
15834 printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
15835 if (test_strings_1 () == -1) {
15836 printf ("test_strings_1 FAILED\n");
15840 printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
15841 if (test_equal_0 () == -1) {
15842 printf ("test_equal_0 FAILED\n");
15846 printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
15847 if (test_equal_1 () == -1) {
15848 printf ("test_equal_1 FAILED\n");
15852 printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
15853 if (test_equal_2 () == -1) {
15854 printf ("test_equal_2 FAILED\n");
15858 printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
15859 if (test_ping_daemon_0 () == -1) {
15860 printf ("test_ping_daemon_0 FAILED\n");
15864 printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
15865 if (test_dmesg_0 () == -1) {
15866 printf ("test_dmesg_0 FAILED\n");
15870 printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
15871 if (test_drop_caches_0 () == -1) {
15872 printf ("test_drop_caches_0 FAILED\n");
15876 printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
15877 if (test_mv_0 () == -1) {
15878 printf ("test_mv_0 FAILED\n");
15882 printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
15883 if (test_mv_1 () == -1) {
15884 printf ("test_mv_1 FAILED\n");
15888 printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
15889 if (test_cp_a_0 () == -1) {
15890 printf ("test_cp_a_0 FAILED\n");
15894 printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
15895 if (test_cp_0 () == -1) {
15896 printf ("test_cp_0 FAILED\n");
15900 printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
15901 if (test_cp_1 () == -1) {
15902 printf ("test_cp_1 FAILED\n");
15906 printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
15907 if (test_cp_2 () == -1) {
15908 printf ("test_cp_2 FAILED\n");
15912 printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
15913 if (test_grub_install_0 () == -1) {
15914 printf ("test_grub_install_0 FAILED\n");
15918 printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
15919 if (test_zero_0 () == -1) {
15920 printf ("test_zero_0 FAILED\n");
15924 printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
15925 if (test_fsck_0 () == -1) {
15926 printf ("test_fsck_0 FAILED\n");
15930 printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
15931 if (test_fsck_1 () == -1) {
15932 printf ("test_fsck_1 FAILED\n");
15936 printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
15937 if (test_set_e2uuid_0 () == -1) {
15938 printf ("test_set_e2uuid_0 FAILED\n");
15942 printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
15943 if (test_set_e2uuid_1 () == -1) {
15944 printf ("test_set_e2uuid_1 FAILED\n");
15948 printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
15949 if (test_set_e2uuid_2 () == -1) {
15950 printf ("test_set_e2uuid_2 FAILED\n");
15954 printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
15955 if (test_set_e2uuid_3 () == -1) {
15956 printf ("test_set_e2uuid_3 FAILED\n");
15960 printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
15961 if (test_set_e2label_0 () == -1) {
15962 printf ("test_set_e2label_0 FAILED\n");
15966 printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
15967 if (test_pvremove_0 () == -1) {
15968 printf ("test_pvremove_0 FAILED\n");
15972 printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
15973 if (test_pvremove_1 () == -1) {
15974 printf ("test_pvremove_1 FAILED\n");
15978 printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
15979 if (test_pvremove_2 () == -1) {
15980 printf ("test_pvremove_2 FAILED\n");
15984 printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
15985 if (test_vgremove_0 () == -1) {
15986 printf ("test_vgremove_0 FAILED\n");
15990 printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
15991 if (test_vgremove_1 () == -1) {
15992 printf ("test_vgremove_1 FAILED\n");
15996 printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
15997 if (test_lvremove_0 () == -1) {
15998 printf ("test_lvremove_0 FAILED\n");
16002 printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
16003 if (test_lvremove_1 () == -1) {
16004 printf ("test_lvremove_1 FAILED\n");
16008 printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
16009 if (test_lvremove_2 () == -1) {
16010 printf ("test_lvremove_2 FAILED\n");
16014 printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
16015 if (test_mount_ro_0 () == -1) {
16016 printf ("test_mount_ro_0 FAILED\n");
16020 printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
16021 if (test_mount_ro_1 () == -1) {
16022 printf ("test_mount_ro_1 FAILED\n");
16026 printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
16027 if (test_tgz_in_0 () == -1) {
16028 printf ("test_tgz_in_0 FAILED\n");
16032 printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
16033 if (test_tar_in_0 () == -1) {
16034 printf ("test_tar_in_0 FAILED\n");
16038 printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
16039 if (test_checksum_0 () == -1) {
16040 printf ("test_checksum_0 FAILED\n");
16044 printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
16045 if (test_checksum_1 () == -1) {
16046 printf ("test_checksum_1 FAILED\n");
16050 printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
16051 if (test_checksum_2 () == -1) {
16052 printf ("test_checksum_2 FAILED\n");
16056 printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
16057 if (test_checksum_3 () == -1) {
16058 printf ("test_checksum_3 FAILED\n");
16062 printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
16063 if (test_checksum_4 () == -1) {
16064 printf ("test_checksum_4 FAILED\n");
16068 printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
16069 if (test_checksum_5 () == -1) {
16070 printf ("test_checksum_5 FAILED\n");
16074 printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
16075 if (test_checksum_6 () == -1) {
16076 printf ("test_checksum_6 FAILED\n");
16080 printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
16081 if (test_checksum_7 () == -1) {
16082 printf ("test_checksum_7 FAILED\n");
16086 printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
16087 if (test_checksum_8 () == -1) {
16088 printf ("test_checksum_8 FAILED\n");
16092 printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
16093 if (test_download_0 () == -1) {
16094 printf ("test_download_0 FAILED\n");
16098 printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
16099 if (test_upload_0 () == -1) {
16100 printf ("test_upload_0 FAILED\n");
16104 printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
16105 if (test_blockdev_rereadpt_0 () == -1) {
16106 printf ("test_blockdev_rereadpt_0 FAILED\n");
16110 printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
16111 if (test_blockdev_flushbufs_0 () == -1) {
16112 printf ("test_blockdev_flushbufs_0 FAILED\n");
16116 printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
16117 if (test_blockdev_getsize64_0 () == -1) {
16118 printf ("test_blockdev_getsize64_0 FAILED\n");
16122 printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
16123 if (test_blockdev_getsz_0 () == -1) {
16124 printf ("test_blockdev_getsz_0 FAILED\n");
16128 printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
16129 if (test_blockdev_getbsz_0 () == -1) {
16130 printf ("test_blockdev_getbsz_0 FAILED\n");
16134 printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
16135 if (test_blockdev_getss_0 () == -1) {
16136 printf ("test_blockdev_getss_0 FAILED\n");
16140 printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
16141 if (test_blockdev_getro_0 () == -1) {
16142 printf ("test_blockdev_getro_0 FAILED\n");
16146 printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
16147 if (test_blockdev_setrw_0 () == -1) {
16148 printf ("test_blockdev_setrw_0 FAILED\n");
16152 printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
16153 if (test_blockdev_setro_0 () == -1) {
16154 printf ("test_blockdev_setro_0 FAILED\n");
16158 printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
16159 if (test_statvfs_0 () == -1) {
16160 printf ("test_statvfs_0 FAILED\n");
16164 printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
16165 if (test_lstat_0 () == -1) {
16166 printf ("test_lstat_0 FAILED\n");
16170 printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
16171 if (test_stat_0 () == -1) {
16172 printf ("test_stat_0 FAILED\n");
16176 printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
16177 if (test_command_lines_0 () == -1) {
16178 printf ("test_command_lines_0 FAILED\n");
16182 printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
16183 if (test_command_lines_1 () == -1) {
16184 printf ("test_command_lines_1 FAILED\n");
16188 printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
16189 if (test_command_lines_2 () == -1) {
16190 printf ("test_command_lines_2 FAILED\n");
16194 printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
16195 if (test_command_lines_3 () == -1) {
16196 printf ("test_command_lines_3 FAILED\n");
16200 printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
16201 if (test_command_lines_4 () == -1) {
16202 printf ("test_command_lines_4 FAILED\n");
16206 printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
16207 if (test_command_lines_5 () == -1) {
16208 printf ("test_command_lines_5 FAILED\n");
16212 printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
16213 if (test_command_lines_6 () == -1) {
16214 printf ("test_command_lines_6 FAILED\n");
16218 printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
16219 if (test_command_lines_7 () == -1) {
16220 printf ("test_command_lines_7 FAILED\n");
16224 printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
16225 if (test_command_lines_8 () == -1) {
16226 printf ("test_command_lines_8 FAILED\n");
16230 printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
16231 if (test_command_lines_9 () == -1) {
16232 printf ("test_command_lines_9 FAILED\n");
16236 printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
16237 if (test_command_lines_10 () == -1) {
16238 printf ("test_command_lines_10 FAILED\n");
16242 printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
16243 if (test_command_0 () == -1) {
16244 printf ("test_command_0 FAILED\n");
16248 printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
16249 if (test_command_1 () == -1) {
16250 printf ("test_command_1 FAILED\n");
16254 printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
16255 if (test_command_2 () == -1) {
16256 printf ("test_command_2 FAILED\n");
16260 printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
16261 if (test_command_3 () == -1) {
16262 printf ("test_command_3 FAILED\n");
16266 printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
16267 if (test_command_4 () == -1) {
16268 printf ("test_command_4 FAILED\n");
16272 printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
16273 if (test_command_5 () == -1) {
16274 printf ("test_command_5 FAILED\n");
16278 printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
16279 if (test_command_6 () == -1) {
16280 printf ("test_command_6 FAILED\n");
16284 printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
16285 if (test_command_7 () == -1) {
16286 printf ("test_command_7 FAILED\n");
16290 printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
16291 if (test_command_8 () == -1) {
16292 printf ("test_command_8 FAILED\n");
16296 printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
16297 if (test_command_9 () == -1) {
16298 printf ("test_command_9 FAILED\n");
16302 printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
16303 if (test_command_10 () == -1) {
16304 printf ("test_command_10 FAILED\n");
16308 printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
16309 if (test_command_11 () == -1) {
16310 printf ("test_command_11 FAILED\n");
16314 printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
16315 if (test_file_0 () == -1) {
16316 printf ("test_file_0 FAILED\n");
16320 printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
16321 if (test_file_1 () == -1) {
16322 printf ("test_file_1 FAILED\n");
16326 printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
16327 if (test_file_2 () == -1) {
16328 printf ("test_file_2 FAILED\n");
16332 printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
16333 if (test_umount_all_0 () == -1) {
16334 printf ("test_umount_all_0 FAILED\n");
16338 printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
16339 if (test_umount_all_1 () == -1) {
16340 printf ("test_umount_all_1 FAILED\n");
16344 printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
16345 if (test_mounts_0 () == -1) {
16346 printf ("test_mounts_0 FAILED\n");
16350 printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
16351 if (test_umount_0 () == -1) {
16352 printf ("test_umount_0 FAILED\n");
16356 printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
16357 if (test_umount_1 () == -1) {
16358 printf ("test_umount_1 FAILED\n");
16362 printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
16363 if (test_write_file_0 () == -1) {
16364 printf ("test_write_file_0 FAILED\n");
16368 printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
16369 if (test_write_file_1 () == -1) {
16370 printf ("test_write_file_1 FAILED\n");
16374 printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
16375 if (test_write_file_2 () == -1) {
16376 printf ("test_write_file_2 FAILED\n");
16380 printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
16381 if (test_write_file_3 () == -1) {
16382 printf ("test_write_file_3 FAILED\n");
16386 printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
16387 if (test_write_file_4 () == -1) {
16388 printf ("test_write_file_4 FAILED\n");
16392 printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
16393 if (test_write_file_5 () == -1) {
16394 printf ("test_write_file_5 FAILED\n");
16398 printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
16399 if (test_mkfs_0 () == -1) {
16400 printf ("test_mkfs_0 FAILED\n");
16404 printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
16405 if (test_lvcreate_0 () == -1) {
16406 printf ("test_lvcreate_0 FAILED\n");
16410 printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
16411 if (test_vgcreate_0 () == -1) {
16412 printf ("test_vgcreate_0 FAILED\n");
16416 printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
16417 if (test_pvcreate_0 () == -1) {
16418 printf ("test_pvcreate_0 FAILED\n");
16422 printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
16423 if (test_is_dir_0 () == -1) {
16424 printf ("test_is_dir_0 FAILED\n");
16428 printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
16429 if (test_is_dir_1 () == -1) {
16430 printf ("test_is_dir_1 FAILED\n");
16434 printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
16435 if (test_is_file_0 () == -1) {
16436 printf ("test_is_file_0 FAILED\n");
16440 printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
16441 if (test_is_file_1 () == -1) {
16442 printf ("test_is_file_1 FAILED\n");
16446 printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
16447 if (test_exists_0 () == -1) {
16448 printf ("test_exists_0 FAILED\n");
16452 printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
16453 if (test_exists_1 () == -1) {
16454 printf ("test_exists_1 FAILED\n");
16458 printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
16459 if (test_mkdir_p_0 () == -1) {
16460 printf ("test_mkdir_p_0 FAILED\n");
16464 printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
16465 if (test_mkdir_p_1 () == -1) {
16466 printf ("test_mkdir_p_1 FAILED\n");
16470 printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
16471 if (test_mkdir_p_2 () == -1) {
16472 printf ("test_mkdir_p_2 FAILED\n");
16476 printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
16477 if (test_mkdir_p_3 () == -1) {
16478 printf ("test_mkdir_p_3 FAILED\n");
16482 printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
16483 if (test_mkdir_p_4 () == -1) {
16484 printf ("test_mkdir_p_4 FAILED\n");
16488 printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
16489 if (test_mkdir_0 () == -1) {
16490 printf ("test_mkdir_0 FAILED\n");
16494 printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
16495 if (test_mkdir_1 () == -1) {
16496 printf ("test_mkdir_1 FAILED\n");
16500 printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
16501 if (test_rm_rf_0 () == -1) {
16502 printf ("test_rm_rf_0 FAILED\n");
16506 printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
16507 if (test_rmdir_0 () == -1) {
16508 printf ("test_rmdir_0 FAILED\n");
16512 printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
16513 if (test_rmdir_1 () == -1) {
16514 printf ("test_rmdir_1 FAILED\n");
16518 printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
16519 if (test_rmdir_2 () == -1) {
16520 printf ("test_rmdir_2 FAILED\n");
16524 printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
16525 if (test_rm_0 () == -1) {
16526 printf ("test_rm_0 FAILED\n");
16530 printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
16531 if (test_rm_1 () == -1) {
16532 printf ("test_rm_1 FAILED\n");
16536 printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
16537 if (test_rm_2 () == -1) {
16538 printf ("test_rm_2 FAILED\n");
16542 printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
16543 if (test_read_lines_0 () == -1) {
16544 printf ("test_read_lines_0 FAILED\n");
16548 printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
16549 if (test_read_lines_1 () == -1) {
16550 printf ("test_read_lines_1 FAILED\n");
16554 printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
16555 if (test_lvs_0 () == -1) {
16556 printf ("test_lvs_0 FAILED\n");
16560 printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
16561 if (test_lvs_1 () == -1) {
16562 printf ("test_lvs_1 FAILED\n");
16566 printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
16567 if (test_vgs_0 () == -1) {
16568 printf ("test_vgs_0 FAILED\n");
16572 printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
16573 if (test_vgs_1 () == -1) {
16574 printf ("test_vgs_1 FAILED\n");
16578 printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
16579 if (test_pvs_0 () == -1) {
16580 printf ("test_pvs_0 FAILED\n");
16584 printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
16585 if (test_pvs_1 () == -1) {
16586 printf ("test_pvs_1 FAILED\n");
16590 printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
16591 if (test_list_partitions_0 () == -1) {
16592 printf ("test_list_partitions_0 FAILED\n");
16596 printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
16597 if (test_list_partitions_1 () == -1) {
16598 printf ("test_list_partitions_1 FAILED\n");
16602 printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
16603 if (test_list_devices_0 () == -1) {
16604 printf ("test_list_devices_0 FAILED\n");
16608 printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
16609 if (test_ls_0 () == -1) {
16610 printf ("test_ls_0 FAILED\n");
16614 printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
16615 if (test_cat_0 () == -1) {
16616 printf ("test_cat_0 FAILED\n");
16620 printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
16621 if (test_touch_0 () == -1) {
16622 printf ("test_touch_0 FAILED\n");
16626 printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
16627 if (test_sync_0 () == -1) {
16628 printf ("test_sync_0 FAILED\n");
16632 printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
16633 if (test_mount_0 () == -1) {
16634 printf ("test_mount_0 FAILED\n");
16639 unlink ("test1.img");
16640 unlink ("test2.img");
16641 unlink ("test3.img");
16644 printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);