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 /* This will be 's' or 'h' depending on whether the guest kernel
35 * names IDE devices /dev/sd* or /dev/hd*.
37 static char devchar = 's';
39 static void print_error (guestfs_h *g, void *data, const char *msg)
42 fprintf (stderr, "%s\n", msg);
45 static void print_strings (char * const * const argv)
49 for (argc = 0; argv[argc] != NULL; ++argc)
50 printf ("\t%s\n", argv[argc]);
54 static void print_table (char * const * const argv)
58 for (i = 0; argv[i] != NULL; i += 2)
59 printf ("%s: %s\n", argv[i], argv[i+1]);
63 static void no_test_warnings (void)
65 fprintf (stderr, "warning: \"guestfs_test0\" has no tests\n");
66 fprintf (stderr, "warning: \"guestfs_test0rint\" has no tests\n");
67 fprintf (stderr, "warning: \"guestfs_test0rinterr\" has no tests\n");
68 fprintf (stderr, "warning: \"guestfs_test0rint64\" has no tests\n");
69 fprintf (stderr, "warning: \"guestfs_test0rint64err\" has no tests\n");
70 fprintf (stderr, "warning: \"guestfs_test0rbool\" has no tests\n");
71 fprintf (stderr, "warning: \"guestfs_test0rboolerr\" has no tests\n");
72 fprintf (stderr, "warning: \"guestfs_test0rconststring\" has no tests\n");
73 fprintf (stderr, "warning: \"guestfs_test0rconststringerr\" has no tests\n");
74 fprintf (stderr, "warning: \"guestfs_test0rstring\" has no tests\n");
75 fprintf (stderr, "warning: \"guestfs_test0rstringerr\" has no tests\n");
76 fprintf (stderr, "warning: \"guestfs_test0rstringlist\" has no tests\n");
77 fprintf (stderr, "warning: \"guestfs_test0rstringlisterr\" has no tests\n");
78 fprintf (stderr, "warning: \"guestfs_test0rintbool\" has no tests\n");
79 fprintf (stderr, "warning: \"guestfs_test0rintboolerr\" has no tests\n");
80 fprintf (stderr, "warning: \"guestfs_test0rpvlist\" has no tests\n");
81 fprintf (stderr, "warning: \"guestfs_test0rpvlisterr\" has no tests\n");
82 fprintf (stderr, "warning: \"guestfs_test0rvglist\" has no tests\n");
83 fprintf (stderr, "warning: \"guestfs_test0rvglisterr\" has no tests\n");
84 fprintf (stderr, "warning: \"guestfs_test0rlvlist\" has no tests\n");
85 fprintf (stderr, "warning: \"guestfs_test0rlvlisterr\" has no tests\n");
86 fprintf (stderr, "warning: \"guestfs_test0rstat\" has no tests\n");
87 fprintf (stderr, "warning: \"guestfs_test0rstaterr\" has no tests\n");
88 fprintf (stderr, "warning: \"guestfs_test0rstatvfs\" has no tests\n");
89 fprintf (stderr, "warning: \"guestfs_test0rstatvfserr\" has no tests\n");
90 fprintf (stderr, "warning: \"guestfs_test0rhashtable\" has no tests\n");
91 fprintf (stderr, "warning: \"guestfs_test0rhashtableerr\" has no tests\n");
92 fprintf (stderr, "warning: \"guestfs_launch\" has no tests\n");
93 fprintf (stderr, "warning: \"guestfs_wait_ready\" has no tests\n");
94 fprintf (stderr, "warning: \"guestfs_kill_subprocess\" has no tests\n");
95 fprintf (stderr, "warning: \"guestfs_add_drive\" has no tests\n");
96 fprintf (stderr, "warning: \"guestfs_add_cdrom\" has no tests\n");
97 fprintf (stderr, "warning: \"guestfs_add_drive_ro\" has no tests\n");
98 fprintf (stderr, "warning: \"guestfs_config\" has no tests\n");
99 fprintf (stderr, "warning: \"guestfs_set_qemu\" has no tests\n");
100 fprintf (stderr, "warning: \"guestfs_get_qemu\" has no tests\n");
101 fprintf (stderr, "warning: \"guestfs_set_path\" has no tests\n");
102 fprintf (stderr, "warning: \"guestfs_get_path\" has no tests\n");
103 fprintf (stderr, "warning: \"guestfs_set_append\" has no tests\n");
104 fprintf (stderr, "warning: \"guestfs_get_append\" has no tests\n");
105 fprintf (stderr, "warning: \"guestfs_set_autosync\" has no tests\n");
106 fprintf (stderr, "warning: \"guestfs_get_autosync\" has no tests\n");
107 fprintf (stderr, "warning: \"guestfs_set_verbose\" has no tests\n");
108 fprintf (stderr, "warning: \"guestfs_get_verbose\" has no tests\n");
109 fprintf (stderr, "warning: \"guestfs_is_ready\" has no tests\n");
110 fprintf (stderr, "warning: \"guestfs_is_config\" has no tests\n");
111 fprintf (stderr, "warning: \"guestfs_is_launching\" has no tests\n");
112 fprintf (stderr, "warning: \"guestfs_is_busy\" has no tests\n");
113 fprintf (stderr, "warning: \"guestfs_get_state\" has no tests\n");
114 fprintf (stderr, "warning: \"guestfs_set_busy\" has no tests\n");
115 fprintf (stderr, "warning: \"guestfs_set_ready\" has no tests\n");
116 fprintf (stderr, "warning: \"guestfs_end_busy\" has no tests\n");
117 fprintf (stderr, "warning: \"guestfs_ll\" has no tests\n");
118 fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n");
119 fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n");
120 fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n");
121 fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n");
122 fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n");
123 fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n");
124 fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n");
125 fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n");
126 fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n");
127 fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n");
128 fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n");
129 fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n");
130 fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n");
131 fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n");
132 fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n");
133 fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n");
134 fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n");
135 fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n");
136 fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n");
137 fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n");
138 fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n");
139 fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n");
140 fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n");
141 fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n");
142 fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n");
143 fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n");
144 fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n");
145 fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n");
146 fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n");
147 fprintf (stderr, "warning: \"guestfs_pvresize\" has no tests\n");
148 fprintf (stderr, "warning: \"guestfs_sfdisk_N\" has no tests\n");
149 fprintf (stderr, "warning: \"guestfs_sfdisk_l\" has no tests\n");
150 fprintf (stderr, "warning: \"guestfs_sfdisk_kernel_geometry\" has no tests\n");
151 fprintf (stderr, "warning: \"guestfs_sfdisk_disk_geometry\" has no tests\n");
152 fprintf (stderr, "warning: \"guestfs_vg_activate_all\" has no tests\n");
153 fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n");
154 fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n");
155 fprintf (stderr, "warning: \"guestfs_e2fsck_f\" has no tests\n");
158 static int test_ntfs_3g_probe_0_skip (void)
162 str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0");
163 if (str && strcmp (str, "1") == 0) return 1;
164 str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
165 if (str && strcmp (str, "1") == 0) return 1;
169 static int test_ntfs_3g_probe_0 (void)
171 if (test_ntfs_3g_probe_0_skip ()) {
172 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ntfs_3g_probe_0");
176 /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
178 char device[] = "/dev/sda";
182 r = guestfs_blockdev_setrw (g, device);
189 r = guestfs_umount_all (g);
196 r = guestfs_lvm_remove_all (g);
200 /* TestOutputInt for ntfs_3g_probe (0) */
202 char device[] = "/dev/sda";
204 char lines_0[] = ",";
211 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
216 char fstype[] = "ntfs";
217 char device[] = "/dev/sda1";
221 r = guestfs_mkfs (g, fstype, device);
226 char device[] = "/dev/sda1";
230 r = guestfs_ntfs_3g_probe (g, 1, device);
234 fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n", (int) r);
241 static int test_ntfs_3g_probe_1_skip (void)
245 str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
246 if (str && strcmp (str, "1") == 0) return 1;
247 str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
248 if (str && strcmp (str, "1") == 0) return 1;
252 static int test_ntfs_3g_probe_1 (void)
254 if (test_ntfs_3g_probe_1_skip ()) {
255 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ntfs_3g_probe_1");
259 /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
261 char device[] = "/dev/sda";
265 r = guestfs_blockdev_setrw (g, device);
272 r = guestfs_umount_all (g);
279 r = guestfs_lvm_remove_all (g);
283 /* TestOutputInt for ntfs_3g_probe (1) */
285 char device[] = "/dev/sda";
287 char lines_0[] = ",";
294 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
299 char fstype[] = "ext2";
300 char device[] = "/dev/sda1";
304 r = guestfs_mkfs (g, fstype, device);
309 char device[] = "/dev/sda1";
313 r = guestfs_ntfs_3g_probe (g, 1, device);
317 fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n", (int) r);
324 static int test_sleep_0_skip (void)
328 str = getenv ("SKIP_TEST_SLEEP_0");
329 if (str && strcmp (str, "1") == 0) return 1;
330 str = getenv ("SKIP_TEST_SLEEP");
331 if (str && strcmp (str, "1") == 0) return 1;
335 static int test_sleep_0 (void)
337 if (test_sleep_0_skip ()) {
338 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sleep_0");
342 /* InitNone|InitEmpty for test_sleep_0 */
344 char device[] = "/dev/sda";
348 r = guestfs_blockdev_setrw (g, device);
355 r = guestfs_umount_all (g);
362 r = guestfs_lvm_remove_all (g);
366 /* TestRun for sleep (0) */
370 r = guestfs_sleep (g, 1);
377 static int test_find_0_skip (void)
381 str = getenv ("SKIP_TEST_FIND_0");
382 if (str && strcmp (str, "1") == 0) return 1;
383 str = getenv ("SKIP_TEST_FIND");
384 if (str && strcmp (str, "1") == 0) return 1;
388 static int test_find_0 (void)
390 if (test_find_0_skip ()) {
391 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_0");
395 /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
397 char device[] = "/dev/sda";
401 r = guestfs_blockdev_setrw (g, device);
408 r = guestfs_umount_all (g);
415 r = guestfs_lvm_remove_all (g);
420 char device[] = "/dev/sda";
422 char lines_0[] = ",";
429 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
434 char fstype[] = "ext2";
435 char device[] = "/dev/sda1";
439 r = guestfs_mkfs (g, fstype, device);
444 char device[] = "/dev/sda1";
446 char mountpoint[] = "/";
449 r = guestfs_mount (g, device, mountpoint);
453 /* TestOutputList for find (0) */
455 char directory[] = "/";
459 r = guestfs_find (g, directory);
463 fprintf (stderr, "test_find_0: short list returned from command\n");
468 char expected[] = "lost+found";
469 if (strcmp (r[0], expected) != 0) {
470 fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
475 fprintf (stderr, "test_find_0: extra elements returned from command\n");
479 for (i = 0; r[i] != NULL; ++i)
486 static int test_find_1_skip (void)
490 str = getenv ("SKIP_TEST_FIND_1");
491 if (str && strcmp (str, "1") == 0) return 1;
492 str = getenv ("SKIP_TEST_FIND");
493 if (str && strcmp (str, "1") == 0) return 1;
497 static int test_find_1 (void)
499 if (test_find_1_skip ()) {
500 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_1");
504 /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
506 char device[] = "/dev/sda";
510 r = guestfs_blockdev_setrw (g, device);
517 r = guestfs_umount_all (g);
524 r = guestfs_lvm_remove_all (g);
529 char device[] = "/dev/sda";
531 char lines_0[] = ",";
538 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
543 char fstype[] = "ext2";
544 char device[] = "/dev/sda1";
548 r = guestfs_mkfs (g, fstype, device);
553 char device[] = "/dev/sda1";
555 char mountpoint[] = "/";
558 r = guestfs_mount (g, device, mountpoint);
562 /* TestOutputList for find (1) */
567 r = guestfs_touch (g, path);
575 r = guestfs_mkdir (g, path);
580 char path[] = "/b/c";
583 r = guestfs_touch (g, path);
588 char directory[] = "/";
592 r = guestfs_find (g, directory);
596 fprintf (stderr, "test_find_1: short list returned from command\n");
601 char expected[] = "a";
602 if (strcmp (r[0], expected) != 0) {
603 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
608 fprintf (stderr, "test_find_1: short list returned from command\n");
613 char expected[] = "b";
614 if (strcmp (r[1], expected) != 0) {
615 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
620 fprintf (stderr, "test_find_1: short list returned from command\n");
625 char expected[] = "b/c";
626 if (strcmp (r[2], expected) != 0) {
627 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
632 fprintf (stderr, "test_find_1: short list returned from command\n");
637 char expected[] = "lost+found";
638 if (strcmp (r[3], expected) != 0) {
639 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
644 fprintf (stderr, "test_find_1: extra elements returned from command\n");
648 for (i = 0; r[i] != NULL; ++i)
655 static int test_find_2_skip (void)
659 str = getenv ("SKIP_TEST_FIND_2");
660 if (str && strcmp (str, "1") == 0) return 1;
661 str = getenv ("SKIP_TEST_FIND");
662 if (str && strcmp (str, "1") == 0) return 1;
666 static int test_find_2 (void)
668 if (test_find_2_skip ()) {
669 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_2");
673 /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
675 char device[] = "/dev/sda";
679 r = guestfs_blockdev_setrw (g, device);
686 r = guestfs_umount_all (g);
693 r = guestfs_lvm_remove_all (g);
698 char device[] = "/dev/sda";
700 char lines_0[] = ",";
707 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
712 char fstype[] = "ext2";
713 char device[] = "/dev/sda1";
717 r = guestfs_mkfs (g, fstype, device);
722 char device[] = "/dev/sda1";
724 char mountpoint[] = "/";
727 r = guestfs_mount (g, device, mountpoint);
731 /* TestOutputList for find (2) */
733 char path[] = "/a/b/c";
736 r = guestfs_mkdir_p (g, path);
741 char path[] = "/a/b/c/d";
744 r = guestfs_touch (g, path);
749 char directory[] = "/a/b/";
753 r = guestfs_find (g, directory);
757 fprintf (stderr, "test_find_2: short list returned from command\n");
762 char expected[] = "c";
763 if (strcmp (r[0], expected) != 0) {
764 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
769 fprintf (stderr, "test_find_2: short list returned from command\n");
774 char expected[] = "c/d";
775 if (strcmp (r[1], expected) != 0) {
776 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
781 fprintf (stderr, "test_find_2: extra elements returned from command\n");
785 for (i = 0; r[i] != NULL; ++i)
792 static int test_lvresize_0_skip (void)
796 str = getenv ("SKIP_TEST_LVRESIZE_0");
797 if (str && strcmp (str, "1") == 0) return 1;
798 str = getenv ("SKIP_TEST_LVRESIZE");
799 if (str && strcmp (str, "1") == 0) return 1;
803 static int test_lvresize_0 (void)
805 if (test_lvresize_0_skip ()) {
806 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvresize_0");
810 /* InitNone|InitEmpty for test_lvresize_0 */
812 char device[] = "/dev/sda";
816 r = guestfs_blockdev_setrw (g, device);
823 r = guestfs_umount_all (g);
830 r = guestfs_lvm_remove_all (g);
834 /* TestOutput for lvresize (0) */
835 char expected[] = "test content";
837 char device[] = "/dev/sda";
839 char lines_0[] = ",";
846 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
851 char device[] = "/dev/sda1";
855 r = guestfs_pvcreate (g, device);
860 char volgroup[] = "VG";
861 char physvols_0[] = "/dev/sda1";
862 physvols_0[5] = devchar;
869 r = guestfs_vgcreate (g, volgroup, physvols);
874 char logvol[] = "LV";
875 char volgroup[] = "VG";
878 r = guestfs_lvcreate (g, logvol, volgroup, 10);
883 char fstype[] = "ext2";
884 char device[] = "/dev/VG/LV";
887 r = guestfs_mkfs (g, fstype, device);
892 char device[] = "/dev/VG/LV";
893 char mountpoint[] = "/";
896 r = guestfs_mount (g, device, mountpoint);
901 char path[] = "/new";
902 char content[] = "test content";
905 r = guestfs_write_file (g, path, content, 0);
910 char pathordevice[] = "/";
913 r = guestfs_umount (g, pathordevice);
918 char device[] = "/dev/VG/LV";
921 r = guestfs_lvresize (g, device, 20);
926 char device[] = "/dev/VG/LV";
929 r = guestfs_e2fsck_f (g, device);
934 char device[] = "/dev/VG/LV";
937 r = guestfs_resize2fs (g, device);
942 char device[] = "/dev/VG/LV";
943 char mountpoint[] = "/";
946 r = guestfs_mount (g, device, mountpoint);
951 char path[] = "/new";
954 r = guestfs_cat (g, path);
957 if (strcmp (r, expected) != 0) {
958 fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
966 static int test_zerofree_0_skip (void)
970 str = getenv ("SKIP_TEST_ZEROFREE_0");
971 if (str && strcmp (str, "1") == 0) return 1;
972 str = getenv ("SKIP_TEST_ZEROFREE");
973 if (str && strcmp (str, "1") == 0) return 1;
977 static int test_zerofree_0 (void)
979 if (test_zerofree_0_skip ()) {
980 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zerofree_0");
984 /* InitNone|InitEmpty for test_zerofree_0 */
986 char device[] = "/dev/sda";
990 r = guestfs_blockdev_setrw (g, device);
997 r = guestfs_umount_all (g);
1004 r = guestfs_lvm_remove_all (g);
1008 /* TestOutput for zerofree (0) */
1009 char expected[] = "test file";
1011 char device[] = "/dev/sda";
1012 device[5] = devchar;
1013 char lines_0[] = ",";
1020 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1025 char fstype[] = "ext3";
1026 char device[] = "/dev/sda1";
1027 device[5] = devchar;
1030 r = guestfs_mkfs (g, fstype, device);
1035 char device[] = "/dev/sda1";
1036 device[5] = devchar;
1037 char mountpoint[] = "/";
1040 r = guestfs_mount (g, device, mountpoint);
1045 char path[] = "/new";
1046 char content[] = "test file";
1049 r = guestfs_write_file (g, path, content, 0);
1054 char pathordevice[] = "/dev/sda1";
1055 pathordevice[5] = devchar;
1058 r = guestfs_umount (g, pathordevice);
1063 char device[] = "/dev/sda1";
1064 device[5] = devchar;
1067 r = guestfs_zerofree (g, device);
1072 char device[] = "/dev/sda1";
1073 device[5] = devchar;
1074 char mountpoint[] = "/";
1077 r = guestfs_mount (g, device, mountpoint);
1082 char path[] = "/new";
1085 r = guestfs_cat (g, path);
1088 if (strcmp (r, expected) != 0) {
1089 fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
1097 static int test_hexdump_0_skip (void)
1101 str = getenv ("SKIP_TEST_HEXDUMP_0");
1102 if (str && strcmp (str, "1") == 0) return 1;
1103 str = getenv ("SKIP_TEST_HEXDUMP");
1104 if (str && strcmp (str, "1") == 0) return 1;
1108 static int test_hexdump_0 (void)
1110 if (test_hexdump_0_skip ()) {
1111 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_hexdump_0");
1115 /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
1117 char device[] = "/dev/sda";
1118 device[5] = devchar;
1121 r = guestfs_blockdev_setrw (g, device);
1128 r = guestfs_umount_all (g);
1135 r = guestfs_lvm_remove_all (g);
1140 char device[] = "/dev/sda";
1141 device[5] = devchar;
1142 char lines_0[] = ",";
1149 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1154 char fstype[] = "ext2";
1155 char device[] = "/dev/sda1";
1156 device[5] = devchar;
1159 r = guestfs_mkfs (g, fstype, device);
1164 char device[] = "/dev/sda1";
1165 device[5] = devchar;
1166 char mountpoint[] = "/";
1169 r = guestfs_mount (g, device, mountpoint);
1173 /* TestOutput for hexdump (0) */
1174 char expected[] = "00000000 68 65 6c 6c 6f 0a 77 6f 72 6c 64 0a |hello.world.|\n0000000c\n";
1176 char path[] = "/new";
1177 char content[] = "hello\nworld\n";
1180 r = guestfs_write_file (g, path, content, 12);
1185 char path[] = "/new";
1188 r = guestfs_hexdump (g, path);
1191 if (strcmp (r, expected) != 0) {
1192 fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
1200 static int test_strings_e_0_skip (void)
1204 str = getenv ("SKIP_TEST_STRINGS_E_0");
1205 if (str && strcmp (str, "1") == 0) return 1;
1206 str = getenv ("SKIP_TEST_STRINGS_E");
1207 if (str && strcmp (str, "1") == 0) return 1;
1211 static int test_strings_e_0 (void)
1213 if (test_strings_e_0_skip ()) {
1214 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_0");
1218 /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
1220 char device[] = "/dev/sda";
1221 device[5] = devchar;
1224 r = guestfs_blockdev_setrw (g, device);
1231 r = guestfs_umount_all (g);
1238 r = guestfs_lvm_remove_all (g);
1243 char device[] = "/dev/sda";
1244 device[5] = devchar;
1245 char lines_0[] = ",";
1252 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1257 char fstype[] = "ext2";
1258 char device[] = "/dev/sda1";
1259 device[5] = devchar;
1262 r = guestfs_mkfs (g, fstype, device);
1267 char device[] = "/dev/sda1";
1268 device[5] = devchar;
1269 char mountpoint[] = "/";
1272 r = guestfs_mount (g, device, mountpoint);
1276 /* TestOutputList for strings_e (0) */
1278 char path[] = "/new";
1279 char content[] = "hello\nworld\n";
1282 r = guestfs_write_file (g, path, content, 0);
1287 char encoding[] = "b";
1288 char path[] = "/new";
1292 r = guestfs_strings_e (g, encoding, path);
1296 fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
1300 for (i = 0; r[i] != NULL; ++i)
1307 static int test_strings_e_1_skip (void)
1311 str = getenv ("SKIP_TEST_STRINGS_E_1");
1312 if (str && strcmp (str, "1") == 0) return 1;
1313 str = getenv ("SKIP_TEST_STRINGS_E");
1314 if (str && strcmp (str, "1") == 0) return 1;
1318 static int test_strings_e_1 (void)
1320 if (test_strings_e_1_skip ()) {
1321 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_1");
1325 printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
1329 static int test_strings_0_skip (void)
1333 str = getenv ("SKIP_TEST_STRINGS_0");
1334 if (str && strcmp (str, "1") == 0) return 1;
1335 str = getenv ("SKIP_TEST_STRINGS");
1336 if (str && strcmp (str, "1") == 0) return 1;
1340 static int test_strings_0 (void)
1342 if (test_strings_0_skip ()) {
1343 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_0");
1347 /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
1349 char device[] = "/dev/sda";
1350 device[5] = devchar;
1353 r = guestfs_blockdev_setrw (g, device);
1360 r = guestfs_umount_all (g);
1367 r = guestfs_lvm_remove_all (g);
1372 char device[] = "/dev/sda";
1373 device[5] = devchar;
1374 char lines_0[] = ",";
1381 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1386 char fstype[] = "ext2";
1387 char device[] = "/dev/sda1";
1388 device[5] = devchar;
1391 r = guestfs_mkfs (g, fstype, device);
1396 char device[] = "/dev/sda1";
1397 device[5] = devchar;
1398 char mountpoint[] = "/";
1401 r = guestfs_mount (g, device, mountpoint);
1405 /* TestOutputList for strings (0) */
1407 char path[] = "/new";
1408 char content[] = "hello\nworld\n";
1411 r = guestfs_write_file (g, path, content, 0);
1416 char path[] = "/new";
1420 r = guestfs_strings (g, path);
1424 fprintf (stderr, "test_strings_0: short list returned from command\n");
1429 char expected[] = "hello";
1430 if (strcmp (r[0], expected) != 0) {
1431 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1436 fprintf (stderr, "test_strings_0: short list returned from command\n");
1441 char expected[] = "world";
1442 if (strcmp (r[1], expected) != 0) {
1443 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1448 fprintf (stderr, "test_strings_0: extra elements returned from command\n");
1452 for (i = 0; r[i] != NULL; ++i)
1459 static int test_strings_1_skip (void)
1463 str = getenv ("SKIP_TEST_STRINGS_1");
1464 if (str && strcmp (str, "1") == 0) return 1;
1465 str = getenv ("SKIP_TEST_STRINGS");
1466 if (str && strcmp (str, "1") == 0) return 1;
1470 static int test_strings_1 (void)
1472 if (test_strings_1_skip ()) {
1473 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_1");
1477 /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
1479 char device[] = "/dev/sda";
1480 device[5] = devchar;
1483 r = guestfs_blockdev_setrw (g, device);
1490 r = guestfs_umount_all (g);
1497 r = guestfs_lvm_remove_all (g);
1502 char device[] = "/dev/sda";
1503 device[5] = devchar;
1504 char lines_0[] = ",";
1511 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1516 char fstype[] = "ext2";
1517 char device[] = "/dev/sda1";
1518 device[5] = devchar;
1521 r = guestfs_mkfs (g, fstype, device);
1526 char device[] = "/dev/sda1";
1527 device[5] = devchar;
1528 char mountpoint[] = "/";
1531 r = guestfs_mount (g, device, mountpoint);
1535 /* TestOutputList for strings (1) */
1537 char path[] = "/new";
1540 r = guestfs_touch (g, path);
1545 char path[] = "/new";
1549 r = guestfs_strings (g, path);
1553 fprintf (stderr, "test_strings_1: extra elements returned from command\n");
1557 for (i = 0; r[i] != NULL; ++i)
1564 static int test_equal_0_skip (void)
1568 str = getenv ("SKIP_TEST_EQUAL_0");
1569 if (str && strcmp (str, "1") == 0) return 1;
1570 str = getenv ("SKIP_TEST_EQUAL");
1571 if (str && strcmp (str, "1") == 0) return 1;
1575 static int test_equal_0 (void)
1577 if (test_equal_0_skip ()) {
1578 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_0");
1582 /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
1584 char device[] = "/dev/sda";
1585 device[5] = devchar;
1588 r = guestfs_blockdev_setrw (g, device);
1595 r = guestfs_umount_all (g);
1602 r = guestfs_lvm_remove_all (g);
1607 char device[] = "/dev/sda";
1608 device[5] = devchar;
1609 char lines_0[] = ",";
1616 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1621 char fstype[] = "ext2";
1622 char device[] = "/dev/sda1";
1623 device[5] = devchar;
1626 r = guestfs_mkfs (g, fstype, device);
1631 char device[] = "/dev/sda1";
1632 device[5] = devchar;
1633 char mountpoint[] = "/";
1636 r = guestfs_mount (g, device, mountpoint);
1640 /* TestOutputTrue for equal (0) */
1642 char path[] = "/file1";
1643 char content[] = "contents of a file";
1646 r = guestfs_write_file (g, path, content, 0);
1651 char src[] = "/file1";
1652 char dest[] = "/file2";
1655 r = guestfs_cp (g, src, dest);
1660 char file1[] = "/file1";
1661 char file2[] = "/file2";
1664 r = guestfs_equal (g, file1, file2);
1668 fprintf (stderr, "test_equal_0: expected true, got false\n");
1675 static int test_equal_1_skip (void)
1679 str = getenv ("SKIP_TEST_EQUAL_1");
1680 if (str && strcmp (str, "1") == 0) return 1;
1681 str = getenv ("SKIP_TEST_EQUAL");
1682 if (str && strcmp (str, "1") == 0) return 1;
1686 static int test_equal_1 (void)
1688 if (test_equal_1_skip ()) {
1689 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_1");
1693 /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
1695 char device[] = "/dev/sda";
1696 device[5] = devchar;
1699 r = guestfs_blockdev_setrw (g, device);
1706 r = guestfs_umount_all (g);
1713 r = guestfs_lvm_remove_all (g);
1718 char device[] = "/dev/sda";
1719 device[5] = devchar;
1720 char lines_0[] = ",";
1727 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1732 char fstype[] = "ext2";
1733 char device[] = "/dev/sda1";
1734 device[5] = devchar;
1737 r = guestfs_mkfs (g, fstype, device);
1742 char device[] = "/dev/sda1";
1743 device[5] = devchar;
1744 char mountpoint[] = "/";
1747 r = guestfs_mount (g, device, mountpoint);
1751 /* TestOutputFalse for equal (1) */
1753 char path[] = "/file1";
1754 char content[] = "contents of a file";
1757 r = guestfs_write_file (g, path, content, 0);
1762 char path[] = "/file2";
1763 char content[] = "contents of another file";
1766 r = guestfs_write_file (g, path, content, 0);
1771 char file1[] = "/file1";
1772 char file2[] = "/file2";
1775 r = guestfs_equal (g, file1, file2);
1779 fprintf (stderr, "test_equal_1: expected false, got true\n");
1786 static int test_equal_2_skip (void)
1790 str = getenv ("SKIP_TEST_EQUAL_2");
1791 if (str && strcmp (str, "1") == 0) return 1;
1792 str = getenv ("SKIP_TEST_EQUAL");
1793 if (str && strcmp (str, "1") == 0) return 1;
1797 static int test_equal_2 (void)
1799 if (test_equal_2_skip ()) {
1800 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_2");
1804 /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
1806 char device[] = "/dev/sda";
1807 device[5] = devchar;
1810 r = guestfs_blockdev_setrw (g, device);
1817 r = guestfs_umount_all (g);
1824 r = guestfs_lvm_remove_all (g);
1829 char device[] = "/dev/sda";
1830 device[5] = devchar;
1831 char lines_0[] = ",";
1838 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1843 char fstype[] = "ext2";
1844 char device[] = "/dev/sda1";
1845 device[5] = devchar;
1848 r = guestfs_mkfs (g, fstype, device);
1853 char device[] = "/dev/sda1";
1854 device[5] = devchar;
1855 char mountpoint[] = "/";
1858 r = guestfs_mount (g, device, mountpoint);
1862 /* TestLastFail for equal (2) */
1864 char file1[] = "/file1";
1865 char file2[] = "/file2";
1868 r = guestfs_equal (g, file1, file2);
1875 static int test_ping_daemon_0_skip (void)
1879 str = getenv ("SKIP_TEST_PING_DAEMON_0");
1880 if (str && strcmp (str, "1") == 0) return 1;
1881 str = getenv ("SKIP_TEST_PING_DAEMON");
1882 if (str && strcmp (str, "1") == 0) return 1;
1886 static int test_ping_daemon_0 (void)
1888 if (test_ping_daemon_0_skip ()) {
1889 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ping_daemon_0");
1893 /* InitNone|InitEmpty for test_ping_daemon_0 */
1895 char device[] = "/dev/sda";
1896 device[5] = devchar;
1899 r = guestfs_blockdev_setrw (g, device);
1906 r = guestfs_umount_all (g);
1913 r = guestfs_lvm_remove_all (g);
1917 /* TestRun for ping_daemon (0) */
1921 r = guestfs_ping_daemon (g);
1928 static int test_dmesg_0_skip (void)
1932 str = getenv ("SKIP_TEST_DMESG_0");
1933 if (str && strcmp (str, "1") == 0) return 1;
1934 str = getenv ("SKIP_TEST_DMESG");
1935 if (str && strcmp (str, "1") == 0) return 1;
1939 static int test_dmesg_0 (void)
1941 if (test_dmesg_0_skip ()) {
1942 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_dmesg_0");
1946 /* InitNone|InitEmpty for test_dmesg_0 */
1948 char device[] = "/dev/sda";
1949 device[5] = devchar;
1952 r = guestfs_blockdev_setrw (g, device);
1959 r = guestfs_umount_all (g);
1966 r = guestfs_lvm_remove_all (g);
1970 /* TestRun for dmesg (0) */
1974 r = guestfs_dmesg (g);
1982 static int test_drop_caches_0_skip (void)
1986 str = getenv ("SKIP_TEST_DROP_CACHES_0");
1987 if (str && strcmp (str, "1") == 0) return 1;
1988 str = getenv ("SKIP_TEST_DROP_CACHES");
1989 if (str && strcmp (str, "1") == 0) return 1;
1993 static int test_drop_caches_0 (void)
1995 if (test_drop_caches_0_skip ()) {
1996 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_drop_caches_0");
2000 /* InitNone|InitEmpty for test_drop_caches_0 */
2002 char device[] = "/dev/sda";
2003 device[5] = devchar;
2006 r = guestfs_blockdev_setrw (g, device);
2013 r = guestfs_umount_all (g);
2020 r = guestfs_lvm_remove_all (g);
2024 /* TestRun for drop_caches (0) */
2028 r = guestfs_drop_caches (g, 3);
2035 static int test_mv_0_skip (void)
2039 str = getenv ("SKIP_TEST_MV_0");
2040 if (str && strcmp (str, "1") == 0) return 1;
2041 str = getenv ("SKIP_TEST_MV");
2042 if (str && strcmp (str, "1") == 0) return 1;
2046 static int test_mv_0 (void)
2048 if (test_mv_0_skip ()) {
2049 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_0");
2053 /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
2055 char device[] = "/dev/sda";
2056 device[5] = devchar;
2059 r = guestfs_blockdev_setrw (g, device);
2066 r = guestfs_umount_all (g);
2073 r = guestfs_lvm_remove_all (g);
2078 char device[] = "/dev/sda";
2079 device[5] = devchar;
2080 char lines_0[] = ",";
2087 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2092 char fstype[] = "ext2";
2093 char device[] = "/dev/sda1";
2094 device[5] = devchar;
2097 r = guestfs_mkfs (g, fstype, device);
2102 char device[] = "/dev/sda1";
2103 device[5] = devchar;
2104 char mountpoint[] = "/";
2107 r = guestfs_mount (g, device, mountpoint);
2111 /* TestOutput for mv (0) */
2112 char expected[] = "file content";
2114 char path[] = "/old";
2115 char content[] = "file content";
2118 r = guestfs_write_file (g, path, content, 0);
2123 char src[] = "/old";
2124 char dest[] = "/new";
2127 r = guestfs_mv (g, src, dest);
2132 char path[] = "/new";
2135 r = guestfs_cat (g, path);
2138 if (strcmp (r, expected) != 0) {
2139 fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
2147 static int test_mv_1_skip (void)
2151 str = getenv ("SKIP_TEST_MV_1");
2152 if (str && strcmp (str, "1") == 0) return 1;
2153 str = getenv ("SKIP_TEST_MV");
2154 if (str && strcmp (str, "1") == 0) return 1;
2158 static int test_mv_1 (void)
2160 if (test_mv_1_skip ()) {
2161 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_1");
2165 /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
2167 char device[] = "/dev/sda";
2168 device[5] = devchar;
2171 r = guestfs_blockdev_setrw (g, device);
2178 r = guestfs_umount_all (g);
2185 r = guestfs_lvm_remove_all (g);
2190 char device[] = "/dev/sda";
2191 device[5] = devchar;
2192 char lines_0[] = ",";
2199 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2204 char fstype[] = "ext2";
2205 char device[] = "/dev/sda1";
2206 device[5] = devchar;
2209 r = guestfs_mkfs (g, fstype, device);
2214 char device[] = "/dev/sda1";
2215 device[5] = devchar;
2216 char mountpoint[] = "/";
2219 r = guestfs_mount (g, device, mountpoint);
2223 /* TestOutputFalse for mv (1) */
2225 char path[] = "/old";
2226 char content[] = "file content";
2229 r = guestfs_write_file (g, path, content, 0);
2234 char src[] = "/old";
2235 char dest[] = "/new";
2238 r = guestfs_mv (g, src, dest);
2243 char path[] = "/old";
2246 r = guestfs_is_file (g, path);
2250 fprintf (stderr, "test_mv_1: expected false, got true\n");
2257 static int test_cp_a_0_skip (void)
2261 str = getenv ("SKIP_TEST_CP_A_0");
2262 if (str && strcmp (str, "1") == 0) return 1;
2263 str = getenv ("SKIP_TEST_CP_A");
2264 if (str && strcmp (str, "1") == 0) return 1;
2268 static int test_cp_a_0 (void)
2270 if (test_cp_a_0_skip ()) {
2271 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_a_0");
2275 /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
2277 char device[] = "/dev/sda";
2278 device[5] = devchar;
2281 r = guestfs_blockdev_setrw (g, device);
2288 r = guestfs_umount_all (g);
2295 r = guestfs_lvm_remove_all (g);
2300 char device[] = "/dev/sda";
2301 device[5] = devchar;
2302 char lines_0[] = ",";
2309 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2314 char fstype[] = "ext2";
2315 char device[] = "/dev/sda1";
2316 device[5] = devchar;
2319 r = guestfs_mkfs (g, fstype, device);
2324 char device[] = "/dev/sda1";
2325 device[5] = devchar;
2326 char mountpoint[] = "/";
2329 r = guestfs_mount (g, device, mountpoint);
2333 /* TestOutput for cp_a (0) */
2334 char expected[] = "file content";
2336 char path[] = "/olddir";
2339 r = guestfs_mkdir (g, path);
2344 char path[] = "/newdir";
2347 r = guestfs_mkdir (g, path);
2352 char path[] = "/olddir/file";
2353 char content[] = "file content";
2356 r = guestfs_write_file (g, path, content, 0);
2361 char src[] = "/olddir";
2362 char dest[] = "/newdir";
2365 r = guestfs_cp_a (g, src, dest);
2370 char path[] = "/newdir/olddir/file";
2373 r = guestfs_cat (g, path);
2376 if (strcmp (r, expected) != 0) {
2377 fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
2385 static int test_cp_0_skip (void)
2389 str = getenv ("SKIP_TEST_CP_0");
2390 if (str && strcmp (str, "1") == 0) return 1;
2391 str = getenv ("SKIP_TEST_CP");
2392 if (str && strcmp (str, "1") == 0) return 1;
2396 static int test_cp_0 (void)
2398 if (test_cp_0_skip ()) {
2399 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_0");
2403 /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
2405 char device[] = "/dev/sda";
2406 device[5] = devchar;
2409 r = guestfs_blockdev_setrw (g, device);
2416 r = guestfs_umount_all (g);
2423 r = guestfs_lvm_remove_all (g);
2428 char device[] = "/dev/sda";
2429 device[5] = devchar;
2430 char lines_0[] = ",";
2437 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2442 char fstype[] = "ext2";
2443 char device[] = "/dev/sda1";
2444 device[5] = devchar;
2447 r = guestfs_mkfs (g, fstype, device);
2452 char device[] = "/dev/sda1";
2453 device[5] = devchar;
2454 char mountpoint[] = "/";
2457 r = guestfs_mount (g, device, mountpoint);
2461 /* TestOutput for cp (0) */
2462 char expected[] = "file content";
2464 char path[] = "/old";
2465 char content[] = "file content";
2468 r = guestfs_write_file (g, path, content, 0);
2473 char src[] = "/old";
2474 char dest[] = "/new";
2477 r = guestfs_cp (g, src, dest);
2482 char path[] = "/new";
2485 r = guestfs_cat (g, path);
2488 if (strcmp (r, expected) != 0) {
2489 fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
2497 static int test_cp_1_skip (void)
2501 str = getenv ("SKIP_TEST_CP_1");
2502 if (str && strcmp (str, "1") == 0) return 1;
2503 str = getenv ("SKIP_TEST_CP");
2504 if (str && strcmp (str, "1") == 0) return 1;
2508 static int test_cp_1 (void)
2510 if (test_cp_1_skip ()) {
2511 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_1");
2515 /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
2517 char device[] = "/dev/sda";
2518 device[5] = devchar;
2521 r = guestfs_blockdev_setrw (g, device);
2528 r = guestfs_umount_all (g);
2535 r = guestfs_lvm_remove_all (g);
2540 char device[] = "/dev/sda";
2541 device[5] = devchar;
2542 char lines_0[] = ",";
2549 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2554 char fstype[] = "ext2";
2555 char device[] = "/dev/sda1";
2556 device[5] = devchar;
2559 r = guestfs_mkfs (g, fstype, device);
2564 char device[] = "/dev/sda1";
2565 device[5] = devchar;
2566 char mountpoint[] = "/";
2569 r = guestfs_mount (g, device, mountpoint);
2573 /* TestOutputTrue for cp (1) */
2575 char path[] = "/old";
2576 char content[] = "file content";
2579 r = guestfs_write_file (g, path, content, 0);
2584 char src[] = "/old";
2585 char dest[] = "/new";
2588 r = guestfs_cp (g, src, dest);
2593 char path[] = "/old";
2596 r = guestfs_is_file (g, path);
2600 fprintf (stderr, "test_cp_1: expected true, got false\n");
2607 static int test_cp_2_skip (void)
2611 str = getenv ("SKIP_TEST_CP_2");
2612 if (str && strcmp (str, "1") == 0) return 1;
2613 str = getenv ("SKIP_TEST_CP");
2614 if (str && strcmp (str, "1") == 0) return 1;
2618 static int test_cp_2 (void)
2620 if (test_cp_2_skip ()) {
2621 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_2");
2625 /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
2627 char device[] = "/dev/sda";
2628 device[5] = devchar;
2631 r = guestfs_blockdev_setrw (g, device);
2638 r = guestfs_umount_all (g);
2645 r = guestfs_lvm_remove_all (g);
2650 char device[] = "/dev/sda";
2651 device[5] = devchar;
2652 char lines_0[] = ",";
2659 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2664 char fstype[] = "ext2";
2665 char device[] = "/dev/sda1";
2666 device[5] = devchar;
2669 r = guestfs_mkfs (g, fstype, device);
2674 char device[] = "/dev/sda1";
2675 device[5] = devchar;
2676 char mountpoint[] = "/";
2679 r = guestfs_mount (g, device, mountpoint);
2683 /* TestOutput for cp (2) */
2684 char expected[] = "file content";
2686 char path[] = "/old";
2687 char content[] = "file content";
2690 r = guestfs_write_file (g, path, content, 0);
2695 char path[] = "/dir";
2698 r = guestfs_mkdir (g, path);
2703 char src[] = "/old";
2704 char dest[] = "/dir/new";
2707 r = guestfs_cp (g, src, dest);
2712 char path[] = "/dir/new";
2715 r = guestfs_cat (g, path);
2718 if (strcmp (r, expected) != 0) {
2719 fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
2727 static int test_grub_install_0_skip (void)
2731 str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
2732 if (str && strcmp (str, "1") == 0) return 1;
2733 str = getenv ("SKIP_TEST_GRUB_INSTALL");
2734 if (str && strcmp (str, "1") == 0) return 1;
2738 static int test_grub_install_0 (void)
2740 if (test_grub_install_0_skip ()) {
2741 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_grub_install_0");
2745 /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
2747 char device[] = "/dev/sda";
2748 device[5] = devchar;
2751 r = guestfs_blockdev_setrw (g, device);
2758 r = guestfs_umount_all (g);
2765 r = guestfs_lvm_remove_all (g);
2770 char device[] = "/dev/sda";
2771 device[5] = devchar;
2772 char lines_0[] = ",";
2779 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2784 char fstype[] = "ext2";
2785 char device[] = "/dev/sda1";
2786 device[5] = devchar;
2789 r = guestfs_mkfs (g, fstype, device);
2794 char device[] = "/dev/sda1";
2795 device[5] = devchar;
2796 char mountpoint[] = "/";
2799 r = guestfs_mount (g, device, mountpoint);
2803 /* TestOutputTrue for grub_install (0) */
2806 char device[] = "/dev/sda1";
2807 device[5] = devchar;
2810 r = guestfs_grub_install (g, root, device);
2815 char path[] = "/boot";
2818 r = guestfs_is_dir (g, path);
2822 fprintf (stderr, "test_grub_install_0: expected true, got false\n");
2829 static int test_zero_0_skip (void)
2833 str = getenv ("SKIP_TEST_ZERO_0");
2834 if (str && strcmp (str, "1") == 0) return 1;
2835 str = getenv ("SKIP_TEST_ZERO");
2836 if (str && strcmp (str, "1") == 0) return 1;
2840 static int test_zero_0 (void)
2842 if (test_zero_0_skip ()) {
2843 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zero_0");
2847 /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
2849 char device[] = "/dev/sda";
2850 device[5] = devchar;
2853 r = guestfs_blockdev_setrw (g, device);
2860 r = guestfs_umount_all (g);
2867 r = guestfs_lvm_remove_all (g);
2872 char device[] = "/dev/sda";
2873 device[5] = devchar;
2874 char lines_0[] = ",";
2881 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2886 char fstype[] = "ext2";
2887 char device[] = "/dev/sda1";
2888 device[5] = devchar;
2891 r = guestfs_mkfs (g, fstype, device);
2896 char device[] = "/dev/sda1";
2897 device[5] = devchar;
2898 char mountpoint[] = "/";
2901 r = guestfs_mount (g, device, mountpoint);
2905 /* TestOutput for zero (0) */
2906 char expected[] = "data";
2908 char pathordevice[] = "/dev/sda1";
2909 pathordevice[5] = devchar;
2912 r = guestfs_umount (g, pathordevice);
2917 char device[] = "/dev/sda1";
2918 device[5] = devchar;
2921 r = guestfs_zero (g, device);
2926 char path[] = "/dev/sda1";
2930 r = guestfs_file (g, path);
2933 if (strcmp (r, expected) != 0) {
2934 fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
2942 static int test_fsck_0_skip (void)
2946 str = getenv ("SKIP_TEST_FSCK_0");
2947 if (str && strcmp (str, "1") == 0) return 1;
2948 str = getenv ("SKIP_TEST_FSCK");
2949 if (str && strcmp (str, "1") == 0) return 1;
2953 static int test_fsck_0 (void)
2955 if (test_fsck_0_skip ()) {
2956 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_0");
2960 /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
2962 char device[] = "/dev/sda";
2963 device[5] = devchar;
2966 r = guestfs_blockdev_setrw (g, device);
2973 r = guestfs_umount_all (g);
2980 r = guestfs_lvm_remove_all (g);
2985 char device[] = "/dev/sda";
2986 device[5] = devchar;
2987 char lines_0[] = ",";
2994 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2999 char fstype[] = "ext2";
3000 char device[] = "/dev/sda1";
3001 device[5] = devchar;
3004 r = guestfs_mkfs (g, fstype, device);
3009 char device[] = "/dev/sda1";
3010 device[5] = devchar;
3011 char mountpoint[] = "/";
3014 r = guestfs_mount (g, device, mountpoint);
3018 /* TestOutputInt for fsck (0) */
3020 char pathordevice[] = "/dev/sda1";
3021 pathordevice[5] = devchar;
3024 r = guestfs_umount (g, pathordevice);
3029 char fstype[] = "ext2";
3030 char device[] = "/dev/sda1";
3031 device[5] = devchar;
3034 r = guestfs_fsck (g, fstype, device);
3038 fprintf (stderr, "test_fsck_0: expected 0 but got %d\n", (int) r);
3045 static int test_fsck_1_skip (void)
3049 str = getenv ("SKIP_TEST_FSCK_1");
3050 if (str && strcmp (str, "1") == 0) return 1;
3051 str = getenv ("SKIP_TEST_FSCK");
3052 if (str && strcmp (str, "1") == 0) return 1;
3056 static int test_fsck_1 (void)
3058 if (test_fsck_1_skip ()) {
3059 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_1");
3063 /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
3065 char device[] = "/dev/sda";
3066 device[5] = devchar;
3069 r = guestfs_blockdev_setrw (g, device);
3076 r = guestfs_umount_all (g);
3083 r = guestfs_lvm_remove_all (g);
3088 char device[] = "/dev/sda";
3089 device[5] = devchar;
3090 char lines_0[] = ",";
3097 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3102 char fstype[] = "ext2";
3103 char device[] = "/dev/sda1";
3104 device[5] = devchar;
3107 r = guestfs_mkfs (g, fstype, device);
3112 char device[] = "/dev/sda1";
3113 device[5] = devchar;
3114 char mountpoint[] = "/";
3117 r = guestfs_mount (g, device, mountpoint);
3121 /* TestOutputInt for fsck (1) */
3123 char pathordevice[] = "/dev/sda1";
3124 pathordevice[5] = devchar;
3127 r = guestfs_umount (g, pathordevice);
3132 char device[] = "/dev/sda1";
3133 device[5] = devchar;
3136 r = guestfs_zero (g, device);
3141 char fstype[] = "ext2";
3142 char device[] = "/dev/sda1";
3143 device[5] = devchar;
3146 r = guestfs_fsck (g, fstype, device);
3150 fprintf (stderr, "test_fsck_1: expected 8 but got %d\n", (int) r);
3157 static int test_set_e2uuid_0_skip (void)
3161 str = getenv ("SKIP_TEST_SET_E2UUID_0");
3162 if (str && strcmp (str, "1") == 0) return 1;
3163 str = getenv ("SKIP_TEST_SET_E2UUID");
3164 if (str && strcmp (str, "1") == 0) return 1;
3168 static int test_set_e2uuid_0 (void)
3170 if (test_set_e2uuid_0_skip ()) {
3171 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_0");
3175 /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
3177 char device[] = "/dev/sda";
3178 device[5] = devchar;
3181 r = guestfs_blockdev_setrw (g, device);
3188 r = guestfs_umount_all (g);
3195 r = guestfs_lvm_remove_all (g);
3200 char device[] = "/dev/sda";
3201 device[5] = devchar;
3202 char lines_0[] = ",";
3209 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3214 char fstype[] = "ext2";
3215 char device[] = "/dev/sda1";
3216 device[5] = devchar;
3219 r = guestfs_mkfs (g, fstype, device);
3224 char device[] = "/dev/sda1";
3225 device[5] = devchar;
3226 char mountpoint[] = "/";
3229 r = guestfs_mount (g, device, mountpoint);
3233 /* TestOutput for set_e2uuid (0) */
3234 char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3236 char device[] = "/dev/sda1";
3237 device[5] = devchar;
3238 char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3241 r = guestfs_set_e2uuid (g, device, uuid);
3246 char device[] = "/dev/sda1";
3247 device[5] = devchar;
3250 r = guestfs_get_e2uuid (g, device);
3253 if (strcmp (r, expected) != 0) {
3254 fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
3262 static int test_set_e2uuid_1_skip (void)
3266 str = getenv ("SKIP_TEST_SET_E2UUID_1");
3267 if (str && strcmp (str, "1") == 0) return 1;
3268 str = getenv ("SKIP_TEST_SET_E2UUID");
3269 if (str && strcmp (str, "1") == 0) return 1;
3273 static int test_set_e2uuid_1 (void)
3275 if (test_set_e2uuid_1_skip ()) {
3276 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_1");
3280 /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
3282 char device[] = "/dev/sda";
3283 device[5] = devchar;
3286 r = guestfs_blockdev_setrw (g, device);
3293 r = guestfs_umount_all (g);
3300 r = guestfs_lvm_remove_all (g);
3305 char device[] = "/dev/sda";
3306 device[5] = devchar;
3307 char lines_0[] = ",";
3314 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3319 char fstype[] = "ext2";
3320 char device[] = "/dev/sda1";
3321 device[5] = devchar;
3324 r = guestfs_mkfs (g, fstype, device);
3329 char device[] = "/dev/sda1";
3330 device[5] = devchar;
3331 char mountpoint[] = "/";
3334 r = guestfs_mount (g, device, mountpoint);
3338 /* TestOutput for set_e2uuid (1) */
3339 char expected[] = "";
3341 char device[] = "/dev/sda1";
3342 device[5] = devchar;
3343 char uuid[] = "clear";
3346 r = guestfs_set_e2uuid (g, device, uuid);
3351 char device[] = "/dev/sda1";
3352 device[5] = devchar;
3355 r = guestfs_get_e2uuid (g, device);
3358 if (strcmp (r, expected) != 0) {
3359 fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
3367 static int test_set_e2uuid_2_skip (void)
3371 str = getenv ("SKIP_TEST_SET_E2UUID_2");
3372 if (str && strcmp (str, "1") == 0) return 1;
3373 str = getenv ("SKIP_TEST_SET_E2UUID");
3374 if (str && strcmp (str, "1") == 0) return 1;
3378 static int test_set_e2uuid_2 (void)
3380 if (test_set_e2uuid_2_skip ()) {
3381 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_2");
3385 /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
3387 char device[] = "/dev/sda";
3388 device[5] = devchar;
3391 r = guestfs_blockdev_setrw (g, device);
3398 r = guestfs_umount_all (g);
3405 r = guestfs_lvm_remove_all (g);
3410 char device[] = "/dev/sda";
3411 device[5] = devchar;
3412 char lines_0[] = ",";
3419 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3424 char fstype[] = "ext2";
3425 char device[] = "/dev/sda1";
3426 device[5] = devchar;
3429 r = guestfs_mkfs (g, fstype, device);
3434 char device[] = "/dev/sda1";
3435 device[5] = devchar;
3436 char mountpoint[] = "/";
3439 r = guestfs_mount (g, device, mountpoint);
3443 /* TestRun for set_e2uuid (2) */
3445 char device[] = "/dev/sda1";
3446 device[5] = devchar;
3447 char uuid[] = "random";
3450 r = guestfs_set_e2uuid (g, device, uuid);
3457 static int test_set_e2uuid_3_skip (void)
3461 str = getenv ("SKIP_TEST_SET_E2UUID_3");
3462 if (str && strcmp (str, "1") == 0) return 1;
3463 str = getenv ("SKIP_TEST_SET_E2UUID");
3464 if (str && strcmp (str, "1") == 0) return 1;
3468 static int test_set_e2uuid_3 (void)
3470 if (test_set_e2uuid_3_skip ()) {
3471 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_3");
3475 /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
3477 char device[] = "/dev/sda";
3478 device[5] = devchar;
3481 r = guestfs_blockdev_setrw (g, device);
3488 r = guestfs_umount_all (g);
3495 r = guestfs_lvm_remove_all (g);
3500 char device[] = "/dev/sda";
3501 device[5] = devchar;
3502 char lines_0[] = ",";
3509 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3514 char fstype[] = "ext2";
3515 char device[] = "/dev/sda1";
3516 device[5] = devchar;
3519 r = guestfs_mkfs (g, fstype, device);
3524 char device[] = "/dev/sda1";
3525 device[5] = devchar;
3526 char mountpoint[] = "/";
3529 r = guestfs_mount (g, device, mountpoint);
3533 /* TestRun for set_e2uuid (3) */
3535 char device[] = "/dev/sda1";
3536 device[5] = devchar;
3537 char uuid[] = "time";
3540 r = guestfs_set_e2uuid (g, device, uuid);
3547 static int test_set_e2label_0_skip (void)
3551 str = getenv ("SKIP_TEST_SET_E2LABEL_0");
3552 if (str && strcmp (str, "1") == 0) return 1;
3553 str = getenv ("SKIP_TEST_SET_E2LABEL");
3554 if (str && strcmp (str, "1") == 0) return 1;
3558 static int test_set_e2label_0 (void)
3560 if (test_set_e2label_0_skip ()) {
3561 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2label_0");
3565 /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
3567 char device[] = "/dev/sda";
3568 device[5] = devchar;
3571 r = guestfs_blockdev_setrw (g, device);
3578 r = guestfs_umount_all (g);
3585 r = guestfs_lvm_remove_all (g);
3590 char device[] = "/dev/sda";
3591 device[5] = devchar;
3592 char lines_0[] = ",";
3599 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3604 char fstype[] = "ext2";
3605 char device[] = "/dev/sda1";
3606 device[5] = devchar;
3609 r = guestfs_mkfs (g, fstype, device);
3614 char device[] = "/dev/sda1";
3615 device[5] = devchar;
3616 char mountpoint[] = "/";
3619 r = guestfs_mount (g, device, mountpoint);
3623 /* TestOutput for set_e2label (0) */
3624 char expected[] = "testlabel";
3626 char device[] = "/dev/sda1";
3627 device[5] = devchar;
3628 char label[] = "testlabel";
3631 r = guestfs_set_e2label (g, device, label);
3636 char device[] = "/dev/sda1";
3637 device[5] = devchar;
3640 r = guestfs_get_e2label (g, device);
3643 if (strcmp (r, expected) != 0) {
3644 fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
3652 static int test_pvremove_0_skip (void)
3656 str = getenv ("SKIP_TEST_PVREMOVE_0");
3657 if (str && strcmp (str, "1") == 0) return 1;
3658 str = getenv ("SKIP_TEST_PVREMOVE");
3659 if (str && strcmp (str, "1") == 0) return 1;
3663 static int test_pvremove_0 (void)
3665 if (test_pvremove_0_skip ()) {
3666 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_0");
3670 /* InitNone|InitEmpty for test_pvremove_0 */
3672 char device[] = "/dev/sda";
3673 device[5] = devchar;
3676 r = guestfs_blockdev_setrw (g, device);
3683 r = guestfs_umount_all (g);
3690 r = guestfs_lvm_remove_all (g);
3694 /* TestOutputList for pvremove (0) */
3696 char device[] = "/dev/sda";
3697 device[5] = devchar;
3698 char lines_0[] = ",";
3705 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3710 char device[] = "/dev/sda1";
3711 device[5] = devchar;
3714 r = guestfs_pvcreate (g, device);
3719 char volgroup[] = "VG";
3720 char physvols_0[] = "/dev/sda1";
3721 physvols_0[5] = devchar;
3722 char *physvols[] = {
3728 r = guestfs_vgcreate (g, volgroup, physvols);
3733 char logvol[] = "LV1";
3734 char volgroup[] = "VG";
3737 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3742 char logvol[] = "LV2";
3743 char volgroup[] = "VG";
3746 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3751 char vgname[] = "VG";
3754 r = guestfs_vgremove (g, vgname);
3759 char device[] = "/dev/sda1";
3760 device[5] = devchar;
3763 r = guestfs_pvremove (g, device);
3771 r = guestfs_lvs (g);
3775 fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
3779 for (i = 0; r[i] != NULL; ++i)
3786 static int test_pvremove_1_skip (void)
3790 str = getenv ("SKIP_TEST_PVREMOVE_1");
3791 if (str && strcmp (str, "1") == 0) return 1;
3792 str = getenv ("SKIP_TEST_PVREMOVE");
3793 if (str && strcmp (str, "1") == 0) return 1;
3797 static int test_pvremove_1 (void)
3799 if (test_pvremove_1_skip ()) {
3800 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_1");
3804 /* InitNone|InitEmpty for test_pvremove_1 */
3806 char device[] = "/dev/sda";
3807 device[5] = devchar;
3810 r = guestfs_blockdev_setrw (g, device);
3817 r = guestfs_umount_all (g);
3824 r = guestfs_lvm_remove_all (g);
3828 /* TestOutputList for pvremove (1) */
3830 char device[] = "/dev/sda";
3831 device[5] = devchar;
3832 char lines_0[] = ",";
3839 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3844 char device[] = "/dev/sda1";
3845 device[5] = devchar;
3848 r = guestfs_pvcreate (g, device);
3853 char volgroup[] = "VG";
3854 char physvols_0[] = "/dev/sda1";
3855 physvols_0[5] = devchar;
3856 char *physvols[] = {
3862 r = guestfs_vgcreate (g, volgroup, physvols);
3867 char logvol[] = "LV1";
3868 char volgroup[] = "VG";
3871 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3876 char logvol[] = "LV2";
3877 char volgroup[] = "VG";
3880 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3885 char vgname[] = "VG";
3888 r = guestfs_vgremove (g, vgname);
3893 char device[] = "/dev/sda1";
3894 device[5] = devchar;
3897 r = guestfs_pvremove (g, device);
3905 r = guestfs_vgs (g);
3909 fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
3913 for (i = 0; r[i] != NULL; ++i)
3920 static int test_pvremove_2_skip (void)
3924 str = getenv ("SKIP_TEST_PVREMOVE_2");
3925 if (str && strcmp (str, "1") == 0) return 1;
3926 str = getenv ("SKIP_TEST_PVREMOVE");
3927 if (str && strcmp (str, "1") == 0) return 1;
3931 static int test_pvremove_2 (void)
3933 if (test_pvremove_2_skip ()) {
3934 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_2");
3938 /* InitNone|InitEmpty for test_pvremove_2 */
3940 char device[] = "/dev/sda";
3941 device[5] = devchar;
3944 r = guestfs_blockdev_setrw (g, device);
3951 r = guestfs_umount_all (g);
3958 r = guestfs_lvm_remove_all (g);
3962 /* TestOutputList for pvremove (2) */
3964 char device[] = "/dev/sda";
3965 device[5] = devchar;
3966 char lines_0[] = ",";
3973 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3978 char device[] = "/dev/sda1";
3979 device[5] = devchar;
3982 r = guestfs_pvcreate (g, device);
3987 char volgroup[] = "VG";
3988 char physvols_0[] = "/dev/sda1";
3989 physvols_0[5] = devchar;
3990 char *physvols[] = {
3996 r = guestfs_vgcreate (g, volgroup, physvols);
4001 char logvol[] = "LV1";
4002 char volgroup[] = "VG";
4005 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4010 char logvol[] = "LV2";
4011 char volgroup[] = "VG";
4014 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4019 char vgname[] = "VG";
4022 r = guestfs_vgremove (g, vgname);
4027 char device[] = "/dev/sda1";
4028 device[5] = devchar;
4031 r = guestfs_pvremove (g, device);
4039 r = guestfs_pvs (g);
4043 fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
4047 for (i = 0; r[i] != NULL; ++i)
4054 static int test_vgremove_0_skip (void)
4058 str = getenv ("SKIP_TEST_VGREMOVE_0");
4059 if (str && strcmp (str, "1") == 0) return 1;
4060 str = getenv ("SKIP_TEST_VGREMOVE");
4061 if (str && strcmp (str, "1") == 0) return 1;
4065 static int test_vgremove_0 (void)
4067 if (test_vgremove_0_skip ()) {
4068 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_0");
4072 /* InitNone|InitEmpty for test_vgremove_0 */
4074 char device[] = "/dev/sda";
4075 device[5] = devchar;
4078 r = guestfs_blockdev_setrw (g, device);
4085 r = guestfs_umount_all (g);
4092 r = guestfs_lvm_remove_all (g);
4096 /* TestOutputList for vgremove (0) */
4098 char device[] = "/dev/sda";
4099 device[5] = devchar;
4100 char lines_0[] = ",";
4107 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4112 char device[] = "/dev/sda1";
4113 device[5] = devchar;
4116 r = guestfs_pvcreate (g, device);
4121 char volgroup[] = "VG";
4122 char physvols_0[] = "/dev/sda1";
4123 physvols_0[5] = devchar;
4124 char *physvols[] = {
4130 r = guestfs_vgcreate (g, volgroup, physvols);
4135 char logvol[] = "LV1";
4136 char volgroup[] = "VG";
4139 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4144 char logvol[] = "LV2";
4145 char volgroup[] = "VG";
4148 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4153 char vgname[] = "VG";
4156 r = guestfs_vgremove (g, vgname);
4164 r = guestfs_lvs (g);
4168 fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
4172 for (i = 0; r[i] != NULL; ++i)
4179 static int test_vgremove_1_skip (void)
4183 str = getenv ("SKIP_TEST_VGREMOVE_1");
4184 if (str && strcmp (str, "1") == 0) return 1;
4185 str = getenv ("SKIP_TEST_VGREMOVE");
4186 if (str && strcmp (str, "1") == 0) return 1;
4190 static int test_vgremove_1 (void)
4192 if (test_vgremove_1_skip ()) {
4193 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_1");
4197 /* InitNone|InitEmpty for test_vgremove_1 */
4199 char device[] = "/dev/sda";
4200 device[5] = devchar;
4203 r = guestfs_blockdev_setrw (g, device);
4210 r = guestfs_umount_all (g);
4217 r = guestfs_lvm_remove_all (g);
4221 /* TestOutputList for vgremove (1) */
4223 char device[] = "/dev/sda";
4224 device[5] = devchar;
4225 char lines_0[] = ",";
4232 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4237 char device[] = "/dev/sda1";
4238 device[5] = devchar;
4241 r = guestfs_pvcreate (g, device);
4246 char volgroup[] = "VG";
4247 char physvols_0[] = "/dev/sda1";
4248 physvols_0[5] = devchar;
4249 char *physvols[] = {
4255 r = guestfs_vgcreate (g, volgroup, physvols);
4260 char logvol[] = "LV1";
4261 char volgroup[] = "VG";
4264 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4269 char logvol[] = "LV2";
4270 char volgroup[] = "VG";
4273 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4278 char vgname[] = "VG";
4281 r = guestfs_vgremove (g, vgname);
4289 r = guestfs_vgs (g);
4293 fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
4297 for (i = 0; r[i] != NULL; ++i)
4304 static int test_lvremove_0_skip (void)
4308 str = getenv ("SKIP_TEST_LVREMOVE_0");
4309 if (str && strcmp (str, "1") == 0) return 1;
4310 str = getenv ("SKIP_TEST_LVREMOVE");
4311 if (str && strcmp (str, "1") == 0) return 1;
4315 static int test_lvremove_0 (void)
4317 if (test_lvremove_0_skip ()) {
4318 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_0");
4322 /* InitNone|InitEmpty for test_lvremove_0 */
4324 char device[] = "/dev/sda";
4325 device[5] = devchar;
4328 r = guestfs_blockdev_setrw (g, device);
4335 r = guestfs_umount_all (g);
4342 r = guestfs_lvm_remove_all (g);
4346 /* TestOutputList for lvremove (0) */
4348 char device[] = "/dev/sda";
4349 device[5] = devchar;
4350 char lines_0[] = ",";
4357 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4362 char device[] = "/dev/sda1";
4363 device[5] = devchar;
4366 r = guestfs_pvcreate (g, device);
4371 char volgroup[] = "VG";
4372 char physvols_0[] = "/dev/sda1";
4373 physvols_0[5] = devchar;
4374 char *physvols[] = {
4380 r = guestfs_vgcreate (g, volgroup, physvols);
4385 char logvol[] = "LV1";
4386 char volgroup[] = "VG";
4389 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4394 char logvol[] = "LV2";
4395 char volgroup[] = "VG";
4398 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4403 char device[] = "/dev/VG/LV1";
4406 r = guestfs_lvremove (g, device);
4414 r = guestfs_lvs (g);
4418 fprintf (stderr, "test_lvremove_0: short list returned from command\n");
4423 char expected[] = "/dev/VG/LV2";
4424 if (strcmp (r[0], expected) != 0) {
4425 fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4430 fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
4434 for (i = 0; r[i] != NULL; ++i)
4441 static int test_lvremove_1_skip (void)
4445 str = getenv ("SKIP_TEST_LVREMOVE_1");
4446 if (str && strcmp (str, "1") == 0) return 1;
4447 str = getenv ("SKIP_TEST_LVREMOVE");
4448 if (str && strcmp (str, "1") == 0) return 1;
4452 static int test_lvremove_1 (void)
4454 if (test_lvremove_1_skip ()) {
4455 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_1");
4459 /* InitNone|InitEmpty for test_lvremove_1 */
4461 char device[] = "/dev/sda";
4462 device[5] = devchar;
4465 r = guestfs_blockdev_setrw (g, device);
4472 r = guestfs_umount_all (g);
4479 r = guestfs_lvm_remove_all (g);
4483 /* TestOutputList for lvremove (1) */
4485 char device[] = "/dev/sda";
4486 device[5] = devchar;
4487 char lines_0[] = ",";
4494 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4499 char device[] = "/dev/sda1";
4500 device[5] = devchar;
4503 r = guestfs_pvcreate (g, device);
4508 char volgroup[] = "VG";
4509 char physvols_0[] = "/dev/sda1";
4510 physvols_0[5] = devchar;
4511 char *physvols[] = {
4517 r = guestfs_vgcreate (g, volgroup, physvols);
4522 char logvol[] = "LV1";
4523 char volgroup[] = "VG";
4526 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4531 char logvol[] = "LV2";
4532 char volgroup[] = "VG";
4535 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4540 char device[] = "/dev/VG";
4543 r = guestfs_lvremove (g, device);
4551 r = guestfs_lvs (g);
4555 fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
4559 for (i = 0; r[i] != NULL; ++i)
4566 static int test_lvremove_2_skip (void)
4570 str = getenv ("SKIP_TEST_LVREMOVE_2");
4571 if (str && strcmp (str, "1") == 0) return 1;
4572 str = getenv ("SKIP_TEST_LVREMOVE");
4573 if (str && strcmp (str, "1") == 0) return 1;
4577 static int test_lvremove_2 (void)
4579 if (test_lvremove_2_skip ()) {
4580 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_2");
4584 /* InitNone|InitEmpty for test_lvremove_2 */
4586 char device[] = "/dev/sda";
4587 device[5] = devchar;
4590 r = guestfs_blockdev_setrw (g, device);
4597 r = guestfs_umount_all (g);
4604 r = guestfs_lvm_remove_all (g);
4608 /* TestOutputList for lvremove (2) */
4610 char device[] = "/dev/sda";
4611 device[5] = devchar;
4612 char lines_0[] = ",";
4619 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4624 char device[] = "/dev/sda1";
4625 device[5] = devchar;
4628 r = guestfs_pvcreate (g, device);
4633 char volgroup[] = "VG";
4634 char physvols_0[] = "/dev/sda1";
4635 physvols_0[5] = devchar;
4636 char *physvols[] = {
4642 r = guestfs_vgcreate (g, volgroup, physvols);
4647 char logvol[] = "LV1";
4648 char volgroup[] = "VG";
4651 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4656 char logvol[] = "LV2";
4657 char volgroup[] = "VG";
4660 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4665 char device[] = "/dev/VG";
4668 r = guestfs_lvremove (g, device);
4676 r = guestfs_vgs (g);
4680 fprintf (stderr, "test_lvremove_2: short list returned from command\n");
4685 char expected[] = "VG";
4686 if (strcmp (r[0], expected) != 0) {
4687 fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4692 fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
4696 for (i = 0; r[i] != NULL; ++i)
4703 static int test_mount_ro_0_skip (void)
4707 str = getenv ("SKIP_TEST_MOUNT_RO_0");
4708 if (str && strcmp (str, "1") == 0) return 1;
4709 str = getenv ("SKIP_TEST_MOUNT_RO");
4710 if (str && strcmp (str, "1") == 0) return 1;
4714 static int test_mount_ro_0 (void)
4716 if (test_mount_ro_0_skip ()) {
4717 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_0");
4721 /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
4723 char device[] = "/dev/sda";
4724 device[5] = devchar;
4727 r = guestfs_blockdev_setrw (g, device);
4734 r = guestfs_umount_all (g);
4741 r = guestfs_lvm_remove_all (g);
4746 char device[] = "/dev/sda";
4747 device[5] = devchar;
4748 char lines_0[] = ",";
4755 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4760 char fstype[] = "ext2";
4761 char device[] = "/dev/sda1";
4762 device[5] = devchar;
4765 r = guestfs_mkfs (g, fstype, device);
4770 char device[] = "/dev/sda1";
4771 device[5] = devchar;
4772 char mountpoint[] = "/";
4775 r = guestfs_mount (g, device, mountpoint);
4779 /* TestLastFail for mount_ro (0) */
4781 char pathordevice[] = "/";
4784 r = guestfs_umount (g, pathordevice);
4789 char device[] = "/dev/sda1";
4790 device[5] = devchar;
4791 char mountpoint[] = "/";
4794 r = guestfs_mount_ro (g, device, mountpoint);
4799 char path[] = "/new";
4802 r = guestfs_touch (g, path);
4809 static int test_mount_ro_1_skip (void)
4813 str = getenv ("SKIP_TEST_MOUNT_RO_1");
4814 if (str && strcmp (str, "1") == 0) return 1;
4815 str = getenv ("SKIP_TEST_MOUNT_RO");
4816 if (str && strcmp (str, "1") == 0) return 1;
4820 static int test_mount_ro_1 (void)
4822 if (test_mount_ro_1_skip ()) {
4823 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_1");
4827 /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
4829 char device[] = "/dev/sda";
4830 device[5] = devchar;
4833 r = guestfs_blockdev_setrw (g, device);
4840 r = guestfs_umount_all (g);
4847 r = guestfs_lvm_remove_all (g);
4852 char device[] = "/dev/sda";
4853 device[5] = devchar;
4854 char lines_0[] = ",";
4861 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4866 char fstype[] = "ext2";
4867 char device[] = "/dev/sda1";
4868 device[5] = devchar;
4871 r = guestfs_mkfs (g, fstype, device);
4876 char device[] = "/dev/sda1";
4877 device[5] = devchar;
4878 char mountpoint[] = "/";
4881 r = guestfs_mount (g, device, mountpoint);
4885 /* TestOutput for mount_ro (1) */
4886 char expected[] = "data";
4888 char path[] = "/new";
4889 char content[] = "data";
4892 r = guestfs_write_file (g, path, content, 0);
4897 char pathordevice[] = "/";
4900 r = guestfs_umount (g, pathordevice);
4905 char device[] = "/dev/sda1";
4906 device[5] = devchar;
4907 char mountpoint[] = "/";
4910 r = guestfs_mount_ro (g, device, mountpoint);
4915 char path[] = "/new";
4918 r = guestfs_cat (g, path);
4921 if (strcmp (r, expected) != 0) {
4922 fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
4930 static int test_tgz_in_0_skip (void)
4934 str = getenv ("SKIP_TEST_TGZ_IN_0");
4935 if (str && strcmp (str, "1") == 0) return 1;
4936 str = getenv ("SKIP_TEST_TGZ_IN");
4937 if (str && strcmp (str, "1") == 0) return 1;
4941 static int test_tgz_in_0 (void)
4943 if (test_tgz_in_0_skip ()) {
4944 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tgz_in_0");
4948 /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
4950 char device[] = "/dev/sda";
4951 device[5] = devchar;
4954 r = guestfs_blockdev_setrw (g, device);
4961 r = guestfs_umount_all (g);
4968 r = guestfs_lvm_remove_all (g);
4973 char device[] = "/dev/sda";
4974 device[5] = devchar;
4975 char lines_0[] = ",";
4982 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4987 char fstype[] = "ext2";
4988 char device[] = "/dev/sda1";
4989 device[5] = devchar;
4992 r = guestfs_mkfs (g, fstype, device);
4997 char device[] = "/dev/sda1";
4998 device[5] = devchar;
4999 char mountpoint[] = "/";
5002 r = guestfs_mount (g, device, mountpoint);
5006 /* TestOutput for tgz_in (0) */
5007 char expected[] = "hello\n";
5009 char directory[] = "/";
5012 r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
5017 char path[] = "/hello";
5020 r = guestfs_cat (g, path);
5023 if (strcmp (r, expected) != 0) {
5024 fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
5032 static int test_tar_in_0_skip (void)
5036 str = getenv ("SKIP_TEST_TAR_IN_0");
5037 if (str && strcmp (str, "1") == 0) return 1;
5038 str = getenv ("SKIP_TEST_TAR_IN");
5039 if (str && strcmp (str, "1") == 0) return 1;
5043 static int test_tar_in_0 (void)
5045 if (test_tar_in_0_skip ()) {
5046 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tar_in_0");
5050 /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
5052 char device[] = "/dev/sda";
5053 device[5] = devchar;
5056 r = guestfs_blockdev_setrw (g, device);
5063 r = guestfs_umount_all (g);
5070 r = guestfs_lvm_remove_all (g);
5075 char device[] = "/dev/sda";
5076 device[5] = devchar;
5077 char lines_0[] = ",";
5084 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5089 char fstype[] = "ext2";
5090 char device[] = "/dev/sda1";
5091 device[5] = devchar;
5094 r = guestfs_mkfs (g, fstype, device);
5099 char device[] = "/dev/sda1";
5100 device[5] = devchar;
5101 char mountpoint[] = "/";
5104 r = guestfs_mount (g, device, mountpoint);
5108 /* TestOutput for tar_in (0) */
5109 char expected[] = "hello\n";
5111 char directory[] = "/";
5114 r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
5119 char path[] = "/hello";
5122 r = guestfs_cat (g, path);
5125 if (strcmp (r, expected) != 0) {
5126 fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
5134 static int test_checksum_0_skip (void)
5138 str = getenv ("SKIP_TEST_CHECKSUM_0");
5139 if (str && strcmp (str, "1") == 0) return 1;
5140 str = getenv ("SKIP_TEST_CHECKSUM");
5141 if (str && strcmp (str, "1") == 0) return 1;
5145 static int test_checksum_0 (void)
5147 if (test_checksum_0_skip ()) {
5148 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_0");
5152 /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
5154 char device[] = "/dev/sda";
5155 device[5] = devchar;
5158 r = guestfs_blockdev_setrw (g, device);
5165 r = guestfs_umount_all (g);
5172 r = guestfs_lvm_remove_all (g);
5177 char device[] = "/dev/sda";
5178 device[5] = devchar;
5179 char lines_0[] = ",";
5186 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5191 char fstype[] = "ext2";
5192 char device[] = "/dev/sda1";
5193 device[5] = devchar;
5196 r = guestfs_mkfs (g, fstype, device);
5201 char device[] = "/dev/sda1";
5202 device[5] = devchar;
5203 char mountpoint[] = "/";
5206 r = guestfs_mount (g, device, mountpoint);
5210 /* TestOutput for checksum (0) */
5211 char expected[] = "935282863";
5213 char path[] = "/new";
5214 char content[] = "test\n";
5217 r = guestfs_write_file (g, path, content, 0);
5222 char csumtype[] = "crc";
5223 char path[] = "/new";
5226 r = guestfs_checksum (g, csumtype, path);
5229 if (strcmp (r, expected) != 0) {
5230 fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
5238 static int test_checksum_1_skip (void)
5242 str = getenv ("SKIP_TEST_CHECKSUM_1");
5243 if (str && strcmp (str, "1") == 0) return 1;
5244 str = getenv ("SKIP_TEST_CHECKSUM");
5245 if (str && strcmp (str, "1") == 0) return 1;
5249 static int test_checksum_1 (void)
5251 if (test_checksum_1_skip ()) {
5252 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_1");
5256 /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
5258 char device[] = "/dev/sda";
5259 device[5] = devchar;
5262 r = guestfs_blockdev_setrw (g, device);
5269 r = guestfs_umount_all (g);
5276 r = guestfs_lvm_remove_all (g);
5281 char device[] = "/dev/sda";
5282 device[5] = devchar;
5283 char lines_0[] = ",";
5290 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5295 char fstype[] = "ext2";
5296 char device[] = "/dev/sda1";
5297 device[5] = devchar;
5300 r = guestfs_mkfs (g, fstype, device);
5305 char device[] = "/dev/sda1";
5306 device[5] = devchar;
5307 char mountpoint[] = "/";
5310 r = guestfs_mount (g, device, mountpoint);
5314 /* TestLastFail for checksum (1) */
5316 char csumtype[] = "crc";
5317 char path[] = "/new";
5320 r = guestfs_checksum (g, csumtype, path);
5328 static int test_checksum_2_skip (void)
5332 str = getenv ("SKIP_TEST_CHECKSUM_2");
5333 if (str && strcmp (str, "1") == 0) return 1;
5334 str = getenv ("SKIP_TEST_CHECKSUM");
5335 if (str && strcmp (str, "1") == 0) return 1;
5339 static int test_checksum_2 (void)
5341 if (test_checksum_2_skip ()) {
5342 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_2");
5346 /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
5348 char device[] = "/dev/sda";
5349 device[5] = devchar;
5352 r = guestfs_blockdev_setrw (g, device);
5359 r = guestfs_umount_all (g);
5366 r = guestfs_lvm_remove_all (g);
5371 char device[] = "/dev/sda";
5372 device[5] = devchar;
5373 char lines_0[] = ",";
5380 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5385 char fstype[] = "ext2";
5386 char device[] = "/dev/sda1";
5387 device[5] = devchar;
5390 r = guestfs_mkfs (g, fstype, device);
5395 char device[] = "/dev/sda1";
5396 device[5] = devchar;
5397 char mountpoint[] = "/";
5400 r = guestfs_mount (g, device, mountpoint);
5404 /* TestOutput for checksum (2) */
5405 char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
5407 char path[] = "/new";
5408 char content[] = "test\n";
5411 r = guestfs_write_file (g, path, content, 0);
5416 char csumtype[] = "md5";
5417 char path[] = "/new";
5420 r = guestfs_checksum (g, csumtype, path);
5423 if (strcmp (r, expected) != 0) {
5424 fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
5432 static int test_checksum_3_skip (void)
5436 str = getenv ("SKIP_TEST_CHECKSUM_3");
5437 if (str && strcmp (str, "1") == 0) return 1;
5438 str = getenv ("SKIP_TEST_CHECKSUM");
5439 if (str && strcmp (str, "1") == 0) return 1;
5443 static int test_checksum_3 (void)
5445 if (test_checksum_3_skip ()) {
5446 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_3");
5450 /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
5452 char device[] = "/dev/sda";
5453 device[5] = devchar;
5456 r = guestfs_blockdev_setrw (g, device);
5463 r = guestfs_umount_all (g);
5470 r = guestfs_lvm_remove_all (g);
5475 char device[] = "/dev/sda";
5476 device[5] = devchar;
5477 char lines_0[] = ",";
5484 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5489 char fstype[] = "ext2";
5490 char device[] = "/dev/sda1";
5491 device[5] = devchar;
5494 r = guestfs_mkfs (g, fstype, device);
5499 char device[] = "/dev/sda1";
5500 device[5] = devchar;
5501 char mountpoint[] = "/";
5504 r = guestfs_mount (g, device, mountpoint);
5508 /* TestOutput for checksum (3) */
5509 char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
5511 char path[] = "/new";
5512 char content[] = "test\n";
5515 r = guestfs_write_file (g, path, content, 0);
5520 char csumtype[] = "sha1";
5521 char path[] = "/new";
5524 r = guestfs_checksum (g, csumtype, path);
5527 if (strcmp (r, expected) != 0) {
5528 fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
5536 static int test_checksum_4_skip (void)
5540 str = getenv ("SKIP_TEST_CHECKSUM_4");
5541 if (str && strcmp (str, "1") == 0) return 1;
5542 str = getenv ("SKIP_TEST_CHECKSUM");
5543 if (str && strcmp (str, "1") == 0) return 1;
5547 static int test_checksum_4 (void)
5549 if (test_checksum_4_skip ()) {
5550 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_4");
5554 /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
5556 char device[] = "/dev/sda";
5557 device[5] = devchar;
5560 r = guestfs_blockdev_setrw (g, device);
5567 r = guestfs_umount_all (g);
5574 r = guestfs_lvm_remove_all (g);
5579 char device[] = "/dev/sda";
5580 device[5] = devchar;
5581 char lines_0[] = ",";
5588 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5593 char fstype[] = "ext2";
5594 char device[] = "/dev/sda1";
5595 device[5] = devchar;
5598 r = guestfs_mkfs (g, fstype, device);
5603 char device[] = "/dev/sda1";
5604 device[5] = devchar;
5605 char mountpoint[] = "/";
5608 r = guestfs_mount (g, device, mountpoint);
5612 /* TestOutput for checksum (4) */
5613 char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
5615 char path[] = "/new";
5616 char content[] = "test\n";
5619 r = guestfs_write_file (g, path, content, 0);
5624 char csumtype[] = "sha224";
5625 char path[] = "/new";
5628 r = guestfs_checksum (g, csumtype, path);
5631 if (strcmp (r, expected) != 0) {
5632 fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
5640 static int test_checksum_5_skip (void)
5644 str = getenv ("SKIP_TEST_CHECKSUM_5");
5645 if (str && strcmp (str, "1") == 0) return 1;
5646 str = getenv ("SKIP_TEST_CHECKSUM");
5647 if (str && strcmp (str, "1") == 0) return 1;
5651 static int test_checksum_5 (void)
5653 if (test_checksum_5_skip ()) {
5654 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_5");
5658 /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
5660 char device[] = "/dev/sda";
5661 device[5] = devchar;
5664 r = guestfs_blockdev_setrw (g, device);
5671 r = guestfs_umount_all (g);
5678 r = guestfs_lvm_remove_all (g);
5683 char device[] = "/dev/sda";
5684 device[5] = devchar;
5685 char lines_0[] = ",";
5692 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5697 char fstype[] = "ext2";
5698 char device[] = "/dev/sda1";
5699 device[5] = devchar;
5702 r = guestfs_mkfs (g, fstype, device);
5707 char device[] = "/dev/sda1";
5708 device[5] = devchar;
5709 char mountpoint[] = "/";
5712 r = guestfs_mount (g, device, mountpoint);
5716 /* TestOutput for checksum (5) */
5717 char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
5719 char path[] = "/new";
5720 char content[] = "test\n";
5723 r = guestfs_write_file (g, path, content, 0);
5728 char csumtype[] = "sha256";
5729 char path[] = "/new";
5732 r = guestfs_checksum (g, csumtype, path);
5735 if (strcmp (r, expected) != 0) {
5736 fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
5744 static int test_checksum_6_skip (void)
5748 str = getenv ("SKIP_TEST_CHECKSUM_6");
5749 if (str && strcmp (str, "1") == 0) return 1;
5750 str = getenv ("SKIP_TEST_CHECKSUM");
5751 if (str && strcmp (str, "1") == 0) return 1;
5755 static int test_checksum_6 (void)
5757 if (test_checksum_6_skip ()) {
5758 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_6");
5762 /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
5764 char device[] = "/dev/sda";
5765 device[5] = devchar;
5768 r = guestfs_blockdev_setrw (g, device);
5775 r = guestfs_umount_all (g);
5782 r = guestfs_lvm_remove_all (g);
5787 char device[] = "/dev/sda";
5788 device[5] = devchar;
5789 char lines_0[] = ",";
5796 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5801 char fstype[] = "ext2";
5802 char device[] = "/dev/sda1";
5803 device[5] = devchar;
5806 r = guestfs_mkfs (g, fstype, device);
5811 char device[] = "/dev/sda1";
5812 device[5] = devchar;
5813 char mountpoint[] = "/";
5816 r = guestfs_mount (g, device, mountpoint);
5820 /* TestOutput for checksum (6) */
5821 char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
5823 char path[] = "/new";
5824 char content[] = "test\n";
5827 r = guestfs_write_file (g, path, content, 0);
5832 char csumtype[] = "sha384";
5833 char path[] = "/new";
5836 r = guestfs_checksum (g, csumtype, path);
5839 if (strcmp (r, expected) != 0) {
5840 fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
5848 static int test_checksum_7_skip (void)
5852 str = getenv ("SKIP_TEST_CHECKSUM_7");
5853 if (str && strcmp (str, "1") == 0) return 1;
5854 str = getenv ("SKIP_TEST_CHECKSUM");
5855 if (str && strcmp (str, "1") == 0) return 1;
5859 static int test_checksum_7 (void)
5861 if (test_checksum_7_skip ()) {
5862 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_7");
5866 /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
5868 char device[] = "/dev/sda";
5869 device[5] = devchar;
5872 r = guestfs_blockdev_setrw (g, device);
5879 r = guestfs_umount_all (g);
5886 r = guestfs_lvm_remove_all (g);
5891 char device[] = "/dev/sda";
5892 device[5] = devchar;
5893 char lines_0[] = ",";
5900 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5905 char fstype[] = "ext2";
5906 char device[] = "/dev/sda1";
5907 device[5] = devchar;
5910 r = guestfs_mkfs (g, fstype, device);
5915 char device[] = "/dev/sda1";
5916 device[5] = devchar;
5917 char mountpoint[] = "/";
5920 r = guestfs_mount (g, device, mountpoint);
5924 /* TestOutput for checksum (7) */
5925 char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
5927 char path[] = "/new";
5928 char content[] = "test\n";
5931 r = guestfs_write_file (g, path, content, 0);
5936 char csumtype[] = "sha512";
5937 char path[] = "/new";
5940 r = guestfs_checksum (g, csumtype, path);
5943 if (strcmp (r, expected) != 0) {
5944 fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
5952 static int test_checksum_8_skip (void)
5956 str = getenv ("SKIP_TEST_CHECKSUM_8");
5957 if (str && strcmp (str, "1") == 0) return 1;
5958 str = getenv ("SKIP_TEST_CHECKSUM");
5959 if (str && strcmp (str, "1") == 0) return 1;
5963 static int test_checksum_8 (void)
5965 if (test_checksum_8_skip ()) {
5966 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_8");
5970 /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
5972 char device[] = "/dev/sda";
5973 device[5] = devchar;
5976 r = guestfs_blockdev_setrw (g, device);
5983 r = guestfs_umount_all (g);
5990 r = guestfs_lvm_remove_all (g);
5995 char device[] = "/dev/sda";
5996 device[5] = devchar;
5997 char lines_0[] = ",";
6004 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6009 char fstype[] = "ext2";
6010 char device[] = "/dev/sda1";
6011 device[5] = devchar;
6014 r = guestfs_mkfs (g, fstype, device);
6019 char device[] = "/dev/sda1";
6020 device[5] = devchar;
6021 char mountpoint[] = "/";
6024 r = guestfs_mount (g, device, mountpoint);
6028 /* TestOutput for checksum (8) */
6029 char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
6031 char device[] = "/dev/sdd";
6032 device[5] = devchar;
6033 char mountpoint[] = "/";
6036 r = guestfs_mount (g, device, mountpoint);
6041 char csumtype[] = "md5";
6042 char path[] = "/known-3";
6045 r = guestfs_checksum (g, csumtype, path);
6048 if (strcmp (r, expected) != 0) {
6049 fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
6057 static int test_download_0_skip (void)
6061 str = getenv ("SKIP_TEST_DOWNLOAD_0");
6062 if (str && strcmp (str, "1") == 0) return 1;
6063 str = getenv ("SKIP_TEST_DOWNLOAD");
6064 if (str && strcmp (str, "1") == 0) return 1;
6068 static int test_download_0 (void)
6070 if (test_download_0_skip ()) {
6071 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_download_0");
6075 /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
6077 char device[] = "/dev/sda";
6078 device[5] = devchar;
6081 r = guestfs_blockdev_setrw (g, device);
6088 r = guestfs_umount_all (g);
6095 r = guestfs_lvm_remove_all (g);
6100 char device[] = "/dev/sda";
6101 device[5] = devchar;
6102 char lines_0[] = ",";
6109 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6114 char fstype[] = "ext2";
6115 char device[] = "/dev/sda1";
6116 device[5] = devchar;
6119 r = guestfs_mkfs (g, fstype, device);
6124 char device[] = "/dev/sda1";
6125 device[5] = devchar;
6126 char mountpoint[] = "/";
6129 r = guestfs_mount (g, device, mountpoint);
6133 /* TestOutput for download (0) */
6134 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
6136 char remotefilename[] = "/COPYING.LIB";
6139 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
6144 char remotefilename[] = "/COPYING.LIB";
6147 r = guestfs_download (g, remotefilename, "testdownload.tmp");
6152 char remotefilename[] = "/upload";
6155 r = guestfs_upload (g, "testdownload.tmp", remotefilename);
6160 char csumtype[] = "md5";
6161 char path[] = "/upload";
6164 r = guestfs_checksum (g, csumtype, path);
6167 if (strcmp (r, expected) != 0) {
6168 fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
6176 static int test_upload_0_skip (void)
6180 str = getenv ("SKIP_TEST_UPLOAD_0");
6181 if (str && strcmp (str, "1") == 0) return 1;
6182 str = getenv ("SKIP_TEST_UPLOAD");
6183 if (str && strcmp (str, "1") == 0) return 1;
6187 static int test_upload_0 (void)
6189 if (test_upload_0_skip ()) {
6190 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_upload_0");
6194 /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
6196 char device[] = "/dev/sda";
6197 device[5] = devchar;
6200 r = guestfs_blockdev_setrw (g, device);
6207 r = guestfs_umount_all (g);
6214 r = guestfs_lvm_remove_all (g);
6219 char device[] = "/dev/sda";
6220 device[5] = devchar;
6221 char lines_0[] = ",";
6228 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6233 char fstype[] = "ext2";
6234 char device[] = "/dev/sda1";
6235 device[5] = devchar;
6238 r = guestfs_mkfs (g, fstype, device);
6243 char device[] = "/dev/sda1";
6244 device[5] = devchar;
6245 char mountpoint[] = "/";
6248 r = guestfs_mount (g, device, mountpoint);
6252 /* TestOutput for upload (0) */
6253 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
6255 char remotefilename[] = "/COPYING.LIB";
6258 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
6263 char csumtype[] = "md5";
6264 char path[] = "/COPYING.LIB";
6267 r = guestfs_checksum (g, csumtype, path);
6270 if (strcmp (r, expected) != 0) {
6271 fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
6279 static int test_blockdev_rereadpt_0_skip (void)
6283 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
6284 if (str && strcmp (str, "1") == 0) return 1;
6285 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
6286 if (str && strcmp (str, "1") == 0) return 1;
6290 static int test_blockdev_rereadpt_0 (void)
6292 if (test_blockdev_rereadpt_0_skip ()) {
6293 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_rereadpt_0");
6297 /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
6299 char device[] = "/dev/sda";
6300 device[5] = devchar;
6303 r = guestfs_blockdev_setrw (g, device);
6310 r = guestfs_umount_all (g);
6317 r = guestfs_lvm_remove_all (g);
6321 /* TestRun for blockdev_rereadpt (0) */
6323 char device[] = "/dev/sda";
6324 device[5] = devchar;
6327 r = guestfs_blockdev_rereadpt (g, device);
6334 static int test_blockdev_flushbufs_0_skip (void)
6338 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
6339 if (str && strcmp (str, "1") == 0) return 1;
6340 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
6341 if (str && strcmp (str, "1") == 0) return 1;
6345 static int test_blockdev_flushbufs_0 (void)
6347 if (test_blockdev_flushbufs_0_skip ()) {
6348 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_flushbufs_0");
6352 /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
6354 char device[] = "/dev/sda";
6355 device[5] = devchar;
6358 r = guestfs_blockdev_setrw (g, device);
6365 r = guestfs_umount_all (g);
6372 r = guestfs_lvm_remove_all (g);
6376 /* TestRun for blockdev_flushbufs (0) */
6378 char device[] = "/dev/sda";
6379 device[5] = devchar;
6382 r = guestfs_blockdev_flushbufs (g, device);
6389 static int test_blockdev_getsize64_0_skip (void)
6393 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
6394 if (str && strcmp (str, "1") == 0) return 1;
6395 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
6396 if (str && strcmp (str, "1") == 0) return 1;
6400 static int test_blockdev_getsize64_0 (void)
6402 if (test_blockdev_getsize64_0_skip ()) {
6403 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsize64_0");
6407 /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
6409 char device[] = "/dev/sda";
6410 device[5] = devchar;
6413 r = guestfs_blockdev_setrw (g, device);
6420 r = guestfs_umount_all (g);
6427 r = guestfs_lvm_remove_all (g);
6431 /* TestOutputInt for blockdev_getsize64 (0) */
6433 char device[] = "/dev/sda";
6434 device[5] = devchar;
6437 r = guestfs_blockdev_getsize64 (g, device);
6440 if (r != 524288000) {
6441 fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n", (int) r);
6448 static int test_blockdev_getsz_0_skip (void)
6452 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
6453 if (str && strcmp (str, "1") == 0) return 1;
6454 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
6455 if (str && strcmp (str, "1") == 0) return 1;
6459 static int test_blockdev_getsz_0 (void)
6461 if (test_blockdev_getsz_0_skip ()) {
6462 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsz_0");
6466 /* InitNone|InitEmpty for test_blockdev_getsz_0 */
6468 char device[] = "/dev/sda";
6469 device[5] = devchar;
6472 r = guestfs_blockdev_setrw (g, device);
6479 r = guestfs_umount_all (g);
6486 r = guestfs_lvm_remove_all (g);
6490 /* TestOutputInt for blockdev_getsz (0) */
6492 char device[] = "/dev/sda";
6493 device[5] = devchar;
6496 r = guestfs_blockdev_getsz (g, device);
6500 fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n", (int) r);
6507 static int test_blockdev_getbsz_0_skip (void)
6511 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
6512 if (str && strcmp (str, "1") == 0) return 1;
6513 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
6514 if (str && strcmp (str, "1") == 0) return 1;
6518 static int test_blockdev_getbsz_0 (void)
6520 if (test_blockdev_getbsz_0_skip ()) {
6521 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getbsz_0");
6525 /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
6527 char device[] = "/dev/sda";
6528 device[5] = devchar;
6531 r = guestfs_blockdev_setrw (g, device);
6538 r = guestfs_umount_all (g);
6545 r = guestfs_lvm_remove_all (g);
6549 /* TestOutputInt for blockdev_getbsz (0) */
6551 char device[] = "/dev/sda";
6552 device[5] = devchar;
6555 r = guestfs_blockdev_getbsz (g, device);
6559 fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n", (int) r);
6566 static int test_blockdev_getss_0_skip (void)
6570 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
6571 if (str && strcmp (str, "1") == 0) return 1;
6572 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
6573 if (str && strcmp (str, "1") == 0) return 1;
6577 static int test_blockdev_getss_0 (void)
6579 if (test_blockdev_getss_0_skip ()) {
6580 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getss_0");
6584 /* InitNone|InitEmpty for test_blockdev_getss_0 */
6586 char device[] = "/dev/sda";
6587 device[5] = devchar;
6590 r = guestfs_blockdev_setrw (g, device);
6597 r = guestfs_umount_all (g);
6604 r = guestfs_lvm_remove_all (g);
6608 /* TestOutputInt for blockdev_getss (0) */
6610 char device[] = "/dev/sda";
6611 device[5] = devchar;
6614 r = guestfs_blockdev_getss (g, device);
6618 fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n", (int) r);
6625 static int test_blockdev_getro_0_skip (void)
6629 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
6630 if (str && strcmp (str, "1") == 0) return 1;
6631 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
6632 if (str && strcmp (str, "1") == 0) return 1;
6636 static int test_blockdev_getro_0 (void)
6638 if (test_blockdev_getro_0_skip ()) {
6639 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getro_0");
6643 /* InitNone|InitEmpty for test_blockdev_getro_0 */
6645 char device[] = "/dev/sda";
6646 device[5] = devchar;
6649 r = guestfs_blockdev_setrw (g, device);
6656 r = guestfs_umount_all (g);
6663 r = guestfs_lvm_remove_all (g);
6667 /* TestOutputTrue for blockdev_getro (0) */
6669 char device[] = "/dev/sda";
6670 device[5] = devchar;
6673 r = guestfs_blockdev_setro (g, device);
6678 char device[] = "/dev/sda";
6679 device[5] = devchar;
6682 r = guestfs_blockdev_getro (g, device);
6686 fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
6693 static int test_blockdev_setrw_0_skip (void)
6697 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
6698 if (str && strcmp (str, "1") == 0) return 1;
6699 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
6700 if (str && strcmp (str, "1") == 0) return 1;
6704 static int test_blockdev_setrw_0 (void)
6706 if (test_blockdev_setrw_0_skip ()) {
6707 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setrw_0");
6711 /* InitNone|InitEmpty for test_blockdev_setrw_0 */
6713 char device[] = "/dev/sda";
6714 device[5] = devchar;
6717 r = guestfs_blockdev_setrw (g, device);
6724 r = guestfs_umount_all (g);
6731 r = guestfs_lvm_remove_all (g);
6735 /* TestOutputFalse for blockdev_setrw (0) */
6737 char device[] = "/dev/sda";
6738 device[5] = devchar;
6741 r = guestfs_blockdev_setrw (g, device);
6746 char device[] = "/dev/sda";
6747 device[5] = devchar;
6750 r = guestfs_blockdev_getro (g, device);
6754 fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
6761 static int test_blockdev_setro_0_skip (void)
6765 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
6766 if (str && strcmp (str, "1") == 0) return 1;
6767 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
6768 if (str && strcmp (str, "1") == 0) return 1;
6772 static int test_blockdev_setro_0 (void)
6774 if (test_blockdev_setro_0_skip ()) {
6775 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setro_0");
6779 /* InitNone|InitEmpty for test_blockdev_setro_0 */
6781 char device[] = "/dev/sda";
6782 device[5] = devchar;
6785 r = guestfs_blockdev_setrw (g, device);
6792 r = guestfs_umount_all (g);
6799 r = guestfs_lvm_remove_all (g);
6803 /* TestOutputTrue for blockdev_setro (0) */
6805 char device[] = "/dev/sda";
6806 device[5] = devchar;
6809 r = guestfs_blockdev_setro (g, device);
6814 char device[] = "/dev/sda";
6815 device[5] = devchar;
6818 r = guestfs_blockdev_getro (g, device);
6822 fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
6829 static int test_statvfs_0_skip (void)
6833 str = getenv ("SKIP_TEST_STATVFS_0");
6834 if (str && strcmp (str, "1") == 0) return 1;
6835 str = getenv ("SKIP_TEST_STATVFS");
6836 if (str && strcmp (str, "1") == 0) return 1;
6840 static int test_statvfs_0 (void)
6842 if (test_statvfs_0_skip ()) {
6843 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_statvfs_0");
6847 /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
6849 char device[] = "/dev/sda";
6850 device[5] = devchar;
6853 r = guestfs_blockdev_setrw (g, device);
6860 r = guestfs_umount_all (g);
6867 r = guestfs_lvm_remove_all (g);
6872 char device[] = "/dev/sda";
6873 device[5] = devchar;
6874 char lines_0[] = ",";
6881 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6886 char fstype[] = "ext2";
6887 char device[] = "/dev/sda1";
6888 device[5] = devchar;
6891 r = guestfs_mkfs (g, fstype, device);
6896 char device[] = "/dev/sda1";
6897 device[5] = devchar;
6898 char mountpoint[] = "/";
6901 r = guestfs_mount (g, device, mountpoint);
6905 /* TestOutputStruct for statvfs (0) */
6908 struct guestfs_statvfs *r;
6910 r = guestfs_statvfs (g, path);
6913 if (r->bfree != 487702) {
6914 fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
6918 if (r->blocks != 490020) {
6919 fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
6923 if (r->bsize != 1024) {
6924 fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
6933 static int test_lstat_0_skip (void)
6937 str = getenv ("SKIP_TEST_LSTAT_0");
6938 if (str && strcmp (str, "1") == 0) return 1;
6939 str = getenv ("SKIP_TEST_LSTAT");
6940 if (str && strcmp (str, "1") == 0) return 1;
6944 static int test_lstat_0 (void)
6946 if (test_lstat_0_skip ()) {
6947 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lstat_0");
6951 /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
6953 char device[] = "/dev/sda";
6954 device[5] = devchar;
6957 r = guestfs_blockdev_setrw (g, device);
6964 r = guestfs_umount_all (g);
6971 r = guestfs_lvm_remove_all (g);
6976 char device[] = "/dev/sda";
6977 device[5] = devchar;
6978 char lines_0[] = ",";
6985 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6990 char fstype[] = "ext2";
6991 char device[] = "/dev/sda1";
6992 device[5] = devchar;
6995 r = guestfs_mkfs (g, fstype, device);
7000 char device[] = "/dev/sda1";
7001 device[5] = devchar;
7002 char mountpoint[] = "/";
7005 r = guestfs_mount (g, device, mountpoint);
7009 /* TestOutputStruct for lstat (0) */
7011 char path[] = "/new";
7014 r = guestfs_touch (g, path);
7019 char path[] = "/new";
7020 struct guestfs_stat *r;
7022 r = guestfs_lstat (g, path);
7026 fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
7035 static int test_stat_0_skip (void)
7039 str = getenv ("SKIP_TEST_STAT_0");
7040 if (str && strcmp (str, "1") == 0) return 1;
7041 str = getenv ("SKIP_TEST_STAT");
7042 if (str && strcmp (str, "1") == 0) return 1;
7046 static int test_stat_0 (void)
7048 if (test_stat_0_skip ()) {
7049 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_stat_0");
7053 /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
7055 char device[] = "/dev/sda";
7056 device[5] = devchar;
7059 r = guestfs_blockdev_setrw (g, device);
7066 r = guestfs_umount_all (g);
7073 r = guestfs_lvm_remove_all (g);
7078 char device[] = "/dev/sda";
7079 device[5] = devchar;
7080 char lines_0[] = ",";
7087 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7092 char fstype[] = "ext2";
7093 char device[] = "/dev/sda1";
7094 device[5] = devchar;
7097 r = guestfs_mkfs (g, fstype, device);
7102 char device[] = "/dev/sda1";
7103 device[5] = devchar;
7104 char mountpoint[] = "/";
7107 r = guestfs_mount (g, device, mountpoint);
7111 /* TestOutputStruct for stat (0) */
7113 char path[] = "/new";
7116 r = guestfs_touch (g, path);
7121 char path[] = "/new";
7122 struct guestfs_stat *r;
7124 r = guestfs_stat (g, path);
7128 fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
7137 static int test_command_lines_0_skip (void)
7141 str = getenv ("SKIP_TEST_COMMAND_LINES_0");
7142 if (str && strcmp (str, "1") == 0) return 1;
7143 str = getenv ("SKIP_TEST_COMMAND_LINES");
7144 if (str && strcmp (str, "1") == 0) return 1;
7148 static int test_command_lines_0 (void)
7150 if (test_command_lines_0_skip ()) {
7151 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_0");
7155 /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
7157 char device[] = "/dev/sda";
7158 device[5] = devchar;
7161 r = guestfs_blockdev_setrw (g, device);
7168 r = guestfs_umount_all (g);
7175 r = guestfs_lvm_remove_all (g);
7180 char device[] = "/dev/sda";
7181 device[5] = devchar;
7182 char lines_0[] = ",";
7189 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7194 char fstype[] = "ext2";
7195 char device[] = "/dev/sda1";
7196 device[5] = devchar;
7199 r = guestfs_mkfs (g, fstype, device);
7204 char device[] = "/dev/sda1";
7205 device[5] = devchar;
7206 char mountpoint[] = "/";
7209 r = guestfs_mount (g, device, mountpoint);
7213 /* TestOutputList for command_lines (0) */
7215 char remotefilename[] = "/test-command";
7218 r = guestfs_upload (g, "test-command", remotefilename);
7223 char path[] = "/test-command";
7226 r = guestfs_chmod (g, 493, path);
7231 char arguments_0[] = "/test-command";
7232 char arguments_1[] = "1";
7233 char *arguments[] = {
7241 r = guestfs_command_lines (g, arguments);
7245 fprintf (stderr, "test_command_lines_0: short list returned from command\n");
7250 char expected[] = "Result1";
7251 if (strcmp (r[0], expected) != 0) {
7252 fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7257 fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
7261 for (i = 0; r[i] != NULL; ++i)
7268 static int test_command_lines_1_skip (void)
7272 str = getenv ("SKIP_TEST_COMMAND_LINES_1");
7273 if (str && strcmp (str, "1") == 0) return 1;
7274 str = getenv ("SKIP_TEST_COMMAND_LINES");
7275 if (str && strcmp (str, "1") == 0) return 1;
7279 static int test_command_lines_1 (void)
7281 if (test_command_lines_1_skip ()) {
7282 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_1");
7286 /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
7288 char device[] = "/dev/sda";
7289 device[5] = devchar;
7292 r = guestfs_blockdev_setrw (g, device);
7299 r = guestfs_umount_all (g);
7306 r = guestfs_lvm_remove_all (g);
7311 char device[] = "/dev/sda";
7312 device[5] = devchar;
7313 char lines_0[] = ",";
7320 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7325 char fstype[] = "ext2";
7326 char device[] = "/dev/sda1";
7327 device[5] = devchar;
7330 r = guestfs_mkfs (g, fstype, device);
7335 char device[] = "/dev/sda1";
7336 device[5] = devchar;
7337 char mountpoint[] = "/";
7340 r = guestfs_mount (g, device, mountpoint);
7344 /* TestOutputList for command_lines (1) */
7346 char remotefilename[] = "/test-command";
7349 r = guestfs_upload (g, "test-command", remotefilename);
7354 char path[] = "/test-command";
7357 r = guestfs_chmod (g, 493, path);
7362 char arguments_0[] = "/test-command";
7363 char arguments_1[] = "2";
7364 char *arguments[] = {
7372 r = guestfs_command_lines (g, arguments);
7376 fprintf (stderr, "test_command_lines_1: short list returned from command\n");
7381 char expected[] = "Result2";
7382 if (strcmp (r[0], expected) != 0) {
7383 fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7388 fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
7392 for (i = 0; r[i] != NULL; ++i)
7399 static int test_command_lines_2_skip (void)
7403 str = getenv ("SKIP_TEST_COMMAND_LINES_2");
7404 if (str && strcmp (str, "1") == 0) return 1;
7405 str = getenv ("SKIP_TEST_COMMAND_LINES");
7406 if (str && strcmp (str, "1") == 0) return 1;
7410 static int test_command_lines_2 (void)
7412 if (test_command_lines_2_skip ()) {
7413 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_2");
7417 /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
7419 char device[] = "/dev/sda";
7420 device[5] = devchar;
7423 r = guestfs_blockdev_setrw (g, device);
7430 r = guestfs_umount_all (g);
7437 r = guestfs_lvm_remove_all (g);
7442 char device[] = "/dev/sda";
7443 device[5] = devchar;
7444 char lines_0[] = ",";
7451 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7456 char fstype[] = "ext2";
7457 char device[] = "/dev/sda1";
7458 device[5] = devchar;
7461 r = guestfs_mkfs (g, fstype, device);
7466 char device[] = "/dev/sda1";
7467 device[5] = devchar;
7468 char mountpoint[] = "/";
7471 r = guestfs_mount (g, device, mountpoint);
7475 /* TestOutputList for command_lines (2) */
7477 char remotefilename[] = "/test-command";
7480 r = guestfs_upload (g, "test-command", remotefilename);
7485 char path[] = "/test-command";
7488 r = guestfs_chmod (g, 493, path);
7493 char arguments_0[] = "/test-command";
7494 char arguments_1[] = "3";
7495 char *arguments[] = {
7503 r = guestfs_command_lines (g, arguments);
7507 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7512 char expected[] = "";
7513 if (strcmp (r[0], expected) != 0) {
7514 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7519 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7524 char expected[] = "Result3";
7525 if (strcmp (r[1], expected) != 0) {
7526 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7531 fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
7535 for (i = 0; r[i] != NULL; ++i)
7542 static int test_command_lines_3_skip (void)
7546 str = getenv ("SKIP_TEST_COMMAND_LINES_3");
7547 if (str && strcmp (str, "1") == 0) return 1;
7548 str = getenv ("SKIP_TEST_COMMAND_LINES");
7549 if (str && strcmp (str, "1") == 0) return 1;
7553 static int test_command_lines_3 (void)
7555 if (test_command_lines_3_skip ()) {
7556 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_3");
7560 /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
7562 char device[] = "/dev/sda";
7563 device[5] = devchar;
7566 r = guestfs_blockdev_setrw (g, device);
7573 r = guestfs_umount_all (g);
7580 r = guestfs_lvm_remove_all (g);
7585 char device[] = "/dev/sda";
7586 device[5] = devchar;
7587 char lines_0[] = ",";
7594 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7599 char fstype[] = "ext2";
7600 char device[] = "/dev/sda1";
7601 device[5] = devchar;
7604 r = guestfs_mkfs (g, fstype, device);
7609 char device[] = "/dev/sda1";
7610 device[5] = devchar;
7611 char mountpoint[] = "/";
7614 r = guestfs_mount (g, device, mountpoint);
7618 /* TestOutputList for command_lines (3) */
7620 char remotefilename[] = "/test-command";
7623 r = guestfs_upload (g, "test-command", remotefilename);
7628 char path[] = "/test-command";
7631 r = guestfs_chmod (g, 493, path);
7636 char arguments_0[] = "/test-command";
7637 char arguments_1[] = "4";
7638 char *arguments[] = {
7646 r = guestfs_command_lines (g, arguments);
7650 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7655 char expected[] = "";
7656 if (strcmp (r[0], expected) != 0) {
7657 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7662 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7667 char expected[] = "Result4";
7668 if (strcmp (r[1], expected) != 0) {
7669 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7674 fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
7678 for (i = 0; r[i] != NULL; ++i)
7685 static int test_command_lines_4_skip (void)
7689 str = getenv ("SKIP_TEST_COMMAND_LINES_4");
7690 if (str && strcmp (str, "1") == 0) return 1;
7691 str = getenv ("SKIP_TEST_COMMAND_LINES");
7692 if (str && strcmp (str, "1") == 0) return 1;
7696 static int test_command_lines_4 (void)
7698 if (test_command_lines_4_skip ()) {
7699 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_4");
7703 /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
7705 char device[] = "/dev/sda";
7706 device[5] = devchar;
7709 r = guestfs_blockdev_setrw (g, device);
7716 r = guestfs_umount_all (g);
7723 r = guestfs_lvm_remove_all (g);
7728 char device[] = "/dev/sda";
7729 device[5] = devchar;
7730 char lines_0[] = ",";
7737 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7742 char fstype[] = "ext2";
7743 char device[] = "/dev/sda1";
7744 device[5] = devchar;
7747 r = guestfs_mkfs (g, fstype, device);
7752 char device[] = "/dev/sda1";
7753 device[5] = devchar;
7754 char mountpoint[] = "/";
7757 r = guestfs_mount (g, device, mountpoint);
7761 /* TestOutputList for command_lines (4) */
7763 char remotefilename[] = "/test-command";
7766 r = guestfs_upload (g, "test-command", remotefilename);
7771 char path[] = "/test-command";
7774 r = guestfs_chmod (g, 493, path);
7779 char arguments_0[] = "/test-command";
7780 char arguments_1[] = "5";
7781 char *arguments[] = {
7789 r = guestfs_command_lines (g, arguments);
7793 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7798 char expected[] = "";
7799 if (strcmp (r[0], expected) != 0) {
7800 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7805 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7810 char expected[] = "Result5";
7811 if (strcmp (r[1], expected) != 0) {
7812 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7817 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7822 char expected[] = "";
7823 if (strcmp (r[2], expected) != 0) {
7824 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
7829 fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
7833 for (i = 0; r[i] != NULL; ++i)
7840 static int test_command_lines_5_skip (void)
7844 str = getenv ("SKIP_TEST_COMMAND_LINES_5");
7845 if (str && strcmp (str, "1") == 0) return 1;
7846 str = getenv ("SKIP_TEST_COMMAND_LINES");
7847 if (str && strcmp (str, "1") == 0) return 1;
7851 static int test_command_lines_5 (void)
7853 if (test_command_lines_5_skip ()) {
7854 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_5");
7858 /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
7860 char device[] = "/dev/sda";
7861 device[5] = devchar;
7864 r = guestfs_blockdev_setrw (g, device);
7871 r = guestfs_umount_all (g);
7878 r = guestfs_lvm_remove_all (g);
7883 char device[] = "/dev/sda";
7884 device[5] = devchar;
7885 char lines_0[] = ",";
7892 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7897 char fstype[] = "ext2";
7898 char device[] = "/dev/sda1";
7899 device[5] = devchar;
7902 r = guestfs_mkfs (g, fstype, device);
7907 char device[] = "/dev/sda1";
7908 device[5] = devchar;
7909 char mountpoint[] = "/";
7912 r = guestfs_mount (g, device, mountpoint);
7916 /* TestOutputList for command_lines (5) */
7918 char remotefilename[] = "/test-command";
7921 r = guestfs_upload (g, "test-command", remotefilename);
7926 char path[] = "/test-command";
7929 r = guestfs_chmod (g, 493, path);
7934 char arguments_0[] = "/test-command";
7935 char arguments_1[] = "6";
7936 char *arguments[] = {
7944 r = guestfs_command_lines (g, arguments);
7948 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7953 char expected[] = "";
7954 if (strcmp (r[0], expected) != 0) {
7955 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7960 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7965 char expected[] = "";
7966 if (strcmp (r[1], expected) != 0) {
7967 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7972 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7977 char expected[] = "Result6";
7978 if (strcmp (r[2], expected) != 0) {
7979 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
7984 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7989 char expected[] = "";
7990 if (strcmp (r[3], expected) != 0) {
7991 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
7996 fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
8000 for (i = 0; r[i] != NULL; ++i)
8007 static int test_command_lines_6_skip (void)
8011 str = getenv ("SKIP_TEST_COMMAND_LINES_6");
8012 if (str && strcmp (str, "1") == 0) return 1;
8013 str = getenv ("SKIP_TEST_COMMAND_LINES");
8014 if (str && strcmp (str, "1") == 0) return 1;
8018 static int test_command_lines_6 (void)
8020 if (test_command_lines_6_skip ()) {
8021 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_6");
8025 /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
8027 char device[] = "/dev/sda";
8028 device[5] = devchar;
8031 r = guestfs_blockdev_setrw (g, device);
8038 r = guestfs_umount_all (g);
8045 r = guestfs_lvm_remove_all (g);
8050 char device[] = "/dev/sda";
8051 device[5] = devchar;
8052 char lines_0[] = ",";
8059 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8064 char fstype[] = "ext2";
8065 char device[] = "/dev/sda1";
8066 device[5] = devchar;
8069 r = guestfs_mkfs (g, fstype, device);
8074 char device[] = "/dev/sda1";
8075 device[5] = devchar;
8076 char mountpoint[] = "/";
8079 r = guestfs_mount (g, device, mountpoint);
8083 /* TestOutputList for command_lines (6) */
8085 char remotefilename[] = "/test-command";
8088 r = guestfs_upload (g, "test-command", remotefilename);
8093 char path[] = "/test-command";
8096 r = guestfs_chmod (g, 493, path);
8101 char arguments_0[] = "/test-command";
8102 char arguments_1[] = "7";
8103 char *arguments[] = {
8111 r = guestfs_command_lines (g, arguments);
8115 fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
8119 for (i = 0; r[i] != NULL; ++i)
8126 static int test_command_lines_7_skip (void)
8130 str = getenv ("SKIP_TEST_COMMAND_LINES_7");
8131 if (str && strcmp (str, "1") == 0) return 1;
8132 str = getenv ("SKIP_TEST_COMMAND_LINES");
8133 if (str && strcmp (str, "1") == 0) return 1;
8137 static int test_command_lines_7 (void)
8139 if (test_command_lines_7_skip ()) {
8140 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_7");
8144 /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
8146 char device[] = "/dev/sda";
8147 device[5] = devchar;
8150 r = guestfs_blockdev_setrw (g, device);
8157 r = guestfs_umount_all (g);
8164 r = guestfs_lvm_remove_all (g);
8169 char device[] = "/dev/sda";
8170 device[5] = devchar;
8171 char lines_0[] = ",";
8178 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8183 char fstype[] = "ext2";
8184 char device[] = "/dev/sda1";
8185 device[5] = devchar;
8188 r = guestfs_mkfs (g, fstype, device);
8193 char device[] = "/dev/sda1";
8194 device[5] = devchar;
8195 char mountpoint[] = "/";
8198 r = guestfs_mount (g, device, mountpoint);
8202 /* TestOutputList for command_lines (7) */
8204 char remotefilename[] = "/test-command";
8207 r = guestfs_upload (g, "test-command", remotefilename);
8212 char path[] = "/test-command";
8215 r = guestfs_chmod (g, 493, path);
8220 char arguments_0[] = "/test-command";
8221 char arguments_1[] = "8";
8222 char *arguments[] = {
8230 r = guestfs_command_lines (g, arguments);
8234 fprintf (stderr, "test_command_lines_7: short list returned from command\n");
8239 char expected[] = "";
8240 if (strcmp (r[0], expected) != 0) {
8241 fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8246 fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
8250 for (i = 0; r[i] != NULL; ++i)
8257 static int test_command_lines_8_skip (void)
8261 str = getenv ("SKIP_TEST_COMMAND_LINES_8");
8262 if (str && strcmp (str, "1") == 0) return 1;
8263 str = getenv ("SKIP_TEST_COMMAND_LINES");
8264 if (str && strcmp (str, "1") == 0) return 1;
8268 static int test_command_lines_8 (void)
8270 if (test_command_lines_8_skip ()) {
8271 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_8");
8275 /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
8277 char device[] = "/dev/sda";
8278 device[5] = devchar;
8281 r = guestfs_blockdev_setrw (g, device);
8288 r = guestfs_umount_all (g);
8295 r = guestfs_lvm_remove_all (g);
8300 char device[] = "/dev/sda";
8301 device[5] = devchar;
8302 char lines_0[] = ",";
8309 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8314 char fstype[] = "ext2";
8315 char device[] = "/dev/sda1";
8316 device[5] = devchar;
8319 r = guestfs_mkfs (g, fstype, device);
8324 char device[] = "/dev/sda1";
8325 device[5] = devchar;
8326 char mountpoint[] = "/";
8329 r = guestfs_mount (g, device, mountpoint);
8333 /* TestOutputList for command_lines (8) */
8335 char remotefilename[] = "/test-command";
8338 r = guestfs_upload (g, "test-command", remotefilename);
8343 char path[] = "/test-command";
8346 r = guestfs_chmod (g, 493, path);
8351 char arguments_0[] = "/test-command";
8352 char arguments_1[] = "9";
8353 char *arguments[] = {
8361 r = guestfs_command_lines (g, arguments);
8365 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8370 char expected[] = "";
8371 if (strcmp (r[0], expected) != 0) {
8372 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8377 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8382 char expected[] = "";
8383 if (strcmp (r[1], expected) != 0) {
8384 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8389 fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
8393 for (i = 0; r[i] != NULL; ++i)
8400 static int test_command_lines_9_skip (void)
8404 str = getenv ("SKIP_TEST_COMMAND_LINES_9");
8405 if (str && strcmp (str, "1") == 0) return 1;
8406 str = getenv ("SKIP_TEST_COMMAND_LINES");
8407 if (str && strcmp (str, "1") == 0) return 1;
8411 static int test_command_lines_9 (void)
8413 if (test_command_lines_9_skip ()) {
8414 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_9");
8418 /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
8420 char device[] = "/dev/sda";
8421 device[5] = devchar;
8424 r = guestfs_blockdev_setrw (g, device);
8431 r = guestfs_umount_all (g);
8438 r = guestfs_lvm_remove_all (g);
8443 char device[] = "/dev/sda";
8444 device[5] = devchar;
8445 char lines_0[] = ",";
8452 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8457 char fstype[] = "ext2";
8458 char device[] = "/dev/sda1";
8459 device[5] = devchar;
8462 r = guestfs_mkfs (g, fstype, device);
8467 char device[] = "/dev/sda1";
8468 device[5] = devchar;
8469 char mountpoint[] = "/";
8472 r = guestfs_mount (g, device, mountpoint);
8476 /* TestOutputList for command_lines (9) */
8478 char remotefilename[] = "/test-command";
8481 r = guestfs_upload (g, "test-command", remotefilename);
8486 char path[] = "/test-command";
8489 r = guestfs_chmod (g, 493, path);
8494 char arguments_0[] = "/test-command";
8495 char arguments_1[] = "10";
8496 char *arguments[] = {
8504 r = guestfs_command_lines (g, arguments);
8508 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8513 char expected[] = "Result10-1";
8514 if (strcmp (r[0], expected) != 0) {
8515 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8520 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8525 char expected[] = "Result10-2";
8526 if (strcmp (r[1], expected) != 0) {
8527 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8532 fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
8536 for (i = 0; r[i] != NULL; ++i)
8543 static int test_command_lines_10_skip (void)
8547 str = getenv ("SKIP_TEST_COMMAND_LINES_10");
8548 if (str && strcmp (str, "1") == 0) return 1;
8549 str = getenv ("SKIP_TEST_COMMAND_LINES");
8550 if (str && strcmp (str, "1") == 0) return 1;
8554 static int test_command_lines_10 (void)
8556 if (test_command_lines_10_skip ()) {
8557 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_10");
8561 /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
8563 char device[] = "/dev/sda";
8564 device[5] = devchar;
8567 r = guestfs_blockdev_setrw (g, device);
8574 r = guestfs_umount_all (g);
8581 r = guestfs_lvm_remove_all (g);
8586 char device[] = "/dev/sda";
8587 device[5] = devchar;
8588 char lines_0[] = ",";
8595 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8600 char fstype[] = "ext2";
8601 char device[] = "/dev/sda1";
8602 device[5] = devchar;
8605 r = guestfs_mkfs (g, fstype, device);
8610 char device[] = "/dev/sda1";
8611 device[5] = devchar;
8612 char mountpoint[] = "/";
8615 r = guestfs_mount (g, device, mountpoint);
8619 /* TestOutputList for command_lines (10) */
8621 char remotefilename[] = "/test-command";
8624 r = guestfs_upload (g, "test-command", remotefilename);
8629 char path[] = "/test-command";
8632 r = guestfs_chmod (g, 493, path);
8637 char arguments_0[] = "/test-command";
8638 char arguments_1[] = "11";
8639 char *arguments[] = {
8647 r = guestfs_command_lines (g, arguments);
8651 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8656 char expected[] = "Result11-1";
8657 if (strcmp (r[0], expected) != 0) {
8658 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8663 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8668 char expected[] = "Result11-2";
8669 if (strcmp (r[1], expected) != 0) {
8670 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8675 fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
8679 for (i = 0; r[i] != NULL; ++i)
8686 static int test_command_0_skip (void)
8690 str = getenv ("SKIP_TEST_COMMAND_0");
8691 if (str && strcmp (str, "1") == 0) return 1;
8692 str = getenv ("SKIP_TEST_COMMAND");
8693 if (str && strcmp (str, "1") == 0) return 1;
8697 static int test_command_0 (void)
8699 if (test_command_0_skip ()) {
8700 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_0");
8704 /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
8706 char device[] = "/dev/sda";
8707 device[5] = devchar;
8710 r = guestfs_blockdev_setrw (g, device);
8717 r = guestfs_umount_all (g);
8724 r = guestfs_lvm_remove_all (g);
8729 char device[] = "/dev/sda";
8730 device[5] = devchar;
8731 char lines_0[] = ",";
8738 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8743 char fstype[] = "ext2";
8744 char device[] = "/dev/sda1";
8745 device[5] = devchar;
8748 r = guestfs_mkfs (g, fstype, device);
8753 char device[] = "/dev/sda1";
8754 device[5] = devchar;
8755 char mountpoint[] = "/";
8758 r = guestfs_mount (g, device, mountpoint);
8762 /* TestOutput for command (0) */
8763 char expected[] = "Result1";
8765 char remotefilename[] = "/test-command";
8768 r = guestfs_upload (g, "test-command", remotefilename);
8773 char path[] = "/test-command";
8776 r = guestfs_chmod (g, 493, path);
8781 char arguments_0[] = "/test-command";
8782 char arguments_1[] = "1";
8783 char *arguments[] = {
8790 r = guestfs_command (g, arguments);
8793 if (strcmp (r, expected) != 0) {
8794 fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
8802 static int test_command_1_skip (void)
8806 str = getenv ("SKIP_TEST_COMMAND_1");
8807 if (str && strcmp (str, "1") == 0) return 1;
8808 str = getenv ("SKIP_TEST_COMMAND");
8809 if (str && strcmp (str, "1") == 0) return 1;
8813 static int test_command_1 (void)
8815 if (test_command_1_skip ()) {
8816 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_1");
8820 /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
8822 char device[] = "/dev/sda";
8823 device[5] = devchar;
8826 r = guestfs_blockdev_setrw (g, device);
8833 r = guestfs_umount_all (g);
8840 r = guestfs_lvm_remove_all (g);
8845 char device[] = "/dev/sda";
8846 device[5] = devchar;
8847 char lines_0[] = ",";
8854 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8859 char fstype[] = "ext2";
8860 char device[] = "/dev/sda1";
8861 device[5] = devchar;
8864 r = guestfs_mkfs (g, fstype, device);
8869 char device[] = "/dev/sda1";
8870 device[5] = devchar;
8871 char mountpoint[] = "/";
8874 r = guestfs_mount (g, device, mountpoint);
8878 /* TestOutput for command (1) */
8879 char expected[] = "Result2\n";
8881 char remotefilename[] = "/test-command";
8884 r = guestfs_upload (g, "test-command", remotefilename);
8889 char path[] = "/test-command";
8892 r = guestfs_chmod (g, 493, path);
8897 char arguments_0[] = "/test-command";
8898 char arguments_1[] = "2";
8899 char *arguments[] = {
8906 r = guestfs_command (g, arguments);
8909 if (strcmp (r, expected) != 0) {
8910 fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
8918 static int test_command_2_skip (void)
8922 str = getenv ("SKIP_TEST_COMMAND_2");
8923 if (str && strcmp (str, "1") == 0) return 1;
8924 str = getenv ("SKIP_TEST_COMMAND");
8925 if (str && strcmp (str, "1") == 0) return 1;
8929 static int test_command_2 (void)
8931 if (test_command_2_skip ()) {
8932 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_2");
8936 /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
8938 char device[] = "/dev/sda";
8939 device[5] = devchar;
8942 r = guestfs_blockdev_setrw (g, device);
8949 r = guestfs_umount_all (g);
8956 r = guestfs_lvm_remove_all (g);
8961 char device[] = "/dev/sda";
8962 device[5] = devchar;
8963 char lines_0[] = ",";
8970 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8975 char fstype[] = "ext2";
8976 char device[] = "/dev/sda1";
8977 device[5] = devchar;
8980 r = guestfs_mkfs (g, fstype, device);
8985 char device[] = "/dev/sda1";
8986 device[5] = devchar;
8987 char mountpoint[] = "/";
8990 r = guestfs_mount (g, device, mountpoint);
8994 /* TestOutput for command (2) */
8995 char expected[] = "\nResult3";
8997 char remotefilename[] = "/test-command";
9000 r = guestfs_upload (g, "test-command", remotefilename);
9005 char path[] = "/test-command";
9008 r = guestfs_chmod (g, 493, path);
9013 char arguments_0[] = "/test-command";
9014 char arguments_1[] = "3";
9015 char *arguments[] = {
9022 r = guestfs_command (g, arguments);
9025 if (strcmp (r, expected) != 0) {
9026 fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
9034 static int test_command_3_skip (void)
9038 str = getenv ("SKIP_TEST_COMMAND_3");
9039 if (str && strcmp (str, "1") == 0) return 1;
9040 str = getenv ("SKIP_TEST_COMMAND");
9041 if (str && strcmp (str, "1") == 0) return 1;
9045 static int test_command_3 (void)
9047 if (test_command_3_skip ()) {
9048 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_3");
9052 /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
9054 char device[] = "/dev/sda";
9055 device[5] = devchar;
9058 r = guestfs_blockdev_setrw (g, device);
9065 r = guestfs_umount_all (g);
9072 r = guestfs_lvm_remove_all (g);
9077 char device[] = "/dev/sda";
9078 device[5] = devchar;
9079 char lines_0[] = ",";
9086 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9091 char fstype[] = "ext2";
9092 char device[] = "/dev/sda1";
9093 device[5] = devchar;
9096 r = guestfs_mkfs (g, fstype, device);
9101 char device[] = "/dev/sda1";
9102 device[5] = devchar;
9103 char mountpoint[] = "/";
9106 r = guestfs_mount (g, device, mountpoint);
9110 /* TestOutput for command (3) */
9111 char expected[] = "\nResult4\n";
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[] = "4";
9131 char *arguments[] = {
9138 r = guestfs_command (g, arguments);
9141 if (strcmp (r, expected) != 0) {
9142 fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
9150 static int test_command_4_skip (void)
9154 str = getenv ("SKIP_TEST_COMMAND_4");
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_4 (void)
9163 if (test_command_4_skip ()) {
9164 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_4");
9168 /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
9170 char device[] = "/dev/sda";
9171 device[5] = devchar;
9174 r = guestfs_blockdev_setrw (g, device);
9181 r = guestfs_umount_all (g);
9188 r = guestfs_lvm_remove_all (g);
9193 char device[] = "/dev/sda";
9194 device[5] = devchar;
9195 char lines_0[] = ",";
9202 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9207 char fstype[] = "ext2";
9208 char device[] = "/dev/sda1";
9209 device[5] = devchar;
9212 r = guestfs_mkfs (g, fstype, device);
9217 char device[] = "/dev/sda1";
9218 device[5] = devchar;
9219 char mountpoint[] = "/";
9222 r = guestfs_mount (g, device, mountpoint);
9226 /* TestOutput for command (4) */
9227 char expected[] = "\nResult5\n\n";
9229 char remotefilename[] = "/test-command";
9232 r = guestfs_upload (g, "test-command", remotefilename);
9237 char path[] = "/test-command";
9240 r = guestfs_chmod (g, 493, path);
9245 char arguments_0[] = "/test-command";
9246 char arguments_1[] = "5";
9247 char *arguments[] = {
9254 r = guestfs_command (g, arguments);
9257 if (strcmp (r, expected) != 0) {
9258 fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
9266 static int test_command_5_skip (void)
9270 str = getenv ("SKIP_TEST_COMMAND_5");
9271 if (str && strcmp (str, "1") == 0) return 1;
9272 str = getenv ("SKIP_TEST_COMMAND");
9273 if (str && strcmp (str, "1") == 0) return 1;
9277 static int test_command_5 (void)
9279 if (test_command_5_skip ()) {
9280 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_5");
9284 /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
9286 char device[] = "/dev/sda";
9287 device[5] = devchar;
9290 r = guestfs_blockdev_setrw (g, device);
9297 r = guestfs_umount_all (g);
9304 r = guestfs_lvm_remove_all (g);
9309 char device[] = "/dev/sda";
9310 device[5] = devchar;
9311 char lines_0[] = ",";
9318 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9323 char fstype[] = "ext2";
9324 char device[] = "/dev/sda1";
9325 device[5] = devchar;
9328 r = guestfs_mkfs (g, fstype, device);
9333 char device[] = "/dev/sda1";
9334 device[5] = devchar;
9335 char mountpoint[] = "/";
9338 r = guestfs_mount (g, device, mountpoint);
9342 /* TestOutput for command (5) */
9343 char expected[] = "\n\nResult6\n\n";
9345 char remotefilename[] = "/test-command";
9348 r = guestfs_upload (g, "test-command", remotefilename);
9353 char path[] = "/test-command";
9356 r = guestfs_chmod (g, 493, path);
9361 char arguments_0[] = "/test-command";
9362 char arguments_1[] = "6";
9363 char *arguments[] = {
9370 r = guestfs_command (g, arguments);
9373 if (strcmp (r, expected) != 0) {
9374 fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
9382 static int test_command_6_skip (void)
9386 str = getenv ("SKIP_TEST_COMMAND_6");
9387 if (str && strcmp (str, "1") == 0) return 1;
9388 str = getenv ("SKIP_TEST_COMMAND");
9389 if (str && strcmp (str, "1") == 0) return 1;
9393 static int test_command_6 (void)
9395 if (test_command_6_skip ()) {
9396 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_6");
9400 /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
9402 char device[] = "/dev/sda";
9403 device[5] = devchar;
9406 r = guestfs_blockdev_setrw (g, device);
9413 r = guestfs_umount_all (g);
9420 r = guestfs_lvm_remove_all (g);
9425 char device[] = "/dev/sda";
9426 device[5] = devchar;
9427 char lines_0[] = ",";
9434 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9439 char fstype[] = "ext2";
9440 char device[] = "/dev/sda1";
9441 device[5] = devchar;
9444 r = guestfs_mkfs (g, fstype, device);
9449 char device[] = "/dev/sda1";
9450 device[5] = devchar;
9451 char mountpoint[] = "/";
9454 r = guestfs_mount (g, device, mountpoint);
9458 /* TestOutput for command (6) */
9459 char expected[] = "";
9461 char remotefilename[] = "/test-command";
9464 r = guestfs_upload (g, "test-command", remotefilename);
9469 char path[] = "/test-command";
9472 r = guestfs_chmod (g, 493, path);
9477 char arguments_0[] = "/test-command";
9478 char arguments_1[] = "7";
9479 char *arguments[] = {
9486 r = guestfs_command (g, arguments);
9489 if (strcmp (r, expected) != 0) {
9490 fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
9498 static int test_command_7_skip (void)
9502 str = getenv ("SKIP_TEST_COMMAND_7");
9503 if (str && strcmp (str, "1") == 0) return 1;
9504 str = getenv ("SKIP_TEST_COMMAND");
9505 if (str && strcmp (str, "1") == 0) return 1;
9509 static int test_command_7 (void)
9511 if (test_command_7_skip ()) {
9512 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_7");
9516 /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
9518 char device[] = "/dev/sda";
9519 device[5] = devchar;
9522 r = guestfs_blockdev_setrw (g, device);
9529 r = guestfs_umount_all (g);
9536 r = guestfs_lvm_remove_all (g);
9541 char device[] = "/dev/sda";
9542 device[5] = devchar;
9543 char lines_0[] = ",";
9550 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9555 char fstype[] = "ext2";
9556 char device[] = "/dev/sda1";
9557 device[5] = devchar;
9560 r = guestfs_mkfs (g, fstype, device);
9565 char device[] = "/dev/sda1";
9566 device[5] = devchar;
9567 char mountpoint[] = "/";
9570 r = guestfs_mount (g, device, mountpoint);
9574 /* TestOutput for command (7) */
9575 char expected[] = "\n";
9577 char remotefilename[] = "/test-command";
9580 r = guestfs_upload (g, "test-command", remotefilename);
9585 char path[] = "/test-command";
9588 r = guestfs_chmod (g, 493, path);
9593 char arguments_0[] = "/test-command";
9594 char arguments_1[] = "8";
9595 char *arguments[] = {
9602 r = guestfs_command (g, arguments);
9605 if (strcmp (r, expected) != 0) {
9606 fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
9614 static int test_command_8_skip (void)
9618 str = getenv ("SKIP_TEST_COMMAND_8");
9619 if (str && strcmp (str, "1") == 0) return 1;
9620 str = getenv ("SKIP_TEST_COMMAND");
9621 if (str && strcmp (str, "1") == 0) return 1;
9625 static int test_command_8 (void)
9627 if (test_command_8_skip ()) {
9628 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_8");
9632 /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
9634 char device[] = "/dev/sda";
9635 device[5] = devchar;
9638 r = guestfs_blockdev_setrw (g, device);
9645 r = guestfs_umount_all (g);
9652 r = guestfs_lvm_remove_all (g);
9657 char device[] = "/dev/sda";
9658 device[5] = devchar;
9659 char lines_0[] = ",";
9666 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9671 char fstype[] = "ext2";
9672 char device[] = "/dev/sda1";
9673 device[5] = devchar;
9676 r = guestfs_mkfs (g, fstype, device);
9681 char device[] = "/dev/sda1";
9682 device[5] = devchar;
9683 char mountpoint[] = "/";
9686 r = guestfs_mount (g, device, mountpoint);
9690 /* TestOutput for command (8) */
9691 char expected[] = "\n\n";
9693 char remotefilename[] = "/test-command";
9696 r = guestfs_upload (g, "test-command", remotefilename);
9701 char path[] = "/test-command";
9704 r = guestfs_chmod (g, 493, path);
9709 char arguments_0[] = "/test-command";
9710 char arguments_1[] = "9";
9711 char *arguments[] = {
9718 r = guestfs_command (g, arguments);
9721 if (strcmp (r, expected) != 0) {
9722 fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
9730 static int test_command_9_skip (void)
9734 str = getenv ("SKIP_TEST_COMMAND_9");
9735 if (str && strcmp (str, "1") == 0) return 1;
9736 str = getenv ("SKIP_TEST_COMMAND");
9737 if (str && strcmp (str, "1") == 0) return 1;
9741 static int test_command_9 (void)
9743 if (test_command_9_skip ()) {
9744 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_9");
9748 /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
9750 char device[] = "/dev/sda";
9751 device[5] = devchar;
9754 r = guestfs_blockdev_setrw (g, device);
9761 r = guestfs_umount_all (g);
9768 r = guestfs_lvm_remove_all (g);
9773 char device[] = "/dev/sda";
9774 device[5] = devchar;
9775 char lines_0[] = ",";
9782 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9787 char fstype[] = "ext2";
9788 char device[] = "/dev/sda1";
9789 device[5] = devchar;
9792 r = guestfs_mkfs (g, fstype, device);
9797 char device[] = "/dev/sda1";
9798 device[5] = devchar;
9799 char mountpoint[] = "/";
9802 r = guestfs_mount (g, device, mountpoint);
9806 /* TestOutput for command (9) */
9807 char expected[] = "Result10-1\nResult10-2\n";
9809 char remotefilename[] = "/test-command";
9812 r = guestfs_upload (g, "test-command", remotefilename);
9817 char path[] = "/test-command";
9820 r = guestfs_chmod (g, 493, path);
9825 char arguments_0[] = "/test-command";
9826 char arguments_1[] = "10";
9827 char *arguments[] = {
9834 r = guestfs_command (g, arguments);
9837 if (strcmp (r, expected) != 0) {
9838 fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
9846 static int test_command_10_skip (void)
9850 str = getenv ("SKIP_TEST_COMMAND_10");
9851 if (str && strcmp (str, "1") == 0) return 1;
9852 str = getenv ("SKIP_TEST_COMMAND");
9853 if (str && strcmp (str, "1") == 0) return 1;
9857 static int test_command_10 (void)
9859 if (test_command_10_skip ()) {
9860 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_10");
9864 /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
9866 char device[] = "/dev/sda";
9867 device[5] = devchar;
9870 r = guestfs_blockdev_setrw (g, device);
9877 r = guestfs_umount_all (g);
9884 r = guestfs_lvm_remove_all (g);
9889 char device[] = "/dev/sda";
9890 device[5] = devchar;
9891 char lines_0[] = ",";
9898 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9903 char fstype[] = "ext2";
9904 char device[] = "/dev/sda1";
9905 device[5] = devchar;
9908 r = guestfs_mkfs (g, fstype, device);
9913 char device[] = "/dev/sda1";
9914 device[5] = devchar;
9915 char mountpoint[] = "/";
9918 r = guestfs_mount (g, device, mountpoint);
9922 /* TestOutput for command (10) */
9923 char expected[] = "Result11-1\nResult11-2";
9925 char remotefilename[] = "/test-command";
9928 r = guestfs_upload (g, "test-command", remotefilename);
9933 char path[] = "/test-command";
9936 r = guestfs_chmod (g, 493, path);
9941 char arguments_0[] = "/test-command";
9942 char arguments_1[] = "11";
9943 char *arguments[] = {
9950 r = guestfs_command (g, arguments);
9953 if (strcmp (r, expected) != 0) {
9954 fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
9962 static int test_command_11_skip (void)
9966 str = getenv ("SKIP_TEST_COMMAND_11");
9967 if (str && strcmp (str, "1") == 0) return 1;
9968 str = getenv ("SKIP_TEST_COMMAND");
9969 if (str && strcmp (str, "1") == 0) return 1;
9973 static int test_command_11 (void)
9975 if (test_command_11_skip ()) {
9976 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_11");
9980 /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
9982 char device[] = "/dev/sda";
9983 device[5] = devchar;
9986 r = guestfs_blockdev_setrw (g, device);
9993 r = guestfs_umount_all (g);
10000 r = guestfs_lvm_remove_all (g);
10005 char device[] = "/dev/sda";
10006 device[5] = devchar;
10007 char lines_0[] = ",";
10013 suppress_error = 0;
10014 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10019 char fstype[] = "ext2";
10020 char device[] = "/dev/sda1";
10021 device[5] = devchar;
10023 suppress_error = 0;
10024 r = guestfs_mkfs (g, fstype, device);
10029 char device[] = "/dev/sda1";
10030 device[5] = devchar;
10031 char mountpoint[] = "/";
10033 suppress_error = 0;
10034 r = guestfs_mount (g, device, mountpoint);
10038 /* TestLastFail for command (11) */
10040 char remotefilename[] = "/test-command";
10042 suppress_error = 0;
10043 r = guestfs_upload (g, "test-command", remotefilename);
10048 char path[] = "/test-command";
10050 suppress_error = 0;
10051 r = guestfs_chmod (g, 493, path);
10056 char arguments_0[] = "/test-command";
10057 char *arguments[] = {
10062 suppress_error = 1;
10063 r = guestfs_command (g, arguments);
10071 static int test_file_0_skip (void)
10075 str = getenv ("SKIP_TEST_FILE_0");
10076 if (str && strcmp (str, "1") == 0) return 1;
10077 str = getenv ("SKIP_TEST_FILE");
10078 if (str && strcmp (str, "1") == 0) return 1;
10082 static int test_file_0 (void)
10084 if (test_file_0_skip ()) {
10085 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_0");
10089 /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
10091 char device[] = "/dev/sda";
10092 device[5] = devchar;
10094 suppress_error = 0;
10095 r = guestfs_blockdev_setrw (g, device);
10101 suppress_error = 0;
10102 r = guestfs_umount_all (g);
10108 suppress_error = 0;
10109 r = guestfs_lvm_remove_all (g);
10114 char device[] = "/dev/sda";
10115 device[5] = devchar;
10116 char lines_0[] = ",";
10122 suppress_error = 0;
10123 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10128 char fstype[] = "ext2";
10129 char device[] = "/dev/sda1";
10130 device[5] = devchar;
10132 suppress_error = 0;
10133 r = guestfs_mkfs (g, fstype, device);
10138 char device[] = "/dev/sda1";
10139 device[5] = devchar;
10140 char mountpoint[] = "/";
10142 suppress_error = 0;
10143 r = guestfs_mount (g, device, mountpoint);
10147 /* TestOutput for file (0) */
10148 char expected[] = "empty";
10150 char path[] = "/new";
10152 suppress_error = 0;
10153 r = guestfs_touch (g, path);
10158 char path[] = "/new";
10160 suppress_error = 0;
10161 r = guestfs_file (g, path);
10164 if (strcmp (r, expected) != 0) {
10165 fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
10173 static int test_file_1_skip (void)
10177 str = getenv ("SKIP_TEST_FILE_1");
10178 if (str && strcmp (str, "1") == 0) return 1;
10179 str = getenv ("SKIP_TEST_FILE");
10180 if (str && strcmp (str, "1") == 0) return 1;
10184 static int test_file_1 (void)
10186 if (test_file_1_skip ()) {
10187 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_1");
10191 /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
10193 char device[] = "/dev/sda";
10194 device[5] = devchar;
10196 suppress_error = 0;
10197 r = guestfs_blockdev_setrw (g, device);
10203 suppress_error = 0;
10204 r = guestfs_umount_all (g);
10210 suppress_error = 0;
10211 r = guestfs_lvm_remove_all (g);
10216 char device[] = "/dev/sda";
10217 device[5] = devchar;
10218 char lines_0[] = ",";
10224 suppress_error = 0;
10225 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10230 char fstype[] = "ext2";
10231 char device[] = "/dev/sda1";
10232 device[5] = devchar;
10234 suppress_error = 0;
10235 r = guestfs_mkfs (g, fstype, device);
10240 char device[] = "/dev/sda1";
10241 device[5] = devchar;
10242 char mountpoint[] = "/";
10244 suppress_error = 0;
10245 r = guestfs_mount (g, device, mountpoint);
10249 /* TestOutput for file (1) */
10250 char expected[] = "ASCII text";
10252 char path[] = "/new";
10253 char content[] = "some content\n";
10255 suppress_error = 0;
10256 r = guestfs_write_file (g, path, content, 0);
10261 char path[] = "/new";
10263 suppress_error = 0;
10264 r = guestfs_file (g, path);
10267 if (strcmp (r, expected) != 0) {
10268 fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
10276 static int test_file_2_skip (void)
10280 str = getenv ("SKIP_TEST_FILE_2");
10281 if (str && strcmp (str, "1") == 0) return 1;
10282 str = getenv ("SKIP_TEST_FILE");
10283 if (str && strcmp (str, "1") == 0) return 1;
10287 static int test_file_2 (void)
10289 if (test_file_2_skip ()) {
10290 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_2");
10294 /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
10296 char device[] = "/dev/sda";
10297 device[5] = devchar;
10299 suppress_error = 0;
10300 r = guestfs_blockdev_setrw (g, device);
10306 suppress_error = 0;
10307 r = guestfs_umount_all (g);
10313 suppress_error = 0;
10314 r = guestfs_lvm_remove_all (g);
10319 char device[] = "/dev/sda";
10320 device[5] = devchar;
10321 char lines_0[] = ",";
10327 suppress_error = 0;
10328 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10333 char fstype[] = "ext2";
10334 char device[] = "/dev/sda1";
10335 device[5] = devchar;
10337 suppress_error = 0;
10338 r = guestfs_mkfs (g, fstype, device);
10343 char device[] = "/dev/sda1";
10344 device[5] = devchar;
10345 char mountpoint[] = "/";
10347 suppress_error = 0;
10348 r = guestfs_mount (g, device, mountpoint);
10352 /* TestLastFail for file (2) */
10354 char path[] = "/nofile";
10356 suppress_error = 1;
10357 r = guestfs_file (g, path);
10365 static int test_umount_all_0_skip (void)
10369 str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
10370 if (str && strcmp (str, "1") == 0) return 1;
10371 str = getenv ("SKIP_TEST_UMOUNT_ALL");
10372 if (str && strcmp (str, "1") == 0) return 1;
10376 static int test_umount_all_0 (void)
10378 if (test_umount_all_0_skip ()) {
10379 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_0");
10383 /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
10385 char device[] = "/dev/sda";
10386 device[5] = devchar;
10388 suppress_error = 0;
10389 r = guestfs_blockdev_setrw (g, device);
10395 suppress_error = 0;
10396 r = guestfs_umount_all (g);
10402 suppress_error = 0;
10403 r = guestfs_lvm_remove_all (g);
10408 char device[] = "/dev/sda";
10409 device[5] = devchar;
10410 char lines_0[] = ",";
10416 suppress_error = 0;
10417 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10422 char fstype[] = "ext2";
10423 char device[] = "/dev/sda1";
10424 device[5] = devchar;
10426 suppress_error = 0;
10427 r = guestfs_mkfs (g, fstype, device);
10432 char device[] = "/dev/sda1";
10433 device[5] = devchar;
10434 char mountpoint[] = "/";
10436 suppress_error = 0;
10437 r = guestfs_mount (g, device, mountpoint);
10441 /* TestOutputList for umount_all (0) */
10444 suppress_error = 0;
10445 r = guestfs_umount_all (g);
10452 suppress_error = 0;
10453 r = guestfs_mounts (g);
10456 if (r[0] != NULL) {
10457 fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
10461 for (i = 0; r[i] != NULL; ++i)
10468 static int test_umount_all_1_skip (void)
10472 str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
10473 if (str && strcmp (str, "1") == 0) return 1;
10474 str = getenv ("SKIP_TEST_UMOUNT_ALL");
10475 if (str && strcmp (str, "1") == 0) return 1;
10479 static int test_umount_all_1 (void)
10481 if (test_umount_all_1_skip ()) {
10482 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_1");
10486 /* InitNone|InitEmpty for test_umount_all_1 */
10488 char device[] = "/dev/sda";
10489 device[5] = devchar;
10491 suppress_error = 0;
10492 r = guestfs_blockdev_setrw (g, device);
10498 suppress_error = 0;
10499 r = guestfs_umount_all (g);
10505 suppress_error = 0;
10506 r = guestfs_lvm_remove_all (g);
10510 /* TestOutputList for umount_all (1) */
10512 char device[] = "/dev/sda";
10513 device[5] = devchar;
10514 char lines_0[] = ",10";
10515 char lines_1[] = ",20";
10516 char lines_2[] = ",";
10524 suppress_error = 0;
10525 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10530 char fstype[] = "ext2";
10531 char device[] = "/dev/sda1";
10532 device[5] = devchar;
10534 suppress_error = 0;
10535 r = guestfs_mkfs (g, fstype, device);
10540 char fstype[] = "ext2";
10541 char device[] = "/dev/sda2";
10542 device[5] = devchar;
10544 suppress_error = 0;
10545 r = guestfs_mkfs (g, fstype, device);
10550 char fstype[] = "ext2";
10551 char device[] = "/dev/sda3";
10552 device[5] = devchar;
10554 suppress_error = 0;
10555 r = guestfs_mkfs (g, fstype, device);
10560 char device[] = "/dev/sda1";
10561 device[5] = devchar;
10562 char mountpoint[] = "/";
10564 suppress_error = 0;
10565 r = guestfs_mount (g, device, mountpoint);
10570 char path[] = "/mp1";
10572 suppress_error = 0;
10573 r = guestfs_mkdir (g, path);
10578 char device[] = "/dev/sda2";
10579 device[5] = devchar;
10580 char mountpoint[] = "/mp1";
10582 suppress_error = 0;
10583 r = guestfs_mount (g, device, mountpoint);
10588 char path[] = "/mp1/mp2";
10590 suppress_error = 0;
10591 r = guestfs_mkdir (g, path);
10596 char device[] = "/dev/sda3";
10597 device[5] = devchar;
10598 char mountpoint[] = "/mp1/mp2";
10600 suppress_error = 0;
10601 r = guestfs_mount (g, device, mountpoint);
10606 char path[] = "/mp1/mp2/mp3";
10608 suppress_error = 0;
10609 r = guestfs_mkdir (g, path);
10615 suppress_error = 0;
10616 r = guestfs_umount_all (g);
10623 suppress_error = 0;
10624 r = guestfs_mounts (g);
10627 if (r[0] != NULL) {
10628 fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
10632 for (i = 0; r[i] != NULL; ++i)
10639 static int test_mounts_0_skip (void)
10643 str = getenv ("SKIP_TEST_MOUNTS_0");
10644 if (str && strcmp (str, "1") == 0) return 1;
10645 str = getenv ("SKIP_TEST_MOUNTS");
10646 if (str && strcmp (str, "1") == 0) return 1;
10650 static int test_mounts_0 (void)
10652 if (test_mounts_0_skip ()) {
10653 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mounts_0");
10657 /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
10659 char device[] = "/dev/sda";
10660 device[5] = devchar;
10662 suppress_error = 0;
10663 r = guestfs_blockdev_setrw (g, device);
10669 suppress_error = 0;
10670 r = guestfs_umount_all (g);
10676 suppress_error = 0;
10677 r = guestfs_lvm_remove_all (g);
10682 char device[] = "/dev/sda";
10683 device[5] = devchar;
10684 char lines_0[] = ",";
10690 suppress_error = 0;
10691 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10696 char fstype[] = "ext2";
10697 char device[] = "/dev/sda1";
10698 device[5] = devchar;
10700 suppress_error = 0;
10701 r = guestfs_mkfs (g, fstype, device);
10706 char device[] = "/dev/sda1";
10707 device[5] = devchar;
10708 char mountpoint[] = "/";
10710 suppress_error = 0;
10711 r = guestfs_mount (g, device, mountpoint);
10715 /* TestOutputList for mounts (0) */
10719 suppress_error = 0;
10720 r = guestfs_mounts (g);
10724 fprintf (stderr, "test_mounts_0: short list returned from command\n");
10729 char expected[] = "/dev/sda1";
10730 expected[5] = devchar;
10731 if (strcmp (r[0], expected) != 0) {
10732 fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10736 if (r[1] != NULL) {
10737 fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
10741 for (i = 0; r[i] != NULL; ++i)
10748 static int test_umount_0_skip (void)
10752 str = getenv ("SKIP_TEST_UMOUNT_0");
10753 if (str && strcmp (str, "1") == 0) return 1;
10754 str = getenv ("SKIP_TEST_UMOUNT");
10755 if (str && strcmp (str, "1") == 0) return 1;
10759 static int test_umount_0 (void)
10761 if (test_umount_0_skip ()) {
10762 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_0");
10766 /* InitNone|InitEmpty for test_umount_0 */
10768 char device[] = "/dev/sda";
10769 device[5] = devchar;
10771 suppress_error = 0;
10772 r = guestfs_blockdev_setrw (g, device);
10778 suppress_error = 0;
10779 r = guestfs_umount_all (g);
10785 suppress_error = 0;
10786 r = guestfs_lvm_remove_all (g);
10790 /* TestOutputList for umount (0) */
10792 char device[] = "/dev/sda";
10793 device[5] = devchar;
10794 char lines_0[] = ",";
10800 suppress_error = 0;
10801 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10806 char fstype[] = "ext2";
10807 char device[] = "/dev/sda1";
10808 device[5] = devchar;
10810 suppress_error = 0;
10811 r = guestfs_mkfs (g, fstype, device);
10816 char device[] = "/dev/sda1";
10817 device[5] = devchar;
10818 char mountpoint[] = "/";
10820 suppress_error = 0;
10821 r = guestfs_mount (g, device, mountpoint);
10828 suppress_error = 0;
10829 r = guestfs_mounts (g);
10833 fprintf (stderr, "test_umount_0: short list returned from command\n");
10838 char expected[] = "/dev/sda1";
10839 expected[5] = devchar;
10840 if (strcmp (r[0], expected) != 0) {
10841 fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10845 if (r[1] != NULL) {
10846 fprintf (stderr, "test_umount_0: extra elements returned from command\n");
10850 for (i = 0; r[i] != NULL; ++i)
10857 static int test_umount_1_skip (void)
10861 str = getenv ("SKIP_TEST_UMOUNT_1");
10862 if (str && strcmp (str, "1") == 0) return 1;
10863 str = getenv ("SKIP_TEST_UMOUNT");
10864 if (str && strcmp (str, "1") == 0) return 1;
10868 static int test_umount_1 (void)
10870 if (test_umount_1_skip ()) {
10871 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_1");
10875 /* InitNone|InitEmpty for test_umount_1 */
10877 char device[] = "/dev/sda";
10878 device[5] = devchar;
10880 suppress_error = 0;
10881 r = guestfs_blockdev_setrw (g, device);
10887 suppress_error = 0;
10888 r = guestfs_umount_all (g);
10894 suppress_error = 0;
10895 r = guestfs_lvm_remove_all (g);
10899 /* TestOutputList for umount (1) */
10901 char device[] = "/dev/sda";
10902 device[5] = devchar;
10903 char lines_0[] = ",";
10909 suppress_error = 0;
10910 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10915 char fstype[] = "ext2";
10916 char device[] = "/dev/sda1";
10917 device[5] = devchar;
10919 suppress_error = 0;
10920 r = guestfs_mkfs (g, fstype, device);
10925 char device[] = "/dev/sda1";
10926 device[5] = devchar;
10927 char mountpoint[] = "/";
10929 suppress_error = 0;
10930 r = guestfs_mount (g, device, mountpoint);
10935 char pathordevice[] = "/";
10937 suppress_error = 0;
10938 r = guestfs_umount (g, pathordevice);
10945 suppress_error = 0;
10946 r = guestfs_mounts (g);
10949 if (r[0] != NULL) {
10950 fprintf (stderr, "test_umount_1: extra elements returned from command\n");
10954 for (i = 0; r[i] != NULL; ++i)
10961 static int test_write_file_0_skip (void)
10965 str = getenv ("SKIP_TEST_WRITE_FILE_0");
10966 if (str && strcmp (str, "1") == 0) return 1;
10967 str = getenv ("SKIP_TEST_WRITE_FILE");
10968 if (str && strcmp (str, "1") == 0) return 1;
10972 static int test_write_file_0 (void)
10974 if (test_write_file_0_skip ()) {
10975 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_0");
10979 /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
10981 char device[] = "/dev/sda";
10982 device[5] = devchar;
10984 suppress_error = 0;
10985 r = guestfs_blockdev_setrw (g, device);
10991 suppress_error = 0;
10992 r = guestfs_umount_all (g);
10998 suppress_error = 0;
10999 r = guestfs_lvm_remove_all (g);
11004 char device[] = "/dev/sda";
11005 device[5] = devchar;
11006 char lines_0[] = ",";
11012 suppress_error = 0;
11013 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11018 char fstype[] = "ext2";
11019 char device[] = "/dev/sda1";
11020 device[5] = devchar;
11022 suppress_error = 0;
11023 r = guestfs_mkfs (g, fstype, device);
11028 char device[] = "/dev/sda1";
11029 device[5] = devchar;
11030 char mountpoint[] = "/";
11032 suppress_error = 0;
11033 r = guestfs_mount (g, device, mountpoint);
11037 /* TestOutput for write_file (0) */
11038 char expected[] = "new file contents";
11040 char path[] = "/new";
11041 char content[] = "new file contents";
11043 suppress_error = 0;
11044 r = guestfs_write_file (g, path, content, 0);
11049 char path[] = "/new";
11051 suppress_error = 0;
11052 r = guestfs_cat (g, path);
11055 if (strcmp (r, expected) != 0) {
11056 fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
11064 static int test_write_file_1_skip (void)
11068 str = getenv ("SKIP_TEST_WRITE_FILE_1");
11069 if (str && strcmp (str, "1") == 0) return 1;
11070 str = getenv ("SKIP_TEST_WRITE_FILE");
11071 if (str && strcmp (str, "1") == 0) return 1;
11075 static int test_write_file_1 (void)
11077 if (test_write_file_1_skip ()) {
11078 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_1");
11082 /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
11084 char device[] = "/dev/sda";
11085 device[5] = devchar;
11087 suppress_error = 0;
11088 r = guestfs_blockdev_setrw (g, device);
11094 suppress_error = 0;
11095 r = guestfs_umount_all (g);
11101 suppress_error = 0;
11102 r = guestfs_lvm_remove_all (g);
11107 char device[] = "/dev/sda";
11108 device[5] = devchar;
11109 char lines_0[] = ",";
11115 suppress_error = 0;
11116 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11121 char fstype[] = "ext2";
11122 char device[] = "/dev/sda1";
11123 device[5] = devchar;
11125 suppress_error = 0;
11126 r = guestfs_mkfs (g, fstype, device);
11131 char device[] = "/dev/sda1";
11132 device[5] = devchar;
11133 char mountpoint[] = "/";
11135 suppress_error = 0;
11136 r = guestfs_mount (g, device, mountpoint);
11140 /* TestOutput for write_file (1) */
11141 char expected[] = "\nnew file contents\n";
11143 char path[] = "/new";
11144 char content[] = "\nnew file contents\n";
11146 suppress_error = 0;
11147 r = guestfs_write_file (g, path, content, 0);
11152 char path[] = "/new";
11154 suppress_error = 0;
11155 r = guestfs_cat (g, path);
11158 if (strcmp (r, expected) != 0) {
11159 fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
11167 static int test_write_file_2_skip (void)
11171 str = getenv ("SKIP_TEST_WRITE_FILE_2");
11172 if (str && strcmp (str, "1") == 0) return 1;
11173 str = getenv ("SKIP_TEST_WRITE_FILE");
11174 if (str && strcmp (str, "1") == 0) return 1;
11178 static int test_write_file_2 (void)
11180 if (test_write_file_2_skip ()) {
11181 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_2");
11185 /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
11187 char device[] = "/dev/sda";
11188 device[5] = devchar;
11190 suppress_error = 0;
11191 r = guestfs_blockdev_setrw (g, device);
11197 suppress_error = 0;
11198 r = guestfs_umount_all (g);
11204 suppress_error = 0;
11205 r = guestfs_lvm_remove_all (g);
11210 char device[] = "/dev/sda";
11211 device[5] = devchar;
11212 char lines_0[] = ",";
11218 suppress_error = 0;
11219 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11224 char fstype[] = "ext2";
11225 char device[] = "/dev/sda1";
11226 device[5] = devchar;
11228 suppress_error = 0;
11229 r = guestfs_mkfs (g, fstype, device);
11234 char device[] = "/dev/sda1";
11235 device[5] = devchar;
11236 char mountpoint[] = "/";
11238 suppress_error = 0;
11239 r = guestfs_mount (g, device, mountpoint);
11243 /* TestOutput for write_file (2) */
11244 char expected[] = "\n\n";
11246 char path[] = "/new";
11247 char content[] = "\n\n";
11249 suppress_error = 0;
11250 r = guestfs_write_file (g, path, content, 0);
11255 char path[] = "/new";
11257 suppress_error = 0;
11258 r = guestfs_cat (g, path);
11261 if (strcmp (r, expected) != 0) {
11262 fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
11270 static int test_write_file_3_skip (void)
11274 str = getenv ("SKIP_TEST_WRITE_FILE_3");
11275 if (str && strcmp (str, "1") == 0) return 1;
11276 str = getenv ("SKIP_TEST_WRITE_FILE");
11277 if (str && strcmp (str, "1") == 0) return 1;
11281 static int test_write_file_3 (void)
11283 if (test_write_file_3_skip ()) {
11284 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_3");
11288 /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
11290 char device[] = "/dev/sda";
11291 device[5] = devchar;
11293 suppress_error = 0;
11294 r = guestfs_blockdev_setrw (g, device);
11300 suppress_error = 0;
11301 r = guestfs_umount_all (g);
11307 suppress_error = 0;
11308 r = guestfs_lvm_remove_all (g);
11313 char device[] = "/dev/sda";
11314 device[5] = devchar;
11315 char lines_0[] = ",";
11321 suppress_error = 0;
11322 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11327 char fstype[] = "ext2";
11328 char device[] = "/dev/sda1";
11329 device[5] = devchar;
11331 suppress_error = 0;
11332 r = guestfs_mkfs (g, fstype, device);
11337 char device[] = "/dev/sda1";
11338 device[5] = devchar;
11339 char mountpoint[] = "/";
11341 suppress_error = 0;
11342 r = guestfs_mount (g, device, mountpoint);
11346 /* TestOutput for write_file (3) */
11347 char expected[] = "";
11349 char path[] = "/new";
11350 char content[] = "";
11352 suppress_error = 0;
11353 r = guestfs_write_file (g, path, content, 0);
11358 char path[] = "/new";
11360 suppress_error = 0;
11361 r = guestfs_cat (g, path);
11364 if (strcmp (r, expected) != 0) {
11365 fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
11373 static int test_write_file_4_skip (void)
11377 str = getenv ("SKIP_TEST_WRITE_FILE_4");
11378 if (str && strcmp (str, "1") == 0) return 1;
11379 str = getenv ("SKIP_TEST_WRITE_FILE");
11380 if (str && strcmp (str, "1") == 0) return 1;
11384 static int test_write_file_4 (void)
11386 if (test_write_file_4_skip ()) {
11387 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_4");
11391 /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
11393 char device[] = "/dev/sda";
11394 device[5] = devchar;
11396 suppress_error = 0;
11397 r = guestfs_blockdev_setrw (g, device);
11403 suppress_error = 0;
11404 r = guestfs_umount_all (g);
11410 suppress_error = 0;
11411 r = guestfs_lvm_remove_all (g);
11416 char device[] = "/dev/sda";
11417 device[5] = devchar;
11418 char lines_0[] = ",";
11424 suppress_error = 0;
11425 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11430 char fstype[] = "ext2";
11431 char device[] = "/dev/sda1";
11432 device[5] = devchar;
11434 suppress_error = 0;
11435 r = guestfs_mkfs (g, fstype, device);
11440 char device[] = "/dev/sda1";
11441 device[5] = devchar;
11442 char mountpoint[] = "/";
11444 suppress_error = 0;
11445 r = guestfs_mount (g, device, mountpoint);
11449 /* TestOutput for write_file (4) */
11450 char expected[] = "\n\n\n";
11452 char path[] = "/new";
11453 char content[] = "\n\n\n";
11455 suppress_error = 0;
11456 r = guestfs_write_file (g, path, content, 0);
11461 char path[] = "/new";
11463 suppress_error = 0;
11464 r = guestfs_cat (g, path);
11467 if (strcmp (r, expected) != 0) {
11468 fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
11476 static int test_write_file_5_skip (void)
11480 str = getenv ("SKIP_TEST_WRITE_FILE_5");
11481 if (str && strcmp (str, "1") == 0) return 1;
11482 str = getenv ("SKIP_TEST_WRITE_FILE");
11483 if (str && strcmp (str, "1") == 0) return 1;
11487 static int test_write_file_5 (void)
11489 if (test_write_file_5_skip ()) {
11490 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_5");
11494 /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
11496 char device[] = "/dev/sda";
11497 device[5] = devchar;
11499 suppress_error = 0;
11500 r = guestfs_blockdev_setrw (g, device);
11506 suppress_error = 0;
11507 r = guestfs_umount_all (g);
11513 suppress_error = 0;
11514 r = guestfs_lvm_remove_all (g);
11519 char device[] = "/dev/sda";
11520 device[5] = devchar;
11521 char lines_0[] = ",";
11527 suppress_error = 0;
11528 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11533 char fstype[] = "ext2";
11534 char device[] = "/dev/sda1";
11535 device[5] = devchar;
11537 suppress_error = 0;
11538 r = guestfs_mkfs (g, fstype, device);
11543 char device[] = "/dev/sda1";
11544 device[5] = devchar;
11545 char mountpoint[] = "/";
11547 suppress_error = 0;
11548 r = guestfs_mount (g, device, mountpoint);
11552 /* TestOutput for write_file (5) */
11553 char expected[] = "\n";
11555 char path[] = "/new";
11556 char content[] = "\n";
11558 suppress_error = 0;
11559 r = guestfs_write_file (g, path, content, 0);
11564 char path[] = "/new";
11566 suppress_error = 0;
11567 r = guestfs_cat (g, path);
11570 if (strcmp (r, expected) != 0) {
11571 fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
11579 static int test_mkfs_0_skip (void)
11583 str = getenv ("SKIP_TEST_MKFS_0");
11584 if (str && strcmp (str, "1") == 0) return 1;
11585 str = getenv ("SKIP_TEST_MKFS");
11586 if (str && strcmp (str, "1") == 0) return 1;
11590 static int test_mkfs_0 (void)
11592 if (test_mkfs_0_skip ()) {
11593 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkfs_0");
11597 /* InitNone|InitEmpty for test_mkfs_0 */
11599 char device[] = "/dev/sda";
11600 device[5] = devchar;
11602 suppress_error = 0;
11603 r = guestfs_blockdev_setrw (g, device);
11609 suppress_error = 0;
11610 r = guestfs_umount_all (g);
11616 suppress_error = 0;
11617 r = guestfs_lvm_remove_all (g);
11621 /* TestOutput for mkfs (0) */
11622 char expected[] = "new file contents";
11624 char device[] = "/dev/sda";
11625 device[5] = devchar;
11626 char lines_0[] = ",";
11632 suppress_error = 0;
11633 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11638 char fstype[] = "ext2";
11639 char device[] = "/dev/sda1";
11640 device[5] = devchar;
11642 suppress_error = 0;
11643 r = guestfs_mkfs (g, fstype, device);
11648 char device[] = "/dev/sda1";
11649 device[5] = devchar;
11650 char mountpoint[] = "/";
11652 suppress_error = 0;
11653 r = guestfs_mount (g, device, mountpoint);
11658 char path[] = "/new";
11659 char content[] = "new file contents";
11661 suppress_error = 0;
11662 r = guestfs_write_file (g, path, content, 0);
11667 char path[] = "/new";
11669 suppress_error = 0;
11670 r = guestfs_cat (g, path);
11673 if (strcmp (r, expected) != 0) {
11674 fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
11682 static int test_lvcreate_0_skip (void)
11686 str = getenv ("SKIP_TEST_LVCREATE_0");
11687 if (str && strcmp (str, "1") == 0) return 1;
11688 str = getenv ("SKIP_TEST_LVCREATE");
11689 if (str && strcmp (str, "1") == 0) return 1;
11693 static int test_lvcreate_0 (void)
11695 if (test_lvcreate_0_skip ()) {
11696 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvcreate_0");
11700 /* InitNone|InitEmpty for test_lvcreate_0 */
11702 char device[] = "/dev/sda";
11703 device[5] = devchar;
11705 suppress_error = 0;
11706 r = guestfs_blockdev_setrw (g, device);
11712 suppress_error = 0;
11713 r = guestfs_umount_all (g);
11719 suppress_error = 0;
11720 r = guestfs_lvm_remove_all (g);
11724 /* TestOutputList for lvcreate (0) */
11726 char device[] = "/dev/sda";
11727 device[5] = devchar;
11728 char lines_0[] = ",10";
11729 char lines_1[] = ",20";
11730 char lines_2[] = ",";
11738 suppress_error = 0;
11739 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11744 char device[] = "/dev/sda1";
11745 device[5] = devchar;
11747 suppress_error = 0;
11748 r = guestfs_pvcreate (g, device);
11753 char device[] = "/dev/sda2";
11754 device[5] = devchar;
11756 suppress_error = 0;
11757 r = guestfs_pvcreate (g, device);
11762 char device[] = "/dev/sda3";
11763 device[5] = devchar;
11765 suppress_error = 0;
11766 r = guestfs_pvcreate (g, device);
11771 char volgroup[] = "VG1";
11772 char physvols_0[] = "/dev/sda1";
11773 physvols_0[5] = devchar;
11774 char physvols_1[] = "/dev/sda2";
11775 physvols_1[5] = devchar;
11776 char *physvols[] = {
11782 suppress_error = 0;
11783 r = guestfs_vgcreate (g, volgroup, physvols);
11788 char volgroup[] = "VG2";
11789 char physvols_0[] = "/dev/sda3";
11790 physvols_0[5] = devchar;
11791 char *physvols[] = {
11796 suppress_error = 0;
11797 r = guestfs_vgcreate (g, volgroup, physvols);
11802 char logvol[] = "LV1";
11803 char volgroup[] = "VG1";
11805 suppress_error = 0;
11806 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11811 char logvol[] = "LV2";
11812 char volgroup[] = "VG1";
11814 suppress_error = 0;
11815 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11820 char logvol[] = "LV3";
11821 char volgroup[] = "VG2";
11823 suppress_error = 0;
11824 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11829 char logvol[] = "LV4";
11830 char volgroup[] = "VG2";
11832 suppress_error = 0;
11833 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11838 char logvol[] = "LV5";
11839 char volgroup[] = "VG2";
11841 suppress_error = 0;
11842 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11849 suppress_error = 0;
11850 r = guestfs_lvs (g);
11854 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11859 char expected[] = "/dev/VG1/LV1";
11860 if (strcmp (r[0], expected) != 0) {
11861 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11866 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11871 char expected[] = "/dev/VG1/LV2";
11872 if (strcmp (r[1], expected) != 0) {
11873 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11878 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11883 char expected[] = "/dev/VG2/LV3";
11884 if (strcmp (r[2], expected) != 0) {
11885 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11890 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11895 char expected[] = "/dev/VG2/LV4";
11896 if (strcmp (r[3], expected) != 0) {
11897 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
11902 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11907 char expected[] = "/dev/VG2/LV5";
11908 if (strcmp (r[4], expected) != 0) {
11909 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
11913 if (r[5] != NULL) {
11914 fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
11918 for (i = 0; r[i] != NULL; ++i)
11925 static int test_vgcreate_0_skip (void)
11929 str = getenv ("SKIP_TEST_VGCREATE_0");
11930 if (str && strcmp (str, "1") == 0) return 1;
11931 str = getenv ("SKIP_TEST_VGCREATE");
11932 if (str && strcmp (str, "1") == 0) return 1;
11936 static int test_vgcreate_0 (void)
11938 if (test_vgcreate_0_skip ()) {
11939 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgcreate_0");
11943 /* InitNone|InitEmpty for test_vgcreate_0 */
11945 char device[] = "/dev/sda";
11946 device[5] = devchar;
11948 suppress_error = 0;
11949 r = guestfs_blockdev_setrw (g, device);
11955 suppress_error = 0;
11956 r = guestfs_umount_all (g);
11962 suppress_error = 0;
11963 r = guestfs_lvm_remove_all (g);
11967 /* TestOutputList for vgcreate (0) */
11969 char device[] = "/dev/sda";
11970 device[5] = devchar;
11971 char lines_0[] = ",10";
11972 char lines_1[] = ",20";
11973 char lines_2[] = ",";
11981 suppress_error = 0;
11982 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11987 char device[] = "/dev/sda1";
11988 device[5] = devchar;
11990 suppress_error = 0;
11991 r = guestfs_pvcreate (g, device);
11996 char device[] = "/dev/sda2";
11997 device[5] = devchar;
11999 suppress_error = 0;
12000 r = guestfs_pvcreate (g, device);
12005 char device[] = "/dev/sda3";
12006 device[5] = devchar;
12008 suppress_error = 0;
12009 r = guestfs_pvcreate (g, device);
12014 char volgroup[] = "VG1";
12015 char physvols_0[] = "/dev/sda1";
12016 physvols_0[5] = devchar;
12017 char physvols_1[] = "/dev/sda2";
12018 physvols_1[5] = devchar;
12019 char *physvols[] = {
12025 suppress_error = 0;
12026 r = guestfs_vgcreate (g, volgroup, physvols);
12031 char volgroup[] = "VG2";
12032 char physvols_0[] = "/dev/sda3";
12033 physvols_0[5] = devchar;
12034 char *physvols[] = {
12039 suppress_error = 0;
12040 r = guestfs_vgcreate (g, volgroup, physvols);
12047 suppress_error = 0;
12048 r = guestfs_vgs (g);
12052 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
12057 char expected[] = "VG1";
12058 if (strcmp (r[0], expected) != 0) {
12059 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12064 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
12069 char expected[] = "VG2";
12070 if (strcmp (r[1], expected) != 0) {
12071 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12075 if (r[2] != NULL) {
12076 fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
12080 for (i = 0; r[i] != NULL; ++i)
12087 static int test_pvcreate_0_skip (void)
12091 str = getenv ("SKIP_TEST_PVCREATE_0");
12092 if (str && strcmp (str, "1") == 0) return 1;
12093 str = getenv ("SKIP_TEST_PVCREATE");
12094 if (str && strcmp (str, "1") == 0) return 1;
12098 static int test_pvcreate_0 (void)
12100 if (test_pvcreate_0_skip ()) {
12101 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvcreate_0");
12105 /* InitNone|InitEmpty for test_pvcreate_0 */
12107 char device[] = "/dev/sda";
12108 device[5] = devchar;
12110 suppress_error = 0;
12111 r = guestfs_blockdev_setrw (g, device);
12117 suppress_error = 0;
12118 r = guestfs_umount_all (g);
12124 suppress_error = 0;
12125 r = guestfs_lvm_remove_all (g);
12129 /* TestOutputList for pvcreate (0) */
12131 char device[] = "/dev/sda";
12132 device[5] = devchar;
12133 char lines_0[] = ",10";
12134 char lines_1[] = ",20";
12135 char lines_2[] = ",";
12143 suppress_error = 0;
12144 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12149 char device[] = "/dev/sda1";
12150 device[5] = devchar;
12152 suppress_error = 0;
12153 r = guestfs_pvcreate (g, device);
12158 char device[] = "/dev/sda2";
12159 device[5] = devchar;
12161 suppress_error = 0;
12162 r = guestfs_pvcreate (g, device);
12167 char device[] = "/dev/sda3";
12168 device[5] = devchar;
12170 suppress_error = 0;
12171 r = guestfs_pvcreate (g, device);
12178 suppress_error = 0;
12179 r = guestfs_pvs (g);
12183 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12188 char expected[] = "/dev/sda1";
12189 expected[5] = devchar;
12190 if (strcmp (r[0], expected) != 0) {
12191 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12196 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12201 char expected[] = "/dev/sda2";
12202 expected[5] = devchar;
12203 if (strcmp (r[1], expected) != 0) {
12204 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12209 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12214 char expected[] = "/dev/sda3";
12215 expected[5] = devchar;
12216 if (strcmp (r[2], expected) != 0) {
12217 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12221 if (r[3] != NULL) {
12222 fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
12226 for (i = 0; r[i] != NULL; ++i)
12233 static int test_is_dir_0_skip (void)
12237 str = getenv ("SKIP_TEST_IS_DIR_0");
12238 if (str && strcmp (str, "1") == 0) return 1;
12239 str = getenv ("SKIP_TEST_IS_DIR");
12240 if (str && strcmp (str, "1") == 0) return 1;
12244 static int test_is_dir_0 (void)
12246 if (test_is_dir_0_skip ()) {
12247 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_0");
12251 /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
12253 char device[] = "/dev/sda";
12254 device[5] = devchar;
12256 suppress_error = 0;
12257 r = guestfs_blockdev_setrw (g, device);
12263 suppress_error = 0;
12264 r = guestfs_umount_all (g);
12270 suppress_error = 0;
12271 r = guestfs_lvm_remove_all (g);
12276 char device[] = "/dev/sda";
12277 device[5] = devchar;
12278 char lines_0[] = ",";
12284 suppress_error = 0;
12285 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12290 char fstype[] = "ext2";
12291 char device[] = "/dev/sda1";
12292 device[5] = devchar;
12294 suppress_error = 0;
12295 r = guestfs_mkfs (g, fstype, device);
12300 char device[] = "/dev/sda1";
12301 device[5] = devchar;
12302 char mountpoint[] = "/";
12304 suppress_error = 0;
12305 r = guestfs_mount (g, device, mountpoint);
12309 /* TestOutputFalse for is_dir (0) */
12311 char path[] = "/new";
12313 suppress_error = 0;
12314 r = guestfs_touch (g, path);
12319 char path[] = "/new";
12321 suppress_error = 0;
12322 r = guestfs_is_dir (g, path);
12326 fprintf (stderr, "test_is_dir_0: expected false, got true\n");
12333 static int test_is_dir_1_skip (void)
12337 str = getenv ("SKIP_TEST_IS_DIR_1");
12338 if (str && strcmp (str, "1") == 0) return 1;
12339 str = getenv ("SKIP_TEST_IS_DIR");
12340 if (str && strcmp (str, "1") == 0) return 1;
12344 static int test_is_dir_1 (void)
12346 if (test_is_dir_1_skip ()) {
12347 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_1");
12351 /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
12353 char device[] = "/dev/sda";
12354 device[5] = devchar;
12356 suppress_error = 0;
12357 r = guestfs_blockdev_setrw (g, device);
12363 suppress_error = 0;
12364 r = guestfs_umount_all (g);
12370 suppress_error = 0;
12371 r = guestfs_lvm_remove_all (g);
12376 char device[] = "/dev/sda";
12377 device[5] = devchar;
12378 char lines_0[] = ",";
12384 suppress_error = 0;
12385 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12390 char fstype[] = "ext2";
12391 char device[] = "/dev/sda1";
12392 device[5] = devchar;
12394 suppress_error = 0;
12395 r = guestfs_mkfs (g, fstype, device);
12400 char device[] = "/dev/sda1";
12401 device[5] = devchar;
12402 char mountpoint[] = "/";
12404 suppress_error = 0;
12405 r = guestfs_mount (g, device, mountpoint);
12409 /* TestOutputTrue for is_dir (1) */
12411 char path[] = "/new";
12413 suppress_error = 0;
12414 r = guestfs_mkdir (g, path);
12419 char path[] = "/new";
12421 suppress_error = 0;
12422 r = guestfs_is_dir (g, path);
12426 fprintf (stderr, "test_is_dir_1: expected true, got false\n");
12433 static int test_is_file_0_skip (void)
12437 str = getenv ("SKIP_TEST_IS_FILE_0");
12438 if (str && strcmp (str, "1") == 0) return 1;
12439 str = getenv ("SKIP_TEST_IS_FILE");
12440 if (str && strcmp (str, "1") == 0) return 1;
12444 static int test_is_file_0 (void)
12446 if (test_is_file_0_skip ()) {
12447 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_0");
12451 /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
12453 char device[] = "/dev/sda";
12454 device[5] = devchar;
12456 suppress_error = 0;
12457 r = guestfs_blockdev_setrw (g, device);
12463 suppress_error = 0;
12464 r = guestfs_umount_all (g);
12470 suppress_error = 0;
12471 r = guestfs_lvm_remove_all (g);
12476 char device[] = "/dev/sda";
12477 device[5] = devchar;
12478 char lines_0[] = ",";
12484 suppress_error = 0;
12485 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12490 char fstype[] = "ext2";
12491 char device[] = "/dev/sda1";
12492 device[5] = devchar;
12494 suppress_error = 0;
12495 r = guestfs_mkfs (g, fstype, device);
12500 char device[] = "/dev/sda1";
12501 device[5] = devchar;
12502 char mountpoint[] = "/";
12504 suppress_error = 0;
12505 r = guestfs_mount (g, device, mountpoint);
12509 /* TestOutputTrue for is_file (0) */
12511 char path[] = "/new";
12513 suppress_error = 0;
12514 r = guestfs_touch (g, path);
12519 char path[] = "/new";
12521 suppress_error = 0;
12522 r = guestfs_is_file (g, path);
12526 fprintf (stderr, "test_is_file_0: expected true, got false\n");
12533 static int test_is_file_1_skip (void)
12537 str = getenv ("SKIP_TEST_IS_FILE_1");
12538 if (str && strcmp (str, "1") == 0) return 1;
12539 str = getenv ("SKIP_TEST_IS_FILE");
12540 if (str && strcmp (str, "1") == 0) return 1;
12544 static int test_is_file_1 (void)
12546 if (test_is_file_1_skip ()) {
12547 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_1");
12551 /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
12553 char device[] = "/dev/sda";
12554 device[5] = devchar;
12556 suppress_error = 0;
12557 r = guestfs_blockdev_setrw (g, device);
12563 suppress_error = 0;
12564 r = guestfs_umount_all (g);
12570 suppress_error = 0;
12571 r = guestfs_lvm_remove_all (g);
12576 char device[] = "/dev/sda";
12577 device[5] = devchar;
12578 char lines_0[] = ",";
12584 suppress_error = 0;
12585 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12590 char fstype[] = "ext2";
12591 char device[] = "/dev/sda1";
12592 device[5] = devchar;
12594 suppress_error = 0;
12595 r = guestfs_mkfs (g, fstype, device);
12600 char device[] = "/dev/sda1";
12601 device[5] = devchar;
12602 char mountpoint[] = "/";
12604 suppress_error = 0;
12605 r = guestfs_mount (g, device, mountpoint);
12609 /* TestOutputFalse for is_file (1) */
12611 char path[] = "/new";
12613 suppress_error = 0;
12614 r = guestfs_mkdir (g, path);
12619 char path[] = "/new";
12621 suppress_error = 0;
12622 r = guestfs_is_file (g, path);
12626 fprintf (stderr, "test_is_file_1: expected false, got true\n");
12633 static int test_exists_0_skip (void)
12637 str = getenv ("SKIP_TEST_EXISTS_0");
12638 if (str && strcmp (str, "1") == 0) return 1;
12639 str = getenv ("SKIP_TEST_EXISTS");
12640 if (str && strcmp (str, "1") == 0) return 1;
12644 static int test_exists_0 (void)
12646 if (test_exists_0_skip ()) {
12647 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_0");
12651 /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
12653 char device[] = "/dev/sda";
12654 device[5] = devchar;
12656 suppress_error = 0;
12657 r = guestfs_blockdev_setrw (g, device);
12663 suppress_error = 0;
12664 r = guestfs_umount_all (g);
12670 suppress_error = 0;
12671 r = guestfs_lvm_remove_all (g);
12676 char device[] = "/dev/sda";
12677 device[5] = devchar;
12678 char lines_0[] = ",";
12684 suppress_error = 0;
12685 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12690 char fstype[] = "ext2";
12691 char device[] = "/dev/sda1";
12692 device[5] = devchar;
12694 suppress_error = 0;
12695 r = guestfs_mkfs (g, fstype, device);
12700 char device[] = "/dev/sda1";
12701 device[5] = devchar;
12702 char mountpoint[] = "/";
12704 suppress_error = 0;
12705 r = guestfs_mount (g, device, mountpoint);
12709 /* TestOutputTrue for exists (0) */
12711 char path[] = "/new";
12713 suppress_error = 0;
12714 r = guestfs_touch (g, path);
12719 char path[] = "/new";
12721 suppress_error = 0;
12722 r = guestfs_exists (g, path);
12726 fprintf (stderr, "test_exists_0: expected true, got false\n");
12733 static int test_exists_1_skip (void)
12737 str = getenv ("SKIP_TEST_EXISTS_1");
12738 if (str && strcmp (str, "1") == 0) return 1;
12739 str = getenv ("SKIP_TEST_EXISTS");
12740 if (str && strcmp (str, "1") == 0) return 1;
12744 static int test_exists_1 (void)
12746 if (test_exists_1_skip ()) {
12747 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_1");
12751 /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
12753 char device[] = "/dev/sda";
12754 device[5] = devchar;
12756 suppress_error = 0;
12757 r = guestfs_blockdev_setrw (g, device);
12763 suppress_error = 0;
12764 r = guestfs_umount_all (g);
12770 suppress_error = 0;
12771 r = guestfs_lvm_remove_all (g);
12776 char device[] = "/dev/sda";
12777 device[5] = devchar;
12778 char lines_0[] = ",";
12784 suppress_error = 0;
12785 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12790 char fstype[] = "ext2";
12791 char device[] = "/dev/sda1";
12792 device[5] = devchar;
12794 suppress_error = 0;
12795 r = guestfs_mkfs (g, fstype, device);
12800 char device[] = "/dev/sda1";
12801 device[5] = devchar;
12802 char mountpoint[] = "/";
12804 suppress_error = 0;
12805 r = guestfs_mount (g, device, mountpoint);
12809 /* TestOutputTrue for exists (1) */
12811 char path[] = "/new";
12813 suppress_error = 0;
12814 r = guestfs_mkdir (g, path);
12819 char path[] = "/new";
12821 suppress_error = 0;
12822 r = guestfs_exists (g, path);
12826 fprintf (stderr, "test_exists_1: expected true, got false\n");
12833 static int test_mkdir_p_0_skip (void)
12837 str = getenv ("SKIP_TEST_MKDIR_P_0");
12838 if (str && strcmp (str, "1") == 0) return 1;
12839 str = getenv ("SKIP_TEST_MKDIR_P");
12840 if (str && strcmp (str, "1") == 0) return 1;
12844 static int test_mkdir_p_0 (void)
12846 if (test_mkdir_p_0_skip ()) {
12847 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_0");
12851 /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
12853 char device[] = "/dev/sda";
12854 device[5] = devchar;
12856 suppress_error = 0;
12857 r = guestfs_blockdev_setrw (g, device);
12863 suppress_error = 0;
12864 r = guestfs_umount_all (g);
12870 suppress_error = 0;
12871 r = guestfs_lvm_remove_all (g);
12876 char device[] = "/dev/sda";
12877 device[5] = devchar;
12878 char lines_0[] = ",";
12884 suppress_error = 0;
12885 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12890 char fstype[] = "ext2";
12891 char device[] = "/dev/sda1";
12892 device[5] = devchar;
12894 suppress_error = 0;
12895 r = guestfs_mkfs (g, fstype, device);
12900 char device[] = "/dev/sda1";
12901 device[5] = devchar;
12902 char mountpoint[] = "/";
12904 suppress_error = 0;
12905 r = guestfs_mount (g, device, mountpoint);
12909 /* TestOutputTrue for mkdir_p (0) */
12911 char path[] = "/new/foo/bar";
12913 suppress_error = 0;
12914 r = guestfs_mkdir_p (g, path);
12919 char path[] = "/new/foo/bar";
12921 suppress_error = 0;
12922 r = guestfs_is_dir (g, path);
12926 fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
12933 static int test_mkdir_p_1_skip (void)
12937 str = getenv ("SKIP_TEST_MKDIR_P_1");
12938 if (str && strcmp (str, "1") == 0) return 1;
12939 str = getenv ("SKIP_TEST_MKDIR_P");
12940 if (str && strcmp (str, "1") == 0) return 1;
12944 static int test_mkdir_p_1 (void)
12946 if (test_mkdir_p_1_skip ()) {
12947 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_1");
12951 /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
12953 char device[] = "/dev/sda";
12954 device[5] = devchar;
12956 suppress_error = 0;
12957 r = guestfs_blockdev_setrw (g, device);
12963 suppress_error = 0;
12964 r = guestfs_umount_all (g);
12970 suppress_error = 0;
12971 r = guestfs_lvm_remove_all (g);
12976 char device[] = "/dev/sda";
12977 device[5] = devchar;
12978 char lines_0[] = ",";
12984 suppress_error = 0;
12985 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12990 char fstype[] = "ext2";
12991 char device[] = "/dev/sda1";
12992 device[5] = devchar;
12994 suppress_error = 0;
12995 r = guestfs_mkfs (g, fstype, device);
13000 char device[] = "/dev/sda1";
13001 device[5] = devchar;
13002 char mountpoint[] = "/";
13004 suppress_error = 0;
13005 r = guestfs_mount (g, device, mountpoint);
13009 /* TestOutputTrue for mkdir_p (1) */
13011 char path[] = "/new/foo/bar";
13013 suppress_error = 0;
13014 r = guestfs_mkdir_p (g, path);
13019 char path[] = "/new/foo";
13021 suppress_error = 0;
13022 r = guestfs_is_dir (g, path);
13026 fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
13033 static int test_mkdir_p_2_skip (void)
13037 str = getenv ("SKIP_TEST_MKDIR_P_2");
13038 if (str && strcmp (str, "1") == 0) return 1;
13039 str = getenv ("SKIP_TEST_MKDIR_P");
13040 if (str && strcmp (str, "1") == 0) return 1;
13044 static int test_mkdir_p_2 (void)
13046 if (test_mkdir_p_2_skip ()) {
13047 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_2");
13051 /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
13053 char device[] = "/dev/sda";
13054 device[5] = devchar;
13056 suppress_error = 0;
13057 r = guestfs_blockdev_setrw (g, device);
13063 suppress_error = 0;
13064 r = guestfs_umount_all (g);
13070 suppress_error = 0;
13071 r = guestfs_lvm_remove_all (g);
13076 char device[] = "/dev/sda";
13077 device[5] = devchar;
13078 char lines_0[] = ",";
13084 suppress_error = 0;
13085 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13090 char fstype[] = "ext2";
13091 char device[] = "/dev/sda1";
13092 device[5] = devchar;
13094 suppress_error = 0;
13095 r = guestfs_mkfs (g, fstype, device);
13100 char device[] = "/dev/sda1";
13101 device[5] = devchar;
13102 char mountpoint[] = "/";
13104 suppress_error = 0;
13105 r = guestfs_mount (g, device, mountpoint);
13109 /* TestOutputTrue for mkdir_p (2) */
13111 char path[] = "/new/foo/bar";
13113 suppress_error = 0;
13114 r = guestfs_mkdir_p (g, path);
13119 char path[] = "/new";
13121 suppress_error = 0;
13122 r = guestfs_is_dir (g, path);
13126 fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
13133 static int test_mkdir_p_3_skip (void)
13137 str = getenv ("SKIP_TEST_MKDIR_P_3");
13138 if (str && strcmp (str, "1") == 0) return 1;
13139 str = getenv ("SKIP_TEST_MKDIR_P");
13140 if (str && strcmp (str, "1") == 0) return 1;
13144 static int test_mkdir_p_3 (void)
13146 if (test_mkdir_p_3_skip ()) {
13147 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_3");
13151 /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
13153 char device[] = "/dev/sda";
13154 device[5] = devchar;
13156 suppress_error = 0;
13157 r = guestfs_blockdev_setrw (g, device);
13163 suppress_error = 0;
13164 r = guestfs_umount_all (g);
13170 suppress_error = 0;
13171 r = guestfs_lvm_remove_all (g);
13176 char device[] = "/dev/sda";
13177 device[5] = devchar;
13178 char lines_0[] = ",";
13184 suppress_error = 0;
13185 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13190 char fstype[] = "ext2";
13191 char device[] = "/dev/sda1";
13192 device[5] = devchar;
13194 suppress_error = 0;
13195 r = guestfs_mkfs (g, fstype, device);
13200 char device[] = "/dev/sda1";
13201 device[5] = devchar;
13202 char mountpoint[] = "/";
13204 suppress_error = 0;
13205 r = guestfs_mount (g, device, mountpoint);
13209 /* TestRun for mkdir_p (3) */
13211 char path[] = "/new";
13213 suppress_error = 0;
13214 r = guestfs_mkdir (g, path);
13219 char path[] = "/new";
13221 suppress_error = 0;
13222 r = guestfs_mkdir_p (g, path);
13229 static int test_mkdir_p_4_skip (void)
13233 str = getenv ("SKIP_TEST_MKDIR_P_4");
13234 if (str && strcmp (str, "1") == 0) return 1;
13235 str = getenv ("SKIP_TEST_MKDIR_P");
13236 if (str && strcmp (str, "1") == 0) return 1;
13240 static int test_mkdir_p_4 (void)
13242 if (test_mkdir_p_4_skip ()) {
13243 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_4");
13247 /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
13249 char device[] = "/dev/sda";
13250 device[5] = devchar;
13252 suppress_error = 0;
13253 r = guestfs_blockdev_setrw (g, device);
13259 suppress_error = 0;
13260 r = guestfs_umount_all (g);
13266 suppress_error = 0;
13267 r = guestfs_lvm_remove_all (g);
13272 char device[] = "/dev/sda";
13273 device[5] = devchar;
13274 char lines_0[] = ",";
13280 suppress_error = 0;
13281 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13286 char fstype[] = "ext2";
13287 char device[] = "/dev/sda1";
13288 device[5] = devchar;
13290 suppress_error = 0;
13291 r = guestfs_mkfs (g, fstype, device);
13296 char device[] = "/dev/sda1";
13297 device[5] = devchar;
13298 char mountpoint[] = "/";
13300 suppress_error = 0;
13301 r = guestfs_mount (g, device, mountpoint);
13305 /* TestLastFail for mkdir_p (4) */
13307 char path[] = "/new";
13309 suppress_error = 0;
13310 r = guestfs_touch (g, path);
13315 char path[] = "/new";
13317 suppress_error = 1;
13318 r = guestfs_mkdir_p (g, path);
13325 static int test_mkdir_0_skip (void)
13329 str = getenv ("SKIP_TEST_MKDIR_0");
13330 if (str && strcmp (str, "1") == 0) return 1;
13331 str = getenv ("SKIP_TEST_MKDIR");
13332 if (str && strcmp (str, "1") == 0) return 1;
13336 static int test_mkdir_0 (void)
13338 if (test_mkdir_0_skip ()) {
13339 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_0");
13343 /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
13345 char device[] = "/dev/sda";
13346 device[5] = devchar;
13348 suppress_error = 0;
13349 r = guestfs_blockdev_setrw (g, device);
13355 suppress_error = 0;
13356 r = guestfs_umount_all (g);
13362 suppress_error = 0;
13363 r = guestfs_lvm_remove_all (g);
13368 char device[] = "/dev/sda";
13369 device[5] = devchar;
13370 char lines_0[] = ",";
13376 suppress_error = 0;
13377 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13382 char fstype[] = "ext2";
13383 char device[] = "/dev/sda1";
13384 device[5] = devchar;
13386 suppress_error = 0;
13387 r = guestfs_mkfs (g, fstype, device);
13392 char device[] = "/dev/sda1";
13393 device[5] = devchar;
13394 char mountpoint[] = "/";
13396 suppress_error = 0;
13397 r = guestfs_mount (g, device, mountpoint);
13401 /* TestOutputTrue for mkdir (0) */
13403 char path[] = "/new";
13405 suppress_error = 0;
13406 r = guestfs_mkdir (g, path);
13411 char path[] = "/new";
13413 suppress_error = 0;
13414 r = guestfs_is_dir (g, path);
13418 fprintf (stderr, "test_mkdir_0: expected true, got false\n");
13425 static int test_mkdir_1_skip (void)
13429 str = getenv ("SKIP_TEST_MKDIR_1");
13430 if (str && strcmp (str, "1") == 0) return 1;
13431 str = getenv ("SKIP_TEST_MKDIR");
13432 if (str && strcmp (str, "1") == 0) return 1;
13436 static int test_mkdir_1 (void)
13438 if (test_mkdir_1_skip ()) {
13439 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_1");
13443 /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
13445 char device[] = "/dev/sda";
13446 device[5] = devchar;
13448 suppress_error = 0;
13449 r = guestfs_blockdev_setrw (g, device);
13455 suppress_error = 0;
13456 r = guestfs_umount_all (g);
13462 suppress_error = 0;
13463 r = guestfs_lvm_remove_all (g);
13468 char device[] = "/dev/sda";
13469 device[5] = devchar;
13470 char lines_0[] = ",";
13476 suppress_error = 0;
13477 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13482 char fstype[] = "ext2";
13483 char device[] = "/dev/sda1";
13484 device[5] = devchar;
13486 suppress_error = 0;
13487 r = guestfs_mkfs (g, fstype, device);
13492 char device[] = "/dev/sda1";
13493 device[5] = devchar;
13494 char mountpoint[] = "/";
13496 suppress_error = 0;
13497 r = guestfs_mount (g, device, mountpoint);
13501 /* TestLastFail for mkdir (1) */
13503 char path[] = "/new/foo/bar";
13505 suppress_error = 1;
13506 r = guestfs_mkdir (g, path);
13513 static int test_rm_rf_0_skip (void)
13517 str = getenv ("SKIP_TEST_RM_RF_0");
13518 if (str && strcmp (str, "1") == 0) return 1;
13519 str = getenv ("SKIP_TEST_RM_RF");
13520 if (str && strcmp (str, "1") == 0) return 1;
13524 static int test_rm_rf_0 (void)
13526 if (test_rm_rf_0_skip ()) {
13527 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_rf_0");
13531 /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
13533 char device[] = "/dev/sda";
13534 device[5] = devchar;
13536 suppress_error = 0;
13537 r = guestfs_blockdev_setrw (g, device);
13543 suppress_error = 0;
13544 r = guestfs_umount_all (g);
13550 suppress_error = 0;
13551 r = guestfs_lvm_remove_all (g);
13556 char device[] = "/dev/sda";
13557 device[5] = devchar;
13558 char lines_0[] = ",";
13564 suppress_error = 0;
13565 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13570 char fstype[] = "ext2";
13571 char device[] = "/dev/sda1";
13572 device[5] = devchar;
13574 suppress_error = 0;
13575 r = guestfs_mkfs (g, fstype, device);
13580 char device[] = "/dev/sda1";
13581 device[5] = devchar;
13582 char mountpoint[] = "/";
13584 suppress_error = 0;
13585 r = guestfs_mount (g, device, mountpoint);
13589 /* TestOutputFalse for rm_rf (0) */
13591 char path[] = "/new";
13593 suppress_error = 0;
13594 r = guestfs_mkdir (g, path);
13599 char path[] = "/new/foo";
13601 suppress_error = 0;
13602 r = guestfs_mkdir (g, path);
13607 char path[] = "/new/foo/bar";
13609 suppress_error = 0;
13610 r = guestfs_touch (g, path);
13615 char path[] = "/new";
13617 suppress_error = 0;
13618 r = guestfs_rm_rf (g, path);
13623 char path[] = "/new";
13625 suppress_error = 0;
13626 r = guestfs_exists (g, path);
13630 fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
13637 static int test_rmdir_0_skip (void)
13641 str = getenv ("SKIP_TEST_RMDIR_0");
13642 if (str && strcmp (str, "1") == 0) return 1;
13643 str = getenv ("SKIP_TEST_RMDIR");
13644 if (str && strcmp (str, "1") == 0) return 1;
13648 static int test_rmdir_0 (void)
13650 if (test_rmdir_0_skip ()) {
13651 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_0");
13655 /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
13657 char device[] = "/dev/sda";
13658 device[5] = devchar;
13660 suppress_error = 0;
13661 r = guestfs_blockdev_setrw (g, device);
13667 suppress_error = 0;
13668 r = guestfs_umount_all (g);
13674 suppress_error = 0;
13675 r = guestfs_lvm_remove_all (g);
13680 char device[] = "/dev/sda";
13681 device[5] = devchar;
13682 char lines_0[] = ",";
13688 suppress_error = 0;
13689 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13694 char fstype[] = "ext2";
13695 char device[] = "/dev/sda1";
13696 device[5] = devchar;
13698 suppress_error = 0;
13699 r = guestfs_mkfs (g, fstype, device);
13704 char device[] = "/dev/sda1";
13705 device[5] = devchar;
13706 char mountpoint[] = "/";
13708 suppress_error = 0;
13709 r = guestfs_mount (g, device, mountpoint);
13713 /* TestRun for rmdir (0) */
13715 char path[] = "/new";
13717 suppress_error = 0;
13718 r = guestfs_mkdir (g, path);
13723 char path[] = "/new";
13725 suppress_error = 0;
13726 r = guestfs_rmdir (g, path);
13733 static int test_rmdir_1_skip (void)
13737 str = getenv ("SKIP_TEST_RMDIR_1");
13738 if (str && strcmp (str, "1") == 0) return 1;
13739 str = getenv ("SKIP_TEST_RMDIR");
13740 if (str && strcmp (str, "1") == 0) return 1;
13744 static int test_rmdir_1 (void)
13746 if (test_rmdir_1_skip ()) {
13747 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_1");
13751 /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
13753 char device[] = "/dev/sda";
13754 device[5] = devchar;
13756 suppress_error = 0;
13757 r = guestfs_blockdev_setrw (g, device);
13763 suppress_error = 0;
13764 r = guestfs_umount_all (g);
13770 suppress_error = 0;
13771 r = guestfs_lvm_remove_all (g);
13776 char device[] = "/dev/sda";
13777 device[5] = devchar;
13778 char lines_0[] = ",";
13784 suppress_error = 0;
13785 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13790 char fstype[] = "ext2";
13791 char device[] = "/dev/sda1";
13792 device[5] = devchar;
13794 suppress_error = 0;
13795 r = guestfs_mkfs (g, fstype, device);
13800 char device[] = "/dev/sda1";
13801 device[5] = devchar;
13802 char mountpoint[] = "/";
13804 suppress_error = 0;
13805 r = guestfs_mount (g, device, mountpoint);
13809 /* TestLastFail for rmdir (1) */
13811 char path[] = "/new";
13813 suppress_error = 1;
13814 r = guestfs_rmdir (g, path);
13821 static int test_rmdir_2_skip (void)
13825 str = getenv ("SKIP_TEST_RMDIR_2");
13826 if (str && strcmp (str, "1") == 0) return 1;
13827 str = getenv ("SKIP_TEST_RMDIR");
13828 if (str && strcmp (str, "1") == 0) return 1;
13832 static int test_rmdir_2 (void)
13834 if (test_rmdir_2_skip ()) {
13835 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_2");
13839 /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
13841 char device[] = "/dev/sda";
13842 device[5] = devchar;
13844 suppress_error = 0;
13845 r = guestfs_blockdev_setrw (g, device);
13851 suppress_error = 0;
13852 r = guestfs_umount_all (g);
13858 suppress_error = 0;
13859 r = guestfs_lvm_remove_all (g);
13864 char device[] = "/dev/sda";
13865 device[5] = devchar;
13866 char lines_0[] = ",";
13872 suppress_error = 0;
13873 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13878 char fstype[] = "ext2";
13879 char device[] = "/dev/sda1";
13880 device[5] = devchar;
13882 suppress_error = 0;
13883 r = guestfs_mkfs (g, fstype, device);
13888 char device[] = "/dev/sda1";
13889 device[5] = devchar;
13890 char mountpoint[] = "/";
13892 suppress_error = 0;
13893 r = guestfs_mount (g, device, mountpoint);
13897 /* TestLastFail for rmdir (2) */
13899 char path[] = "/new";
13901 suppress_error = 0;
13902 r = guestfs_touch (g, path);
13907 char path[] = "/new";
13909 suppress_error = 1;
13910 r = guestfs_rmdir (g, path);
13917 static int test_rm_0_skip (void)
13921 str = getenv ("SKIP_TEST_RM_0");
13922 if (str && strcmp (str, "1") == 0) return 1;
13923 str = getenv ("SKIP_TEST_RM");
13924 if (str && strcmp (str, "1") == 0) return 1;
13928 static int test_rm_0 (void)
13930 if (test_rm_0_skip ()) {
13931 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_0");
13935 /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
13937 char device[] = "/dev/sda";
13938 device[5] = devchar;
13940 suppress_error = 0;
13941 r = guestfs_blockdev_setrw (g, device);
13947 suppress_error = 0;
13948 r = guestfs_umount_all (g);
13954 suppress_error = 0;
13955 r = guestfs_lvm_remove_all (g);
13960 char device[] = "/dev/sda";
13961 device[5] = devchar;
13962 char lines_0[] = ",";
13968 suppress_error = 0;
13969 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13974 char fstype[] = "ext2";
13975 char device[] = "/dev/sda1";
13976 device[5] = devchar;
13978 suppress_error = 0;
13979 r = guestfs_mkfs (g, fstype, device);
13984 char device[] = "/dev/sda1";
13985 device[5] = devchar;
13986 char mountpoint[] = "/";
13988 suppress_error = 0;
13989 r = guestfs_mount (g, device, mountpoint);
13993 /* TestRun for rm (0) */
13995 char path[] = "/new";
13997 suppress_error = 0;
13998 r = guestfs_touch (g, path);
14003 char path[] = "/new";
14005 suppress_error = 0;
14006 r = guestfs_rm (g, path);
14013 static int test_rm_1_skip (void)
14017 str = getenv ("SKIP_TEST_RM_1");
14018 if (str && strcmp (str, "1") == 0) return 1;
14019 str = getenv ("SKIP_TEST_RM");
14020 if (str && strcmp (str, "1") == 0) return 1;
14024 static int test_rm_1 (void)
14026 if (test_rm_1_skip ()) {
14027 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_1");
14031 /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
14033 char device[] = "/dev/sda";
14034 device[5] = devchar;
14036 suppress_error = 0;
14037 r = guestfs_blockdev_setrw (g, device);
14043 suppress_error = 0;
14044 r = guestfs_umount_all (g);
14050 suppress_error = 0;
14051 r = guestfs_lvm_remove_all (g);
14056 char device[] = "/dev/sda";
14057 device[5] = devchar;
14058 char lines_0[] = ",";
14064 suppress_error = 0;
14065 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14070 char fstype[] = "ext2";
14071 char device[] = "/dev/sda1";
14072 device[5] = devchar;
14074 suppress_error = 0;
14075 r = guestfs_mkfs (g, fstype, device);
14080 char device[] = "/dev/sda1";
14081 device[5] = devchar;
14082 char mountpoint[] = "/";
14084 suppress_error = 0;
14085 r = guestfs_mount (g, device, mountpoint);
14089 /* TestLastFail for rm (1) */
14091 char path[] = "/new";
14093 suppress_error = 1;
14094 r = guestfs_rm (g, path);
14101 static int test_rm_2_skip (void)
14105 str = getenv ("SKIP_TEST_RM_2");
14106 if (str && strcmp (str, "1") == 0) return 1;
14107 str = getenv ("SKIP_TEST_RM");
14108 if (str && strcmp (str, "1") == 0) return 1;
14112 static int test_rm_2 (void)
14114 if (test_rm_2_skip ()) {
14115 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_2");
14119 /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
14121 char device[] = "/dev/sda";
14122 device[5] = devchar;
14124 suppress_error = 0;
14125 r = guestfs_blockdev_setrw (g, device);
14131 suppress_error = 0;
14132 r = guestfs_umount_all (g);
14138 suppress_error = 0;
14139 r = guestfs_lvm_remove_all (g);
14144 char device[] = "/dev/sda";
14145 device[5] = devchar;
14146 char lines_0[] = ",";
14152 suppress_error = 0;
14153 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14158 char fstype[] = "ext2";
14159 char device[] = "/dev/sda1";
14160 device[5] = devchar;
14162 suppress_error = 0;
14163 r = guestfs_mkfs (g, fstype, device);
14168 char device[] = "/dev/sda1";
14169 device[5] = devchar;
14170 char mountpoint[] = "/";
14172 suppress_error = 0;
14173 r = guestfs_mount (g, device, mountpoint);
14177 /* TestLastFail for rm (2) */
14179 char path[] = "/new";
14181 suppress_error = 0;
14182 r = guestfs_mkdir (g, path);
14187 char path[] = "/new";
14189 suppress_error = 1;
14190 r = guestfs_rm (g, path);
14197 static int test_read_lines_0_skip (void)
14201 str = getenv ("SKIP_TEST_READ_LINES_0");
14202 if (str && strcmp (str, "1") == 0) return 1;
14203 str = getenv ("SKIP_TEST_READ_LINES");
14204 if (str && strcmp (str, "1") == 0) return 1;
14208 static int test_read_lines_0 (void)
14210 if (test_read_lines_0_skip ()) {
14211 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_0");
14215 /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
14217 char device[] = "/dev/sda";
14218 device[5] = devchar;
14220 suppress_error = 0;
14221 r = guestfs_blockdev_setrw (g, device);
14227 suppress_error = 0;
14228 r = guestfs_umount_all (g);
14234 suppress_error = 0;
14235 r = guestfs_lvm_remove_all (g);
14240 char device[] = "/dev/sda";
14241 device[5] = devchar;
14242 char lines_0[] = ",";
14248 suppress_error = 0;
14249 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14254 char fstype[] = "ext2";
14255 char device[] = "/dev/sda1";
14256 device[5] = devchar;
14258 suppress_error = 0;
14259 r = guestfs_mkfs (g, fstype, device);
14264 char device[] = "/dev/sda1";
14265 device[5] = devchar;
14266 char mountpoint[] = "/";
14268 suppress_error = 0;
14269 r = guestfs_mount (g, device, mountpoint);
14273 /* TestOutputList for read_lines (0) */
14275 char path[] = "/new";
14276 char content[] = "line1\r\nline2\nline3";
14278 suppress_error = 0;
14279 r = guestfs_write_file (g, path, content, 0);
14284 char path[] = "/new";
14287 suppress_error = 0;
14288 r = guestfs_read_lines (g, path);
14292 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14297 char expected[] = "line1";
14298 if (strcmp (r[0], expected) != 0) {
14299 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14304 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14309 char expected[] = "line2";
14310 if (strcmp (r[1], expected) != 0) {
14311 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14316 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14321 char expected[] = "line3";
14322 if (strcmp (r[2], expected) != 0) {
14323 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14327 if (r[3] != NULL) {
14328 fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
14332 for (i = 0; r[i] != NULL; ++i)
14339 static int test_read_lines_1_skip (void)
14343 str = getenv ("SKIP_TEST_READ_LINES_1");
14344 if (str && strcmp (str, "1") == 0) return 1;
14345 str = getenv ("SKIP_TEST_READ_LINES");
14346 if (str && strcmp (str, "1") == 0) return 1;
14350 static int test_read_lines_1 (void)
14352 if (test_read_lines_1_skip ()) {
14353 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_1");
14357 /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
14359 char device[] = "/dev/sda";
14360 device[5] = devchar;
14362 suppress_error = 0;
14363 r = guestfs_blockdev_setrw (g, device);
14369 suppress_error = 0;
14370 r = guestfs_umount_all (g);
14376 suppress_error = 0;
14377 r = guestfs_lvm_remove_all (g);
14382 char device[] = "/dev/sda";
14383 device[5] = devchar;
14384 char lines_0[] = ",";
14390 suppress_error = 0;
14391 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14396 char fstype[] = "ext2";
14397 char device[] = "/dev/sda1";
14398 device[5] = devchar;
14400 suppress_error = 0;
14401 r = guestfs_mkfs (g, fstype, device);
14406 char device[] = "/dev/sda1";
14407 device[5] = devchar;
14408 char mountpoint[] = "/";
14410 suppress_error = 0;
14411 r = guestfs_mount (g, device, mountpoint);
14415 /* TestOutputList for read_lines (1) */
14417 char path[] = "/new";
14418 char content[] = "";
14420 suppress_error = 0;
14421 r = guestfs_write_file (g, path, content, 0);
14426 char path[] = "/new";
14429 suppress_error = 0;
14430 r = guestfs_read_lines (g, path);
14433 if (r[0] != NULL) {
14434 fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
14438 for (i = 0; r[i] != NULL; ++i)
14445 static int test_lvs_0_skip (void)
14449 str = getenv ("SKIP_TEST_LVS_0");
14450 if (str && strcmp (str, "1") == 0) return 1;
14451 str = getenv ("SKIP_TEST_LVS");
14452 if (str && strcmp (str, "1") == 0) return 1;
14456 static int test_lvs_0 (void)
14458 if (test_lvs_0_skip ()) {
14459 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_0");
14463 /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
14465 char device[] = "/dev/sda";
14466 device[5] = devchar;
14468 suppress_error = 0;
14469 r = guestfs_blockdev_setrw (g, device);
14475 suppress_error = 0;
14476 r = guestfs_umount_all (g);
14482 suppress_error = 0;
14483 r = guestfs_lvm_remove_all (g);
14488 char device[] = "/dev/sda";
14489 device[5] = devchar;
14490 char lines_0[] = ",";
14496 suppress_error = 0;
14497 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14502 char device[] = "/dev/sda1";
14503 device[5] = devchar;
14505 suppress_error = 0;
14506 r = guestfs_pvcreate (g, device);
14511 char volgroup[] = "VG";
14512 char physvols_0[] = "/dev/sda1";
14513 physvols_0[5] = devchar;
14514 char *physvols[] = {
14519 suppress_error = 0;
14520 r = guestfs_vgcreate (g, volgroup, physvols);
14525 char logvol[] = "LV";
14526 char volgroup[] = "VG";
14528 suppress_error = 0;
14529 r = guestfs_lvcreate (g, logvol, volgroup, 8);
14534 char fstype[] = "ext2";
14535 char device[] = "/dev/VG/LV";
14537 suppress_error = 0;
14538 r = guestfs_mkfs (g, fstype, device);
14543 char device[] = "/dev/VG/LV";
14544 char mountpoint[] = "/";
14546 suppress_error = 0;
14547 r = guestfs_mount (g, device, mountpoint);
14551 /* TestOutputList for lvs (0) */
14555 suppress_error = 0;
14556 r = guestfs_lvs (g);
14560 fprintf (stderr, "test_lvs_0: short list returned from command\n");
14565 char expected[] = "/dev/VG/LV";
14566 if (strcmp (r[0], expected) != 0) {
14567 fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14571 if (r[1] != NULL) {
14572 fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
14576 for (i = 0; r[i] != NULL; ++i)
14583 static int test_lvs_1_skip (void)
14587 str = getenv ("SKIP_TEST_LVS_1");
14588 if (str && strcmp (str, "1") == 0) return 1;
14589 str = getenv ("SKIP_TEST_LVS");
14590 if (str && strcmp (str, "1") == 0) return 1;
14594 static int test_lvs_1 (void)
14596 if (test_lvs_1_skip ()) {
14597 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_1");
14601 /* InitNone|InitEmpty for test_lvs_1 */
14603 char device[] = "/dev/sda";
14604 device[5] = devchar;
14606 suppress_error = 0;
14607 r = guestfs_blockdev_setrw (g, device);
14613 suppress_error = 0;
14614 r = guestfs_umount_all (g);
14620 suppress_error = 0;
14621 r = guestfs_lvm_remove_all (g);
14625 /* TestOutputList for lvs (1) */
14627 char device[] = "/dev/sda";
14628 device[5] = devchar;
14629 char lines_0[] = ",10";
14630 char lines_1[] = ",20";
14631 char lines_2[] = ",";
14639 suppress_error = 0;
14640 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14645 char device[] = "/dev/sda1";
14646 device[5] = devchar;
14648 suppress_error = 0;
14649 r = guestfs_pvcreate (g, device);
14654 char device[] = "/dev/sda2";
14655 device[5] = devchar;
14657 suppress_error = 0;
14658 r = guestfs_pvcreate (g, device);
14663 char device[] = "/dev/sda3";
14664 device[5] = devchar;
14666 suppress_error = 0;
14667 r = guestfs_pvcreate (g, device);
14672 char volgroup[] = "VG1";
14673 char physvols_0[] = "/dev/sda1";
14674 physvols_0[5] = devchar;
14675 char physvols_1[] = "/dev/sda2";
14676 physvols_1[5] = devchar;
14677 char *physvols[] = {
14683 suppress_error = 0;
14684 r = guestfs_vgcreate (g, volgroup, physvols);
14689 char volgroup[] = "VG2";
14690 char physvols_0[] = "/dev/sda3";
14691 physvols_0[5] = devchar;
14692 char *physvols[] = {
14697 suppress_error = 0;
14698 r = guestfs_vgcreate (g, volgroup, physvols);
14703 char logvol[] = "LV1";
14704 char volgroup[] = "VG1";
14706 suppress_error = 0;
14707 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14712 char logvol[] = "LV2";
14713 char volgroup[] = "VG1";
14715 suppress_error = 0;
14716 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14721 char logvol[] = "LV3";
14722 char volgroup[] = "VG2";
14724 suppress_error = 0;
14725 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14732 suppress_error = 0;
14733 r = guestfs_lvs (g);
14737 fprintf (stderr, "test_lvs_1: short list returned from command\n");
14742 char expected[] = "/dev/VG1/LV1";
14743 if (strcmp (r[0], expected) != 0) {
14744 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14749 fprintf (stderr, "test_lvs_1: short list returned from command\n");
14754 char expected[] = "/dev/VG1/LV2";
14755 if (strcmp (r[1], expected) != 0) {
14756 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14761 fprintf (stderr, "test_lvs_1: short list returned from command\n");
14766 char expected[] = "/dev/VG2/LV3";
14767 if (strcmp (r[2], expected) != 0) {
14768 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14772 if (r[3] != NULL) {
14773 fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
14777 for (i = 0; r[i] != NULL; ++i)
14784 static int test_vgs_0_skip (void)
14788 str = getenv ("SKIP_TEST_VGS_0");
14789 if (str && strcmp (str, "1") == 0) return 1;
14790 str = getenv ("SKIP_TEST_VGS");
14791 if (str && strcmp (str, "1") == 0) return 1;
14795 static int test_vgs_0 (void)
14797 if (test_vgs_0_skip ()) {
14798 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_0");
14802 /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
14804 char device[] = "/dev/sda";
14805 device[5] = devchar;
14807 suppress_error = 0;
14808 r = guestfs_blockdev_setrw (g, device);
14814 suppress_error = 0;
14815 r = guestfs_umount_all (g);
14821 suppress_error = 0;
14822 r = guestfs_lvm_remove_all (g);
14827 char device[] = "/dev/sda";
14828 device[5] = devchar;
14829 char lines_0[] = ",";
14835 suppress_error = 0;
14836 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14841 char device[] = "/dev/sda1";
14842 device[5] = devchar;
14844 suppress_error = 0;
14845 r = guestfs_pvcreate (g, device);
14850 char volgroup[] = "VG";
14851 char physvols_0[] = "/dev/sda1";
14852 physvols_0[5] = devchar;
14853 char *physvols[] = {
14858 suppress_error = 0;
14859 r = guestfs_vgcreate (g, volgroup, physvols);
14864 char logvol[] = "LV";
14865 char volgroup[] = "VG";
14867 suppress_error = 0;
14868 r = guestfs_lvcreate (g, logvol, volgroup, 8);
14873 char fstype[] = "ext2";
14874 char device[] = "/dev/VG/LV";
14876 suppress_error = 0;
14877 r = guestfs_mkfs (g, fstype, device);
14882 char device[] = "/dev/VG/LV";
14883 char mountpoint[] = "/";
14885 suppress_error = 0;
14886 r = guestfs_mount (g, device, mountpoint);
14890 /* TestOutputList for vgs (0) */
14894 suppress_error = 0;
14895 r = guestfs_vgs (g);
14899 fprintf (stderr, "test_vgs_0: short list returned from command\n");
14904 char expected[] = "VG";
14905 if (strcmp (r[0], expected) != 0) {
14906 fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14910 if (r[1] != NULL) {
14911 fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
14915 for (i = 0; r[i] != NULL; ++i)
14922 static int test_vgs_1_skip (void)
14926 str = getenv ("SKIP_TEST_VGS_1");
14927 if (str && strcmp (str, "1") == 0) return 1;
14928 str = getenv ("SKIP_TEST_VGS");
14929 if (str && strcmp (str, "1") == 0) return 1;
14933 static int test_vgs_1 (void)
14935 if (test_vgs_1_skip ()) {
14936 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_1");
14940 /* InitNone|InitEmpty for test_vgs_1 */
14942 char device[] = "/dev/sda";
14943 device[5] = devchar;
14945 suppress_error = 0;
14946 r = guestfs_blockdev_setrw (g, device);
14952 suppress_error = 0;
14953 r = guestfs_umount_all (g);
14959 suppress_error = 0;
14960 r = guestfs_lvm_remove_all (g);
14964 /* TestOutputList for vgs (1) */
14966 char device[] = "/dev/sda";
14967 device[5] = devchar;
14968 char lines_0[] = ",10";
14969 char lines_1[] = ",20";
14970 char lines_2[] = ",";
14978 suppress_error = 0;
14979 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14984 char device[] = "/dev/sda1";
14985 device[5] = devchar;
14987 suppress_error = 0;
14988 r = guestfs_pvcreate (g, device);
14993 char device[] = "/dev/sda2";
14994 device[5] = devchar;
14996 suppress_error = 0;
14997 r = guestfs_pvcreate (g, device);
15002 char device[] = "/dev/sda3";
15003 device[5] = devchar;
15005 suppress_error = 0;
15006 r = guestfs_pvcreate (g, device);
15011 char volgroup[] = "VG1";
15012 char physvols_0[] = "/dev/sda1";
15013 physvols_0[5] = devchar;
15014 char physvols_1[] = "/dev/sda2";
15015 physvols_1[5] = devchar;
15016 char *physvols[] = {
15022 suppress_error = 0;
15023 r = guestfs_vgcreate (g, volgroup, physvols);
15028 char volgroup[] = "VG2";
15029 char physvols_0[] = "/dev/sda3";
15030 physvols_0[5] = devchar;
15031 char *physvols[] = {
15036 suppress_error = 0;
15037 r = guestfs_vgcreate (g, volgroup, physvols);
15044 suppress_error = 0;
15045 r = guestfs_vgs (g);
15049 fprintf (stderr, "test_vgs_1: short list returned from command\n");
15054 char expected[] = "VG1";
15055 if (strcmp (r[0], expected) != 0) {
15056 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15061 fprintf (stderr, "test_vgs_1: short list returned from command\n");
15066 char expected[] = "VG2";
15067 if (strcmp (r[1], expected) != 0) {
15068 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15072 if (r[2] != NULL) {
15073 fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
15077 for (i = 0; r[i] != NULL; ++i)
15084 static int test_pvs_0_skip (void)
15088 str = getenv ("SKIP_TEST_PVS_0");
15089 if (str && strcmp (str, "1") == 0) return 1;
15090 str = getenv ("SKIP_TEST_PVS");
15091 if (str && strcmp (str, "1") == 0) return 1;
15095 static int test_pvs_0 (void)
15097 if (test_pvs_0_skip ()) {
15098 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_0");
15102 /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
15104 char device[] = "/dev/sda";
15105 device[5] = devchar;
15107 suppress_error = 0;
15108 r = guestfs_blockdev_setrw (g, device);
15114 suppress_error = 0;
15115 r = guestfs_umount_all (g);
15121 suppress_error = 0;
15122 r = guestfs_lvm_remove_all (g);
15127 char device[] = "/dev/sda";
15128 device[5] = devchar;
15129 char lines_0[] = ",";
15135 suppress_error = 0;
15136 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15141 char device[] = "/dev/sda1";
15142 device[5] = devchar;
15144 suppress_error = 0;
15145 r = guestfs_pvcreate (g, device);
15150 char volgroup[] = "VG";
15151 char physvols_0[] = "/dev/sda1";
15152 physvols_0[5] = devchar;
15153 char *physvols[] = {
15158 suppress_error = 0;
15159 r = guestfs_vgcreate (g, volgroup, physvols);
15164 char logvol[] = "LV";
15165 char volgroup[] = "VG";
15167 suppress_error = 0;
15168 r = guestfs_lvcreate (g, logvol, volgroup, 8);
15173 char fstype[] = "ext2";
15174 char device[] = "/dev/VG/LV";
15176 suppress_error = 0;
15177 r = guestfs_mkfs (g, fstype, device);
15182 char device[] = "/dev/VG/LV";
15183 char mountpoint[] = "/";
15185 suppress_error = 0;
15186 r = guestfs_mount (g, device, mountpoint);
15190 /* TestOutputList for pvs (0) */
15194 suppress_error = 0;
15195 r = guestfs_pvs (g);
15199 fprintf (stderr, "test_pvs_0: short list returned from command\n");
15204 char expected[] = "/dev/sda1";
15205 expected[5] = devchar;
15206 if (strcmp (r[0], expected) != 0) {
15207 fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15211 if (r[1] != NULL) {
15212 fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
15216 for (i = 0; r[i] != NULL; ++i)
15223 static int test_pvs_1_skip (void)
15227 str = getenv ("SKIP_TEST_PVS_1");
15228 if (str && strcmp (str, "1") == 0) return 1;
15229 str = getenv ("SKIP_TEST_PVS");
15230 if (str && strcmp (str, "1") == 0) return 1;
15234 static int test_pvs_1 (void)
15236 if (test_pvs_1_skip ()) {
15237 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_1");
15241 /* InitNone|InitEmpty for test_pvs_1 */
15243 char device[] = "/dev/sda";
15244 device[5] = devchar;
15246 suppress_error = 0;
15247 r = guestfs_blockdev_setrw (g, device);
15253 suppress_error = 0;
15254 r = guestfs_umount_all (g);
15260 suppress_error = 0;
15261 r = guestfs_lvm_remove_all (g);
15265 /* TestOutputList for pvs (1) */
15267 char device[] = "/dev/sda";
15268 device[5] = devchar;
15269 char lines_0[] = ",10";
15270 char lines_1[] = ",20";
15271 char lines_2[] = ",";
15279 suppress_error = 0;
15280 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15285 char device[] = "/dev/sda1";
15286 device[5] = devchar;
15288 suppress_error = 0;
15289 r = guestfs_pvcreate (g, device);
15294 char device[] = "/dev/sda2";
15295 device[5] = devchar;
15297 suppress_error = 0;
15298 r = guestfs_pvcreate (g, device);
15303 char device[] = "/dev/sda3";
15304 device[5] = devchar;
15306 suppress_error = 0;
15307 r = guestfs_pvcreate (g, device);
15314 suppress_error = 0;
15315 r = guestfs_pvs (g);
15319 fprintf (stderr, "test_pvs_1: short list returned from command\n");
15324 char expected[] = "/dev/sda1";
15325 expected[5] = devchar;
15326 if (strcmp (r[0], expected) != 0) {
15327 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15332 fprintf (stderr, "test_pvs_1: short list returned from command\n");
15337 char expected[] = "/dev/sda2";
15338 expected[5] = devchar;
15339 if (strcmp (r[1], expected) != 0) {
15340 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15345 fprintf (stderr, "test_pvs_1: short list returned from command\n");
15350 char expected[] = "/dev/sda3";
15351 expected[5] = devchar;
15352 if (strcmp (r[2], expected) != 0) {
15353 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15357 if (r[3] != NULL) {
15358 fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
15362 for (i = 0; r[i] != NULL; ++i)
15369 static int test_list_partitions_0_skip (void)
15373 str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
15374 if (str && strcmp (str, "1") == 0) return 1;
15375 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
15376 if (str && strcmp (str, "1") == 0) return 1;
15380 static int test_list_partitions_0 (void)
15382 if (test_list_partitions_0_skip ()) {
15383 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_0");
15387 /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
15389 char device[] = "/dev/sda";
15390 device[5] = devchar;
15392 suppress_error = 0;
15393 r = guestfs_blockdev_setrw (g, device);
15399 suppress_error = 0;
15400 r = guestfs_umount_all (g);
15406 suppress_error = 0;
15407 r = guestfs_lvm_remove_all (g);
15412 char device[] = "/dev/sda";
15413 device[5] = devchar;
15414 char lines_0[] = ",";
15420 suppress_error = 0;
15421 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15426 char fstype[] = "ext2";
15427 char device[] = "/dev/sda1";
15428 device[5] = devchar;
15430 suppress_error = 0;
15431 r = guestfs_mkfs (g, fstype, device);
15436 char device[] = "/dev/sda1";
15437 device[5] = devchar;
15438 char mountpoint[] = "/";
15440 suppress_error = 0;
15441 r = guestfs_mount (g, device, mountpoint);
15445 /* TestOutputList for list_partitions (0) */
15449 suppress_error = 0;
15450 r = guestfs_list_partitions (g);
15454 fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
15459 char expected[] = "/dev/sda1";
15460 expected[5] = devchar;
15461 if (strcmp (r[0], expected) != 0) {
15462 fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15466 if (r[1] != NULL) {
15467 fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
15471 for (i = 0; r[i] != NULL; ++i)
15478 static int test_list_partitions_1_skip (void)
15482 str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
15483 if (str && strcmp (str, "1") == 0) return 1;
15484 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
15485 if (str && strcmp (str, "1") == 0) return 1;
15489 static int test_list_partitions_1 (void)
15491 if (test_list_partitions_1_skip ()) {
15492 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_1");
15496 /* InitNone|InitEmpty for test_list_partitions_1 */
15498 char device[] = "/dev/sda";
15499 device[5] = devchar;
15501 suppress_error = 0;
15502 r = guestfs_blockdev_setrw (g, device);
15508 suppress_error = 0;
15509 r = guestfs_umount_all (g);
15515 suppress_error = 0;
15516 r = guestfs_lvm_remove_all (g);
15520 /* TestOutputList for list_partitions (1) */
15522 char device[] = "/dev/sda";
15523 device[5] = devchar;
15524 char lines_0[] = ",10";
15525 char lines_1[] = ",20";
15526 char lines_2[] = ",";
15534 suppress_error = 0;
15535 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15542 suppress_error = 0;
15543 r = guestfs_list_partitions (g);
15547 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15552 char expected[] = "/dev/sda1";
15553 expected[5] = devchar;
15554 if (strcmp (r[0], expected) != 0) {
15555 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15560 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15565 char expected[] = "/dev/sda2";
15566 expected[5] = devchar;
15567 if (strcmp (r[1], expected) != 0) {
15568 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15573 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15578 char expected[] = "/dev/sda3";
15579 expected[5] = devchar;
15580 if (strcmp (r[2], expected) != 0) {
15581 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15585 if (r[3] != NULL) {
15586 fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
15590 for (i = 0; r[i] != NULL; ++i)
15597 static int test_list_devices_0_skip (void)
15601 str = getenv ("SKIP_TEST_LIST_DEVICES_0");
15602 if (str && strcmp (str, "1") == 0) return 1;
15603 str = getenv ("SKIP_TEST_LIST_DEVICES");
15604 if (str && strcmp (str, "1") == 0) return 1;
15608 static int test_list_devices_0 (void)
15610 if (test_list_devices_0_skip ()) {
15611 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_devices_0");
15615 /* InitNone|InitEmpty for test_list_devices_0 */
15617 char device[] = "/dev/sda";
15618 device[5] = devchar;
15620 suppress_error = 0;
15621 r = guestfs_blockdev_setrw (g, device);
15627 suppress_error = 0;
15628 r = guestfs_umount_all (g);
15634 suppress_error = 0;
15635 r = guestfs_lvm_remove_all (g);
15639 /* TestOutputList for list_devices (0) */
15643 suppress_error = 0;
15644 r = guestfs_list_devices (g);
15648 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15653 char expected[] = "/dev/sda";
15654 expected[5] = devchar;
15655 if (strcmp (r[0], expected) != 0) {
15656 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15661 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15666 char expected[] = "/dev/sdb";
15667 expected[5] = devchar;
15668 if (strcmp (r[1], expected) != 0) {
15669 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15674 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15679 char expected[] = "/dev/sdc";
15680 expected[5] = devchar;
15681 if (strcmp (r[2], expected) != 0) {
15682 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15687 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15692 char expected[] = "/dev/sdd";
15693 expected[5] = devchar;
15694 if (strcmp (r[3], expected) != 0) {
15695 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15699 if (r[4] != NULL) {
15700 fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
15704 for (i = 0; r[i] != NULL; ++i)
15711 static int test_ls_0_skip (void)
15715 str = getenv ("SKIP_TEST_LS_0");
15716 if (str && strcmp (str, "1") == 0) return 1;
15717 str = getenv ("SKIP_TEST_LS");
15718 if (str && strcmp (str, "1") == 0) return 1;
15722 static int test_ls_0 (void)
15724 if (test_ls_0_skip ()) {
15725 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ls_0");
15729 /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
15731 char device[] = "/dev/sda";
15732 device[5] = devchar;
15734 suppress_error = 0;
15735 r = guestfs_blockdev_setrw (g, device);
15741 suppress_error = 0;
15742 r = guestfs_umount_all (g);
15748 suppress_error = 0;
15749 r = guestfs_lvm_remove_all (g);
15754 char device[] = "/dev/sda";
15755 device[5] = devchar;
15756 char lines_0[] = ",";
15762 suppress_error = 0;
15763 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15768 char fstype[] = "ext2";
15769 char device[] = "/dev/sda1";
15770 device[5] = devchar;
15772 suppress_error = 0;
15773 r = guestfs_mkfs (g, fstype, device);
15778 char device[] = "/dev/sda1";
15779 device[5] = devchar;
15780 char mountpoint[] = "/";
15782 suppress_error = 0;
15783 r = guestfs_mount (g, device, mountpoint);
15787 /* TestOutputList for ls (0) */
15789 char path[] = "/new";
15791 suppress_error = 0;
15792 r = guestfs_touch (g, path);
15797 char path[] = "/newer";
15799 suppress_error = 0;
15800 r = guestfs_touch (g, path);
15805 char path[] = "/newest";
15807 suppress_error = 0;
15808 r = guestfs_touch (g, path);
15813 char directory[] = "/";
15816 suppress_error = 0;
15817 r = guestfs_ls (g, directory);
15821 fprintf (stderr, "test_ls_0: short list returned from command\n");
15826 char expected[] = "lost+found";
15827 if (strcmp (r[0], expected) != 0) {
15828 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15833 fprintf (stderr, "test_ls_0: short list returned from command\n");
15838 char expected[] = "new";
15839 if (strcmp (r[1], expected) != 0) {
15840 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15845 fprintf (stderr, "test_ls_0: short list returned from command\n");
15850 char expected[] = "newer";
15851 if (strcmp (r[2], expected) != 0) {
15852 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15857 fprintf (stderr, "test_ls_0: short list returned from command\n");
15862 char expected[] = "newest";
15863 if (strcmp (r[3], expected) != 0) {
15864 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15868 if (r[4] != NULL) {
15869 fprintf (stderr, "test_ls_0: extra elements returned from command\n");
15873 for (i = 0; r[i] != NULL; ++i)
15880 static int test_cat_0_skip (void)
15884 str = getenv ("SKIP_TEST_CAT_0");
15885 if (str && strcmp (str, "1") == 0) return 1;
15886 str = getenv ("SKIP_TEST_CAT");
15887 if (str && strcmp (str, "1") == 0) return 1;
15891 static int test_cat_0 (void)
15893 if (test_cat_0_skip ()) {
15894 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cat_0");
15898 /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
15900 char device[] = "/dev/sda";
15901 device[5] = devchar;
15903 suppress_error = 0;
15904 r = guestfs_blockdev_setrw (g, device);
15910 suppress_error = 0;
15911 r = guestfs_umount_all (g);
15917 suppress_error = 0;
15918 r = guestfs_lvm_remove_all (g);
15923 char device[] = "/dev/sda";
15924 device[5] = devchar;
15925 char lines_0[] = ",";
15931 suppress_error = 0;
15932 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15937 char fstype[] = "ext2";
15938 char device[] = "/dev/sda1";
15939 device[5] = devchar;
15941 suppress_error = 0;
15942 r = guestfs_mkfs (g, fstype, device);
15947 char device[] = "/dev/sda1";
15948 device[5] = devchar;
15949 char mountpoint[] = "/";
15951 suppress_error = 0;
15952 r = guestfs_mount (g, device, mountpoint);
15956 /* TestOutput for cat (0) */
15957 char expected[] = "new file contents";
15959 char path[] = "/new";
15960 char content[] = "new file contents";
15962 suppress_error = 0;
15963 r = guestfs_write_file (g, path, content, 0);
15968 char path[] = "/new";
15970 suppress_error = 0;
15971 r = guestfs_cat (g, path);
15974 if (strcmp (r, expected) != 0) {
15975 fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
15983 static int test_touch_0_skip (void)
15987 str = getenv ("SKIP_TEST_TOUCH_0");
15988 if (str && strcmp (str, "1") == 0) return 1;
15989 str = getenv ("SKIP_TEST_TOUCH");
15990 if (str && strcmp (str, "1") == 0) return 1;
15994 static int test_touch_0 (void)
15996 if (test_touch_0_skip ()) {
15997 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_touch_0");
16001 /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
16003 char device[] = "/dev/sda";
16004 device[5] = devchar;
16006 suppress_error = 0;
16007 r = guestfs_blockdev_setrw (g, device);
16013 suppress_error = 0;
16014 r = guestfs_umount_all (g);
16020 suppress_error = 0;
16021 r = guestfs_lvm_remove_all (g);
16026 char device[] = "/dev/sda";
16027 device[5] = devchar;
16028 char lines_0[] = ",";
16034 suppress_error = 0;
16035 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16040 char fstype[] = "ext2";
16041 char device[] = "/dev/sda1";
16042 device[5] = devchar;
16044 suppress_error = 0;
16045 r = guestfs_mkfs (g, fstype, device);
16050 char device[] = "/dev/sda1";
16051 device[5] = devchar;
16052 char mountpoint[] = "/";
16054 suppress_error = 0;
16055 r = guestfs_mount (g, device, mountpoint);
16059 /* TestOutputTrue for touch (0) */
16061 char path[] = "/new";
16063 suppress_error = 0;
16064 r = guestfs_touch (g, path);
16069 char path[] = "/new";
16071 suppress_error = 0;
16072 r = guestfs_exists (g, path);
16076 fprintf (stderr, "test_touch_0: expected true, got false\n");
16083 static int test_sync_0_skip (void)
16087 str = getenv ("SKIP_TEST_SYNC_0");
16088 if (str && strcmp (str, "1") == 0) return 1;
16089 str = getenv ("SKIP_TEST_SYNC");
16090 if (str && strcmp (str, "1") == 0) return 1;
16094 static int test_sync_0 (void)
16096 if (test_sync_0_skip ()) {
16097 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sync_0");
16101 /* InitNone|InitEmpty for test_sync_0 */
16103 char device[] = "/dev/sda";
16104 device[5] = devchar;
16106 suppress_error = 0;
16107 r = guestfs_blockdev_setrw (g, device);
16113 suppress_error = 0;
16114 r = guestfs_umount_all (g);
16120 suppress_error = 0;
16121 r = guestfs_lvm_remove_all (g);
16125 /* TestRun for sync (0) */
16128 suppress_error = 0;
16129 r = guestfs_sync (g);
16136 static int test_mount_0_skip (void)
16140 str = getenv ("SKIP_TEST_MOUNT_0");
16141 if (str && strcmp (str, "1") == 0) return 1;
16142 str = getenv ("SKIP_TEST_MOUNT");
16143 if (str && strcmp (str, "1") == 0) return 1;
16147 static int test_mount_0 (void)
16149 if (test_mount_0_skip ()) {
16150 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_0");
16154 /* InitNone|InitEmpty for test_mount_0 */
16156 char device[] = "/dev/sda";
16157 device[5] = devchar;
16159 suppress_error = 0;
16160 r = guestfs_blockdev_setrw (g, device);
16166 suppress_error = 0;
16167 r = guestfs_umount_all (g);
16173 suppress_error = 0;
16174 r = guestfs_lvm_remove_all (g);
16178 /* TestOutput for mount (0) */
16179 char expected[] = "new file contents";
16181 char device[] = "/dev/sda";
16182 device[5] = devchar;
16183 char lines_0[] = ",";
16189 suppress_error = 0;
16190 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16195 char fstype[] = "ext2";
16196 char device[] = "/dev/sda1";
16197 device[5] = devchar;
16199 suppress_error = 0;
16200 r = guestfs_mkfs (g, fstype, device);
16205 char device[] = "/dev/sda1";
16206 device[5] = devchar;
16207 char mountpoint[] = "/";
16209 suppress_error = 0;
16210 r = guestfs_mount (g, device, mountpoint);
16215 char path[] = "/new";
16216 char content[] = "new file contents";
16218 suppress_error = 0;
16219 r = guestfs_write_file (g, path, content, 0);
16224 char path[] = "/new";
16226 suppress_error = 0;
16227 r = guestfs_cat (g, path);
16230 if (strcmp (r, expected) != 0) {
16231 fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
16239 int main (int argc, char *argv[])
16243 const char *filename;
16245 int nr_tests, test_num = 0;
16248 no_test_warnings ();
16250 g = guestfs_create ();
16252 printf ("guestfs_create FAILED\n");
16256 guestfs_set_error_handler (g, print_error, NULL);
16258 guestfs_set_path (g, "../appliance");
16260 filename = "test1.img";
16261 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16266 if (lseek (fd, 524288000, SEEK_SET) == -1) {
16272 if (write (fd, &c, 1) == -1) {
16278 if (close (fd) == -1) {
16283 if (guestfs_add_drive (g, filename) == -1) {
16284 printf ("guestfs_add_drive %s FAILED\n", filename);
16288 filename = "test2.img";
16289 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16294 if (lseek (fd, 52428800, SEEK_SET) == -1) {
16300 if (write (fd, &c, 1) == -1) {
16306 if (close (fd) == -1) {
16311 if (guestfs_add_drive (g, filename) == -1) {
16312 printf ("guestfs_add_drive %s FAILED\n", filename);
16316 filename = "test3.img";
16317 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16322 if (lseek (fd, 10485760, SEEK_SET) == -1) {
16328 if (write (fd, &c, 1) == -1) {
16334 if (close (fd) == -1) {
16339 if (guestfs_add_drive (g, filename) == -1) {
16340 printf ("guestfs_add_drive %s FAILED\n", filename);
16344 if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
16345 printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
16349 if (guestfs_launch (g) == -1) {
16350 printf ("guestfs_launch FAILED\n");
16353 if (guestfs_wait_ready (g) == -1) {
16354 printf ("guestfs_wait_ready FAILED\n");
16358 /* Detect if the appliance uses /dev/sd* or /dev/hd* in device
16359 * names. This changed between RHEL 5 and RHEL 6 so we have to
16362 devs = guestfs_list_devices (g);
16363 if (devs == NULL || devs[0] == NULL) {
16364 printf ("guestfs_list_devices FAILED\n");
16367 if (strncmp (devs[0], "/dev/sd", 7) == 0)
16369 else if (strncmp (devs[0], "/dev/hd", 7) == 0)
16372 printf ("guestfs_list_devices returned unexpected string '%s'\n",
16376 for (i = 0; devs[i] != NULL; ++i)
16383 printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
16384 if (test_ntfs_3g_probe_0 () == -1) {
16385 printf ("test_ntfs_3g_probe_0 FAILED\n");
16389 printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
16390 if (test_ntfs_3g_probe_1 () == -1) {
16391 printf ("test_ntfs_3g_probe_1 FAILED\n");
16395 printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
16396 if (test_sleep_0 () == -1) {
16397 printf ("test_sleep_0 FAILED\n");
16401 printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
16402 if (test_find_0 () == -1) {
16403 printf ("test_find_0 FAILED\n");
16407 printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
16408 if (test_find_1 () == -1) {
16409 printf ("test_find_1 FAILED\n");
16413 printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
16414 if (test_find_2 () == -1) {
16415 printf ("test_find_2 FAILED\n");
16419 printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
16420 if (test_lvresize_0 () == -1) {
16421 printf ("test_lvresize_0 FAILED\n");
16425 printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
16426 if (test_zerofree_0 () == -1) {
16427 printf ("test_zerofree_0 FAILED\n");
16431 printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
16432 if (test_hexdump_0 () == -1) {
16433 printf ("test_hexdump_0 FAILED\n");
16437 printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
16438 if (test_strings_e_0 () == -1) {
16439 printf ("test_strings_e_0 FAILED\n");
16443 printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
16444 if (test_strings_e_1 () == -1) {
16445 printf ("test_strings_e_1 FAILED\n");
16449 printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
16450 if (test_strings_0 () == -1) {
16451 printf ("test_strings_0 FAILED\n");
16455 printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
16456 if (test_strings_1 () == -1) {
16457 printf ("test_strings_1 FAILED\n");
16461 printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
16462 if (test_equal_0 () == -1) {
16463 printf ("test_equal_0 FAILED\n");
16467 printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
16468 if (test_equal_1 () == -1) {
16469 printf ("test_equal_1 FAILED\n");
16473 printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
16474 if (test_equal_2 () == -1) {
16475 printf ("test_equal_2 FAILED\n");
16479 printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
16480 if (test_ping_daemon_0 () == -1) {
16481 printf ("test_ping_daemon_0 FAILED\n");
16485 printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
16486 if (test_dmesg_0 () == -1) {
16487 printf ("test_dmesg_0 FAILED\n");
16491 printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
16492 if (test_drop_caches_0 () == -1) {
16493 printf ("test_drop_caches_0 FAILED\n");
16497 printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
16498 if (test_mv_0 () == -1) {
16499 printf ("test_mv_0 FAILED\n");
16503 printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
16504 if (test_mv_1 () == -1) {
16505 printf ("test_mv_1 FAILED\n");
16509 printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
16510 if (test_cp_a_0 () == -1) {
16511 printf ("test_cp_a_0 FAILED\n");
16515 printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
16516 if (test_cp_0 () == -1) {
16517 printf ("test_cp_0 FAILED\n");
16521 printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
16522 if (test_cp_1 () == -1) {
16523 printf ("test_cp_1 FAILED\n");
16527 printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
16528 if (test_cp_2 () == -1) {
16529 printf ("test_cp_2 FAILED\n");
16533 printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
16534 if (test_grub_install_0 () == -1) {
16535 printf ("test_grub_install_0 FAILED\n");
16539 printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
16540 if (test_zero_0 () == -1) {
16541 printf ("test_zero_0 FAILED\n");
16545 printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
16546 if (test_fsck_0 () == -1) {
16547 printf ("test_fsck_0 FAILED\n");
16551 printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
16552 if (test_fsck_1 () == -1) {
16553 printf ("test_fsck_1 FAILED\n");
16557 printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
16558 if (test_set_e2uuid_0 () == -1) {
16559 printf ("test_set_e2uuid_0 FAILED\n");
16563 printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
16564 if (test_set_e2uuid_1 () == -1) {
16565 printf ("test_set_e2uuid_1 FAILED\n");
16569 printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
16570 if (test_set_e2uuid_2 () == -1) {
16571 printf ("test_set_e2uuid_2 FAILED\n");
16575 printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
16576 if (test_set_e2uuid_3 () == -1) {
16577 printf ("test_set_e2uuid_3 FAILED\n");
16581 printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
16582 if (test_set_e2label_0 () == -1) {
16583 printf ("test_set_e2label_0 FAILED\n");
16587 printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
16588 if (test_pvremove_0 () == -1) {
16589 printf ("test_pvremove_0 FAILED\n");
16593 printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
16594 if (test_pvremove_1 () == -1) {
16595 printf ("test_pvremove_1 FAILED\n");
16599 printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
16600 if (test_pvremove_2 () == -1) {
16601 printf ("test_pvremove_2 FAILED\n");
16605 printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
16606 if (test_vgremove_0 () == -1) {
16607 printf ("test_vgremove_0 FAILED\n");
16611 printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
16612 if (test_vgremove_1 () == -1) {
16613 printf ("test_vgremove_1 FAILED\n");
16617 printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
16618 if (test_lvremove_0 () == -1) {
16619 printf ("test_lvremove_0 FAILED\n");
16623 printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
16624 if (test_lvremove_1 () == -1) {
16625 printf ("test_lvremove_1 FAILED\n");
16629 printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
16630 if (test_lvremove_2 () == -1) {
16631 printf ("test_lvremove_2 FAILED\n");
16635 printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
16636 if (test_mount_ro_0 () == -1) {
16637 printf ("test_mount_ro_0 FAILED\n");
16641 printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
16642 if (test_mount_ro_1 () == -1) {
16643 printf ("test_mount_ro_1 FAILED\n");
16647 printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
16648 if (test_tgz_in_0 () == -1) {
16649 printf ("test_tgz_in_0 FAILED\n");
16653 printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
16654 if (test_tar_in_0 () == -1) {
16655 printf ("test_tar_in_0 FAILED\n");
16659 printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
16660 if (test_checksum_0 () == -1) {
16661 printf ("test_checksum_0 FAILED\n");
16665 printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
16666 if (test_checksum_1 () == -1) {
16667 printf ("test_checksum_1 FAILED\n");
16671 printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
16672 if (test_checksum_2 () == -1) {
16673 printf ("test_checksum_2 FAILED\n");
16677 printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
16678 if (test_checksum_3 () == -1) {
16679 printf ("test_checksum_3 FAILED\n");
16683 printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
16684 if (test_checksum_4 () == -1) {
16685 printf ("test_checksum_4 FAILED\n");
16689 printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
16690 if (test_checksum_5 () == -1) {
16691 printf ("test_checksum_5 FAILED\n");
16695 printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
16696 if (test_checksum_6 () == -1) {
16697 printf ("test_checksum_6 FAILED\n");
16701 printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
16702 if (test_checksum_7 () == -1) {
16703 printf ("test_checksum_7 FAILED\n");
16707 printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
16708 if (test_checksum_8 () == -1) {
16709 printf ("test_checksum_8 FAILED\n");
16713 printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
16714 if (test_download_0 () == -1) {
16715 printf ("test_download_0 FAILED\n");
16719 printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
16720 if (test_upload_0 () == -1) {
16721 printf ("test_upload_0 FAILED\n");
16725 printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
16726 if (test_blockdev_rereadpt_0 () == -1) {
16727 printf ("test_blockdev_rereadpt_0 FAILED\n");
16731 printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
16732 if (test_blockdev_flushbufs_0 () == -1) {
16733 printf ("test_blockdev_flushbufs_0 FAILED\n");
16737 printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
16738 if (test_blockdev_getsize64_0 () == -1) {
16739 printf ("test_blockdev_getsize64_0 FAILED\n");
16743 printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
16744 if (test_blockdev_getsz_0 () == -1) {
16745 printf ("test_blockdev_getsz_0 FAILED\n");
16749 printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
16750 if (test_blockdev_getbsz_0 () == -1) {
16751 printf ("test_blockdev_getbsz_0 FAILED\n");
16755 printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
16756 if (test_blockdev_getss_0 () == -1) {
16757 printf ("test_blockdev_getss_0 FAILED\n");
16761 printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
16762 if (test_blockdev_getro_0 () == -1) {
16763 printf ("test_blockdev_getro_0 FAILED\n");
16767 printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
16768 if (test_blockdev_setrw_0 () == -1) {
16769 printf ("test_blockdev_setrw_0 FAILED\n");
16773 printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
16774 if (test_blockdev_setro_0 () == -1) {
16775 printf ("test_blockdev_setro_0 FAILED\n");
16779 printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
16780 if (test_statvfs_0 () == -1) {
16781 printf ("test_statvfs_0 FAILED\n");
16785 printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
16786 if (test_lstat_0 () == -1) {
16787 printf ("test_lstat_0 FAILED\n");
16791 printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
16792 if (test_stat_0 () == -1) {
16793 printf ("test_stat_0 FAILED\n");
16797 printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
16798 if (test_command_lines_0 () == -1) {
16799 printf ("test_command_lines_0 FAILED\n");
16803 printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
16804 if (test_command_lines_1 () == -1) {
16805 printf ("test_command_lines_1 FAILED\n");
16809 printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
16810 if (test_command_lines_2 () == -1) {
16811 printf ("test_command_lines_2 FAILED\n");
16815 printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
16816 if (test_command_lines_3 () == -1) {
16817 printf ("test_command_lines_3 FAILED\n");
16821 printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
16822 if (test_command_lines_4 () == -1) {
16823 printf ("test_command_lines_4 FAILED\n");
16827 printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
16828 if (test_command_lines_5 () == -1) {
16829 printf ("test_command_lines_5 FAILED\n");
16833 printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
16834 if (test_command_lines_6 () == -1) {
16835 printf ("test_command_lines_6 FAILED\n");
16839 printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
16840 if (test_command_lines_7 () == -1) {
16841 printf ("test_command_lines_7 FAILED\n");
16845 printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
16846 if (test_command_lines_8 () == -1) {
16847 printf ("test_command_lines_8 FAILED\n");
16851 printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
16852 if (test_command_lines_9 () == -1) {
16853 printf ("test_command_lines_9 FAILED\n");
16857 printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
16858 if (test_command_lines_10 () == -1) {
16859 printf ("test_command_lines_10 FAILED\n");
16863 printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
16864 if (test_command_0 () == -1) {
16865 printf ("test_command_0 FAILED\n");
16869 printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
16870 if (test_command_1 () == -1) {
16871 printf ("test_command_1 FAILED\n");
16875 printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
16876 if (test_command_2 () == -1) {
16877 printf ("test_command_2 FAILED\n");
16881 printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
16882 if (test_command_3 () == -1) {
16883 printf ("test_command_3 FAILED\n");
16887 printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
16888 if (test_command_4 () == -1) {
16889 printf ("test_command_4 FAILED\n");
16893 printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
16894 if (test_command_5 () == -1) {
16895 printf ("test_command_5 FAILED\n");
16899 printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
16900 if (test_command_6 () == -1) {
16901 printf ("test_command_6 FAILED\n");
16905 printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
16906 if (test_command_7 () == -1) {
16907 printf ("test_command_7 FAILED\n");
16911 printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
16912 if (test_command_8 () == -1) {
16913 printf ("test_command_8 FAILED\n");
16917 printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
16918 if (test_command_9 () == -1) {
16919 printf ("test_command_9 FAILED\n");
16923 printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
16924 if (test_command_10 () == -1) {
16925 printf ("test_command_10 FAILED\n");
16929 printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
16930 if (test_command_11 () == -1) {
16931 printf ("test_command_11 FAILED\n");
16935 printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
16936 if (test_file_0 () == -1) {
16937 printf ("test_file_0 FAILED\n");
16941 printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
16942 if (test_file_1 () == -1) {
16943 printf ("test_file_1 FAILED\n");
16947 printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
16948 if (test_file_2 () == -1) {
16949 printf ("test_file_2 FAILED\n");
16953 printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
16954 if (test_umount_all_0 () == -1) {
16955 printf ("test_umount_all_0 FAILED\n");
16959 printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
16960 if (test_umount_all_1 () == -1) {
16961 printf ("test_umount_all_1 FAILED\n");
16965 printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
16966 if (test_mounts_0 () == -1) {
16967 printf ("test_mounts_0 FAILED\n");
16971 printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
16972 if (test_umount_0 () == -1) {
16973 printf ("test_umount_0 FAILED\n");
16977 printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
16978 if (test_umount_1 () == -1) {
16979 printf ("test_umount_1 FAILED\n");
16983 printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
16984 if (test_write_file_0 () == -1) {
16985 printf ("test_write_file_0 FAILED\n");
16989 printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
16990 if (test_write_file_1 () == -1) {
16991 printf ("test_write_file_1 FAILED\n");
16995 printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
16996 if (test_write_file_2 () == -1) {
16997 printf ("test_write_file_2 FAILED\n");
17001 printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
17002 if (test_write_file_3 () == -1) {
17003 printf ("test_write_file_3 FAILED\n");
17007 printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
17008 if (test_write_file_4 () == -1) {
17009 printf ("test_write_file_4 FAILED\n");
17013 printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
17014 if (test_write_file_5 () == -1) {
17015 printf ("test_write_file_5 FAILED\n");
17019 printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
17020 if (test_mkfs_0 () == -1) {
17021 printf ("test_mkfs_0 FAILED\n");
17025 printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
17026 if (test_lvcreate_0 () == -1) {
17027 printf ("test_lvcreate_0 FAILED\n");
17031 printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
17032 if (test_vgcreate_0 () == -1) {
17033 printf ("test_vgcreate_0 FAILED\n");
17037 printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
17038 if (test_pvcreate_0 () == -1) {
17039 printf ("test_pvcreate_0 FAILED\n");
17043 printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
17044 if (test_is_dir_0 () == -1) {
17045 printf ("test_is_dir_0 FAILED\n");
17049 printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
17050 if (test_is_dir_1 () == -1) {
17051 printf ("test_is_dir_1 FAILED\n");
17055 printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
17056 if (test_is_file_0 () == -1) {
17057 printf ("test_is_file_0 FAILED\n");
17061 printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
17062 if (test_is_file_1 () == -1) {
17063 printf ("test_is_file_1 FAILED\n");
17067 printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
17068 if (test_exists_0 () == -1) {
17069 printf ("test_exists_0 FAILED\n");
17073 printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
17074 if (test_exists_1 () == -1) {
17075 printf ("test_exists_1 FAILED\n");
17079 printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
17080 if (test_mkdir_p_0 () == -1) {
17081 printf ("test_mkdir_p_0 FAILED\n");
17085 printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
17086 if (test_mkdir_p_1 () == -1) {
17087 printf ("test_mkdir_p_1 FAILED\n");
17091 printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
17092 if (test_mkdir_p_2 () == -1) {
17093 printf ("test_mkdir_p_2 FAILED\n");
17097 printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
17098 if (test_mkdir_p_3 () == -1) {
17099 printf ("test_mkdir_p_3 FAILED\n");
17103 printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
17104 if (test_mkdir_p_4 () == -1) {
17105 printf ("test_mkdir_p_4 FAILED\n");
17109 printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
17110 if (test_mkdir_0 () == -1) {
17111 printf ("test_mkdir_0 FAILED\n");
17115 printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
17116 if (test_mkdir_1 () == -1) {
17117 printf ("test_mkdir_1 FAILED\n");
17121 printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
17122 if (test_rm_rf_0 () == -1) {
17123 printf ("test_rm_rf_0 FAILED\n");
17127 printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
17128 if (test_rmdir_0 () == -1) {
17129 printf ("test_rmdir_0 FAILED\n");
17133 printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
17134 if (test_rmdir_1 () == -1) {
17135 printf ("test_rmdir_1 FAILED\n");
17139 printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
17140 if (test_rmdir_2 () == -1) {
17141 printf ("test_rmdir_2 FAILED\n");
17145 printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
17146 if (test_rm_0 () == -1) {
17147 printf ("test_rm_0 FAILED\n");
17151 printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
17152 if (test_rm_1 () == -1) {
17153 printf ("test_rm_1 FAILED\n");
17157 printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
17158 if (test_rm_2 () == -1) {
17159 printf ("test_rm_2 FAILED\n");
17163 printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
17164 if (test_read_lines_0 () == -1) {
17165 printf ("test_read_lines_0 FAILED\n");
17169 printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
17170 if (test_read_lines_1 () == -1) {
17171 printf ("test_read_lines_1 FAILED\n");
17175 printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
17176 if (test_lvs_0 () == -1) {
17177 printf ("test_lvs_0 FAILED\n");
17181 printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
17182 if (test_lvs_1 () == -1) {
17183 printf ("test_lvs_1 FAILED\n");
17187 printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
17188 if (test_vgs_0 () == -1) {
17189 printf ("test_vgs_0 FAILED\n");
17193 printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
17194 if (test_vgs_1 () == -1) {
17195 printf ("test_vgs_1 FAILED\n");
17199 printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
17200 if (test_pvs_0 () == -1) {
17201 printf ("test_pvs_0 FAILED\n");
17205 printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
17206 if (test_pvs_1 () == -1) {
17207 printf ("test_pvs_1 FAILED\n");
17211 printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
17212 if (test_list_partitions_0 () == -1) {
17213 printf ("test_list_partitions_0 FAILED\n");
17217 printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
17218 if (test_list_partitions_1 () == -1) {
17219 printf ("test_list_partitions_1 FAILED\n");
17223 printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
17224 if (test_list_devices_0 () == -1) {
17225 printf ("test_list_devices_0 FAILED\n");
17229 printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
17230 if (test_ls_0 () == -1) {
17231 printf ("test_ls_0 FAILED\n");
17235 printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
17236 if (test_cat_0 () == -1) {
17237 printf ("test_cat_0 FAILED\n");
17241 printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
17242 if (test_touch_0 () == -1) {
17243 printf ("test_touch_0 FAILED\n");
17247 printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
17248 if (test_sync_0 () == -1) {
17249 printf ("test_sync_0 FAILED\n");
17253 printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
17254 if (test_mount_0 () == -1) {
17255 printf ("test_mount_0 FAILED\n");
17260 unlink ("test1.img");
17261 unlink ("test2.img");
17262 unlink ("test3.img");
17265 printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);