1 /* libguestfs generated file
2 * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
3 * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
5 * Copyright (C) 2009 Red Hat Inc.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
26 #include <sys/types.h>
32 static int suppress_error = 0;
34 static void print_error (guestfs_h *g, void *data, const char *msg)
37 fprintf (stderr, "%s\n", msg);
40 static void print_strings (char * const * const argv)
44 for (argc = 0; argv[argc] != NULL; ++argc)
45 printf ("\t%s\n", argv[argc]);
49 static void print_table (char * const * const argv)
53 for (i = 0; argv[i] != NULL; i += 2)
54 printf ("%s: %s\n", argv[i], argv[i+1]);
58 static void no_test_warnings (void)
60 fprintf (stderr, "warning: \"guestfs_test0\" has no tests\n");
61 fprintf (stderr, "warning: \"guestfs_test0rint\" has no tests\n");
62 fprintf (stderr, "warning: \"guestfs_test0rinterr\" has no tests\n");
63 fprintf (stderr, "warning: \"guestfs_test0rint64\" has no tests\n");
64 fprintf (stderr, "warning: \"guestfs_test0rint64err\" has no tests\n");
65 fprintf (stderr, "warning: \"guestfs_test0rbool\" has no tests\n");
66 fprintf (stderr, "warning: \"guestfs_test0rboolerr\" has no tests\n");
67 fprintf (stderr, "warning: \"guestfs_test0rconststring\" has no tests\n");
68 fprintf (stderr, "warning: \"guestfs_test0rconststringerr\" has no tests\n");
69 fprintf (stderr, "warning: \"guestfs_test0rstring\" has no tests\n");
70 fprintf (stderr, "warning: \"guestfs_test0rstringerr\" has no tests\n");
71 fprintf (stderr, "warning: \"guestfs_test0rstringlist\" has no tests\n");
72 fprintf (stderr, "warning: \"guestfs_test0rstringlisterr\" has no tests\n");
73 fprintf (stderr, "warning: \"guestfs_test0rintbool\" has no tests\n");
74 fprintf (stderr, "warning: \"guestfs_test0rintboolerr\" has no tests\n");
75 fprintf (stderr, "warning: \"guestfs_test0rpvlist\" has no tests\n");
76 fprintf (stderr, "warning: \"guestfs_test0rpvlisterr\" has no tests\n");
77 fprintf (stderr, "warning: \"guestfs_test0rvglist\" has no tests\n");
78 fprintf (stderr, "warning: \"guestfs_test0rvglisterr\" has no tests\n");
79 fprintf (stderr, "warning: \"guestfs_test0rlvlist\" has no tests\n");
80 fprintf (stderr, "warning: \"guestfs_test0rlvlisterr\" has no tests\n");
81 fprintf (stderr, "warning: \"guestfs_test0rstat\" has no tests\n");
82 fprintf (stderr, "warning: \"guestfs_test0rstaterr\" has no tests\n");
83 fprintf (stderr, "warning: \"guestfs_test0rstatvfs\" has no tests\n");
84 fprintf (stderr, "warning: \"guestfs_test0rstatvfserr\" has no tests\n");
85 fprintf (stderr, "warning: \"guestfs_test0rhashtable\" has no tests\n");
86 fprintf (stderr, "warning: \"guestfs_test0rhashtableerr\" has no tests\n");
87 fprintf (stderr, "warning: \"guestfs_launch\" has no tests\n");
88 fprintf (stderr, "warning: \"guestfs_wait_ready\" has no tests\n");
89 fprintf (stderr, "warning: \"guestfs_kill_subprocess\" has no tests\n");
90 fprintf (stderr, "warning: \"guestfs_add_drive\" has no tests\n");
91 fprintf (stderr, "warning: \"guestfs_add_cdrom\" has no tests\n");
92 fprintf (stderr, "warning: \"guestfs_add_drive_ro\" has no tests\n");
93 fprintf (stderr, "warning: \"guestfs_config\" has no tests\n");
94 fprintf (stderr, "warning: \"guestfs_set_qemu\" has no tests\n");
95 fprintf (stderr, "warning: \"guestfs_get_qemu\" has no tests\n");
96 fprintf (stderr, "warning: \"guestfs_set_path\" has no tests\n");
97 fprintf (stderr, "warning: \"guestfs_get_path\" has no tests\n");
98 fprintf (stderr, "warning: \"guestfs_set_append\" has no tests\n");
99 fprintf (stderr, "warning: \"guestfs_get_append\" has no tests\n");
100 fprintf (stderr, "warning: \"guestfs_set_autosync\" has no tests\n");
101 fprintf (stderr, "warning: \"guestfs_get_autosync\" has no tests\n");
102 fprintf (stderr, "warning: \"guestfs_set_verbose\" has no tests\n");
103 fprintf (stderr, "warning: \"guestfs_get_verbose\" has no tests\n");
104 fprintf (stderr, "warning: \"guestfs_is_ready\" has no tests\n");
105 fprintf (stderr, "warning: \"guestfs_is_config\" has no tests\n");
106 fprintf (stderr, "warning: \"guestfs_is_launching\" has no tests\n");
107 fprintf (stderr, "warning: \"guestfs_is_busy\" has no tests\n");
108 fprintf (stderr, "warning: \"guestfs_get_state\" has no tests\n");
109 fprintf (stderr, "warning: \"guestfs_set_busy\" has no tests\n");
110 fprintf (stderr, "warning: \"guestfs_set_ready\" has no tests\n");
111 fprintf (stderr, "warning: \"guestfs_end_busy\" has no tests\n");
112 fprintf (stderr, "warning: \"guestfs_set_memsize\" has no tests\n");
113 fprintf (stderr, "warning: \"guestfs_get_memsize\" has no tests\n");
114 fprintf (stderr, "warning: \"guestfs_ll\" has no tests\n");
115 fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n");
116 fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n");
117 fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n");
118 fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n");
119 fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n");
120 fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n");
121 fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n");
122 fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n");
123 fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n");
124 fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n");
125 fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n");
126 fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n");
127 fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n");
128 fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n");
129 fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n");
130 fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n");
131 fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n");
132 fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n");
133 fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n");
134 fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n");
135 fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n");
136 fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n");
137 fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n");
138 fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n");
139 fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n");
140 fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n");
141 fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n");
142 fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n");
143 fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n");
144 fprintf (stderr, "warning: \"guestfs_pvresize\" has no tests\n");
145 fprintf (stderr, "warning: \"guestfs_sfdisk_N\" has no tests\n");
146 fprintf (stderr, "warning: \"guestfs_sfdisk_l\" has no tests\n");
147 fprintf (stderr, "warning: \"guestfs_sfdisk_kernel_geometry\" has no tests\n");
148 fprintf (stderr, "warning: \"guestfs_sfdisk_disk_geometry\" has no tests\n");
149 fprintf (stderr, "warning: \"guestfs_vg_activate_all\" has no tests\n");
150 fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n");
151 fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n");
152 fprintf (stderr, "warning: \"guestfs_e2fsck_f\" has no tests\n");
153 fprintf (stderr, "warning: \"guestfs_sh\" has no tests\n");
154 fprintf (stderr, "warning: \"guestfs_sh_lines\" has no tests\n");
155 fprintf (stderr, "warning: \"guestfs_scrub_freespace\" has no tests\n");
156 fprintf (stderr, "warning: \"guestfs_df\" has no tests\n");
157 fprintf (stderr, "warning: \"guestfs_df_h\" has no tests\n");
158 fprintf (stderr, "warning: \"guestfs_mount_loop\" has no tests\n");
159 fprintf (stderr, "warning: \"guestfs_umask\" has no tests\n");
162 static int test_mknod_c_0_skip (void)
166 str = getenv ("TEST_ONLY");
168 return strstr (str, "mknod_c") == NULL;
169 str = getenv ("SKIP_TEST_MKNOD_C_0");
170 if (str && strcmp (str, "1") == 0) return 1;
171 str = getenv ("SKIP_TEST_MKNOD_C");
172 if (str && strcmp (str, "1") == 0) return 1;
176 static int test_mknod_c_0 (void)
178 if (test_mknod_c_0_skip ()) {
179 printf ("%s skipped (reason: environment variable set)\n", "test_mknod_c_0");
183 /* InitBasicFS for test_mknod_c_0: create ext2 on /dev/sda1 */
185 char device[] = "/dev/sda";
188 r = guestfs_blockdev_setrw (g, device);
195 r = guestfs_umount_all (g);
202 r = guestfs_lvm_remove_all (g);
207 char device[] = "/dev/sda";
208 char lines_0[] = ",";
215 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
220 char fstype[] = "ext2";
221 char device[] = "/dev/sda1";
224 r = guestfs_mkfs (g, fstype, device);
229 char device[] = "/dev/sda1";
230 char mountpoint[] = "/";
233 r = guestfs_mount (g, device, mountpoint);
237 /* TestOutputStruct for mknod_c (0) */
239 char path[] = "/node";
242 r = guestfs_mknod_c (g, 511, 99, 66, path);
247 char path[] = "/node";
248 struct guestfs_stat *r;
250 r = guestfs_stat (g, path);
253 if (r->mode != 8685) {
254 fprintf (stderr, "test_mknod_c_0: mode was %d, expected 8685\n",
263 static int test_mknod_b_0_skip (void)
267 str = getenv ("TEST_ONLY");
269 return strstr (str, "mknod_b") == NULL;
270 str = getenv ("SKIP_TEST_MKNOD_B_0");
271 if (str && strcmp (str, "1") == 0) return 1;
272 str = getenv ("SKIP_TEST_MKNOD_B");
273 if (str && strcmp (str, "1") == 0) return 1;
277 static int test_mknod_b_0 (void)
279 if (test_mknod_b_0_skip ()) {
280 printf ("%s skipped (reason: environment variable set)\n", "test_mknod_b_0");
284 /* InitBasicFS for test_mknod_b_0: create ext2 on /dev/sda1 */
286 char device[] = "/dev/sda";
289 r = guestfs_blockdev_setrw (g, device);
296 r = guestfs_umount_all (g);
303 r = guestfs_lvm_remove_all (g);
308 char device[] = "/dev/sda";
309 char lines_0[] = ",";
316 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
321 char fstype[] = "ext2";
322 char device[] = "/dev/sda1";
325 r = guestfs_mkfs (g, fstype, device);
330 char device[] = "/dev/sda1";
331 char mountpoint[] = "/";
334 r = guestfs_mount (g, device, mountpoint);
338 /* TestOutputStruct for mknod_b (0) */
340 char path[] = "/node";
343 r = guestfs_mknod_b (g, 511, 99, 66, path);
348 char path[] = "/node";
349 struct guestfs_stat *r;
351 r = guestfs_stat (g, path);
354 if (r->mode != 25069) {
355 fprintf (stderr, "test_mknod_b_0: mode was %d, expected 25069\n",
364 static int test_mkfifo_0_skip (void)
368 str = getenv ("TEST_ONLY");
370 return strstr (str, "mkfifo") == NULL;
371 str = getenv ("SKIP_TEST_MKFIFO_0");
372 if (str && strcmp (str, "1") == 0) return 1;
373 str = getenv ("SKIP_TEST_MKFIFO");
374 if (str && strcmp (str, "1") == 0) return 1;
378 static int test_mkfifo_0 (void)
380 if (test_mkfifo_0_skip ()) {
381 printf ("%s skipped (reason: environment variable set)\n", "test_mkfifo_0");
385 /* InitBasicFS for test_mkfifo_0: create ext2 on /dev/sda1 */
387 char device[] = "/dev/sda";
390 r = guestfs_blockdev_setrw (g, device);
397 r = guestfs_umount_all (g);
404 r = guestfs_lvm_remove_all (g);
409 char device[] = "/dev/sda";
410 char lines_0[] = ",";
417 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
422 char fstype[] = "ext2";
423 char device[] = "/dev/sda1";
426 r = guestfs_mkfs (g, fstype, device);
431 char device[] = "/dev/sda1";
432 char mountpoint[] = "/";
435 r = guestfs_mount (g, device, mountpoint);
439 /* TestOutputStruct for mkfifo (0) */
441 char path[] = "/node";
444 r = guestfs_mkfifo (g, 511, path);
449 char path[] = "/node";
450 struct guestfs_stat *r;
452 r = guestfs_stat (g, path);
455 if (r->mode != 4589) {
456 fprintf (stderr, "test_mkfifo_0: mode was %d, expected 4589\n",
465 static int test_mknod_0_skip (void)
469 str = getenv ("TEST_ONLY");
471 return strstr (str, "mknod") == NULL;
472 str = getenv ("SKIP_TEST_MKNOD_0");
473 if (str && strcmp (str, "1") == 0) return 1;
474 str = getenv ("SKIP_TEST_MKNOD");
475 if (str && strcmp (str, "1") == 0) return 1;
479 static int test_mknod_0 (void)
481 if (test_mknod_0_skip ()) {
482 printf ("%s skipped (reason: environment variable set)\n", "test_mknod_0");
486 /* InitBasicFS for test_mknod_0: create ext2 on /dev/sda1 */
488 char device[] = "/dev/sda";
491 r = guestfs_blockdev_setrw (g, device);
498 r = guestfs_umount_all (g);
505 r = guestfs_lvm_remove_all (g);
510 char device[] = "/dev/sda";
511 char lines_0[] = ",";
518 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
523 char fstype[] = "ext2";
524 char device[] = "/dev/sda1";
527 r = guestfs_mkfs (g, fstype, device);
532 char device[] = "/dev/sda1";
533 char mountpoint[] = "/";
536 r = guestfs_mount (g, device, mountpoint);
540 /* TestOutputStruct for mknod (0) */
542 char path[] = "/node";
545 r = guestfs_mknod (g, 4607, 0, 0, path);
550 char path[] = "/node";
551 struct guestfs_stat *r;
553 r = guestfs_stat (g, path);
556 if (r->mode != 4589) {
557 fprintf (stderr, "test_mknod_0: mode was %d, expected 4589\n",
566 static int test_mknod_1_skip (void)
570 str = getenv ("TEST_ONLY");
572 return strstr (str, "mknod") == NULL;
573 str = getenv ("SKIP_TEST_MKNOD_1");
574 if (str && strcmp (str, "1") == 0) return 1;
575 str = getenv ("SKIP_TEST_MKNOD");
576 if (str && strcmp (str, "1") == 0) return 1;
580 static int test_mknod_1 (void)
582 if (test_mknod_1_skip ()) {
583 printf ("%s skipped (reason: environment variable set)\n", "test_mknod_1");
587 /* InitBasicFS for test_mknod_1: create ext2 on /dev/sda1 */
589 char device[] = "/dev/sda";
592 r = guestfs_blockdev_setrw (g, device);
599 r = guestfs_umount_all (g);
606 r = guestfs_lvm_remove_all (g);
611 char device[] = "/dev/sda";
612 char lines_0[] = ",";
619 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
624 char fstype[] = "ext2";
625 char device[] = "/dev/sda1";
628 r = guestfs_mkfs (g, fstype, device);
633 char device[] = "/dev/sda1";
634 char mountpoint[] = "/";
637 r = guestfs_mount (g, device, mountpoint);
641 /* TestOutputStruct for mknod (1) */
643 char path[] = "/node";
646 r = guestfs_mknod (g, 25087, 66, 99, path);
651 char path[] = "/node";
652 struct guestfs_stat *r;
654 r = guestfs_stat (g, path);
657 if (r->mode != 25069) {
658 fprintf (stderr, "test_mknod_1: mode was %d, expected 25069\n",
667 static int test_mkswap_U_0_skip (void)
671 str = getenv ("TEST_ONLY");
673 return strstr (str, "mkswap_U") == NULL;
674 str = getenv ("SKIP_TEST_MKSWAP_U_0");
675 if (str && strcmp (str, "1") == 0) return 1;
676 str = getenv ("SKIP_TEST_MKSWAP_U");
677 if (str && strcmp (str, "1") == 0) return 1;
681 static int test_mkswap_U_0 (void)
683 if (test_mkswap_U_0_skip ()) {
684 printf ("%s skipped (reason: environment variable set)\n", "test_mkswap_U_0");
688 /* InitNone|InitEmpty for test_mkswap_U_0 */
690 char device[] = "/dev/sda";
693 r = guestfs_blockdev_setrw (g, device);
700 r = guestfs_umount_all (g);
707 r = guestfs_lvm_remove_all (g);
711 /* TestRun for mkswap_U (0) */
713 char device[] = "/dev/sda";
714 char lines_0[] = ",";
721 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
726 char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
727 char device[] = "/dev/sda1";
730 r = guestfs_mkswap_U (g, uuid, device);
737 static int test_mkswap_L_0_skip (void)
741 str = getenv ("TEST_ONLY");
743 return strstr (str, "mkswap_L") == NULL;
744 str = getenv ("SKIP_TEST_MKSWAP_L_0");
745 if (str && strcmp (str, "1") == 0) return 1;
746 str = getenv ("SKIP_TEST_MKSWAP_L");
747 if (str && strcmp (str, "1") == 0) return 1;
751 static int test_mkswap_L_0 (void)
753 if (test_mkswap_L_0_skip ()) {
754 printf ("%s skipped (reason: environment variable set)\n", "test_mkswap_L_0");
758 /* InitNone|InitEmpty for test_mkswap_L_0 */
760 char device[] = "/dev/sda";
763 r = guestfs_blockdev_setrw (g, device);
770 r = guestfs_umount_all (g);
777 r = guestfs_lvm_remove_all (g);
781 /* TestRun for mkswap_L (0) */
783 char device[] = "/dev/sda";
784 char lines_0[] = ",";
791 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
796 char label[] = "hello";
797 char device[] = "/dev/sda1";
800 r = guestfs_mkswap_L (g, label, device);
807 static int test_mkswap_0_skip (void)
811 str = getenv ("TEST_ONLY");
813 return strstr (str, "mkswap") == NULL;
814 str = getenv ("SKIP_TEST_MKSWAP_0");
815 if (str && strcmp (str, "1") == 0) return 1;
816 str = getenv ("SKIP_TEST_MKSWAP");
817 if (str && strcmp (str, "1") == 0) return 1;
821 static int test_mkswap_0 (void)
823 if (test_mkswap_0_skip ()) {
824 printf ("%s skipped (reason: environment variable set)\n", "test_mkswap_0");
828 /* InitNone|InitEmpty for test_mkswap_0 */
830 char device[] = "/dev/sda";
833 r = guestfs_blockdev_setrw (g, device);
840 r = guestfs_umount_all (g);
847 r = guestfs_lvm_remove_all (g);
851 /* TestRun for mkswap (0) */
853 char device[] = "/dev/sda";
854 char lines_0[] = ",";
861 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
866 char device[] = "/dev/sda1";
869 r = guestfs_mkswap (g, device);
876 static int test_initrd_list_0_skip (void)
880 str = getenv ("TEST_ONLY");
882 return strstr (str, "initrd_list") == NULL;
883 str = getenv ("SKIP_TEST_INITRD_LIST_0");
884 if (str && strcmp (str, "1") == 0) return 1;
885 str = getenv ("SKIP_TEST_INITRD_LIST");
886 if (str && strcmp (str, "1") == 0) return 1;
890 static int test_initrd_list_0 (void)
892 if (test_initrd_list_0_skip ()) {
893 printf ("%s skipped (reason: environment variable set)\n", "test_initrd_list_0");
897 /* InitBasicFS for test_initrd_list_0: create ext2 on /dev/sda1 */
899 char device[] = "/dev/sda";
902 r = guestfs_blockdev_setrw (g, device);
909 r = guestfs_umount_all (g);
916 r = guestfs_lvm_remove_all (g);
921 char device[] = "/dev/sda";
922 char lines_0[] = ",";
929 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
934 char fstype[] = "ext2";
935 char device[] = "/dev/sda1";
938 r = guestfs_mkfs (g, fstype, device);
943 char device[] = "/dev/sda1";
944 char mountpoint[] = "/";
947 r = guestfs_mount (g, device, mountpoint);
951 /* TestOutputList for initrd_list (0) */
953 char options[] = "ro";
954 char vfstype[] = "squashfs";
955 char device[] = "/dev/sdd";
956 char mountpoint[] = "/";
959 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
964 char path[] = "/initrd";
968 r = guestfs_initrd_list (g, path);
972 fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
977 char expected[] = "empty";
978 if (strcmp (r[0], expected) != 0) {
979 fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
984 fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
989 char expected[] = "known-1";
990 if (strcmp (r[1], expected) != 0) {
991 fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
996 fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
1001 char expected[] = "known-2";
1002 if (strcmp (r[2], expected) != 0) {
1003 fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1008 fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
1013 char expected[] = "known-3";
1014 if (strcmp (r[3], expected) != 0) {
1015 fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1020 fprintf (stderr, "test_initrd_list_0: extra elements returned from command\n");
1024 for (i = 0; r[i] != NULL; ++i)
1031 static int test_du_0_skip (void)
1035 str = getenv ("TEST_ONLY");
1037 return strstr (str, "du") == NULL;
1038 str = getenv ("SKIP_TEST_DU_0");
1039 if (str && strcmp (str, "1") == 0) return 1;
1040 str = getenv ("SKIP_TEST_DU");
1041 if (str && strcmp (str, "1") == 0) return 1;
1045 static int test_du_0 (void)
1047 if (test_du_0_skip ()) {
1048 printf ("%s skipped (reason: environment variable set)\n", "test_du_0");
1052 /* InitBasicFS for test_du_0: create ext2 on /dev/sda1 */
1054 char device[] = "/dev/sda";
1057 r = guestfs_blockdev_setrw (g, device);
1064 r = guestfs_umount_all (g);
1071 r = guestfs_lvm_remove_all (g);
1076 char device[] = "/dev/sda";
1077 char lines_0[] = ",";
1084 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1089 char fstype[] = "ext2";
1090 char device[] = "/dev/sda1";
1093 r = guestfs_mkfs (g, fstype, device);
1098 char device[] = "/dev/sda1";
1099 char mountpoint[] = "/";
1102 r = guestfs_mount (g, device, mountpoint);
1106 /* TestOutputInt for du (0) */
1111 r = guestfs_mkdir (g, path);
1119 r = guestfs_du (g, path);
1123 fprintf (stderr, "test_du_0: expected 1 but got %d\n", (int) r);
1130 static int test_tail_n_0_skip (void)
1134 str = getenv ("TEST_ONLY");
1136 return strstr (str, "tail_n") == NULL;
1137 str = getenv ("SKIP_TEST_TAIL_N_0");
1138 if (str && strcmp (str, "1") == 0) return 1;
1139 str = getenv ("SKIP_TEST_TAIL_N");
1140 if (str && strcmp (str, "1") == 0) return 1;
1144 static int test_tail_n_0 (void)
1146 if (test_tail_n_0_skip ()) {
1147 printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_0");
1151 /* InitBasicFS for test_tail_n_0: create ext2 on /dev/sda1 */
1153 char device[] = "/dev/sda";
1156 r = guestfs_blockdev_setrw (g, device);
1163 r = guestfs_umount_all (g);
1170 r = guestfs_lvm_remove_all (g);
1175 char device[] = "/dev/sda";
1176 char lines_0[] = ",";
1183 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1188 char fstype[] = "ext2";
1189 char device[] = "/dev/sda1";
1192 r = guestfs_mkfs (g, fstype, device);
1197 char device[] = "/dev/sda1";
1198 char mountpoint[] = "/";
1201 r = guestfs_mount (g, device, mountpoint);
1205 /* TestOutputList for tail_n (0) */
1207 char options[] = "ro";
1208 char vfstype[] = "squashfs";
1209 char device[] = "/dev/sdd";
1210 char mountpoint[] = "/";
1213 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1218 char path[] = "/10klines";
1222 r = guestfs_tail_n (g, 3, path);
1226 fprintf (stderr, "test_tail_n_0: short list returned from command\n");
1231 char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
1232 if (strcmp (r[0], expected) != 0) {
1233 fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1238 fprintf (stderr, "test_tail_n_0: short list returned from command\n");
1243 char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
1244 if (strcmp (r[1], expected) != 0) {
1245 fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1250 fprintf (stderr, "test_tail_n_0: short list returned from command\n");
1255 char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
1256 if (strcmp (r[2], expected) != 0) {
1257 fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1262 fprintf (stderr, "test_tail_n_0: extra elements returned from command\n");
1266 for (i = 0; r[i] != NULL; ++i)
1273 static int test_tail_n_1_skip (void)
1277 str = getenv ("TEST_ONLY");
1279 return strstr (str, "tail_n") == NULL;
1280 str = getenv ("SKIP_TEST_TAIL_N_1");
1281 if (str && strcmp (str, "1") == 0) return 1;
1282 str = getenv ("SKIP_TEST_TAIL_N");
1283 if (str && strcmp (str, "1") == 0) return 1;
1287 static int test_tail_n_1 (void)
1289 if (test_tail_n_1_skip ()) {
1290 printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_1");
1294 /* InitBasicFS for test_tail_n_1: create ext2 on /dev/sda1 */
1296 char device[] = "/dev/sda";
1299 r = guestfs_blockdev_setrw (g, device);
1306 r = guestfs_umount_all (g);
1313 r = guestfs_lvm_remove_all (g);
1318 char device[] = "/dev/sda";
1319 char lines_0[] = ",";
1326 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1331 char fstype[] = "ext2";
1332 char device[] = "/dev/sda1";
1335 r = guestfs_mkfs (g, fstype, device);
1340 char device[] = "/dev/sda1";
1341 char mountpoint[] = "/";
1344 r = guestfs_mount (g, device, mountpoint);
1348 /* TestOutputList for tail_n (1) */
1350 char options[] = "ro";
1351 char vfstype[] = "squashfs";
1352 char device[] = "/dev/sdd";
1353 char mountpoint[] = "/";
1356 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1361 char path[] = "/10klines";
1365 r = guestfs_tail_n (g, -9998, path);
1369 fprintf (stderr, "test_tail_n_1: short list returned from command\n");
1374 char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
1375 if (strcmp (r[0], expected) != 0) {
1376 fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1381 fprintf (stderr, "test_tail_n_1: short list returned from command\n");
1386 char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
1387 if (strcmp (r[1], expected) != 0) {
1388 fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1393 fprintf (stderr, "test_tail_n_1: short list returned from command\n");
1398 char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
1399 if (strcmp (r[2], expected) != 0) {
1400 fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1405 fprintf (stderr, "test_tail_n_1: extra elements returned from command\n");
1409 for (i = 0; r[i] != NULL; ++i)
1416 static int test_tail_n_2_skip (void)
1420 str = getenv ("TEST_ONLY");
1422 return strstr (str, "tail_n") == NULL;
1423 str = getenv ("SKIP_TEST_TAIL_N_2");
1424 if (str && strcmp (str, "1") == 0) return 1;
1425 str = getenv ("SKIP_TEST_TAIL_N");
1426 if (str && strcmp (str, "1") == 0) return 1;
1430 static int test_tail_n_2 (void)
1432 if (test_tail_n_2_skip ()) {
1433 printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_2");
1437 /* InitBasicFS for test_tail_n_2: create ext2 on /dev/sda1 */
1439 char device[] = "/dev/sda";
1442 r = guestfs_blockdev_setrw (g, device);
1449 r = guestfs_umount_all (g);
1456 r = guestfs_lvm_remove_all (g);
1461 char device[] = "/dev/sda";
1462 char lines_0[] = ",";
1469 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1474 char fstype[] = "ext2";
1475 char device[] = "/dev/sda1";
1478 r = guestfs_mkfs (g, fstype, device);
1483 char device[] = "/dev/sda1";
1484 char mountpoint[] = "/";
1487 r = guestfs_mount (g, device, mountpoint);
1491 /* TestOutputList for tail_n (2) */
1493 char options[] = "ro";
1494 char vfstype[] = "squashfs";
1495 char device[] = "/dev/sdd";
1496 char mountpoint[] = "/";
1499 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1504 char path[] = "/10klines";
1508 r = guestfs_tail_n (g, 0, path);
1512 fprintf (stderr, "test_tail_n_2: extra elements returned from command\n");
1516 for (i = 0; r[i] != NULL; ++i)
1523 static int test_tail_0_skip (void)
1527 str = getenv ("TEST_ONLY");
1529 return strstr (str, "tail") == NULL;
1530 str = getenv ("SKIP_TEST_TAIL_0");
1531 if (str && strcmp (str, "1") == 0) return 1;
1532 str = getenv ("SKIP_TEST_TAIL");
1533 if (str && strcmp (str, "1") == 0) return 1;
1537 static int test_tail_0 (void)
1539 if (test_tail_0_skip ()) {
1540 printf ("%s skipped (reason: environment variable set)\n", "test_tail_0");
1544 /* InitBasicFS for test_tail_0: create ext2 on /dev/sda1 */
1546 char device[] = "/dev/sda";
1549 r = guestfs_blockdev_setrw (g, device);
1556 r = guestfs_umount_all (g);
1563 r = guestfs_lvm_remove_all (g);
1568 char device[] = "/dev/sda";
1569 char lines_0[] = ",";
1576 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1581 char fstype[] = "ext2";
1582 char device[] = "/dev/sda1";
1585 r = guestfs_mkfs (g, fstype, device);
1590 char device[] = "/dev/sda1";
1591 char mountpoint[] = "/";
1594 r = guestfs_mount (g, device, mountpoint);
1598 /* TestOutputList for tail (0) */
1600 char options[] = "ro";
1601 char vfstype[] = "squashfs";
1602 char device[] = "/dev/sdd";
1603 char mountpoint[] = "/";
1606 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1611 char path[] = "/10klines";
1615 r = guestfs_tail (g, path);
1619 fprintf (stderr, "test_tail_0: short list returned from command\n");
1624 char expected[] = "9990abcdefghijklmnopqrstuvwxyz";
1625 if (strcmp (r[0], expected) != 0) {
1626 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1631 fprintf (stderr, "test_tail_0: short list returned from command\n");
1636 char expected[] = "9991abcdefghijklmnopqrstuvwxyz";
1637 if (strcmp (r[1], expected) != 0) {
1638 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1643 fprintf (stderr, "test_tail_0: short list returned from command\n");
1648 char expected[] = "9992abcdefghijklmnopqrstuvwxyz";
1649 if (strcmp (r[2], expected) != 0) {
1650 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1655 fprintf (stderr, "test_tail_0: short list returned from command\n");
1660 char expected[] = "9993abcdefghijklmnopqrstuvwxyz";
1661 if (strcmp (r[3], expected) != 0) {
1662 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1667 fprintf (stderr, "test_tail_0: short list returned from command\n");
1672 char expected[] = "9994abcdefghijklmnopqrstuvwxyz";
1673 if (strcmp (r[4], expected) != 0) {
1674 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
1679 fprintf (stderr, "test_tail_0: short list returned from command\n");
1684 char expected[] = "9995abcdefghijklmnopqrstuvwxyz";
1685 if (strcmp (r[5], expected) != 0) {
1686 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
1691 fprintf (stderr, "test_tail_0: short list returned from command\n");
1696 char expected[] = "9996abcdefghijklmnopqrstuvwxyz";
1697 if (strcmp (r[6], expected) != 0) {
1698 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
1703 fprintf (stderr, "test_tail_0: short list returned from command\n");
1708 char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
1709 if (strcmp (r[7], expected) != 0) {
1710 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
1715 fprintf (stderr, "test_tail_0: short list returned from command\n");
1720 char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
1721 if (strcmp (r[8], expected) != 0) {
1722 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
1727 fprintf (stderr, "test_tail_0: short list returned from command\n");
1732 char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
1733 if (strcmp (r[9], expected) != 0) {
1734 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
1738 if (r[10] != NULL) {
1739 fprintf (stderr, "test_tail_0: extra elements returned from command\n");
1743 for (i = 0; r[i] != NULL; ++i)
1750 static int test_head_n_0_skip (void)
1754 str = getenv ("TEST_ONLY");
1756 return strstr (str, "head_n") == NULL;
1757 str = getenv ("SKIP_TEST_HEAD_N_0");
1758 if (str && strcmp (str, "1") == 0) return 1;
1759 str = getenv ("SKIP_TEST_HEAD_N");
1760 if (str && strcmp (str, "1") == 0) return 1;
1764 static int test_head_n_0 (void)
1766 if (test_head_n_0_skip ()) {
1767 printf ("%s skipped (reason: environment variable set)\n", "test_head_n_0");
1771 /* InitBasicFS for test_head_n_0: create ext2 on /dev/sda1 */
1773 char device[] = "/dev/sda";
1776 r = guestfs_blockdev_setrw (g, device);
1783 r = guestfs_umount_all (g);
1790 r = guestfs_lvm_remove_all (g);
1795 char device[] = "/dev/sda";
1796 char lines_0[] = ",";
1803 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1808 char fstype[] = "ext2";
1809 char device[] = "/dev/sda1";
1812 r = guestfs_mkfs (g, fstype, device);
1817 char device[] = "/dev/sda1";
1818 char mountpoint[] = "/";
1821 r = guestfs_mount (g, device, mountpoint);
1825 /* TestOutputList for head_n (0) */
1827 char options[] = "ro";
1828 char vfstype[] = "squashfs";
1829 char device[] = "/dev/sdd";
1830 char mountpoint[] = "/";
1833 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1838 char path[] = "/10klines";
1842 r = guestfs_head_n (g, 3, path);
1846 fprintf (stderr, "test_head_n_0: short list returned from command\n");
1851 char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1852 if (strcmp (r[0], expected) != 0) {
1853 fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1858 fprintf (stderr, "test_head_n_0: short list returned from command\n");
1863 char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1864 if (strcmp (r[1], expected) != 0) {
1865 fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1870 fprintf (stderr, "test_head_n_0: short list returned from command\n");
1875 char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1876 if (strcmp (r[2], expected) != 0) {
1877 fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1882 fprintf (stderr, "test_head_n_0: extra elements returned from command\n");
1886 for (i = 0; r[i] != NULL; ++i)
1893 static int test_head_n_1_skip (void)
1897 str = getenv ("TEST_ONLY");
1899 return strstr (str, "head_n") == NULL;
1900 str = getenv ("SKIP_TEST_HEAD_N_1");
1901 if (str && strcmp (str, "1") == 0) return 1;
1902 str = getenv ("SKIP_TEST_HEAD_N");
1903 if (str && strcmp (str, "1") == 0) return 1;
1907 static int test_head_n_1 (void)
1909 if (test_head_n_1_skip ()) {
1910 printf ("%s skipped (reason: environment variable set)\n", "test_head_n_1");
1914 /* InitBasicFS for test_head_n_1: create ext2 on /dev/sda1 */
1916 char device[] = "/dev/sda";
1919 r = guestfs_blockdev_setrw (g, device);
1926 r = guestfs_umount_all (g);
1933 r = guestfs_lvm_remove_all (g);
1938 char device[] = "/dev/sda";
1939 char lines_0[] = ",";
1946 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1951 char fstype[] = "ext2";
1952 char device[] = "/dev/sda1";
1955 r = guestfs_mkfs (g, fstype, device);
1960 char device[] = "/dev/sda1";
1961 char mountpoint[] = "/";
1964 r = guestfs_mount (g, device, mountpoint);
1968 /* TestOutputList for head_n (1) */
1970 char options[] = "ro";
1971 char vfstype[] = "squashfs";
1972 char device[] = "/dev/sdd";
1973 char mountpoint[] = "/";
1976 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1981 char path[] = "/10klines";
1985 r = guestfs_head_n (g, -9997, path);
1989 fprintf (stderr, "test_head_n_1: short list returned from command\n");
1994 char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1995 if (strcmp (r[0], expected) != 0) {
1996 fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2001 fprintf (stderr, "test_head_n_1: short list returned from command\n");
2006 char expected[] = "1abcdefghijklmnopqrstuvwxyz";
2007 if (strcmp (r[1], expected) != 0) {
2008 fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2013 fprintf (stderr, "test_head_n_1: short list returned from command\n");
2018 char expected[] = "2abcdefghijklmnopqrstuvwxyz";
2019 if (strcmp (r[2], expected) != 0) {
2020 fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
2025 fprintf (stderr, "test_head_n_1: extra elements returned from command\n");
2029 for (i = 0; r[i] != NULL; ++i)
2036 static int test_head_n_2_skip (void)
2040 str = getenv ("TEST_ONLY");
2042 return strstr (str, "head_n") == NULL;
2043 str = getenv ("SKIP_TEST_HEAD_N_2");
2044 if (str && strcmp (str, "1") == 0) return 1;
2045 str = getenv ("SKIP_TEST_HEAD_N");
2046 if (str && strcmp (str, "1") == 0) return 1;
2050 static int test_head_n_2 (void)
2052 if (test_head_n_2_skip ()) {
2053 printf ("%s skipped (reason: environment variable set)\n", "test_head_n_2");
2057 /* InitBasicFS for test_head_n_2: create ext2 on /dev/sda1 */
2059 char device[] = "/dev/sda";
2062 r = guestfs_blockdev_setrw (g, device);
2069 r = guestfs_umount_all (g);
2076 r = guestfs_lvm_remove_all (g);
2081 char device[] = "/dev/sda";
2082 char lines_0[] = ",";
2089 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2094 char fstype[] = "ext2";
2095 char device[] = "/dev/sda1";
2098 r = guestfs_mkfs (g, fstype, device);
2103 char device[] = "/dev/sda1";
2104 char mountpoint[] = "/";
2107 r = guestfs_mount (g, device, mountpoint);
2111 /* TestOutputList for head_n (2) */
2113 char options[] = "ro";
2114 char vfstype[] = "squashfs";
2115 char device[] = "/dev/sdd";
2116 char mountpoint[] = "/";
2119 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2124 char path[] = "/10klines";
2128 r = guestfs_head_n (g, 0, path);
2132 fprintf (stderr, "test_head_n_2: extra elements returned from command\n");
2136 for (i = 0; r[i] != NULL; ++i)
2143 static int test_head_0_skip (void)
2147 str = getenv ("TEST_ONLY");
2149 return strstr (str, "head") == NULL;
2150 str = getenv ("SKIP_TEST_HEAD_0");
2151 if (str && strcmp (str, "1") == 0) return 1;
2152 str = getenv ("SKIP_TEST_HEAD");
2153 if (str && strcmp (str, "1") == 0) return 1;
2157 static int test_head_0 (void)
2159 if (test_head_0_skip ()) {
2160 printf ("%s skipped (reason: environment variable set)\n", "test_head_0");
2164 /* InitBasicFS for test_head_0: create ext2 on /dev/sda1 */
2166 char device[] = "/dev/sda";
2169 r = guestfs_blockdev_setrw (g, device);
2176 r = guestfs_umount_all (g);
2183 r = guestfs_lvm_remove_all (g);
2188 char device[] = "/dev/sda";
2189 char lines_0[] = ",";
2196 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2201 char fstype[] = "ext2";
2202 char device[] = "/dev/sda1";
2205 r = guestfs_mkfs (g, fstype, device);
2210 char device[] = "/dev/sda1";
2211 char mountpoint[] = "/";
2214 r = guestfs_mount (g, device, mountpoint);
2218 /* TestOutputList for head (0) */
2220 char options[] = "ro";
2221 char vfstype[] = "squashfs";
2222 char device[] = "/dev/sdd";
2223 char mountpoint[] = "/";
2226 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2231 char path[] = "/10klines";
2235 r = guestfs_head (g, path);
2239 fprintf (stderr, "test_head_0: short list returned from command\n");
2244 char expected[] = "0abcdefghijklmnopqrstuvwxyz";
2245 if (strcmp (r[0], expected) != 0) {
2246 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2251 fprintf (stderr, "test_head_0: short list returned from command\n");
2256 char expected[] = "1abcdefghijklmnopqrstuvwxyz";
2257 if (strcmp (r[1], expected) != 0) {
2258 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2263 fprintf (stderr, "test_head_0: short list returned from command\n");
2268 char expected[] = "2abcdefghijklmnopqrstuvwxyz";
2269 if (strcmp (r[2], expected) != 0) {
2270 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
2275 fprintf (stderr, "test_head_0: short list returned from command\n");
2280 char expected[] = "3abcdefghijklmnopqrstuvwxyz";
2281 if (strcmp (r[3], expected) != 0) {
2282 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
2287 fprintf (stderr, "test_head_0: short list returned from command\n");
2292 char expected[] = "4abcdefghijklmnopqrstuvwxyz";
2293 if (strcmp (r[4], expected) != 0) {
2294 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
2299 fprintf (stderr, "test_head_0: short list returned from command\n");
2304 char expected[] = "5abcdefghijklmnopqrstuvwxyz";
2305 if (strcmp (r[5], expected) != 0) {
2306 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
2311 fprintf (stderr, "test_head_0: short list returned from command\n");
2316 char expected[] = "6abcdefghijklmnopqrstuvwxyz";
2317 if (strcmp (r[6], expected) != 0) {
2318 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
2323 fprintf (stderr, "test_head_0: short list returned from command\n");
2328 char expected[] = "7abcdefghijklmnopqrstuvwxyz";
2329 if (strcmp (r[7], expected) != 0) {
2330 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
2335 fprintf (stderr, "test_head_0: short list returned from command\n");
2340 char expected[] = "8abcdefghijklmnopqrstuvwxyz";
2341 if (strcmp (r[8], expected) != 0) {
2342 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
2347 fprintf (stderr, "test_head_0: short list returned from command\n");
2352 char expected[] = "9abcdefghijklmnopqrstuvwxyz";
2353 if (strcmp (r[9], expected) != 0) {
2354 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
2358 if (r[10] != NULL) {
2359 fprintf (stderr, "test_head_0: extra elements returned from command\n");
2363 for (i = 0; r[i] != NULL; ++i)
2370 static int test_wc_c_0_skip (void)
2374 str = getenv ("TEST_ONLY");
2376 return strstr (str, "wc_c") == NULL;
2377 str = getenv ("SKIP_TEST_WC_C_0");
2378 if (str && strcmp (str, "1") == 0) return 1;
2379 str = getenv ("SKIP_TEST_WC_C");
2380 if (str && strcmp (str, "1") == 0) return 1;
2384 static int test_wc_c_0 (void)
2386 if (test_wc_c_0_skip ()) {
2387 printf ("%s skipped (reason: environment variable set)\n", "test_wc_c_0");
2391 /* InitBasicFS for test_wc_c_0: create ext2 on /dev/sda1 */
2393 char device[] = "/dev/sda";
2396 r = guestfs_blockdev_setrw (g, device);
2403 r = guestfs_umount_all (g);
2410 r = guestfs_lvm_remove_all (g);
2415 char device[] = "/dev/sda";
2416 char lines_0[] = ",";
2423 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2428 char fstype[] = "ext2";
2429 char device[] = "/dev/sda1";
2432 r = guestfs_mkfs (g, fstype, device);
2437 char device[] = "/dev/sda1";
2438 char mountpoint[] = "/";
2441 r = guestfs_mount (g, device, mountpoint);
2445 /* TestOutputInt for wc_c (0) */
2447 char options[] = "ro";
2448 char vfstype[] = "squashfs";
2449 char device[] = "/dev/sdd";
2450 char mountpoint[] = "/";
2453 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2458 char path[] = "/100kallspaces";
2461 r = guestfs_wc_c (g, path);
2465 fprintf (stderr, "test_wc_c_0: expected 102400 but got %d\n", (int) r);
2472 static int test_wc_w_0_skip (void)
2476 str = getenv ("TEST_ONLY");
2478 return strstr (str, "wc_w") == NULL;
2479 str = getenv ("SKIP_TEST_WC_W_0");
2480 if (str && strcmp (str, "1") == 0) return 1;
2481 str = getenv ("SKIP_TEST_WC_W");
2482 if (str && strcmp (str, "1") == 0) return 1;
2486 static int test_wc_w_0 (void)
2488 if (test_wc_w_0_skip ()) {
2489 printf ("%s skipped (reason: environment variable set)\n", "test_wc_w_0");
2493 /* InitBasicFS for test_wc_w_0: create ext2 on /dev/sda1 */
2495 char device[] = "/dev/sda";
2498 r = guestfs_blockdev_setrw (g, device);
2505 r = guestfs_umount_all (g);
2512 r = guestfs_lvm_remove_all (g);
2517 char device[] = "/dev/sda";
2518 char lines_0[] = ",";
2525 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2530 char fstype[] = "ext2";
2531 char device[] = "/dev/sda1";
2534 r = guestfs_mkfs (g, fstype, device);
2539 char device[] = "/dev/sda1";
2540 char mountpoint[] = "/";
2543 r = guestfs_mount (g, device, mountpoint);
2547 /* TestOutputInt for wc_w (0) */
2549 char options[] = "ro";
2550 char vfstype[] = "squashfs";
2551 char device[] = "/dev/sdd";
2552 char mountpoint[] = "/";
2555 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2560 char path[] = "/10klines";
2563 r = guestfs_wc_w (g, path);
2567 fprintf (stderr, "test_wc_w_0: expected 10000 but got %d\n", (int) r);
2574 static int test_wc_l_0_skip (void)
2578 str = getenv ("TEST_ONLY");
2580 return strstr (str, "wc_l") == NULL;
2581 str = getenv ("SKIP_TEST_WC_L_0");
2582 if (str && strcmp (str, "1") == 0) return 1;
2583 str = getenv ("SKIP_TEST_WC_L");
2584 if (str && strcmp (str, "1") == 0) return 1;
2588 static int test_wc_l_0 (void)
2590 if (test_wc_l_0_skip ()) {
2591 printf ("%s skipped (reason: environment variable set)\n", "test_wc_l_0");
2595 /* InitBasicFS for test_wc_l_0: create ext2 on /dev/sda1 */
2597 char device[] = "/dev/sda";
2600 r = guestfs_blockdev_setrw (g, device);
2607 r = guestfs_umount_all (g);
2614 r = guestfs_lvm_remove_all (g);
2619 char device[] = "/dev/sda";
2620 char lines_0[] = ",";
2627 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2632 char fstype[] = "ext2";
2633 char device[] = "/dev/sda1";
2636 r = guestfs_mkfs (g, fstype, device);
2641 char device[] = "/dev/sda1";
2642 char mountpoint[] = "/";
2645 r = guestfs_mount (g, device, mountpoint);
2649 /* TestOutputInt for wc_l (0) */
2651 char options[] = "ro";
2652 char vfstype[] = "squashfs";
2653 char device[] = "/dev/sdd";
2654 char mountpoint[] = "/";
2657 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2662 char path[] = "/10klines";
2665 r = guestfs_wc_l (g, path);
2669 fprintf (stderr, "test_wc_l_0: expected 10000 but got %d\n", (int) r);
2676 static int test_mkdtemp_0_skip (void)
2680 str = getenv ("TEST_ONLY");
2682 return strstr (str, "mkdtemp") == NULL;
2683 str = getenv ("SKIP_TEST_MKDTEMP_0");
2684 if (str && strcmp (str, "1") == 0) return 1;
2685 str = getenv ("SKIP_TEST_MKDTEMP");
2686 if (str && strcmp (str, "1") == 0) return 1;
2690 static int test_mkdtemp_0 (void)
2692 if (test_mkdtemp_0_skip ()) {
2693 printf ("%s skipped (reason: environment variable set)\n", "test_mkdtemp_0");
2697 /* InitBasicFS for test_mkdtemp_0: create ext2 on /dev/sda1 */
2699 char device[] = "/dev/sda";
2702 r = guestfs_blockdev_setrw (g, device);
2709 r = guestfs_umount_all (g);
2716 r = guestfs_lvm_remove_all (g);
2721 char device[] = "/dev/sda";
2722 char lines_0[] = ",";
2729 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2734 char fstype[] = "ext2";
2735 char device[] = "/dev/sda1";
2738 r = guestfs_mkfs (g, fstype, device);
2743 char device[] = "/dev/sda1";
2744 char mountpoint[] = "/";
2747 r = guestfs_mount (g, device, mountpoint);
2751 /* TestRun for mkdtemp (0) */
2753 char path[] = "/tmp";
2756 r = guestfs_mkdir (g, path);
2761 char template[] = "/tmp/tmpXXXXXX";
2764 r = guestfs_mkdtemp (g, template);
2772 static int test_scrub_file_0_skip (void)
2776 str = getenv ("TEST_ONLY");
2778 return strstr (str, "scrub_file") == NULL;
2779 str = getenv ("SKIP_TEST_SCRUB_FILE_0");
2780 if (str && strcmp (str, "1") == 0) return 1;
2781 str = getenv ("SKIP_TEST_SCRUB_FILE");
2782 if (str && strcmp (str, "1") == 0) return 1;
2786 static int test_scrub_file_0 (void)
2788 if (test_scrub_file_0_skip ()) {
2789 printf ("%s skipped (reason: environment variable set)\n", "test_scrub_file_0");
2793 /* InitBasicFS for test_scrub_file_0: create ext2 on /dev/sda1 */
2795 char device[] = "/dev/sda";
2798 r = guestfs_blockdev_setrw (g, device);
2805 r = guestfs_umount_all (g);
2812 r = guestfs_lvm_remove_all (g);
2817 char device[] = "/dev/sda";
2818 char lines_0[] = ",";
2825 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2830 char fstype[] = "ext2";
2831 char device[] = "/dev/sda1";
2834 r = guestfs_mkfs (g, fstype, device);
2839 char device[] = "/dev/sda1";
2840 char mountpoint[] = "/";
2843 r = guestfs_mount (g, device, mountpoint);
2847 /* TestRun for scrub_file (0) */
2849 char path[] = "/file";
2850 char content[] = "content";
2853 r = guestfs_write_file (g, path, content, 0);
2858 char file[] = "/file";
2861 r = guestfs_scrub_file (g, file);
2868 static int test_scrub_device_0_skip (void)
2872 str = getenv ("TEST_ONLY");
2874 return strstr (str, "scrub_device") == NULL;
2875 str = getenv ("SKIP_TEST_SCRUB_DEVICE_0");
2876 if (str && strcmp (str, "1") == 0) return 1;
2877 str = getenv ("SKIP_TEST_SCRUB_DEVICE");
2878 if (str && strcmp (str, "1") == 0) return 1;
2882 static int test_scrub_device_0 (void)
2884 if (test_scrub_device_0_skip ()) {
2885 printf ("%s skipped (reason: environment variable set)\n", "test_scrub_device_0");
2889 /* InitNone|InitEmpty for test_scrub_device_0 */
2891 char device[] = "/dev/sda";
2894 r = guestfs_blockdev_setrw (g, device);
2901 r = guestfs_umount_all (g);
2908 r = guestfs_lvm_remove_all (g);
2912 /* TestRun for scrub_device (0) */
2914 char device[] = "/dev/sdc";
2917 r = guestfs_scrub_device (g, device);
2924 static int test_glob_expand_0_skip (void)
2928 str = getenv ("TEST_ONLY");
2930 return strstr (str, "glob_expand") == NULL;
2931 str = getenv ("SKIP_TEST_GLOB_EXPAND_0");
2932 if (str && strcmp (str, "1") == 0) return 1;
2933 str = getenv ("SKIP_TEST_GLOB_EXPAND");
2934 if (str && strcmp (str, "1") == 0) return 1;
2938 static int test_glob_expand_0 (void)
2940 if (test_glob_expand_0_skip ()) {
2941 printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_0");
2945 /* InitBasicFS for test_glob_expand_0: create ext2 on /dev/sda1 */
2947 char device[] = "/dev/sda";
2950 r = guestfs_blockdev_setrw (g, device);
2957 r = guestfs_umount_all (g);
2964 r = guestfs_lvm_remove_all (g);
2969 char device[] = "/dev/sda";
2970 char lines_0[] = ",";
2977 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2982 char fstype[] = "ext2";
2983 char device[] = "/dev/sda1";
2986 r = guestfs_mkfs (g, fstype, device);
2991 char device[] = "/dev/sda1";
2992 char mountpoint[] = "/";
2995 r = guestfs_mount (g, device, mountpoint);
2999 /* TestOutputList for glob_expand (0) */
3001 char path[] = "/a/b/c";
3004 r = guestfs_mkdir_p (g, path);
3009 char path[] = "/a/b/c/d";
3012 r = guestfs_touch (g, path);
3017 char path[] = "/a/b/c/e";
3020 r = guestfs_touch (g, path);
3025 char pattern[] = "/a/b/c/*";
3029 r = guestfs_glob_expand (g, pattern);
3033 fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
3038 char expected[] = "/a/b/c/d";
3039 if (strcmp (r[0], expected) != 0) {
3040 fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3045 fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
3050 char expected[] = "/a/b/c/e";
3051 if (strcmp (r[1], expected) != 0) {
3052 fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3057 fprintf (stderr, "test_glob_expand_0: extra elements returned from command\n");
3061 for (i = 0; r[i] != NULL; ++i)
3068 static int test_glob_expand_1_skip (void)
3072 str = getenv ("TEST_ONLY");
3074 return strstr (str, "glob_expand") == NULL;
3075 str = getenv ("SKIP_TEST_GLOB_EXPAND_1");
3076 if (str && strcmp (str, "1") == 0) return 1;
3077 str = getenv ("SKIP_TEST_GLOB_EXPAND");
3078 if (str && strcmp (str, "1") == 0) return 1;
3082 static int test_glob_expand_1 (void)
3084 if (test_glob_expand_1_skip ()) {
3085 printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_1");
3089 /* InitBasicFS for test_glob_expand_1: create ext2 on /dev/sda1 */
3091 char device[] = "/dev/sda";
3094 r = guestfs_blockdev_setrw (g, device);
3101 r = guestfs_umount_all (g);
3108 r = guestfs_lvm_remove_all (g);
3113 char device[] = "/dev/sda";
3114 char lines_0[] = ",";
3121 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3126 char fstype[] = "ext2";
3127 char device[] = "/dev/sda1";
3130 r = guestfs_mkfs (g, fstype, device);
3135 char device[] = "/dev/sda1";
3136 char mountpoint[] = "/";
3139 r = guestfs_mount (g, device, mountpoint);
3143 /* TestOutputList for glob_expand (1) */
3145 char path[] = "/a/b/c";
3148 r = guestfs_mkdir_p (g, path);
3153 char path[] = "/a/b/c/d";
3156 r = guestfs_touch (g, path);
3161 char path[] = "/a/b/c/e";
3164 r = guestfs_touch (g, path);
3169 char pattern[] = "/a/*/c/*";
3173 r = guestfs_glob_expand (g, pattern);
3177 fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
3182 char expected[] = "/a/b/c/d";
3183 if (strcmp (r[0], expected) != 0) {
3184 fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3189 fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
3194 char expected[] = "/a/b/c/e";
3195 if (strcmp (r[1], expected) != 0) {
3196 fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3201 fprintf (stderr, "test_glob_expand_1: extra elements returned from command\n");
3205 for (i = 0; r[i] != NULL; ++i)
3212 static int test_glob_expand_2_skip (void)
3216 str = getenv ("TEST_ONLY");
3218 return strstr (str, "glob_expand") == NULL;
3219 str = getenv ("SKIP_TEST_GLOB_EXPAND_2");
3220 if (str && strcmp (str, "1") == 0) return 1;
3221 str = getenv ("SKIP_TEST_GLOB_EXPAND");
3222 if (str && strcmp (str, "1") == 0) return 1;
3226 static int test_glob_expand_2 (void)
3228 if (test_glob_expand_2_skip ()) {
3229 printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_2");
3233 /* InitBasicFS for test_glob_expand_2: create ext2 on /dev/sda1 */
3235 char device[] = "/dev/sda";
3238 r = guestfs_blockdev_setrw (g, device);
3245 r = guestfs_umount_all (g);
3252 r = guestfs_lvm_remove_all (g);
3257 char device[] = "/dev/sda";
3258 char lines_0[] = ",";
3265 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3270 char fstype[] = "ext2";
3271 char device[] = "/dev/sda1";
3274 r = guestfs_mkfs (g, fstype, device);
3279 char device[] = "/dev/sda1";
3280 char mountpoint[] = "/";
3283 r = guestfs_mount (g, device, mountpoint);
3287 /* TestOutputList for glob_expand (2) */
3289 char path[] = "/a/b/c";
3292 r = guestfs_mkdir_p (g, path);
3297 char path[] = "/a/b/c/d";
3300 r = guestfs_touch (g, path);
3305 char path[] = "/a/b/c/e";
3308 r = guestfs_touch (g, path);
3313 char pattern[] = "/a/*/x/*";
3317 r = guestfs_glob_expand (g, pattern);
3321 fprintf (stderr, "test_glob_expand_2: extra elements returned from command\n");
3325 for (i = 0; r[i] != NULL; ++i)
3332 static int test_ntfs_3g_probe_0_skip (void)
3336 str = getenv ("TEST_ONLY");
3338 return strstr (str, "ntfs_3g_probe") == NULL;
3339 str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0");
3340 if (str && strcmp (str, "1") == 0) return 1;
3341 str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
3342 if (str && strcmp (str, "1") == 0) return 1;
3346 static int test_ntfs_3g_probe_0 (void)
3348 if (test_ntfs_3g_probe_0_skip ()) {
3349 printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_0");
3353 /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
3355 char device[] = "/dev/sda";
3358 r = guestfs_blockdev_setrw (g, device);
3365 r = guestfs_umount_all (g);
3372 r = guestfs_lvm_remove_all (g);
3376 /* TestOutputInt for ntfs_3g_probe (0) */
3378 char device[] = "/dev/sda";
3379 char lines_0[] = ",";
3386 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3391 char fstype[] = "ntfs";
3392 char device[] = "/dev/sda1";
3395 r = guestfs_mkfs (g, fstype, device);
3400 char device[] = "/dev/sda1";
3403 r = guestfs_ntfs_3g_probe (g, 1, device);
3407 fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n", (int) r);
3414 static int test_ntfs_3g_probe_1_skip (void)
3418 str = getenv ("TEST_ONLY");
3420 return strstr (str, "ntfs_3g_probe") == NULL;
3421 str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
3422 if (str && strcmp (str, "1") == 0) return 1;
3423 str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
3424 if (str && strcmp (str, "1") == 0) return 1;
3428 static int test_ntfs_3g_probe_1 (void)
3430 if (test_ntfs_3g_probe_1_skip ()) {
3431 printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_1");
3435 /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
3437 char device[] = "/dev/sda";
3440 r = guestfs_blockdev_setrw (g, device);
3447 r = guestfs_umount_all (g);
3454 r = guestfs_lvm_remove_all (g);
3458 /* TestOutputInt for ntfs_3g_probe (1) */
3460 char device[] = "/dev/sda";
3461 char lines_0[] = ",";
3468 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3473 char fstype[] = "ext2";
3474 char device[] = "/dev/sda1";
3477 r = guestfs_mkfs (g, fstype, device);
3482 char device[] = "/dev/sda1";
3485 r = guestfs_ntfs_3g_probe (g, 1, device);
3489 fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n", (int) r);
3496 static int test_sleep_0_skip (void)
3500 str = getenv ("TEST_ONLY");
3502 return strstr (str, "sleep") == NULL;
3503 str = getenv ("SKIP_TEST_SLEEP_0");
3504 if (str && strcmp (str, "1") == 0) return 1;
3505 str = getenv ("SKIP_TEST_SLEEP");
3506 if (str && strcmp (str, "1") == 0) return 1;
3510 static int test_sleep_0 (void)
3512 if (test_sleep_0_skip ()) {
3513 printf ("%s skipped (reason: environment variable set)\n", "test_sleep_0");
3517 /* InitNone|InitEmpty for test_sleep_0 */
3519 char device[] = "/dev/sda";
3522 r = guestfs_blockdev_setrw (g, device);
3529 r = guestfs_umount_all (g);
3536 r = guestfs_lvm_remove_all (g);
3540 /* TestRun for sleep (0) */
3544 r = guestfs_sleep (g, 1);
3551 static int test_find_0_skip (void)
3555 str = getenv ("TEST_ONLY");
3557 return strstr (str, "find") == NULL;
3558 str = getenv ("SKIP_TEST_FIND_0");
3559 if (str && strcmp (str, "1") == 0) return 1;
3560 str = getenv ("SKIP_TEST_FIND");
3561 if (str && strcmp (str, "1") == 0) return 1;
3565 static int test_find_0 (void)
3567 if (test_find_0_skip ()) {
3568 printf ("%s skipped (reason: environment variable set)\n", "test_find_0");
3572 /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
3574 char device[] = "/dev/sda";
3577 r = guestfs_blockdev_setrw (g, device);
3584 r = guestfs_umount_all (g);
3591 r = guestfs_lvm_remove_all (g);
3596 char device[] = "/dev/sda";
3597 char lines_0[] = ",";
3604 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3609 char fstype[] = "ext2";
3610 char device[] = "/dev/sda1";
3613 r = guestfs_mkfs (g, fstype, device);
3618 char device[] = "/dev/sda1";
3619 char mountpoint[] = "/";
3622 r = guestfs_mount (g, device, mountpoint);
3626 /* TestOutputList for find (0) */
3628 char directory[] = "/";
3632 r = guestfs_find (g, directory);
3636 fprintf (stderr, "test_find_0: short list returned from command\n");
3641 char expected[] = "lost+found";
3642 if (strcmp (r[0], expected) != 0) {
3643 fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3648 fprintf (stderr, "test_find_0: extra elements returned from command\n");
3652 for (i = 0; r[i] != NULL; ++i)
3659 static int test_find_1_skip (void)
3663 str = getenv ("TEST_ONLY");
3665 return strstr (str, "find") == NULL;
3666 str = getenv ("SKIP_TEST_FIND_1");
3667 if (str && strcmp (str, "1") == 0) return 1;
3668 str = getenv ("SKIP_TEST_FIND");
3669 if (str && strcmp (str, "1") == 0) return 1;
3673 static int test_find_1 (void)
3675 if (test_find_1_skip ()) {
3676 printf ("%s skipped (reason: environment variable set)\n", "test_find_1");
3680 /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
3682 char device[] = "/dev/sda";
3685 r = guestfs_blockdev_setrw (g, device);
3692 r = guestfs_umount_all (g);
3699 r = guestfs_lvm_remove_all (g);
3704 char device[] = "/dev/sda";
3705 char lines_0[] = ",";
3712 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3717 char fstype[] = "ext2";
3718 char device[] = "/dev/sda1";
3721 r = guestfs_mkfs (g, fstype, device);
3726 char device[] = "/dev/sda1";
3727 char mountpoint[] = "/";
3730 r = guestfs_mount (g, device, mountpoint);
3734 /* TestOutputList for find (1) */
3739 r = guestfs_touch (g, path);
3747 r = guestfs_mkdir (g, path);
3752 char path[] = "/b/c";
3755 r = guestfs_touch (g, path);
3760 char directory[] = "/";
3764 r = guestfs_find (g, directory);
3768 fprintf (stderr, "test_find_1: short list returned from command\n");
3773 char expected[] = "a";
3774 if (strcmp (r[0], expected) != 0) {
3775 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3780 fprintf (stderr, "test_find_1: short list returned from command\n");
3785 char expected[] = "b";
3786 if (strcmp (r[1], expected) != 0) {
3787 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3792 fprintf (stderr, "test_find_1: short list returned from command\n");
3797 char expected[] = "b/c";
3798 if (strcmp (r[2], expected) != 0) {
3799 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
3804 fprintf (stderr, "test_find_1: short list returned from command\n");
3809 char expected[] = "lost+found";
3810 if (strcmp (r[3], expected) != 0) {
3811 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
3816 fprintf (stderr, "test_find_1: extra elements returned from command\n");
3820 for (i = 0; r[i] != NULL; ++i)
3827 static int test_find_2_skip (void)
3831 str = getenv ("TEST_ONLY");
3833 return strstr (str, "find") == NULL;
3834 str = getenv ("SKIP_TEST_FIND_2");
3835 if (str && strcmp (str, "1") == 0) return 1;
3836 str = getenv ("SKIP_TEST_FIND");
3837 if (str && strcmp (str, "1") == 0) return 1;
3841 static int test_find_2 (void)
3843 if (test_find_2_skip ()) {
3844 printf ("%s skipped (reason: environment variable set)\n", "test_find_2");
3848 /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
3850 char device[] = "/dev/sda";
3853 r = guestfs_blockdev_setrw (g, device);
3860 r = guestfs_umount_all (g);
3867 r = guestfs_lvm_remove_all (g);
3872 char device[] = "/dev/sda";
3873 char lines_0[] = ",";
3880 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3885 char fstype[] = "ext2";
3886 char device[] = "/dev/sda1";
3889 r = guestfs_mkfs (g, fstype, device);
3894 char device[] = "/dev/sda1";
3895 char mountpoint[] = "/";
3898 r = guestfs_mount (g, device, mountpoint);
3902 /* TestOutputList for find (2) */
3904 char path[] = "/a/b/c";
3907 r = guestfs_mkdir_p (g, path);
3912 char path[] = "/a/b/c/d";
3915 r = guestfs_touch (g, path);
3920 char directory[] = "/a/b/";
3924 r = guestfs_find (g, directory);
3928 fprintf (stderr, "test_find_2: short list returned from command\n");
3933 char expected[] = "c";
3934 if (strcmp (r[0], expected) != 0) {
3935 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3940 fprintf (stderr, "test_find_2: short list returned from command\n");
3945 char expected[] = "c/d";
3946 if (strcmp (r[1], expected) != 0) {
3947 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3952 fprintf (stderr, "test_find_2: extra elements returned from command\n");
3956 for (i = 0; r[i] != NULL; ++i)
3963 static int test_lvresize_0_skip (void)
3967 str = getenv ("TEST_ONLY");
3969 return strstr (str, "lvresize") == NULL;
3970 str = getenv ("SKIP_TEST_LVRESIZE_0");
3971 if (str && strcmp (str, "1") == 0) return 1;
3972 str = getenv ("SKIP_TEST_LVRESIZE");
3973 if (str && strcmp (str, "1") == 0) return 1;
3977 static int test_lvresize_0 (void)
3979 if (test_lvresize_0_skip ()) {
3980 printf ("%s skipped (reason: environment variable set)\n", "test_lvresize_0");
3984 /* InitNone|InitEmpty for test_lvresize_0 */
3986 char device[] = "/dev/sda";
3989 r = guestfs_blockdev_setrw (g, device);
3996 r = guestfs_umount_all (g);
4003 r = guestfs_lvm_remove_all (g);
4007 /* TestOutput for lvresize (0) */
4008 char expected[] = "test content";
4010 char device[] = "/dev/sda";
4011 char lines_0[] = ",";
4018 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4023 char device[] = "/dev/sda1";
4026 r = guestfs_pvcreate (g, device);
4031 char volgroup[] = "VG";
4032 char physvols_0[] = "/dev/sda1";
4033 char *physvols[] = {
4039 r = guestfs_vgcreate (g, volgroup, physvols);
4044 char logvol[] = "LV";
4045 char volgroup[] = "VG";
4048 r = guestfs_lvcreate (g, logvol, volgroup, 10);
4053 char fstype[] = "ext2";
4054 char device[] = "/dev/VG/LV";
4057 r = guestfs_mkfs (g, fstype, device);
4062 char device[] = "/dev/VG/LV";
4063 char mountpoint[] = "/";
4066 r = guestfs_mount (g, device, mountpoint);
4071 char path[] = "/new";
4072 char content[] = "test content";
4075 r = guestfs_write_file (g, path, content, 0);
4080 char pathordevice[] = "/";
4083 r = guestfs_umount (g, pathordevice);
4088 char device[] = "/dev/VG/LV";
4091 r = guestfs_lvresize (g, device, 20);
4096 char device[] = "/dev/VG/LV";
4099 r = guestfs_e2fsck_f (g, device);
4104 char device[] = "/dev/VG/LV";
4107 r = guestfs_resize2fs (g, device);
4112 char device[] = "/dev/VG/LV";
4113 char mountpoint[] = "/";
4116 r = guestfs_mount (g, device, mountpoint);
4121 char path[] = "/new";
4124 r = guestfs_cat (g, path);
4127 if (strcmp (r, expected) != 0) {
4128 fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
4136 static int test_zerofree_0_skip (void)
4140 str = getenv ("TEST_ONLY");
4142 return strstr (str, "zerofree") == NULL;
4143 str = getenv ("SKIP_TEST_ZEROFREE_0");
4144 if (str && strcmp (str, "1") == 0) return 1;
4145 str = getenv ("SKIP_TEST_ZEROFREE");
4146 if (str && strcmp (str, "1") == 0) return 1;
4150 static int test_zerofree_0 (void)
4152 if (test_zerofree_0_skip ()) {
4153 printf ("%s skipped (reason: environment variable set)\n", "test_zerofree_0");
4157 /* InitNone|InitEmpty for test_zerofree_0 */
4159 char device[] = "/dev/sda";
4162 r = guestfs_blockdev_setrw (g, device);
4169 r = guestfs_umount_all (g);
4176 r = guestfs_lvm_remove_all (g);
4180 /* TestOutput for zerofree (0) */
4181 char expected[] = "test file";
4183 char device[] = "/dev/sda";
4184 char lines_0[] = ",";
4191 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4196 char fstype[] = "ext3";
4197 char device[] = "/dev/sda1";
4200 r = guestfs_mkfs (g, fstype, device);
4205 char device[] = "/dev/sda1";
4206 char mountpoint[] = "/";
4209 r = guestfs_mount (g, device, mountpoint);
4214 char path[] = "/new";
4215 char content[] = "test file";
4218 r = guestfs_write_file (g, path, content, 0);
4223 char pathordevice[] = "/dev/sda1";
4226 r = guestfs_umount (g, pathordevice);
4231 char device[] = "/dev/sda1";
4234 r = guestfs_zerofree (g, device);
4239 char device[] = "/dev/sda1";
4240 char mountpoint[] = "/";
4243 r = guestfs_mount (g, device, mountpoint);
4248 char path[] = "/new";
4251 r = guestfs_cat (g, path);
4254 if (strcmp (r, expected) != 0) {
4255 fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
4263 static int test_hexdump_0_skip (void)
4267 str = getenv ("TEST_ONLY");
4269 return strstr (str, "hexdump") == NULL;
4270 str = getenv ("SKIP_TEST_HEXDUMP_0");
4271 if (str && strcmp (str, "1") == 0) return 1;
4272 str = getenv ("SKIP_TEST_HEXDUMP");
4273 if (str && strcmp (str, "1") == 0) return 1;
4277 static int test_hexdump_0 (void)
4279 if (test_hexdump_0_skip ()) {
4280 printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_0");
4284 /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
4286 char device[] = "/dev/sda";
4289 r = guestfs_blockdev_setrw (g, device);
4296 r = guestfs_umount_all (g);
4303 r = guestfs_lvm_remove_all (g);
4308 char device[] = "/dev/sda";
4309 char lines_0[] = ",";
4316 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4321 char fstype[] = "ext2";
4322 char device[] = "/dev/sda1";
4325 r = guestfs_mkfs (g, fstype, device);
4330 char device[] = "/dev/sda1";
4331 char mountpoint[] = "/";
4334 r = guestfs_mount (g, device, mountpoint);
4338 /* TestOutput for hexdump (0) */
4339 char expected[] = "00000000 68 65 6c 6c 6f 0a 77 6f 72 6c 64 0a |hello.world.|\n0000000c\n";
4341 char path[] = "/new";
4342 char content[] = "hello\nworld\n";
4345 r = guestfs_write_file (g, path, content, 12);
4350 char path[] = "/new";
4353 r = guestfs_hexdump (g, path);
4356 if (strcmp (r, expected) != 0) {
4357 fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
4365 static int test_hexdump_1_skip (void)
4369 str = getenv ("TEST_ONLY");
4371 return strstr (str, "hexdump") == NULL;
4372 str = getenv ("SKIP_TEST_HEXDUMP_1");
4373 if (str && strcmp (str, "1") == 0) return 1;
4374 str = getenv ("SKIP_TEST_HEXDUMP");
4375 if (str && strcmp (str, "1") == 0) return 1;
4379 static int test_hexdump_1 (void)
4381 if (test_hexdump_1_skip ()) {
4382 printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_1");
4386 /* InitBasicFS for test_hexdump_1: create ext2 on /dev/sda1 */
4388 char device[] = "/dev/sda";
4391 r = guestfs_blockdev_setrw (g, device);
4398 r = guestfs_umount_all (g);
4405 r = guestfs_lvm_remove_all (g);
4410 char device[] = "/dev/sda";
4411 char lines_0[] = ",";
4418 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4423 char fstype[] = "ext2";
4424 char device[] = "/dev/sda1";
4427 r = guestfs_mkfs (g, fstype, device);
4432 char device[] = "/dev/sda1";
4433 char mountpoint[] = "/";
4436 r = guestfs_mount (g, device, mountpoint);
4440 /* TestRun for hexdump (1) */
4442 char options[] = "ro";
4443 char vfstype[] = "squashfs";
4444 char device[] = "/dev/sdd";
4445 char mountpoint[] = "/";
4448 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
4453 char path[] = "/100krandom";
4456 r = guestfs_hexdump (g, path);
4464 static int test_strings_e_0_skip (void)
4468 str = getenv ("TEST_ONLY");
4470 return strstr (str, "strings_e") == NULL;
4471 str = getenv ("SKIP_TEST_STRINGS_E_0");
4472 if (str && strcmp (str, "1") == 0) return 1;
4473 str = getenv ("SKIP_TEST_STRINGS_E");
4474 if (str && strcmp (str, "1") == 0) return 1;
4478 static int test_strings_e_0 (void)
4480 if (test_strings_e_0_skip ()) {
4481 printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_0");
4485 /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
4487 char device[] = "/dev/sda";
4490 r = guestfs_blockdev_setrw (g, device);
4497 r = guestfs_umount_all (g);
4504 r = guestfs_lvm_remove_all (g);
4509 char device[] = "/dev/sda";
4510 char lines_0[] = ",";
4517 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4522 char fstype[] = "ext2";
4523 char device[] = "/dev/sda1";
4526 r = guestfs_mkfs (g, fstype, device);
4531 char device[] = "/dev/sda1";
4532 char mountpoint[] = "/";
4535 r = guestfs_mount (g, device, mountpoint);
4539 /* TestOutputList for strings_e (0) */
4541 char path[] = "/new";
4542 char content[] = "hello\nworld\n";
4545 r = guestfs_write_file (g, path, content, 0);
4550 char encoding[] = "b";
4551 char path[] = "/new";
4555 r = guestfs_strings_e (g, encoding, path);
4559 fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
4563 for (i = 0; r[i] != NULL; ++i)
4570 static int test_strings_e_1_skip (void)
4574 str = getenv ("TEST_ONLY");
4576 return strstr (str, "strings_e") == NULL;
4577 str = getenv ("SKIP_TEST_STRINGS_E_1");
4578 if (str && strcmp (str, "1") == 0) return 1;
4579 str = getenv ("SKIP_TEST_STRINGS_E");
4580 if (str && strcmp (str, "1") == 0) return 1;
4584 static int test_strings_e_1 (void)
4586 if (test_strings_e_1_skip ()) {
4587 printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_1");
4591 printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
4595 static int test_strings_0_skip (void)
4599 str = getenv ("TEST_ONLY");
4601 return strstr (str, "strings") == NULL;
4602 str = getenv ("SKIP_TEST_STRINGS_0");
4603 if (str && strcmp (str, "1") == 0) return 1;
4604 str = getenv ("SKIP_TEST_STRINGS");
4605 if (str && strcmp (str, "1") == 0) return 1;
4609 static int test_strings_0 (void)
4611 if (test_strings_0_skip ()) {
4612 printf ("%s skipped (reason: environment variable set)\n", "test_strings_0");
4616 /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
4618 char device[] = "/dev/sda";
4621 r = guestfs_blockdev_setrw (g, device);
4628 r = guestfs_umount_all (g);
4635 r = guestfs_lvm_remove_all (g);
4640 char device[] = "/dev/sda";
4641 char lines_0[] = ",";
4648 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4653 char fstype[] = "ext2";
4654 char device[] = "/dev/sda1";
4657 r = guestfs_mkfs (g, fstype, device);
4662 char device[] = "/dev/sda1";
4663 char mountpoint[] = "/";
4666 r = guestfs_mount (g, device, mountpoint);
4670 /* TestOutputList for strings (0) */
4672 char path[] = "/new";
4673 char content[] = "hello\nworld\n";
4676 r = guestfs_write_file (g, path, content, 0);
4681 char path[] = "/new";
4685 r = guestfs_strings (g, path);
4689 fprintf (stderr, "test_strings_0: short list returned from command\n");
4694 char expected[] = "hello";
4695 if (strcmp (r[0], expected) != 0) {
4696 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4701 fprintf (stderr, "test_strings_0: short list returned from command\n");
4706 char expected[] = "world";
4707 if (strcmp (r[1], expected) != 0) {
4708 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
4713 fprintf (stderr, "test_strings_0: extra elements returned from command\n");
4717 for (i = 0; r[i] != NULL; ++i)
4724 static int test_strings_1_skip (void)
4728 str = getenv ("TEST_ONLY");
4730 return strstr (str, "strings") == NULL;
4731 str = getenv ("SKIP_TEST_STRINGS_1");
4732 if (str && strcmp (str, "1") == 0) return 1;
4733 str = getenv ("SKIP_TEST_STRINGS");
4734 if (str && strcmp (str, "1") == 0) return 1;
4738 static int test_strings_1 (void)
4740 if (test_strings_1_skip ()) {
4741 printf ("%s skipped (reason: environment variable set)\n", "test_strings_1");
4745 /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
4747 char device[] = "/dev/sda";
4750 r = guestfs_blockdev_setrw (g, device);
4757 r = guestfs_umount_all (g);
4764 r = guestfs_lvm_remove_all (g);
4769 char device[] = "/dev/sda";
4770 char lines_0[] = ",";
4777 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4782 char fstype[] = "ext2";
4783 char device[] = "/dev/sda1";
4786 r = guestfs_mkfs (g, fstype, device);
4791 char device[] = "/dev/sda1";
4792 char mountpoint[] = "/";
4795 r = guestfs_mount (g, device, mountpoint);
4799 /* TestOutputList for strings (1) */
4801 char path[] = "/new";
4804 r = guestfs_touch (g, path);
4809 char path[] = "/new";
4813 r = guestfs_strings (g, path);
4817 fprintf (stderr, "test_strings_1: extra elements returned from command\n");
4821 for (i = 0; r[i] != NULL; ++i)
4828 static int test_equal_0_skip (void)
4832 str = getenv ("TEST_ONLY");
4834 return strstr (str, "equal") == NULL;
4835 str = getenv ("SKIP_TEST_EQUAL_0");
4836 if (str && strcmp (str, "1") == 0) return 1;
4837 str = getenv ("SKIP_TEST_EQUAL");
4838 if (str && strcmp (str, "1") == 0) return 1;
4842 static int test_equal_0 (void)
4844 if (test_equal_0_skip ()) {
4845 printf ("%s skipped (reason: environment variable set)\n", "test_equal_0");
4849 /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
4851 char device[] = "/dev/sda";
4854 r = guestfs_blockdev_setrw (g, device);
4861 r = guestfs_umount_all (g);
4868 r = guestfs_lvm_remove_all (g);
4873 char device[] = "/dev/sda";
4874 char lines_0[] = ",";
4881 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4886 char fstype[] = "ext2";
4887 char device[] = "/dev/sda1";
4890 r = guestfs_mkfs (g, fstype, device);
4895 char device[] = "/dev/sda1";
4896 char mountpoint[] = "/";
4899 r = guestfs_mount (g, device, mountpoint);
4903 /* TestOutputTrue for equal (0) */
4905 char path[] = "/file1";
4906 char content[] = "contents of a file";
4909 r = guestfs_write_file (g, path, content, 0);
4914 char src[] = "/file1";
4915 char dest[] = "/file2";
4918 r = guestfs_cp (g, src, dest);
4923 char file1[] = "/file1";
4924 char file2[] = "/file2";
4927 r = guestfs_equal (g, file1, file2);
4931 fprintf (stderr, "test_equal_0: expected true, got false\n");
4938 static int test_equal_1_skip (void)
4942 str = getenv ("TEST_ONLY");
4944 return strstr (str, "equal") == NULL;
4945 str = getenv ("SKIP_TEST_EQUAL_1");
4946 if (str && strcmp (str, "1") == 0) return 1;
4947 str = getenv ("SKIP_TEST_EQUAL");
4948 if (str && strcmp (str, "1") == 0) return 1;
4952 static int test_equal_1 (void)
4954 if (test_equal_1_skip ()) {
4955 printf ("%s skipped (reason: environment variable set)\n", "test_equal_1");
4959 /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
4961 char device[] = "/dev/sda";
4964 r = guestfs_blockdev_setrw (g, device);
4971 r = guestfs_umount_all (g);
4978 r = guestfs_lvm_remove_all (g);
4983 char device[] = "/dev/sda";
4984 char lines_0[] = ",";
4991 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4996 char fstype[] = "ext2";
4997 char device[] = "/dev/sda1";
5000 r = guestfs_mkfs (g, fstype, device);
5005 char device[] = "/dev/sda1";
5006 char mountpoint[] = "/";
5009 r = guestfs_mount (g, device, mountpoint);
5013 /* TestOutputFalse for equal (1) */
5015 char path[] = "/file1";
5016 char content[] = "contents of a file";
5019 r = guestfs_write_file (g, path, content, 0);
5024 char path[] = "/file2";
5025 char content[] = "contents of another file";
5028 r = guestfs_write_file (g, path, content, 0);
5033 char file1[] = "/file1";
5034 char file2[] = "/file2";
5037 r = guestfs_equal (g, file1, file2);
5041 fprintf (stderr, "test_equal_1: expected false, got true\n");
5048 static int test_equal_2_skip (void)
5052 str = getenv ("TEST_ONLY");
5054 return strstr (str, "equal") == NULL;
5055 str = getenv ("SKIP_TEST_EQUAL_2");
5056 if (str && strcmp (str, "1") == 0) return 1;
5057 str = getenv ("SKIP_TEST_EQUAL");
5058 if (str && strcmp (str, "1") == 0) return 1;
5062 static int test_equal_2 (void)
5064 if (test_equal_2_skip ()) {
5065 printf ("%s skipped (reason: environment variable set)\n", "test_equal_2");
5069 /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
5071 char device[] = "/dev/sda";
5074 r = guestfs_blockdev_setrw (g, device);
5081 r = guestfs_umount_all (g);
5088 r = guestfs_lvm_remove_all (g);
5093 char device[] = "/dev/sda";
5094 char lines_0[] = ",";
5101 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5106 char fstype[] = "ext2";
5107 char device[] = "/dev/sda1";
5110 r = guestfs_mkfs (g, fstype, device);
5115 char device[] = "/dev/sda1";
5116 char mountpoint[] = "/";
5119 r = guestfs_mount (g, device, mountpoint);
5123 /* TestLastFail for equal (2) */
5125 char file1[] = "/file1";
5126 char file2[] = "/file2";
5129 r = guestfs_equal (g, file1, file2);
5136 static int test_ping_daemon_0_skip (void)
5140 str = getenv ("TEST_ONLY");
5142 return strstr (str, "ping_daemon") == NULL;
5143 str = getenv ("SKIP_TEST_PING_DAEMON_0");
5144 if (str && strcmp (str, "1") == 0) return 1;
5145 str = getenv ("SKIP_TEST_PING_DAEMON");
5146 if (str && strcmp (str, "1") == 0) return 1;
5150 static int test_ping_daemon_0 (void)
5152 if (test_ping_daemon_0_skip ()) {
5153 printf ("%s skipped (reason: environment variable set)\n", "test_ping_daemon_0");
5157 /* InitNone|InitEmpty for test_ping_daemon_0 */
5159 char device[] = "/dev/sda";
5162 r = guestfs_blockdev_setrw (g, device);
5169 r = guestfs_umount_all (g);
5176 r = guestfs_lvm_remove_all (g);
5180 /* TestRun for ping_daemon (0) */
5184 r = guestfs_ping_daemon (g);
5191 static int test_dmesg_0_skip (void)
5195 str = getenv ("TEST_ONLY");
5197 return strstr (str, "dmesg") == NULL;
5198 str = getenv ("SKIP_TEST_DMESG_0");
5199 if (str && strcmp (str, "1") == 0) return 1;
5200 str = getenv ("SKIP_TEST_DMESG");
5201 if (str && strcmp (str, "1") == 0) return 1;
5205 static int test_dmesg_0 (void)
5207 if (test_dmesg_0_skip ()) {
5208 printf ("%s skipped (reason: environment variable set)\n", "test_dmesg_0");
5212 /* InitNone|InitEmpty for test_dmesg_0 */
5214 char device[] = "/dev/sda";
5217 r = guestfs_blockdev_setrw (g, device);
5224 r = guestfs_umount_all (g);
5231 r = guestfs_lvm_remove_all (g);
5235 /* TestRun for dmesg (0) */
5239 r = guestfs_dmesg (g);
5247 static int test_drop_caches_0_skip (void)
5251 str = getenv ("TEST_ONLY");
5253 return strstr (str, "drop_caches") == NULL;
5254 str = getenv ("SKIP_TEST_DROP_CACHES_0");
5255 if (str && strcmp (str, "1") == 0) return 1;
5256 str = getenv ("SKIP_TEST_DROP_CACHES");
5257 if (str && strcmp (str, "1") == 0) return 1;
5261 static int test_drop_caches_0 (void)
5263 if (test_drop_caches_0_skip ()) {
5264 printf ("%s skipped (reason: environment variable set)\n", "test_drop_caches_0");
5268 /* InitNone|InitEmpty for test_drop_caches_0 */
5270 char device[] = "/dev/sda";
5273 r = guestfs_blockdev_setrw (g, device);
5280 r = guestfs_umount_all (g);
5287 r = guestfs_lvm_remove_all (g);
5291 /* TestRun for drop_caches (0) */
5295 r = guestfs_drop_caches (g, 3);
5302 static int test_mv_0_skip (void)
5306 str = getenv ("TEST_ONLY");
5308 return strstr (str, "mv") == NULL;
5309 str = getenv ("SKIP_TEST_MV_0");
5310 if (str && strcmp (str, "1") == 0) return 1;
5311 str = getenv ("SKIP_TEST_MV");
5312 if (str && strcmp (str, "1") == 0) return 1;
5316 static int test_mv_0 (void)
5318 if (test_mv_0_skip ()) {
5319 printf ("%s skipped (reason: environment variable set)\n", "test_mv_0");
5323 /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
5325 char device[] = "/dev/sda";
5328 r = guestfs_blockdev_setrw (g, device);
5335 r = guestfs_umount_all (g);
5342 r = guestfs_lvm_remove_all (g);
5347 char device[] = "/dev/sda";
5348 char lines_0[] = ",";
5355 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5360 char fstype[] = "ext2";
5361 char device[] = "/dev/sda1";
5364 r = guestfs_mkfs (g, fstype, device);
5369 char device[] = "/dev/sda1";
5370 char mountpoint[] = "/";
5373 r = guestfs_mount (g, device, mountpoint);
5377 /* TestOutput for mv (0) */
5378 char expected[] = "file content";
5380 char path[] = "/old";
5381 char content[] = "file content";
5384 r = guestfs_write_file (g, path, content, 0);
5389 char src[] = "/old";
5390 char dest[] = "/new";
5393 r = guestfs_mv (g, src, dest);
5398 char path[] = "/new";
5401 r = guestfs_cat (g, path);
5404 if (strcmp (r, expected) != 0) {
5405 fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
5413 static int test_mv_1_skip (void)
5417 str = getenv ("TEST_ONLY");
5419 return strstr (str, "mv") == NULL;
5420 str = getenv ("SKIP_TEST_MV_1");
5421 if (str && strcmp (str, "1") == 0) return 1;
5422 str = getenv ("SKIP_TEST_MV");
5423 if (str && strcmp (str, "1") == 0) return 1;
5427 static int test_mv_1 (void)
5429 if (test_mv_1_skip ()) {
5430 printf ("%s skipped (reason: environment variable set)\n", "test_mv_1");
5434 /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
5436 char device[] = "/dev/sda";
5439 r = guestfs_blockdev_setrw (g, device);
5446 r = guestfs_umount_all (g);
5453 r = guestfs_lvm_remove_all (g);
5458 char device[] = "/dev/sda";
5459 char lines_0[] = ",";
5466 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5471 char fstype[] = "ext2";
5472 char device[] = "/dev/sda1";
5475 r = guestfs_mkfs (g, fstype, device);
5480 char device[] = "/dev/sda1";
5481 char mountpoint[] = "/";
5484 r = guestfs_mount (g, device, mountpoint);
5488 /* TestOutputFalse for mv (1) */
5490 char path[] = "/old";
5491 char content[] = "file content";
5494 r = guestfs_write_file (g, path, content, 0);
5499 char src[] = "/old";
5500 char dest[] = "/new";
5503 r = guestfs_mv (g, src, dest);
5508 char path[] = "/old";
5511 r = guestfs_is_file (g, path);
5515 fprintf (stderr, "test_mv_1: expected false, got true\n");
5522 static int test_cp_a_0_skip (void)
5526 str = getenv ("TEST_ONLY");
5528 return strstr (str, "cp_a") == NULL;
5529 str = getenv ("SKIP_TEST_CP_A_0");
5530 if (str && strcmp (str, "1") == 0) return 1;
5531 str = getenv ("SKIP_TEST_CP_A");
5532 if (str && strcmp (str, "1") == 0) return 1;
5536 static int test_cp_a_0 (void)
5538 if (test_cp_a_0_skip ()) {
5539 printf ("%s skipped (reason: environment variable set)\n", "test_cp_a_0");
5543 /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
5545 char device[] = "/dev/sda";
5548 r = guestfs_blockdev_setrw (g, device);
5555 r = guestfs_umount_all (g);
5562 r = guestfs_lvm_remove_all (g);
5567 char device[] = "/dev/sda";
5568 char lines_0[] = ",";
5575 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5580 char fstype[] = "ext2";
5581 char device[] = "/dev/sda1";
5584 r = guestfs_mkfs (g, fstype, device);
5589 char device[] = "/dev/sda1";
5590 char mountpoint[] = "/";
5593 r = guestfs_mount (g, device, mountpoint);
5597 /* TestOutput for cp_a (0) */
5598 char expected[] = "file content";
5600 char path[] = "/olddir";
5603 r = guestfs_mkdir (g, path);
5608 char path[] = "/newdir";
5611 r = guestfs_mkdir (g, path);
5616 char path[] = "/olddir/file";
5617 char content[] = "file content";
5620 r = guestfs_write_file (g, path, content, 0);
5625 char src[] = "/olddir";
5626 char dest[] = "/newdir";
5629 r = guestfs_cp_a (g, src, dest);
5634 char path[] = "/newdir/olddir/file";
5637 r = guestfs_cat (g, path);
5640 if (strcmp (r, expected) != 0) {
5641 fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
5649 static int test_cp_0_skip (void)
5653 str = getenv ("TEST_ONLY");
5655 return strstr (str, "cp") == NULL;
5656 str = getenv ("SKIP_TEST_CP_0");
5657 if (str && strcmp (str, "1") == 0) return 1;
5658 str = getenv ("SKIP_TEST_CP");
5659 if (str && strcmp (str, "1") == 0) return 1;
5663 static int test_cp_0 (void)
5665 if (test_cp_0_skip ()) {
5666 printf ("%s skipped (reason: environment variable set)\n", "test_cp_0");
5670 /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
5672 char device[] = "/dev/sda";
5675 r = guestfs_blockdev_setrw (g, device);
5682 r = guestfs_umount_all (g);
5689 r = guestfs_lvm_remove_all (g);
5694 char device[] = "/dev/sda";
5695 char lines_0[] = ",";
5702 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5707 char fstype[] = "ext2";
5708 char device[] = "/dev/sda1";
5711 r = guestfs_mkfs (g, fstype, device);
5716 char device[] = "/dev/sda1";
5717 char mountpoint[] = "/";
5720 r = guestfs_mount (g, device, mountpoint);
5724 /* TestOutput for cp (0) */
5725 char expected[] = "file content";
5727 char path[] = "/old";
5728 char content[] = "file content";
5731 r = guestfs_write_file (g, path, content, 0);
5736 char src[] = "/old";
5737 char dest[] = "/new";
5740 r = guestfs_cp (g, src, dest);
5745 char path[] = "/new";
5748 r = guestfs_cat (g, path);
5751 if (strcmp (r, expected) != 0) {
5752 fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
5760 static int test_cp_1_skip (void)
5764 str = getenv ("TEST_ONLY");
5766 return strstr (str, "cp") == NULL;
5767 str = getenv ("SKIP_TEST_CP_1");
5768 if (str && strcmp (str, "1") == 0) return 1;
5769 str = getenv ("SKIP_TEST_CP");
5770 if (str && strcmp (str, "1") == 0) return 1;
5774 static int test_cp_1 (void)
5776 if (test_cp_1_skip ()) {
5777 printf ("%s skipped (reason: environment variable set)\n", "test_cp_1");
5781 /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
5783 char device[] = "/dev/sda";
5786 r = guestfs_blockdev_setrw (g, device);
5793 r = guestfs_umount_all (g);
5800 r = guestfs_lvm_remove_all (g);
5805 char device[] = "/dev/sda";
5806 char lines_0[] = ",";
5813 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5818 char fstype[] = "ext2";
5819 char device[] = "/dev/sda1";
5822 r = guestfs_mkfs (g, fstype, device);
5827 char device[] = "/dev/sda1";
5828 char mountpoint[] = "/";
5831 r = guestfs_mount (g, device, mountpoint);
5835 /* TestOutputTrue for cp (1) */
5837 char path[] = "/old";
5838 char content[] = "file content";
5841 r = guestfs_write_file (g, path, content, 0);
5846 char src[] = "/old";
5847 char dest[] = "/new";
5850 r = guestfs_cp (g, src, dest);
5855 char path[] = "/old";
5858 r = guestfs_is_file (g, path);
5862 fprintf (stderr, "test_cp_1: expected true, got false\n");
5869 static int test_cp_2_skip (void)
5873 str = getenv ("TEST_ONLY");
5875 return strstr (str, "cp") == NULL;
5876 str = getenv ("SKIP_TEST_CP_2");
5877 if (str && strcmp (str, "1") == 0) return 1;
5878 str = getenv ("SKIP_TEST_CP");
5879 if (str && strcmp (str, "1") == 0) return 1;
5883 static int test_cp_2 (void)
5885 if (test_cp_2_skip ()) {
5886 printf ("%s skipped (reason: environment variable set)\n", "test_cp_2");
5890 /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
5892 char device[] = "/dev/sda";
5895 r = guestfs_blockdev_setrw (g, device);
5902 r = guestfs_umount_all (g);
5909 r = guestfs_lvm_remove_all (g);
5914 char device[] = "/dev/sda";
5915 char lines_0[] = ",";
5922 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5927 char fstype[] = "ext2";
5928 char device[] = "/dev/sda1";
5931 r = guestfs_mkfs (g, fstype, device);
5936 char device[] = "/dev/sda1";
5937 char mountpoint[] = "/";
5940 r = guestfs_mount (g, device, mountpoint);
5944 /* TestOutput for cp (2) */
5945 char expected[] = "file content";
5947 char path[] = "/old";
5948 char content[] = "file content";
5951 r = guestfs_write_file (g, path, content, 0);
5956 char path[] = "/dir";
5959 r = guestfs_mkdir (g, path);
5964 char src[] = "/old";
5965 char dest[] = "/dir/new";
5968 r = guestfs_cp (g, src, dest);
5973 char path[] = "/dir/new";
5976 r = guestfs_cat (g, path);
5979 if (strcmp (r, expected) != 0) {
5980 fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
5988 static int test_grub_install_0_skip (void)
5992 str = getenv ("TEST_ONLY");
5994 return strstr (str, "grub_install") == NULL;
5995 str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
5996 if (str && strcmp (str, "1") == 0) return 1;
5997 str = getenv ("SKIP_TEST_GRUB_INSTALL");
5998 if (str && strcmp (str, "1") == 0) return 1;
6002 static int test_grub_install_0 (void)
6004 if (test_grub_install_0_skip ()) {
6005 printf ("%s skipped (reason: environment variable set)\n", "test_grub_install_0");
6009 /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
6011 char device[] = "/dev/sda";
6014 r = guestfs_blockdev_setrw (g, device);
6021 r = guestfs_umount_all (g);
6028 r = guestfs_lvm_remove_all (g);
6033 char device[] = "/dev/sda";
6034 char lines_0[] = ",";
6041 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6046 char fstype[] = "ext2";
6047 char device[] = "/dev/sda1";
6050 r = guestfs_mkfs (g, fstype, device);
6055 char device[] = "/dev/sda1";
6056 char mountpoint[] = "/";
6059 r = guestfs_mount (g, device, mountpoint);
6063 /* TestOutputTrue for grub_install (0) */
6066 char device[] = "/dev/sda1";
6069 r = guestfs_grub_install (g, root, device);
6074 char path[] = "/boot";
6077 r = guestfs_is_dir (g, path);
6081 fprintf (stderr, "test_grub_install_0: expected true, got false\n");
6088 static int test_zero_0_skip (void)
6092 str = getenv ("TEST_ONLY");
6094 return strstr (str, "zero") == NULL;
6095 str = getenv ("SKIP_TEST_ZERO_0");
6096 if (str && strcmp (str, "1") == 0) return 1;
6097 str = getenv ("SKIP_TEST_ZERO");
6098 if (str && strcmp (str, "1") == 0) return 1;
6102 static int test_zero_0 (void)
6104 if (test_zero_0_skip ()) {
6105 printf ("%s skipped (reason: environment variable set)\n", "test_zero_0");
6109 /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
6111 char device[] = "/dev/sda";
6114 r = guestfs_blockdev_setrw (g, device);
6121 r = guestfs_umount_all (g);
6128 r = guestfs_lvm_remove_all (g);
6133 char device[] = "/dev/sda";
6134 char lines_0[] = ",";
6141 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6146 char fstype[] = "ext2";
6147 char device[] = "/dev/sda1";
6150 r = guestfs_mkfs (g, fstype, device);
6155 char device[] = "/dev/sda1";
6156 char mountpoint[] = "/";
6159 r = guestfs_mount (g, device, mountpoint);
6163 /* TestOutput for zero (0) */
6164 char expected[] = "data";
6166 char pathordevice[] = "/dev/sda1";
6169 r = guestfs_umount (g, pathordevice);
6174 char device[] = "/dev/sda1";
6177 r = guestfs_zero (g, device);
6182 char path[] = "/dev/sda1";
6185 r = guestfs_file (g, path);
6188 if (strcmp (r, expected) != 0) {
6189 fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
6197 static int test_fsck_0_skip (void)
6201 str = getenv ("TEST_ONLY");
6203 return strstr (str, "fsck") == NULL;
6204 str = getenv ("SKIP_TEST_FSCK_0");
6205 if (str && strcmp (str, "1") == 0) return 1;
6206 str = getenv ("SKIP_TEST_FSCK");
6207 if (str && strcmp (str, "1") == 0) return 1;
6211 static int test_fsck_0 (void)
6213 if (test_fsck_0_skip ()) {
6214 printf ("%s skipped (reason: environment variable set)\n", "test_fsck_0");
6218 /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
6220 char device[] = "/dev/sda";
6223 r = guestfs_blockdev_setrw (g, device);
6230 r = guestfs_umount_all (g);
6237 r = guestfs_lvm_remove_all (g);
6242 char device[] = "/dev/sda";
6243 char lines_0[] = ",";
6250 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6255 char fstype[] = "ext2";
6256 char device[] = "/dev/sda1";
6259 r = guestfs_mkfs (g, fstype, device);
6264 char device[] = "/dev/sda1";
6265 char mountpoint[] = "/";
6268 r = guestfs_mount (g, device, mountpoint);
6272 /* TestOutputInt for fsck (0) */
6274 char pathordevice[] = "/dev/sda1";
6277 r = guestfs_umount (g, pathordevice);
6282 char fstype[] = "ext2";
6283 char device[] = "/dev/sda1";
6286 r = guestfs_fsck (g, fstype, device);
6290 fprintf (stderr, "test_fsck_0: expected 0 but got %d\n", (int) r);
6297 static int test_fsck_1_skip (void)
6301 str = getenv ("TEST_ONLY");
6303 return strstr (str, "fsck") == NULL;
6304 str = getenv ("SKIP_TEST_FSCK_1");
6305 if (str && strcmp (str, "1") == 0) return 1;
6306 str = getenv ("SKIP_TEST_FSCK");
6307 if (str && strcmp (str, "1") == 0) return 1;
6311 static int test_fsck_1 (void)
6313 if (test_fsck_1_skip ()) {
6314 printf ("%s skipped (reason: environment variable set)\n", "test_fsck_1");
6318 /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
6320 char device[] = "/dev/sda";
6323 r = guestfs_blockdev_setrw (g, device);
6330 r = guestfs_umount_all (g);
6337 r = guestfs_lvm_remove_all (g);
6342 char device[] = "/dev/sda";
6343 char lines_0[] = ",";
6350 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6355 char fstype[] = "ext2";
6356 char device[] = "/dev/sda1";
6359 r = guestfs_mkfs (g, fstype, device);
6364 char device[] = "/dev/sda1";
6365 char mountpoint[] = "/";
6368 r = guestfs_mount (g, device, mountpoint);
6372 /* TestOutputInt for fsck (1) */
6374 char pathordevice[] = "/dev/sda1";
6377 r = guestfs_umount (g, pathordevice);
6382 char device[] = "/dev/sda1";
6385 r = guestfs_zero (g, device);
6390 char fstype[] = "ext2";
6391 char device[] = "/dev/sda1";
6394 r = guestfs_fsck (g, fstype, device);
6398 fprintf (stderr, "test_fsck_1: expected 8 but got %d\n", (int) r);
6405 static int test_set_e2uuid_0_skip (void)
6409 str = getenv ("TEST_ONLY");
6411 return strstr (str, "set_e2uuid") == NULL;
6412 str = getenv ("SKIP_TEST_SET_E2UUID_0");
6413 if (str && strcmp (str, "1") == 0) return 1;
6414 str = getenv ("SKIP_TEST_SET_E2UUID");
6415 if (str && strcmp (str, "1") == 0) return 1;
6419 static int test_set_e2uuid_0 (void)
6421 if (test_set_e2uuid_0_skip ()) {
6422 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_0");
6426 /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
6428 char device[] = "/dev/sda";
6431 r = guestfs_blockdev_setrw (g, device);
6438 r = guestfs_umount_all (g);
6445 r = guestfs_lvm_remove_all (g);
6450 char device[] = "/dev/sda";
6451 char lines_0[] = ",";
6458 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6463 char fstype[] = "ext2";
6464 char device[] = "/dev/sda1";
6467 r = guestfs_mkfs (g, fstype, device);
6472 char device[] = "/dev/sda1";
6473 char mountpoint[] = "/";
6476 r = guestfs_mount (g, device, mountpoint);
6480 /* TestOutput for set_e2uuid (0) */
6481 char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
6483 char device[] = "/dev/sda1";
6484 char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
6487 r = guestfs_set_e2uuid (g, device, uuid);
6492 char device[] = "/dev/sda1";
6495 r = guestfs_get_e2uuid (g, device);
6498 if (strcmp (r, expected) != 0) {
6499 fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
6507 static int test_set_e2uuid_1_skip (void)
6511 str = getenv ("TEST_ONLY");
6513 return strstr (str, "set_e2uuid") == NULL;
6514 str = getenv ("SKIP_TEST_SET_E2UUID_1");
6515 if (str && strcmp (str, "1") == 0) return 1;
6516 str = getenv ("SKIP_TEST_SET_E2UUID");
6517 if (str && strcmp (str, "1") == 0) return 1;
6521 static int test_set_e2uuid_1 (void)
6523 if (test_set_e2uuid_1_skip ()) {
6524 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_1");
6528 /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
6530 char device[] = "/dev/sda";
6533 r = guestfs_blockdev_setrw (g, device);
6540 r = guestfs_umount_all (g);
6547 r = guestfs_lvm_remove_all (g);
6552 char device[] = "/dev/sda";
6553 char lines_0[] = ",";
6560 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6565 char fstype[] = "ext2";
6566 char device[] = "/dev/sda1";
6569 r = guestfs_mkfs (g, fstype, device);
6574 char device[] = "/dev/sda1";
6575 char mountpoint[] = "/";
6578 r = guestfs_mount (g, device, mountpoint);
6582 /* TestOutput for set_e2uuid (1) */
6583 char expected[] = "";
6585 char device[] = "/dev/sda1";
6586 char uuid[] = "clear";
6589 r = guestfs_set_e2uuid (g, device, uuid);
6594 char device[] = "/dev/sda1";
6597 r = guestfs_get_e2uuid (g, device);
6600 if (strcmp (r, expected) != 0) {
6601 fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
6609 static int test_set_e2uuid_2_skip (void)
6613 str = getenv ("TEST_ONLY");
6615 return strstr (str, "set_e2uuid") == NULL;
6616 str = getenv ("SKIP_TEST_SET_E2UUID_2");
6617 if (str && strcmp (str, "1") == 0) return 1;
6618 str = getenv ("SKIP_TEST_SET_E2UUID");
6619 if (str && strcmp (str, "1") == 0) return 1;
6623 static int test_set_e2uuid_2 (void)
6625 if (test_set_e2uuid_2_skip ()) {
6626 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_2");
6630 /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
6632 char device[] = "/dev/sda";
6635 r = guestfs_blockdev_setrw (g, device);
6642 r = guestfs_umount_all (g);
6649 r = guestfs_lvm_remove_all (g);
6654 char device[] = "/dev/sda";
6655 char lines_0[] = ",";
6662 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6667 char fstype[] = "ext2";
6668 char device[] = "/dev/sda1";
6671 r = guestfs_mkfs (g, fstype, device);
6676 char device[] = "/dev/sda1";
6677 char mountpoint[] = "/";
6680 r = guestfs_mount (g, device, mountpoint);
6684 /* TestRun for set_e2uuid (2) */
6686 char device[] = "/dev/sda1";
6687 char uuid[] = "random";
6690 r = guestfs_set_e2uuid (g, device, uuid);
6697 static int test_set_e2uuid_3_skip (void)
6701 str = getenv ("TEST_ONLY");
6703 return strstr (str, "set_e2uuid") == NULL;
6704 str = getenv ("SKIP_TEST_SET_E2UUID_3");
6705 if (str && strcmp (str, "1") == 0) return 1;
6706 str = getenv ("SKIP_TEST_SET_E2UUID");
6707 if (str && strcmp (str, "1") == 0) return 1;
6711 static int test_set_e2uuid_3 (void)
6713 if (test_set_e2uuid_3_skip ()) {
6714 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_3");
6718 /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
6720 char device[] = "/dev/sda";
6723 r = guestfs_blockdev_setrw (g, device);
6730 r = guestfs_umount_all (g);
6737 r = guestfs_lvm_remove_all (g);
6742 char device[] = "/dev/sda";
6743 char lines_0[] = ",";
6750 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6755 char fstype[] = "ext2";
6756 char device[] = "/dev/sda1";
6759 r = guestfs_mkfs (g, fstype, device);
6764 char device[] = "/dev/sda1";
6765 char mountpoint[] = "/";
6768 r = guestfs_mount (g, device, mountpoint);
6772 /* TestRun for set_e2uuid (3) */
6774 char device[] = "/dev/sda1";
6775 char uuid[] = "time";
6778 r = guestfs_set_e2uuid (g, device, uuid);
6785 static int test_set_e2label_0_skip (void)
6789 str = getenv ("TEST_ONLY");
6791 return strstr (str, "set_e2label") == NULL;
6792 str = getenv ("SKIP_TEST_SET_E2LABEL_0");
6793 if (str && strcmp (str, "1") == 0) return 1;
6794 str = getenv ("SKIP_TEST_SET_E2LABEL");
6795 if (str && strcmp (str, "1") == 0) return 1;
6799 static int test_set_e2label_0 (void)
6801 if (test_set_e2label_0_skip ()) {
6802 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2label_0");
6806 /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
6808 char device[] = "/dev/sda";
6811 r = guestfs_blockdev_setrw (g, device);
6818 r = guestfs_umount_all (g);
6825 r = guestfs_lvm_remove_all (g);
6830 char device[] = "/dev/sda";
6831 char lines_0[] = ",";
6838 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6843 char fstype[] = "ext2";
6844 char device[] = "/dev/sda1";
6847 r = guestfs_mkfs (g, fstype, device);
6852 char device[] = "/dev/sda1";
6853 char mountpoint[] = "/";
6856 r = guestfs_mount (g, device, mountpoint);
6860 /* TestOutput for set_e2label (0) */
6861 char expected[] = "testlabel";
6863 char device[] = "/dev/sda1";
6864 char label[] = "testlabel";
6867 r = guestfs_set_e2label (g, device, label);
6872 char device[] = "/dev/sda1";
6875 r = guestfs_get_e2label (g, device);
6878 if (strcmp (r, expected) != 0) {
6879 fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
6887 static int test_pvremove_0_skip (void)
6891 str = getenv ("TEST_ONLY");
6893 return strstr (str, "pvremove") == NULL;
6894 str = getenv ("SKIP_TEST_PVREMOVE_0");
6895 if (str && strcmp (str, "1") == 0) return 1;
6896 str = getenv ("SKIP_TEST_PVREMOVE");
6897 if (str && strcmp (str, "1") == 0) return 1;
6901 static int test_pvremove_0 (void)
6903 if (test_pvremove_0_skip ()) {
6904 printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_0");
6908 /* InitNone|InitEmpty for test_pvremove_0 */
6910 char device[] = "/dev/sda";
6913 r = guestfs_blockdev_setrw (g, device);
6920 r = guestfs_umount_all (g);
6927 r = guestfs_lvm_remove_all (g);
6931 /* TestOutputListOfDevices for pvremove (0) */
6933 char device[] = "/dev/sda";
6934 char lines_0[] = ",";
6941 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6946 char device[] = "/dev/sda1";
6949 r = guestfs_pvcreate (g, device);
6954 char volgroup[] = "VG";
6955 char physvols_0[] = "/dev/sda1";
6956 char *physvols[] = {
6962 r = guestfs_vgcreate (g, volgroup, physvols);
6967 char logvol[] = "LV1";
6968 char volgroup[] = "VG";
6971 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6976 char logvol[] = "LV2";
6977 char volgroup[] = "VG";
6980 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6985 char vgname[] = "VG";
6988 r = guestfs_vgremove (g, vgname);
6993 char device[] = "/dev/sda1";
6996 r = guestfs_pvremove (g, device);
7004 r = guestfs_lvs (g);
7008 fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
7012 for (i = 0; r[i] != NULL; ++i)
7019 static int test_pvremove_1_skip (void)
7023 str = getenv ("TEST_ONLY");
7025 return strstr (str, "pvremove") == NULL;
7026 str = getenv ("SKIP_TEST_PVREMOVE_1");
7027 if (str && strcmp (str, "1") == 0) return 1;
7028 str = getenv ("SKIP_TEST_PVREMOVE");
7029 if (str && strcmp (str, "1") == 0) return 1;
7033 static int test_pvremove_1 (void)
7035 if (test_pvremove_1_skip ()) {
7036 printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_1");
7040 /* InitNone|InitEmpty for test_pvremove_1 */
7042 char device[] = "/dev/sda";
7045 r = guestfs_blockdev_setrw (g, device);
7052 r = guestfs_umount_all (g);
7059 r = guestfs_lvm_remove_all (g);
7063 /* TestOutputListOfDevices for pvremove (1) */
7065 char device[] = "/dev/sda";
7066 char lines_0[] = ",";
7073 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7078 char device[] = "/dev/sda1";
7081 r = guestfs_pvcreate (g, device);
7086 char volgroup[] = "VG";
7087 char physvols_0[] = "/dev/sda1";
7088 char *physvols[] = {
7094 r = guestfs_vgcreate (g, volgroup, physvols);
7099 char logvol[] = "LV1";
7100 char volgroup[] = "VG";
7103 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7108 char logvol[] = "LV2";
7109 char volgroup[] = "VG";
7112 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7117 char vgname[] = "VG";
7120 r = guestfs_vgremove (g, vgname);
7125 char device[] = "/dev/sda1";
7128 r = guestfs_pvremove (g, device);
7136 r = guestfs_vgs (g);
7140 fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
7144 for (i = 0; r[i] != NULL; ++i)
7151 static int test_pvremove_2_skip (void)
7155 str = getenv ("TEST_ONLY");
7157 return strstr (str, "pvremove") == NULL;
7158 str = getenv ("SKIP_TEST_PVREMOVE_2");
7159 if (str && strcmp (str, "1") == 0) return 1;
7160 str = getenv ("SKIP_TEST_PVREMOVE");
7161 if (str && strcmp (str, "1") == 0) return 1;
7165 static int test_pvremove_2 (void)
7167 if (test_pvremove_2_skip ()) {
7168 printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_2");
7172 /* InitNone|InitEmpty for test_pvremove_2 */
7174 char device[] = "/dev/sda";
7177 r = guestfs_blockdev_setrw (g, device);
7184 r = guestfs_umount_all (g);
7191 r = guestfs_lvm_remove_all (g);
7195 /* TestOutputListOfDevices for pvremove (2) */
7197 char device[] = "/dev/sda";
7198 char lines_0[] = ",";
7205 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7210 char device[] = "/dev/sda1";
7213 r = guestfs_pvcreate (g, device);
7218 char volgroup[] = "VG";
7219 char physvols_0[] = "/dev/sda1";
7220 char *physvols[] = {
7226 r = guestfs_vgcreate (g, volgroup, physvols);
7231 char logvol[] = "LV1";
7232 char volgroup[] = "VG";
7235 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7240 char logvol[] = "LV2";
7241 char volgroup[] = "VG";
7244 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7249 char vgname[] = "VG";
7252 r = guestfs_vgremove (g, vgname);
7257 char device[] = "/dev/sda1";
7260 r = guestfs_pvremove (g, device);
7268 r = guestfs_pvs (g);
7272 fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
7276 for (i = 0; r[i] != NULL; ++i)
7283 static int test_vgremove_0_skip (void)
7287 str = getenv ("TEST_ONLY");
7289 return strstr (str, "vgremove") == NULL;
7290 str = getenv ("SKIP_TEST_VGREMOVE_0");
7291 if (str && strcmp (str, "1") == 0) return 1;
7292 str = getenv ("SKIP_TEST_VGREMOVE");
7293 if (str && strcmp (str, "1") == 0) return 1;
7297 static int test_vgremove_0 (void)
7299 if (test_vgremove_0_skip ()) {
7300 printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_0");
7304 /* InitNone|InitEmpty for test_vgremove_0 */
7306 char device[] = "/dev/sda";
7309 r = guestfs_blockdev_setrw (g, device);
7316 r = guestfs_umount_all (g);
7323 r = guestfs_lvm_remove_all (g);
7327 /* TestOutputList for vgremove (0) */
7329 char device[] = "/dev/sda";
7330 char lines_0[] = ",";
7337 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7342 char device[] = "/dev/sda1";
7345 r = guestfs_pvcreate (g, device);
7350 char volgroup[] = "VG";
7351 char physvols_0[] = "/dev/sda1";
7352 char *physvols[] = {
7358 r = guestfs_vgcreate (g, volgroup, physvols);
7363 char logvol[] = "LV1";
7364 char volgroup[] = "VG";
7367 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7372 char logvol[] = "LV2";
7373 char volgroup[] = "VG";
7376 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7381 char vgname[] = "VG";
7384 r = guestfs_vgremove (g, vgname);
7392 r = guestfs_lvs (g);
7396 fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
7400 for (i = 0; r[i] != NULL; ++i)
7407 static int test_vgremove_1_skip (void)
7411 str = getenv ("TEST_ONLY");
7413 return strstr (str, "vgremove") == NULL;
7414 str = getenv ("SKIP_TEST_VGREMOVE_1");
7415 if (str && strcmp (str, "1") == 0) return 1;
7416 str = getenv ("SKIP_TEST_VGREMOVE");
7417 if (str && strcmp (str, "1") == 0) return 1;
7421 static int test_vgremove_1 (void)
7423 if (test_vgremove_1_skip ()) {
7424 printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_1");
7428 /* InitNone|InitEmpty for test_vgremove_1 */
7430 char device[] = "/dev/sda";
7433 r = guestfs_blockdev_setrw (g, device);
7440 r = guestfs_umount_all (g);
7447 r = guestfs_lvm_remove_all (g);
7451 /* TestOutputList for vgremove (1) */
7453 char device[] = "/dev/sda";
7454 char lines_0[] = ",";
7461 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7466 char device[] = "/dev/sda1";
7469 r = guestfs_pvcreate (g, device);
7474 char volgroup[] = "VG";
7475 char physvols_0[] = "/dev/sda1";
7476 char *physvols[] = {
7482 r = guestfs_vgcreate (g, volgroup, physvols);
7487 char logvol[] = "LV1";
7488 char volgroup[] = "VG";
7491 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7496 char logvol[] = "LV2";
7497 char volgroup[] = "VG";
7500 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7505 char vgname[] = "VG";
7508 r = guestfs_vgremove (g, vgname);
7516 r = guestfs_vgs (g);
7520 fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
7524 for (i = 0; r[i] != NULL; ++i)
7531 static int test_lvremove_0_skip (void)
7535 str = getenv ("TEST_ONLY");
7537 return strstr (str, "lvremove") == NULL;
7538 str = getenv ("SKIP_TEST_LVREMOVE_0");
7539 if (str && strcmp (str, "1") == 0) return 1;
7540 str = getenv ("SKIP_TEST_LVREMOVE");
7541 if (str && strcmp (str, "1") == 0) return 1;
7545 static int test_lvremove_0 (void)
7547 if (test_lvremove_0_skip ()) {
7548 printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_0");
7552 /* InitNone|InitEmpty for test_lvremove_0 */
7554 char device[] = "/dev/sda";
7557 r = guestfs_blockdev_setrw (g, device);
7564 r = guestfs_umount_all (g);
7571 r = guestfs_lvm_remove_all (g);
7575 /* TestOutputList for lvremove (0) */
7577 char device[] = "/dev/sda";
7578 char lines_0[] = ",";
7585 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7590 char device[] = "/dev/sda1";
7593 r = guestfs_pvcreate (g, device);
7598 char volgroup[] = "VG";
7599 char physvols_0[] = "/dev/sda1";
7600 char *physvols[] = {
7606 r = guestfs_vgcreate (g, volgroup, physvols);
7611 char logvol[] = "LV1";
7612 char volgroup[] = "VG";
7615 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7620 char logvol[] = "LV2";
7621 char volgroup[] = "VG";
7624 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7629 char device[] = "/dev/VG/LV1";
7632 r = guestfs_lvremove (g, device);
7640 r = guestfs_lvs (g);
7644 fprintf (stderr, "test_lvremove_0: short list returned from command\n");
7649 char expected[] = "/dev/VG/LV2";
7650 if (strcmp (r[0], expected) != 0) {
7651 fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7656 fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
7660 for (i = 0; r[i] != NULL; ++i)
7667 static int test_lvremove_1_skip (void)
7671 str = getenv ("TEST_ONLY");
7673 return strstr (str, "lvremove") == NULL;
7674 str = getenv ("SKIP_TEST_LVREMOVE_1");
7675 if (str && strcmp (str, "1") == 0) return 1;
7676 str = getenv ("SKIP_TEST_LVREMOVE");
7677 if (str && strcmp (str, "1") == 0) return 1;
7681 static int test_lvremove_1 (void)
7683 if (test_lvremove_1_skip ()) {
7684 printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_1");
7688 /* InitNone|InitEmpty for test_lvremove_1 */
7690 char device[] = "/dev/sda";
7693 r = guestfs_blockdev_setrw (g, device);
7700 r = guestfs_umount_all (g);
7707 r = guestfs_lvm_remove_all (g);
7711 /* TestOutputList for lvremove (1) */
7713 char device[] = "/dev/sda";
7714 char lines_0[] = ",";
7721 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7726 char device[] = "/dev/sda1";
7729 r = guestfs_pvcreate (g, device);
7734 char volgroup[] = "VG";
7735 char physvols_0[] = "/dev/sda1";
7736 char *physvols[] = {
7742 r = guestfs_vgcreate (g, volgroup, physvols);
7747 char logvol[] = "LV1";
7748 char volgroup[] = "VG";
7751 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7756 char logvol[] = "LV2";
7757 char volgroup[] = "VG";
7760 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7765 char device[] = "/dev/VG";
7768 r = guestfs_lvremove (g, device);
7776 r = guestfs_lvs (g);
7780 fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
7784 for (i = 0; r[i] != NULL; ++i)
7791 static int test_lvremove_2_skip (void)
7795 str = getenv ("TEST_ONLY");
7797 return strstr (str, "lvremove") == NULL;
7798 str = getenv ("SKIP_TEST_LVREMOVE_2");
7799 if (str && strcmp (str, "1") == 0) return 1;
7800 str = getenv ("SKIP_TEST_LVREMOVE");
7801 if (str && strcmp (str, "1") == 0) return 1;
7805 static int test_lvremove_2 (void)
7807 if (test_lvremove_2_skip ()) {
7808 printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_2");
7812 /* InitNone|InitEmpty for test_lvremove_2 */
7814 char device[] = "/dev/sda";
7817 r = guestfs_blockdev_setrw (g, device);
7824 r = guestfs_umount_all (g);
7831 r = guestfs_lvm_remove_all (g);
7835 /* TestOutputList for lvremove (2) */
7837 char device[] = "/dev/sda";
7838 char lines_0[] = ",";
7845 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7850 char device[] = "/dev/sda1";
7853 r = guestfs_pvcreate (g, device);
7858 char volgroup[] = "VG";
7859 char physvols_0[] = "/dev/sda1";
7860 char *physvols[] = {
7866 r = guestfs_vgcreate (g, volgroup, physvols);
7871 char logvol[] = "LV1";
7872 char volgroup[] = "VG";
7875 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7880 char logvol[] = "LV2";
7881 char volgroup[] = "VG";
7884 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7889 char device[] = "/dev/VG";
7892 r = guestfs_lvremove (g, device);
7900 r = guestfs_vgs (g);
7904 fprintf (stderr, "test_lvremove_2: short list returned from command\n");
7909 char expected[] = "VG";
7910 if (strcmp (r[0], expected) != 0) {
7911 fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7916 fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
7920 for (i = 0; r[i] != NULL; ++i)
7927 static int test_mount_ro_0_skip (void)
7931 str = getenv ("TEST_ONLY");
7933 return strstr (str, "mount_ro") == NULL;
7934 str = getenv ("SKIP_TEST_MOUNT_RO_0");
7935 if (str && strcmp (str, "1") == 0) return 1;
7936 str = getenv ("SKIP_TEST_MOUNT_RO");
7937 if (str && strcmp (str, "1") == 0) return 1;
7941 static int test_mount_ro_0 (void)
7943 if (test_mount_ro_0_skip ()) {
7944 printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_0");
7948 /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
7950 char device[] = "/dev/sda";
7953 r = guestfs_blockdev_setrw (g, device);
7960 r = guestfs_umount_all (g);
7967 r = guestfs_lvm_remove_all (g);
7972 char device[] = "/dev/sda";
7973 char lines_0[] = ",";
7980 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7985 char fstype[] = "ext2";
7986 char device[] = "/dev/sda1";
7989 r = guestfs_mkfs (g, fstype, device);
7994 char device[] = "/dev/sda1";
7995 char mountpoint[] = "/";
7998 r = guestfs_mount (g, device, mountpoint);
8002 /* TestLastFail for mount_ro (0) */
8004 char pathordevice[] = "/";
8007 r = guestfs_umount (g, pathordevice);
8012 char device[] = "/dev/sda1";
8013 char mountpoint[] = "/";
8016 r = guestfs_mount_ro (g, device, mountpoint);
8021 char path[] = "/new";
8024 r = guestfs_touch (g, path);
8031 static int test_mount_ro_1_skip (void)
8035 str = getenv ("TEST_ONLY");
8037 return strstr (str, "mount_ro") == NULL;
8038 str = getenv ("SKIP_TEST_MOUNT_RO_1");
8039 if (str && strcmp (str, "1") == 0) return 1;
8040 str = getenv ("SKIP_TEST_MOUNT_RO");
8041 if (str && strcmp (str, "1") == 0) return 1;
8045 static int test_mount_ro_1 (void)
8047 if (test_mount_ro_1_skip ()) {
8048 printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_1");
8052 /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
8054 char device[] = "/dev/sda";
8057 r = guestfs_blockdev_setrw (g, device);
8064 r = guestfs_umount_all (g);
8071 r = guestfs_lvm_remove_all (g);
8076 char device[] = "/dev/sda";
8077 char lines_0[] = ",";
8084 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8089 char fstype[] = "ext2";
8090 char device[] = "/dev/sda1";
8093 r = guestfs_mkfs (g, fstype, device);
8098 char device[] = "/dev/sda1";
8099 char mountpoint[] = "/";
8102 r = guestfs_mount (g, device, mountpoint);
8106 /* TestOutput for mount_ro (1) */
8107 char expected[] = "data";
8109 char path[] = "/new";
8110 char content[] = "data";
8113 r = guestfs_write_file (g, path, content, 0);
8118 char pathordevice[] = "/";
8121 r = guestfs_umount (g, pathordevice);
8126 char device[] = "/dev/sda1";
8127 char mountpoint[] = "/";
8130 r = guestfs_mount_ro (g, device, mountpoint);
8135 char path[] = "/new";
8138 r = guestfs_cat (g, path);
8141 if (strcmp (r, expected) != 0) {
8142 fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
8150 static int test_tgz_in_0_skip (void)
8154 str = getenv ("TEST_ONLY");
8156 return strstr (str, "tgz_in") == NULL;
8157 str = getenv ("SKIP_TEST_TGZ_IN_0");
8158 if (str && strcmp (str, "1") == 0) return 1;
8159 str = getenv ("SKIP_TEST_TGZ_IN");
8160 if (str && strcmp (str, "1") == 0) return 1;
8164 static int test_tgz_in_0 (void)
8166 if (test_tgz_in_0_skip ()) {
8167 printf ("%s skipped (reason: environment variable set)\n", "test_tgz_in_0");
8171 /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
8173 char device[] = "/dev/sda";
8176 r = guestfs_blockdev_setrw (g, device);
8183 r = guestfs_umount_all (g);
8190 r = guestfs_lvm_remove_all (g);
8195 char device[] = "/dev/sda";
8196 char lines_0[] = ",";
8203 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8208 char fstype[] = "ext2";
8209 char device[] = "/dev/sda1";
8212 r = guestfs_mkfs (g, fstype, device);
8217 char device[] = "/dev/sda1";
8218 char mountpoint[] = "/";
8221 r = guestfs_mount (g, device, mountpoint);
8225 /* TestOutput for tgz_in (0) */
8226 char expected[] = "hello\n";
8228 char directory[] = "/";
8231 r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
8236 char path[] = "/hello";
8239 r = guestfs_cat (g, path);
8242 if (strcmp (r, expected) != 0) {
8243 fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
8251 static int test_tar_in_0_skip (void)
8255 str = getenv ("TEST_ONLY");
8257 return strstr (str, "tar_in") == NULL;
8258 str = getenv ("SKIP_TEST_TAR_IN_0");
8259 if (str && strcmp (str, "1") == 0) return 1;
8260 str = getenv ("SKIP_TEST_TAR_IN");
8261 if (str && strcmp (str, "1") == 0) return 1;
8265 static int test_tar_in_0 (void)
8267 if (test_tar_in_0_skip ()) {
8268 printf ("%s skipped (reason: environment variable set)\n", "test_tar_in_0");
8272 /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
8274 char device[] = "/dev/sda";
8277 r = guestfs_blockdev_setrw (g, device);
8284 r = guestfs_umount_all (g);
8291 r = guestfs_lvm_remove_all (g);
8296 char device[] = "/dev/sda";
8297 char lines_0[] = ",";
8304 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8309 char fstype[] = "ext2";
8310 char device[] = "/dev/sda1";
8313 r = guestfs_mkfs (g, fstype, device);
8318 char device[] = "/dev/sda1";
8319 char mountpoint[] = "/";
8322 r = guestfs_mount (g, device, mountpoint);
8326 /* TestOutput for tar_in (0) */
8327 char expected[] = "hello\n";
8329 char directory[] = "/";
8332 r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
8337 char path[] = "/hello";
8340 r = guestfs_cat (g, path);
8343 if (strcmp (r, expected) != 0) {
8344 fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
8352 static int test_checksum_0_skip (void)
8356 str = getenv ("TEST_ONLY");
8358 return strstr (str, "checksum") == NULL;
8359 str = getenv ("SKIP_TEST_CHECKSUM_0");
8360 if (str && strcmp (str, "1") == 0) return 1;
8361 str = getenv ("SKIP_TEST_CHECKSUM");
8362 if (str && strcmp (str, "1") == 0) return 1;
8366 static int test_checksum_0 (void)
8368 if (test_checksum_0_skip ()) {
8369 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_0");
8373 /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
8375 char device[] = "/dev/sda";
8378 r = guestfs_blockdev_setrw (g, device);
8385 r = guestfs_umount_all (g);
8392 r = guestfs_lvm_remove_all (g);
8397 char device[] = "/dev/sda";
8398 char lines_0[] = ",";
8405 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8410 char fstype[] = "ext2";
8411 char device[] = "/dev/sda1";
8414 r = guestfs_mkfs (g, fstype, device);
8419 char device[] = "/dev/sda1";
8420 char mountpoint[] = "/";
8423 r = guestfs_mount (g, device, mountpoint);
8427 /* TestOutput for checksum (0) */
8428 char expected[] = "935282863";
8430 char path[] = "/new";
8431 char content[] = "test\n";
8434 r = guestfs_write_file (g, path, content, 0);
8439 char csumtype[] = "crc";
8440 char path[] = "/new";
8443 r = guestfs_checksum (g, csumtype, path);
8446 if (strcmp (r, expected) != 0) {
8447 fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
8455 static int test_checksum_1_skip (void)
8459 str = getenv ("TEST_ONLY");
8461 return strstr (str, "checksum") == NULL;
8462 str = getenv ("SKIP_TEST_CHECKSUM_1");
8463 if (str && strcmp (str, "1") == 0) return 1;
8464 str = getenv ("SKIP_TEST_CHECKSUM");
8465 if (str && strcmp (str, "1") == 0) return 1;
8469 static int test_checksum_1 (void)
8471 if (test_checksum_1_skip ()) {
8472 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_1");
8476 /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
8478 char device[] = "/dev/sda";
8481 r = guestfs_blockdev_setrw (g, device);
8488 r = guestfs_umount_all (g);
8495 r = guestfs_lvm_remove_all (g);
8500 char device[] = "/dev/sda";
8501 char lines_0[] = ",";
8508 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8513 char fstype[] = "ext2";
8514 char device[] = "/dev/sda1";
8517 r = guestfs_mkfs (g, fstype, device);
8522 char device[] = "/dev/sda1";
8523 char mountpoint[] = "/";
8526 r = guestfs_mount (g, device, mountpoint);
8530 /* TestLastFail for checksum (1) */
8532 char csumtype[] = "crc";
8533 char path[] = "/new";
8536 r = guestfs_checksum (g, csumtype, path);
8544 static int test_checksum_2_skip (void)
8548 str = getenv ("TEST_ONLY");
8550 return strstr (str, "checksum") == NULL;
8551 str = getenv ("SKIP_TEST_CHECKSUM_2");
8552 if (str && strcmp (str, "1") == 0) return 1;
8553 str = getenv ("SKIP_TEST_CHECKSUM");
8554 if (str && strcmp (str, "1") == 0) return 1;
8558 static int test_checksum_2 (void)
8560 if (test_checksum_2_skip ()) {
8561 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_2");
8565 /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
8567 char device[] = "/dev/sda";
8570 r = guestfs_blockdev_setrw (g, device);
8577 r = guestfs_umount_all (g);
8584 r = guestfs_lvm_remove_all (g);
8589 char device[] = "/dev/sda";
8590 char lines_0[] = ",";
8597 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8602 char fstype[] = "ext2";
8603 char device[] = "/dev/sda1";
8606 r = guestfs_mkfs (g, fstype, device);
8611 char device[] = "/dev/sda1";
8612 char mountpoint[] = "/";
8615 r = guestfs_mount (g, device, mountpoint);
8619 /* TestOutput for checksum (2) */
8620 char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
8622 char path[] = "/new";
8623 char content[] = "test\n";
8626 r = guestfs_write_file (g, path, content, 0);
8631 char csumtype[] = "md5";
8632 char path[] = "/new";
8635 r = guestfs_checksum (g, csumtype, path);
8638 if (strcmp (r, expected) != 0) {
8639 fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
8647 static int test_checksum_3_skip (void)
8651 str = getenv ("TEST_ONLY");
8653 return strstr (str, "checksum") == NULL;
8654 str = getenv ("SKIP_TEST_CHECKSUM_3");
8655 if (str && strcmp (str, "1") == 0) return 1;
8656 str = getenv ("SKIP_TEST_CHECKSUM");
8657 if (str && strcmp (str, "1") == 0) return 1;
8661 static int test_checksum_3 (void)
8663 if (test_checksum_3_skip ()) {
8664 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_3");
8668 /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
8670 char device[] = "/dev/sda";
8673 r = guestfs_blockdev_setrw (g, device);
8680 r = guestfs_umount_all (g);
8687 r = guestfs_lvm_remove_all (g);
8692 char device[] = "/dev/sda";
8693 char lines_0[] = ",";
8700 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8705 char fstype[] = "ext2";
8706 char device[] = "/dev/sda1";
8709 r = guestfs_mkfs (g, fstype, device);
8714 char device[] = "/dev/sda1";
8715 char mountpoint[] = "/";
8718 r = guestfs_mount (g, device, mountpoint);
8722 /* TestOutput for checksum (3) */
8723 char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
8725 char path[] = "/new";
8726 char content[] = "test\n";
8729 r = guestfs_write_file (g, path, content, 0);
8734 char csumtype[] = "sha1";
8735 char path[] = "/new";
8738 r = guestfs_checksum (g, csumtype, path);
8741 if (strcmp (r, expected) != 0) {
8742 fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
8750 static int test_checksum_4_skip (void)
8754 str = getenv ("TEST_ONLY");
8756 return strstr (str, "checksum") == NULL;
8757 str = getenv ("SKIP_TEST_CHECKSUM_4");
8758 if (str && strcmp (str, "1") == 0) return 1;
8759 str = getenv ("SKIP_TEST_CHECKSUM");
8760 if (str && strcmp (str, "1") == 0) return 1;
8764 static int test_checksum_4 (void)
8766 if (test_checksum_4_skip ()) {
8767 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_4");
8771 /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
8773 char device[] = "/dev/sda";
8776 r = guestfs_blockdev_setrw (g, device);
8783 r = guestfs_umount_all (g);
8790 r = guestfs_lvm_remove_all (g);
8795 char device[] = "/dev/sda";
8796 char lines_0[] = ",";
8803 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8808 char fstype[] = "ext2";
8809 char device[] = "/dev/sda1";
8812 r = guestfs_mkfs (g, fstype, device);
8817 char device[] = "/dev/sda1";
8818 char mountpoint[] = "/";
8821 r = guestfs_mount (g, device, mountpoint);
8825 /* TestOutput for checksum (4) */
8826 char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
8828 char path[] = "/new";
8829 char content[] = "test\n";
8832 r = guestfs_write_file (g, path, content, 0);
8837 char csumtype[] = "sha224";
8838 char path[] = "/new";
8841 r = guestfs_checksum (g, csumtype, path);
8844 if (strcmp (r, expected) != 0) {
8845 fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
8853 static int test_checksum_5_skip (void)
8857 str = getenv ("TEST_ONLY");
8859 return strstr (str, "checksum") == NULL;
8860 str = getenv ("SKIP_TEST_CHECKSUM_5");
8861 if (str && strcmp (str, "1") == 0) return 1;
8862 str = getenv ("SKIP_TEST_CHECKSUM");
8863 if (str && strcmp (str, "1") == 0) return 1;
8867 static int test_checksum_5 (void)
8869 if (test_checksum_5_skip ()) {
8870 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_5");
8874 /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
8876 char device[] = "/dev/sda";
8879 r = guestfs_blockdev_setrw (g, device);
8886 r = guestfs_umount_all (g);
8893 r = guestfs_lvm_remove_all (g);
8898 char device[] = "/dev/sda";
8899 char lines_0[] = ",";
8906 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8911 char fstype[] = "ext2";
8912 char device[] = "/dev/sda1";
8915 r = guestfs_mkfs (g, fstype, device);
8920 char device[] = "/dev/sda1";
8921 char mountpoint[] = "/";
8924 r = guestfs_mount (g, device, mountpoint);
8928 /* TestOutput for checksum (5) */
8929 char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
8931 char path[] = "/new";
8932 char content[] = "test\n";
8935 r = guestfs_write_file (g, path, content, 0);
8940 char csumtype[] = "sha256";
8941 char path[] = "/new";
8944 r = guestfs_checksum (g, csumtype, path);
8947 if (strcmp (r, expected) != 0) {
8948 fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
8956 static int test_checksum_6_skip (void)
8960 str = getenv ("TEST_ONLY");
8962 return strstr (str, "checksum") == NULL;
8963 str = getenv ("SKIP_TEST_CHECKSUM_6");
8964 if (str && strcmp (str, "1") == 0) return 1;
8965 str = getenv ("SKIP_TEST_CHECKSUM");
8966 if (str && strcmp (str, "1") == 0) return 1;
8970 static int test_checksum_6 (void)
8972 if (test_checksum_6_skip ()) {
8973 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_6");
8977 /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
8979 char device[] = "/dev/sda";
8982 r = guestfs_blockdev_setrw (g, device);
8989 r = guestfs_umount_all (g);
8996 r = guestfs_lvm_remove_all (g);
9001 char device[] = "/dev/sda";
9002 char lines_0[] = ",";
9009 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9014 char fstype[] = "ext2";
9015 char device[] = "/dev/sda1";
9018 r = guestfs_mkfs (g, fstype, device);
9023 char device[] = "/dev/sda1";
9024 char mountpoint[] = "/";
9027 r = guestfs_mount (g, device, mountpoint);
9031 /* TestOutput for checksum (6) */
9032 char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
9034 char path[] = "/new";
9035 char content[] = "test\n";
9038 r = guestfs_write_file (g, path, content, 0);
9043 char csumtype[] = "sha384";
9044 char path[] = "/new";
9047 r = guestfs_checksum (g, csumtype, path);
9050 if (strcmp (r, expected) != 0) {
9051 fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
9059 static int test_checksum_7_skip (void)
9063 str = getenv ("TEST_ONLY");
9065 return strstr (str, "checksum") == NULL;
9066 str = getenv ("SKIP_TEST_CHECKSUM_7");
9067 if (str && strcmp (str, "1") == 0) return 1;
9068 str = getenv ("SKIP_TEST_CHECKSUM");
9069 if (str && strcmp (str, "1") == 0) return 1;
9073 static int test_checksum_7 (void)
9075 if (test_checksum_7_skip ()) {
9076 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_7");
9080 /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
9082 char device[] = "/dev/sda";
9085 r = guestfs_blockdev_setrw (g, device);
9092 r = guestfs_umount_all (g);
9099 r = guestfs_lvm_remove_all (g);
9104 char device[] = "/dev/sda";
9105 char lines_0[] = ",";
9112 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9117 char fstype[] = "ext2";
9118 char device[] = "/dev/sda1";
9121 r = guestfs_mkfs (g, fstype, device);
9126 char device[] = "/dev/sda1";
9127 char mountpoint[] = "/";
9130 r = guestfs_mount (g, device, mountpoint);
9134 /* TestOutput for checksum (7) */
9135 char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
9137 char path[] = "/new";
9138 char content[] = "test\n";
9141 r = guestfs_write_file (g, path, content, 0);
9146 char csumtype[] = "sha512";
9147 char path[] = "/new";
9150 r = guestfs_checksum (g, csumtype, path);
9153 if (strcmp (r, expected) != 0) {
9154 fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
9162 static int test_checksum_8_skip (void)
9166 str = getenv ("TEST_ONLY");
9168 return strstr (str, "checksum") == NULL;
9169 str = getenv ("SKIP_TEST_CHECKSUM_8");
9170 if (str && strcmp (str, "1") == 0) return 1;
9171 str = getenv ("SKIP_TEST_CHECKSUM");
9172 if (str && strcmp (str, "1") == 0) return 1;
9176 static int test_checksum_8 (void)
9178 if (test_checksum_8_skip ()) {
9179 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_8");
9183 /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
9185 char device[] = "/dev/sda";
9188 r = guestfs_blockdev_setrw (g, device);
9195 r = guestfs_umount_all (g);
9202 r = guestfs_lvm_remove_all (g);
9207 char device[] = "/dev/sda";
9208 char lines_0[] = ",";
9215 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9220 char fstype[] = "ext2";
9221 char device[] = "/dev/sda1";
9224 r = guestfs_mkfs (g, fstype, device);
9229 char device[] = "/dev/sda1";
9230 char mountpoint[] = "/";
9233 r = guestfs_mount (g, device, mountpoint);
9237 /* TestOutput for checksum (8) */
9238 char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
9240 char options[] = "ro";
9241 char vfstype[] = "squashfs";
9242 char device[] = "/dev/sdd";
9243 char mountpoint[] = "/";
9246 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
9251 char csumtype[] = "md5";
9252 char path[] = "/known-3";
9255 r = guestfs_checksum (g, csumtype, path);
9258 if (strcmp (r, expected) != 0) {
9259 fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
9267 static int test_download_0_skip (void)
9271 str = getenv ("TEST_ONLY");
9273 return strstr (str, "download") == NULL;
9274 str = getenv ("SKIP_TEST_DOWNLOAD_0");
9275 if (str && strcmp (str, "1") == 0) return 1;
9276 str = getenv ("SKIP_TEST_DOWNLOAD");
9277 if (str && strcmp (str, "1") == 0) return 1;
9281 static int test_download_0 (void)
9283 if (test_download_0_skip ()) {
9284 printf ("%s skipped (reason: environment variable set)\n", "test_download_0");
9288 /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
9290 char device[] = "/dev/sda";
9293 r = guestfs_blockdev_setrw (g, device);
9300 r = guestfs_umount_all (g);
9307 r = guestfs_lvm_remove_all (g);
9312 char device[] = "/dev/sda";
9313 char lines_0[] = ",";
9320 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9325 char fstype[] = "ext2";
9326 char device[] = "/dev/sda1";
9329 r = guestfs_mkfs (g, fstype, device);
9334 char device[] = "/dev/sda1";
9335 char mountpoint[] = "/";
9338 r = guestfs_mount (g, device, mountpoint);
9342 /* TestOutput for download (0) */
9343 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
9345 char remotefilename[] = "/COPYING.LIB";
9348 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
9353 char remotefilename[] = "/COPYING.LIB";
9356 r = guestfs_download (g, remotefilename, "testdownload.tmp");
9361 char remotefilename[] = "/upload";
9364 r = guestfs_upload (g, "testdownload.tmp", remotefilename);
9369 char csumtype[] = "md5";
9370 char path[] = "/upload";
9373 r = guestfs_checksum (g, csumtype, path);
9376 if (strcmp (r, expected) != 0) {
9377 fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
9385 static int test_upload_0_skip (void)
9389 str = getenv ("TEST_ONLY");
9391 return strstr (str, "upload") == NULL;
9392 str = getenv ("SKIP_TEST_UPLOAD_0");
9393 if (str && strcmp (str, "1") == 0) return 1;
9394 str = getenv ("SKIP_TEST_UPLOAD");
9395 if (str && strcmp (str, "1") == 0) return 1;
9399 static int test_upload_0 (void)
9401 if (test_upload_0_skip ()) {
9402 printf ("%s skipped (reason: environment variable set)\n", "test_upload_0");
9406 /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
9408 char device[] = "/dev/sda";
9411 r = guestfs_blockdev_setrw (g, device);
9418 r = guestfs_umount_all (g);
9425 r = guestfs_lvm_remove_all (g);
9430 char device[] = "/dev/sda";
9431 char lines_0[] = ",";
9438 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9443 char fstype[] = "ext2";
9444 char device[] = "/dev/sda1";
9447 r = guestfs_mkfs (g, fstype, device);
9452 char device[] = "/dev/sda1";
9453 char mountpoint[] = "/";
9456 r = guestfs_mount (g, device, mountpoint);
9460 /* TestOutput for upload (0) */
9461 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
9463 char remotefilename[] = "/COPYING.LIB";
9466 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
9471 char csumtype[] = "md5";
9472 char path[] = "/COPYING.LIB";
9475 r = guestfs_checksum (g, csumtype, path);
9478 if (strcmp (r, expected) != 0) {
9479 fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
9487 static int test_blockdev_rereadpt_0_skip (void)
9491 str = getenv ("TEST_ONLY");
9493 return strstr (str, "blockdev_rereadpt") == NULL;
9494 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
9495 if (str && strcmp (str, "1") == 0) return 1;
9496 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
9497 if (str && strcmp (str, "1") == 0) return 1;
9501 static int test_blockdev_rereadpt_0 (void)
9503 if (test_blockdev_rereadpt_0_skip ()) {
9504 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_rereadpt_0");
9508 /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
9510 char device[] = "/dev/sda";
9513 r = guestfs_blockdev_setrw (g, device);
9520 r = guestfs_umount_all (g);
9527 r = guestfs_lvm_remove_all (g);
9531 /* TestRun for blockdev_rereadpt (0) */
9533 char device[] = "/dev/sda";
9536 r = guestfs_blockdev_rereadpt (g, device);
9543 static int test_blockdev_flushbufs_0_skip (void)
9547 str = getenv ("TEST_ONLY");
9549 return strstr (str, "blockdev_flushbufs") == NULL;
9550 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
9551 if (str && strcmp (str, "1") == 0) return 1;
9552 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
9553 if (str && strcmp (str, "1") == 0) return 1;
9557 static int test_blockdev_flushbufs_0 (void)
9559 if (test_blockdev_flushbufs_0_skip ()) {
9560 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_flushbufs_0");
9564 /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
9566 char device[] = "/dev/sda";
9569 r = guestfs_blockdev_setrw (g, device);
9576 r = guestfs_umount_all (g);
9583 r = guestfs_lvm_remove_all (g);
9587 /* TestRun for blockdev_flushbufs (0) */
9589 char device[] = "/dev/sda";
9592 r = guestfs_blockdev_flushbufs (g, device);
9599 static int test_blockdev_getsize64_0_skip (void)
9603 str = getenv ("TEST_ONLY");
9605 return strstr (str, "blockdev_getsize64") == NULL;
9606 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
9607 if (str && strcmp (str, "1") == 0) return 1;
9608 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
9609 if (str && strcmp (str, "1") == 0) return 1;
9613 static int test_blockdev_getsize64_0 (void)
9615 if (test_blockdev_getsize64_0_skip ()) {
9616 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsize64_0");
9620 /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
9622 char device[] = "/dev/sda";
9625 r = guestfs_blockdev_setrw (g, device);
9632 r = guestfs_umount_all (g);
9639 r = guestfs_lvm_remove_all (g);
9643 /* TestOutputInt for blockdev_getsize64 (0) */
9645 char device[] = "/dev/sda";
9648 r = guestfs_blockdev_getsize64 (g, device);
9651 if (r != 524288000) {
9652 fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n", (int) r);
9659 static int test_blockdev_getsz_0_skip (void)
9663 str = getenv ("TEST_ONLY");
9665 return strstr (str, "blockdev_getsz") == NULL;
9666 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
9667 if (str && strcmp (str, "1") == 0) return 1;
9668 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
9669 if (str && strcmp (str, "1") == 0) return 1;
9673 static int test_blockdev_getsz_0 (void)
9675 if (test_blockdev_getsz_0_skip ()) {
9676 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsz_0");
9680 /* InitNone|InitEmpty for test_blockdev_getsz_0 */
9682 char device[] = "/dev/sda";
9685 r = guestfs_blockdev_setrw (g, device);
9692 r = guestfs_umount_all (g);
9699 r = guestfs_lvm_remove_all (g);
9703 /* TestOutputInt for blockdev_getsz (0) */
9705 char device[] = "/dev/sda";
9708 r = guestfs_blockdev_getsz (g, device);
9712 fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n", (int) r);
9719 static int test_blockdev_getbsz_0_skip (void)
9723 str = getenv ("TEST_ONLY");
9725 return strstr (str, "blockdev_getbsz") == NULL;
9726 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
9727 if (str && strcmp (str, "1") == 0) return 1;
9728 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
9729 if (str && strcmp (str, "1") == 0) return 1;
9733 static int test_blockdev_getbsz_0 (void)
9735 if (test_blockdev_getbsz_0_skip ()) {
9736 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getbsz_0");
9740 /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
9742 char device[] = "/dev/sda";
9745 r = guestfs_blockdev_setrw (g, device);
9752 r = guestfs_umount_all (g);
9759 r = guestfs_lvm_remove_all (g);
9763 /* TestOutputInt for blockdev_getbsz (0) */
9765 char device[] = "/dev/sda";
9768 r = guestfs_blockdev_getbsz (g, device);
9772 fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n", (int) r);
9779 static int test_blockdev_getss_0_skip (void)
9783 str = getenv ("TEST_ONLY");
9785 return strstr (str, "blockdev_getss") == NULL;
9786 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
9787 if (str && strcmp (str, "1") == 0) return 1;
9788 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
9789 if (str && strcmp (str, "1") == 0) return 1;
9793 static int test_blockdev_getss_0 (void)
9795 if (test_blockdev_getss_0_skip ()) {
9796 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getss_0");
9800 /* InitNone|InitEmpty for test_blockdev_getss_0 */
9802 char device[] = "/dev/sda";
9805 r = guestfs_blockdev_setrw (g, device);
9812 r = guestfs_umount_all (g);
9819 r = guestfs_lvm_remove_all (g);
9823 /* TestOutputInt for blockdev_getss (0) */
9825 char device[] = "/dev/sda";
9828 r = guestfs_blockdev_getss (g, device);
9832 fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n", (int) r);
9839 static int test_blockdev_getro_0_skip (void)
9843 str = getenv ("TEST_ONLY");
9845 return strstr (str, "blockdev_getro") == NULL;
9846 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
9847 if (str && strcmp (str, "1") == 0) return 1;
9848 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
9849 if (str && strcmp (str, "1") == 0) return 1;
9853 static int test_blockdev_getro_0 (void)
9855 if (test_blockdev_getro_0_skip ()) {
9856 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getro_0");
9860 /* InitNone|InitEmpty for test_blockdev_getro_0 */
9862 char device[] = "/dev/sda";
9865 r = guestfs_blockdev_setrw (g, device);
9872 r = guestfs_umount_all (g);
9879 r = guestfs_lvm_remove_all (g);
9883 /* TestOutputTrue for blockdev_getro (0) */
9885 char device[] = "/dev/sda";
9888 r = guestfs_blockdev_setro (g, device);
9893 char device[] = "/dev/sda";
9896 r = guestfs_blockdev_getro (g, device);
9900 fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
9907 static int test_blockdev_setrw_0_skip (void)
9911 str = getenv ("TEST_ONLY");
9913 return strstr (str, "blockdev_setrw") == NULL;
9914 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
9915 if (str && strcmp (str, "1") == 0) return 1;
9916 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
9917 if (str && strcmp (str, "1") == 0) return 1;
9921 static int test_blockdev_setrw_0 (void)
9923 if (test_blockdev_setrw_0_skip ()) {
9924 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setrw_0");
9928 /* InitNone|InitEmpty for test_blockdev_setrw_0 */
9930 char device[] = "/dev/sda";
9933 r = guestfs_blockdev_setrw (g, device);
9940 r = guestfs_umount_all (g);
9947 r = guestfs_lvm_remove_all (g);
9951 /* TestOutputFalse for blockdev_setrw (0) */
9953 char device[] = "/dev/sda";
9956 r = guestfs_blockdev_setrw (g, device);
9961 char device[] = "/dev/sda";
9964 r = guestfs_blockdev_getro (g, device);
9968 fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
9975 static int test_blockdev_setro_0_skip (void)
9979 str = getenv ("TEST_ONLY");
9981 return strstr (str, "blockdev_setro") == NULL;
9982 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
9983 if (str && strcmp (str, "1") == 0) return 1;
9984 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
9985 if (str && strcmp (str, "1") == 0) return 1;
9989 static int test_blockdev_setro_0 (void)
9991 if (test_blockdev_setro_0_skip ()) {
9992 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setro_0");
9996 /* InitNone|InitEmpty for test_blockdev_setro_0 */
9998 char device[] = "/dev/sda";
10000 suppress_error = 0;
10001 r = guestfs_blockdev_setrw (g, device);
10007 suppress_error = 0;
10008 r = guestfs_umount_all (g);
10014 suppress_error = 0;
10015 r = guestfs_lvm_remove_all (g);
10019 /* TestOutputTrue for blockdev_setro (0) */
10021 char device[] = "/dev/sda";
10023 suppress_error = 0;
10024 r = guestfs_blockdev_setro (g, device);
10029 char device[] = "/dev/sda";
10031 suppress_error = 0;
10032 r = guestfs_blockdev_getro (g, device);
10036 fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
10043 static int test_statvfs_0_skip (void)
10047 str = getenv ("TEST_ONLY");
10049 return strstr (str, "statvfs") == NULL;
10050 str = getenv ("SKIP_TEST_STATVFS_0");
10051 if (str && strcmp (str, "1") == 0) return 1;
10052 str = getenv ("SKIP_TEST_STATVFS");
10053 if (str && strcmp (str, "1") == 0) return 1;
10057 static int test_statvfs_0 (void)
10059 if (test_statvfs_0_skip ()) {
10060 printf ("%s skipped (reason: environment variable set)\n", "test_statvfs_0");
10064 /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
10066 char device[] = "/dev/sda";
10068 suppress_error = 0;
10069 r = guestfs_blockdev_setrw (g, device);
10075 suppress_error = 0;
10076 r = guestfs_umount_all (g);
10082 suppress_error = 0;
10083 r = guestfs_lvm_remove_all (g);
10088 char device[] = "/dev/sda";
10089 char lines_0[] = ",";
10095 suppress_error = 0;
10096 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10101 char fstype[] = "ext2";
10102 char device[] = "/dev/sda1";
10104 suppress_error = 0;
10105 r = guestfs_mkfs (g, fstype, device);
10110 char device[] = "/dev/sda1";
10111 char mountpoint[] = "/";
10113 suppress_error = 0;
10114 r = guestfs_mount (g, device, mountpoint);
10118 /* TestOutputStruct for statvfs (0) */
10121 struct guestfs_statvfs *r;
10122 suppress_error = 0;
10123 r = guestfs_statvfs (g, path);
10126 if (r->bfree != 487702) {
10127 fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
10131 if (r->blocks != 490020) {
10132 fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
10136 if (r->bsize != 1024) {
10137 fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
10146 static int test_lstat_0_skip (void)
10150 str = getenv ("TEST_ONLY");
10152 return strstr (str, "lstat") == NULL;
10153 str = getenv ("SKIP_TEST_LSTAT_0");
10154 if (str && strcmp (str, "1") == 0) return 1;
10155 str = getenv ("SKIP_TEST_LSTAT");
10156 if (str && strcmp (str, "1") == 0) return 1;
10160 static int test_lstat_0 (void)
10162 if (test_lstat_0_skip ()) {
10163 printf ("%s skipped (reason: environment variable set)\n", "test_lstat_0");
10167 /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
10169 char device[] = "/dev/sda";
10171 suppress_error = 0;
10172 r = guestfs_blockdev_setrw (g, device);
10178 suppress_error = 0;
10179 r = guestfs_umount_all (g);
10185 suppress_error = 0;
10186 r = guestfs_lvm_remove_all (g);
10191 char device[] = "/dev/sda";
10192 char lines_0[] = ",";
10198 suppress_error = 0;
10199 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10204 char fstype[] = "ext2";
10205 char device[] = "/dev/sda1";
10207 suppress_error = 0;
10208 r = guestfs_mkfs (g, fstype, device);
10213 char device[] = "/dev/sda1";
10214 char mountpoint[] = "/";
10216 suppress_error = 0;
10217 r = guestfs_mount (g, device, mountpoint);
10221 /* TestOutputStruct for lstat (0) */
10223 char path[] = "/new";
10225 suppress_error = 0;
10226 r = guestfs_touch (g, path);
10231 char path[] = "/new";
10232 struct guestfs_stat *r;
10233 suppress_error = 0;
10234 r = guestfs_lstat (g, path);
10237 if (r->size != 0) {
10238 fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
10247 static int test_stat_0_skip (void)
10251 str = getenv ("TEST_ONLY");
10253 return strstr (str, "stat") == NULL;
10254 str = getenv ("SKIP_TEST_STAT_0");
10255 if (str && strcmp (str, "1") == 0) return 1;
10256 str = getenv ("SKIP_TEST_STAT");
10257 if (str && strcmp (str, "1") == 0) return 1;
10261 static int test_stat_0 (void)
10263 if (test_stat_0_skip ()) {
10264 printf ("%s skipped (reason: environment variable set)\n", "test_stat_0");
10268 /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
10270 char device[] = "/dev/sda";
10272 suppress_error = 0;
10273 r = guestfs_blockdev_setrw (g, device);
10279 suppress_error = 0;
10280 r = guestfs_umount_all (g);
10286 suppress_error = 0;
10287 r = guestfs_lvm_remove_all (g);
10292 char device[] = "/dev/sda";
10293 char lines_0[] = ",";
10299 suppress_error = 0;
10300 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10305 char fstype[] = "ext2";
10306 char device[] = "/dev/sda1";
10308 suppress_error = 0;
10309 r = guestfs_mkfs (g, fstype, device);
10314 char device[] = "/dev/sda1";
10315 char mountpoint[] = "/";
10317 suppress_error = 0;
10318 r = guestfs_mount (g, device, mountpoint);
10322 /* TestOutputStruct for stat (0) */
10324 char path[] = "/new";
10326 suppress_error = 0;
10327 r = guestfs_touch (g, path);
10332 char path[] = "/new";
10333 struct guestfs_stat *r;
10334 suppress_error = 0;
10335 r = guestfs_stat (g, path);
10338 if (r->size != 0) {
10339 fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
10348 static int test_command_lines_0_skip (void)
10352 str = getenv ("TEST_ONLY");
10354 return strstr (str, "command_lines") == NULL;
10355 str = getenv ("SKIP_TEST_COMMAND_LINES_0");
10356 if (str && strcmp (str, "1") == 0) return 1;
10357 str = getenv ("SKIP_TEST_COMMAND_LINES");
10358 if (str && strcmp (str, "1") == 0) return 1;
10362 static int test_command_lines_0 (void)
10364 if (test_command_lines_0_skip ()) {
10365 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_0");
10369 /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
10371 char device[] = "/dev/sda";
10373 suppress_error = 0;
10374 r = guestfs_blockdev_setrw (g, device);
10380 suppress_error = 0;
10381 r = guestfs_umount_all (g);
10387 suppress_error = 0;
10388 r = guestfs_lvm_remove_all (g);
10393 char device[] = "/dev/sda";
10394 char lines_0[] = ",";
10400 suppress_error = 0;
10401 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10406 char fstype[] = "ext2";
10407 char device[] = "/dev/sda1";
10409 suppress_error = 0;
10410 r = guestfs_mkfs (g, fstype, device);
10415 char device[] = "/dev/sda1";
10416 char mountpoint[] = "/";
10418 suppress_error = 0;
10419 r = guestfs_mount (g, device, mountpoint);
10423 /* TestOutputList for command_lines (0) */
10425 char remotefilename[] = "/test-command";
10427 suppress_error = 0;
10428 r = guestfs_upload (g, "test-command", remotefilename);
10433 char path[] = "/test-command";
10435 suppress_error = 0;
10436 r = guestfs_chmod (g, 493, path);
10441 char arguments_0[] = "/test-command";
10442 char arguments_1[] = "1";
10443 char *arguments[] = {
10450 suppress_error = 0;
10451 r = guestfs_command_lines (g, arguments);
10455 fprintf (stderr, "test_command_lines_0: short list returned from command\n");
10460 char expected[] = "Result1";
10461 if (strcmp (r[0], expected) != 0) {
10462 fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10466 if (r[1] != NULL) {
10467 fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
10471 for (i = 0; r[i] != NULL; ++i)
10478 static int test_command_lines_1_skip (void)
10482 str = getenv ("TEST_ONLY");
10484 return strstr (str, "command_lines") == NULL;
10485 str = getenv ("SKIP_TEST_COMMAND_LINES_1");
10486 if (str && strcmp (str, "1") == 0) return 1;
10487 str = getenv ("SKIP_TEST_COMMAND_LINES");
10488 if (str && strcmp (str, "1") == 0) return 1;
10492 static int test_command_lines_1 (void)
10494 if (test_command_lines_1_skip ()) {
10495 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_1");
10499 /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
10501 char device[] = "/dev/sda";
10503 suppress_error = 0;
10504 r = guestfs_blockdev_setrw (g, device);
10510 suppress_error = 0;
10511 r = guestfs_umount_all (g);
10517 suppress_error = 0;
10518 r = guestfs_lvm_remove_all (g);
10523 char device[] = "/dev/sda";
10524 char lines_0[] = ",";
10530 suppress_error = 0;
10531 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10536 char fstype[] = "ext2";
10537 char device[] = "/dev/sda1";
10539 suppress_error = 0;
10540 r = guestfs_mkfs (g, fstype, device);
10545 char device[] = "/dev/sda1";
10546 char mountpoint[] = "/";
10548 suppress_error = 0;
10549 r = guestfs_mount (g, device, mountpoint);
10553 /* TestOutputList for command_lines (1) */
10555 char remotefilename[] = "/test-command";
10557 suppress_error = 0;
10558 r = guestfs_upload (g, "test-command", remotefilename);
10563 char path[] = "/test-command";
10565 suppress_error = 0;
10566 r = guestfs_chmod (g, 493, path);
10571 char arguments_0[] = "/test-command";
10572 char arguments_1[] = "2";
10573 char *arguments[] = {
10580 suppress_error = 0;
10581 r = guestfs_command_lines (g, arguments);
10585 fprintf (stderr, "test_command_lines_1: short list returned from command\n");
10590 char expected[] = "Result2";
10591 if (strcmp (r[0], expected) != 0) {
10592 fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10596 if (r[1] != NULL) {
10597 fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
10601 for (i = 0; r[i] != NULL; ++i)
10608 static int test_command_lines_2_skip (void)
10612 str = getenv ("TEST_ONLY");
10614 return strstr (str, "command_lines") == NULL;
10615 str = getenv ("SKIP_TEST_COMMAND_LINES_2");
10616 if (str && strcmp (str, "1") == 0) return 1;
10617 str = getenv ("SKIP_TEST_COMMAND_LINES");
10618 if (str && strcmp (str, "1") == 0) return 1;
10622 static int test_command_lines_2 (void)
10624 if (test_command_lines_2_skip ()) {
10625 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_2");
10629 /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
10631 char device[] = "/dev/sda";
10633 suppress_error = 0;
10634 r = guestfs_blockdev_setrw (g, device);
10640 suppress_error = 0;
10641 r = guestfs_umount_all (g);
10647 suppress_error = 0;
10648 r = guestfs_lvm_remove_all (g);
10653 char device[] = "/dev/sda";
10654 char lines_0[] = ",";
10660 suppress_error = 0;
10661 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10666 char fstype[] = "ext2";
10667 char device[] = "/dev/sda1";
10669 suppress_error = 0;
10670 r = guestfs_mkfs (g, fstype, device);
10675 char device[] = "/dev/sda1";
10676 char mountpoint[] = "/";
10678 suppress_error = 0;
10679 r = guestfs_mount (g, device, mountpoint);
10683 /* TestOutputList for command_lines (2) */
10685 char remotefilename[] = "/test-command";
10687 suppress_error = 0;
10688 r = guestfs_upload (g, "test-command", remotefilename);
10693 char path[] = "/test-command";
10695 suppress_error = 0;
10696 r = guestfs_chmod (g, 493, path);
10701 char arguments_0[] = "/test-command";
10702 char arguments_1[] = "3";
10703 char *arguments[] = {
10710 suppress_error = 0;
10711 r = guestfs_command_lines (g, arguments);
10715 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
10720 char expected[] = "";
10721 if (strcmp (r[0], expected) != 0) {
10722 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10727 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
10732 char expected[] = "Result3";
10733 if (strcmp (r[1], expected) != 0) {
10734 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10738 if (r[2] != NULL) {
10739 fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
10743 for (i = 0; r[i] != NULL; ++i)
10750 static int test_command_lines_3_skip (void)
10754 str = getenv ("TEST_ONLY");
10756 return strstr (str, "command_lines") == NULL;
10757 str = getenv ("SKIP_TEST_COMMAND_LINES_3");
10758 if (str && strcmp (str, "1") == 0) return 1;
10759 str = getenv ("SKIP_TEST_COMMAND_LINES");
10760 if (str && strcmp (str, "1") == 0) return 1;
10764 static int test_command_lines_3 (void)
10766 if (test_command_lines_3_skip ()) {
10767 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_3");
10771 /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
10773 char device[] = "/dev/sda";
10775 suppress_error = 0;
10776 r = guestfs_blockdev_setrw (g, device);
10782 suppress_error = 0;
10783 r = guestfs_umount_all (g);
10789 suppress_error = 0;
10790 r = guestfs_lvm_remove_all (g);
10795 char device[] = "/dev/sda";
10796 char lines_0[] = ",";
10802 suppress_error = 0;
10803 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10808 char fstype[] = "ext2";
10809 char device[] = "/dev/sda1";
10811 suppress_error = 0;
10812 r = guestfs_mkfs (g, fstype, device);
10817 char device[] = "/dev/sda1";
10818 char mountpoint[] = "/";
10820 suppress_error = 0;
10821 r = guestfs_mount (g, device, mountpoint);
10825 /* TestOutputList for command_lines (3) */
10827 char remotefilename[] = "/test-command";
10829 suppress_error = 0;
10830 r = guestfs_upload (g, "test-command", remotefilename);
10835 char path[] = "/test-command";
10837 suppress_error = 0;
10838 r = guestfs_chmod (g, 493, path);
10843 char arguments_0[] = "/test-command";
10844 char arguments_1[] = "4";
10845 char *arguments[] = {
10852 suppress_error = 0;
10853 r = guestfs_command_lines (g, arguments);
10857 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
10862 char expected[] = "";
10863 if (strcmp (r[0], expected) != 0) {
10864 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10869 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
10874 char expected[] = "Result4";
10875 if (strcmp (r[1], expected) != 0) {
10876 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10880 if (r[2] != NULL) {
10881 fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
10885 for (i = 0; r[i] != NULL; ++i)
10892 static int test_command_lines_4_skip (void)
10896 str = getenv ("TEST_ONLY");
10898 return strstr (str, "command_lines") == NULL;
10899 str = getenv ("SKIP_TEST_COMMAND_LINES_4");
10900 if (str && strcmp (str, "1") == 0) return 1;
10901 str = getenv ("SKIP_TEST_COMMAND_LINES");
10902 if (str && strcmp (str, "1") == 0) return 1;
10906 static int test_command_lines_4 (void)
10908 if (test_command_lines_4_skip ()) {
10909 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_4");
10913 /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
10915 char device[] = "/dev/sda";
10917 suppress_error = 0;
10918 r = guestfs_blockdev_setrw (g, device);
10924 suppress_error = 0;
10925 r = guestfs_umount_all (g);
10931 suppress_error = 0;
10932 r = guestfs_lvm_remove_all (g);
10937 char device[] = "/dev/sda";
10938 char lines_0[] = ",";
10944 suppress_error = 0;
10945 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10950 char fstype[] = "ext2";
10951 char device[] = "/dev/sda1";
10953 suppress_error = 0;
10954 r = guestfs_mkfs (g, fstype, device);
10959 char device[] = "/dev/sda1";
10960 char mountpoint[] = "/";
10962 suppress_error = 0;
10963 r = guestfs_mount (g, device, mountpoint);
10967 /* TestOutputList for command_lines (4) */
10969 char remotefilename[] = "/test-command";
10971 suppress_error = 0;
10972 r = guestfs_upload (g, "test-command", remotefilename);
10977 char path[] = "/test-command";
10979 suppress_error = 0;
10980 r = guestfs_chmod (g, 493, path);
10985 char arguments_0[] = "/test-command";
10986 char arguments_1[] = "5";
10987 char *arguments[] = {
10994 suppress_error = 0;
10995 r = guestfs_command_lines (g, arguments);
10999 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
11004 char expected[] = "";
11005 if (strcmp (r[0], expected) != 0) {
11006 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11011 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
11016 char expected[] = "Result5";
11017 if (strcmp (r[1], expected) != 0) {
11018 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11023 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
11028 char expected[] = "";
11029 if (strcmp (r[2], expected) != 0) {
11030 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11034 if (r[3] != NULL) {
11035 fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
11039 for (i = 0; r[i] != NULL; ++i)
11046 static int test_command_lines_5_skip (void)
11050 str = getenv ("TEST_ONLY");
11052 return strstr (str, "command_lines") == NULL;
11053 str = getenv ("SKIP_TEST_COMMAND_LINES_5");
11054 if (str && strcmp (str, "1") == 0) return 1;
11055 str = getenv ("SKIP_TEST_COMMAND_LINES");
11056 if (str && strcmp (str, "1") == 0) return 1;
11060 static int test_command_lines_5 (void)
11062 if (test_command_lines_5_skip ()) {
11063 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_5");
11067 /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
11069 char device[] = "/dev/sda";
11071 suppress_error = 0;
11072 r = guestfs_blockdev_setrw (g, device);
11078 suppress_error = 0;
11079 r = guestfs_umount_all (g);
11085 suppress_error = 0;
11086 r = guestfs_lvm_remove_all (g);
11091 char device[] = "/dev/sda";
11092 char lines_0[] = ",";
11098 suppress_error = 0;
11099 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11104 char fstype[] = "ext2";
11105 char device[] = "/dev/sda1";
11107 suppress_error = 0;
11108 r = guestfs_mkfs (g, fstype, device);
11113 char device[] = "/dev/sda1";
11114 char mountpoint[] = "/";
11116 suppress_error = 0;
11117 r = guestfs_mount (g, device, mountpoint);
11121 /* TestOutputList for command_lines (5) */
11123 char remotefilename[] = "/test-command";
11125 suppress_error = 0;
11126 r = guestfs_upload (g, "test-command", remotefilename);
11131 char path[] = "/test-command";
11133 suppress_error = 0;
11134 r = guestfs_chmod (g, 493, path);
11139 char arguments_0[] = "/test-command";
11140 char arguments_1[] = "6";
11141 char *arguments[] = {
11148 suppress_error = 0;
11149 r = guestfs_command_lines (g, arguments);
11153 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
11158 char expected[] = "";
11159 if (strcmp (r[0], expected) != 0) {
11160 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11165 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
11170 char expected[] = "";
11171 if (strcmp (r[1], expected) != 0) {
11172 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11177 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
11182 char expected[] = "Result6";
11183 if (strcmp (r[2], expected) != 0) {
11184 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11189 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
11194 char expected[] = "";
11195 if (strcmp (r[3], expected) != 0) {
11196 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
11200 if (r[4] != NULL) {
11201 fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
11205 for (i = 0; r[i] != NULL; ++i)
11212 static int test_command_lines_6_skip (void)
11216 str = getenv ("TEST_ONLY");
11218 return strstr (str, "command_lines") == NULL;
11219 str = getenv ("SKIP_TEST_COMMAND_LINES_6");
11220 if (str && strcmp (str, "1") == 0) return 1;
11221 str = getenv ("SKIP_TEST_COMMAND_LINES");
11222 if (str && strcmp (str, "1") == 0) return 1;
11226 static int test_command_lines_6 (void)
11228 if (test_command_lines_6_skip ()) {
11229 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_6");
11233 /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
11235 char device[] = "/dev/sda";
11237 suppress_error = 0;
11238 r = guestfs_blockdev_setrw (g, device);
11244 suppress_error = 0;
11245 r = guestfs_umount_all (g);
11251 suppress_error = 0;
11252 r = guestfs_lvm_remove_all (g);
11257 char device[] = "/dev/sda";
11258 char lines_0[] = ",";
11264 suppress_error = 0;
11265 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11270 char fstype[] = "ext2";
11271 char device[] = "/dev/sda1";
11273 suppress_error = 0;
11274 r = guestfs_mkfs (g, fstype, device);
11279 char device[] = "/dev/sda1";
11280 char mountpoint[] = "/";
11282 suppress_error = 0;
11283 r = guestfs_mount (g, device, mountpoint);
11287 /* TestOutputList for command_lines (6) */
11289 char remotefilename[] = "/test-command";
11291 suppress_error = 0;
11292 r = guestfs_upload (g, "test-command", remotefilename);
11297 char path[] = "/test-command";
11299 suppress_error = 0;
11300 r = guestfs_chmod (g, 493, path);
11305 char arguments_0[] = "/test-command";
11306 char arguments_1[] = "7";
11307 char *arguments[] = {
11314 suppress_error = 0;
11315 r = guestfs_command_lines (g, arguments);
11318 if (r[0] != NULL) {
11319 fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
11323 for (i = 0; r[i] != NULL; ++i)
11330 static int test_command_lines_7_skip (void)
11334 str = getenv ("TEST_ONLY");
11336 return strstr (str, "command_lines") == NULL;
11337 str = getenv ("SKIP_TEST_COMMAND_LINES_7");
11338 if (str && strcmp (str, "1") == 0) return 1;
11339 str = getenv ("SKIP_TEST_COMMAND_LINES");
11340 if (str && strcmp (str, "1") == 0) return 1;
11344 static int test_command_lines_7 (void)
11346 if (test_command_lines_7_skip ()) {
11347 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_7");
11351 /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
11353 char device[] = "/dev/sda";
11355 suppress_error = 0;
11356 r = guestfs_blockdev_setrw (g, device);
11362 suppress_error = 0;
11363 r = guestfs_umount_all (g);
11369 suppress_error = 0;
11370 r = guestfs_lvm_remove_all (g);
11375 char device[] = "/dev/sda";
11376 char lines_0[] = ",";
11382 suppress_error = 0;
11383 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11388 char fstype[] = "ext2";
11389 char device[] = "/dev/sda1";
11391 suppress_error = 0;
11392 r = guestfs_mkfs (g, fstype, device);
11397 char device[] = "/dev/sda1";
11398 char mountpoint[] = "/";
11400 suppress_error = 0;
11401 r = guestfs_mount (g, device, mountpoint);
11405 /* TestOutputList for command_lines (7) */
11407 char remotefilename[] = "/test-command";
11409 suppress_error = 0;
11410 r = guestfs_upload (g, "test-command", remotefilename);
11415 char path[] = "/test-command";
11417 suppress_error = 0;
11418 r = guestfs_chmod (g, 493, path);
11423 char arguments_0[] = "/test-command";
11424 char arguments_1[] = "8";
11425 char *arguments[] = {
11432 suppress_error = 0;
11433 r = guestfs_command_lines (g, arguments);
11437 fprintf (stderr, "test_command_lines_7: short list returned from command\n");
11442 char expected[] = "";
11443 if (strcmp (r[0], expected) != 0) {
11444 fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11448 if (r[1] != NULL) {
11449 fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
11453 for (i = 0; r[i] != NULL; ++i)
11460 static int test_command_lines_8_skip (void)
11464 str = getenv ("TEST_ONLY");
11466 return strstr (str, "command_lines") == NULL;
11467 str = getenv ("SKIP_TEST_COMMAND_LINES_8");
11468 if (str && strcmp (str, "1") == 0) return 1;
11469 str = getenv ("SKIP_TEST_COMMAND_LINES");
11470 if (str && strcmp (str, "1") == 0) return 1;
11474 static int test_command_lines_8 (void)
11476 if (test_command_lines_8_skip ()) {
11477 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_8");
11481 /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
11483 char device[] = "/dev/sda";
11485 suppress_error = 0;
11486 r = guestfs_blockdev_setrw (g, device);
11492 suppress_error = 0;
11493 r = guestfs_umount_all (g);
11499 suppress_error = 0;
11500 r = guestfs_lvm_remove_all (g);
11505 char device[] = "/dev/sda";
11506 char lines_0[] = ",";
11512 suppress_error = 0;
11513 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11518 char fstype[] = "ext2";
11519 char device[] = "/dev/sda1";
11521 suppress_error = 0;
11522 r = guestfs_mkfs (g, fstype, device);
11527 char device[] = "/dev/sda1";
11528 char mountpoint[] = "/";
11530 suppress_error = 0;
11531 r = guestfs_mount (g, device, mountpoint);
11535 /* TestOutputList for command_lines (8) */
11537 char remotefilename[] = "/test-command";
11539 suppress_error = 0;
11540 r = guestfs_upload (g, "test-command", remotefilename);
11545 char path[] = "/test-command";
11547 suppress_error = 0;
11548 r = guestfs_chmod (g, 493, path);
11553 char arguments_0[] = "/test-command";
11554 char arguments_1[] = "9";
11555 char *arguments[] = {
11562 suppress_error = 0;
11563 r = guestfs_command_lines (g, arguments);
11567 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
11572 char expected[] = "";
11573 if (strcmp (r[0], expected) != 0) {
11574 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11579 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
11584 char expected[] = "";
11585 if (strcmp (r[1], expected) != 0) {
11586 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11590 if (r[2] != NULL) {
11591 fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
11595 for (i = 0; r[i] != NULL; ++i)
11602 static int test_command_lines_9_skip (void)
11606 str = getenv ("TEST_ONLY");
11608 return strstr (str, "command_lines") == NULL;
11609 str = getenv ("SKIP_TEST_COMMAND_LINES_9");
11610 if (str && strcmp (str, "1") == 0) return 1;
11611 str = getenv ("SKIP_TEST_COMMAND_LINES");
11612 if (str && strcmp (str, "1") == 0) return 1;
11616 static int test_command_lines_9 (void)
11618 if (test_command_lines_9_skip ()) {
11619 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_9");
11623 /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
11625 char device[] = "/dev/sda";
11627 suppress_error = 0;
11628 r = guestfs_blockdev_setrw (g, device);
11634 suppress_error = 0;
11635 r = guestfs_umount_all (g);
11641 suppress_error = 0;
11642 r = guestfs_lvm_remove_all (g);
11647 char device[] = "/dev/sda";
11648 char lines_0[] = ",";
11654 suppress_error = 0;
11655 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11660 char fstype[] = "ext2";
11661 char device[] = "/dev/sda1";
11663 suppress_error = 0;
11664 r = guestfs_mkfs (g, fstype, device);
11669 char device[] = "/dev/sda1";
11670 char mountpoint[] = "/";
11672 suppress_error = 0;
11673 r = guestfs_mount (g, device, mountpoint);
11677 /* TestOutputList for command_lines (9) */
11679 char remotefilename[] = "/test-command";
11681 suppress_error = 0;
11682 r = guestfs_upload (g, "test-command", remotefilename);
11687 char path[] = "/test-command";
11689 suppress_error = 0;
11690 r = guestfs_chmod (g, 493, path);
11695 char arguments_0[] = "/test-command";
11696 char arguments_1[] = "10";
11697 char *arguments[] = {
11704 suppress_error = 0;
11705 r = guestfs_command_lines (g, arguments);
11709 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
11714 char expected[] = "Result10-1";
11715 if (strcmp (r[0], expected) != 0) {
11716 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11721 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
11726 char expected[] = "Result10-2";
11727 if (strcmp (r[1], expected) != 0) {
11728 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11732 if (r[2] != NULL) {
11733 fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
11737 for (i = 0; r[i] != NULL; ++i)
11744 static int test_command_lines_10_skip (void)
11748 str = getenv ("TEST_ONLY");
11750 return strstr (str, "command_lines") == NULL;
11751 str = getenv ("SKIP_TEST_COMMAND_LINES_10");
11752 if (str && strcmp (str, "1") == 0) return 1;
11753 str = getenv ("SKIP_TEST_COMMAND_LINES");
11754 if (str && strcmp (str, "1") == 0) return 1;
11758 static int test_command_lines_10 (void)
11760 if (test_command_lines_10_skip ()) {
11761 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_10");
11765 /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
11767 char device[] = "/dev/sda";
11769 suppress_error = 0;
11770 r = guestfs_blockdev_setrw (g, device);
11776 suppress_error = 0;
11777 r = guestfs_umount_all (g);
11783 suppress_error = 0;
11784 r = guestfs_lvm_remove_all (g);
11789 char device[] = "/dev/sda";
11790 char lines_0[] = ",";
11796 suppress_error = 0;
11797 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11802 char fstype[] = "ext2";
11803 char device[] = "/dev/sda1";
11805 suppress_error = 0;
11806 r = guestfs_mkfs (g, fstype, device);
11811 char device[] = "/dev/sda1";
11812 char mountpoint[] = "/";
11814 suppress_error = 0;
11815 r = guestfs_mount (g, device, mountpoint);
11819 /* TestOutputList for command_lines (10) */
11821 char remotefilename[] = "/test-command";
11823 suppress_error = 0;
11824 r = guestfs_upload (g, "test-command", remotefilename);
11829 char path[] = "/test-command";
11831 suppress_error = 0;
11832 r = guestfs_chmod (g, 493, path);
11837 char arguments_0[] = "/test-command";
11838 char arguments_1[] = "11";
11839 char *arguments[] = {
11846 suppress_error = 0;
11847 r = guestfs_command_lines (g, arguments);
11851 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
11856 char expected[] = "Result11-1";
11857 if (strcmp (r[0], expected) != 0) {
11858 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11863 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
11868 char expected[] = "Result11-2";
11869 if (strcmp (r[1], expected) != 0) {
11870 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11874 if (r[2] != NULL) {
11875 fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
11879 for (i = 0; r[i] != NULL; ++i)
11886 static int test_command_0_skip (void)
11890 str = getenv ("TEST_ONLY");
11892 return strstr (str, "command") == NULL;
11893 str = getenv ("SKIP_TEST_COMMAND_0");
11894 if (str && strcmp (str, "1") == 0) return 1;
11895 str = getenv ("SKIP_TEST_COMMAND");
11896 if (str && strcmp (str, "1") == 0) return 1;
11900 static int test_command_0 (void)
11902 if (test_command_0_skip ()) {
11903 printf ("%s skipped (reason: environment variable set)\n", "test_command_0");
11907 /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
11909 char device[] = "/dev/sda";
11911 suppress_error = 0;
11912 r = guestfs_blockdev_setrw (g, device);
11918 suppress_error = 0;
11919 r = guestfs_umount_all (g);
11925 suppress_error = 0;
11926 r = guestfs_lvm_remove_all (g);
11931 char device[] = "/dev/sda";
11932 char lines_0[] = ",";
11938 suppress_error = 0;
11939 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11944 char fstype[] = "ext2";
11945 char device[] = "/dev/sda1";
11947 suppress_error = 0;
11948 r = guestfs_mkfs (g, fstype, device);
11953 char device[] = "/dev/sda1";
11954 char mountpoint[] = "/";
11956 suppress_error = 0;
11957 r = guestfs_mount (g, device, mountpoint);
11961 /* TestOutput for command (0) */
11962 char expected[] = "Result1";
11964 char remotefilename[] = "/test-command";
11966 suppress_error = 0;
11967 r = guestfs_upload (g, "test-command", remotefilename);
11972 char path[] = "/test-command";
11974 suppress_error = 0;
11975 r = guestfs_chmod (g, 493, path);
11980 char arguments_0[] = "/test-command";
11981 char arguments_1[] = "1";
11982 char *arguments[] = {
11988 suppress_error = 0;
11989 r = guestfs_command (g, arguments);
11992 if (strcmp (r, expected) != 0) {
11993 fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
12001 static int test_command_1_skip (void)
12005 str = getenv ("TEST_ONLY");
12007 return strstr (str, "command") == NULL;
12008 str = getenv ("SKIP_TEST_COMMAND_1");
12009 if (str && strcmp (str, "1") == 0) return 1;
12010 str = getenv ("SKIP_TEST_COMMAND");
12011 if (str && strcmp (str, "1") == 0) return 1;
12015 static int test_command_1 (void)
12017 if (test_command_1_skip ()) {
12018 printf ("%s skipped (reason: environment variable set)\n", "test_command_1");
12022 /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
12024 char device[] = "/dev/sda";
12026 suppress_error = 0;
12027 r = guestfs_blockdev_setrw (g, device);
12033 suppress_error = 0;
12034 r = guestfs_umount_all (g);
12040 suppress_error = 0;
12041 r = guestfs_lvm_remove_all (g);
12046 char device[] = "/dev/sda";
12047 char lines_0[] = ",";
12053 suppress_error = 0;
12054 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12059 char fstype[] = "ext2";
12060 char device[] = "/dev/sda1";
12062 suppress_error = 0;
12063 r = guestfs_mkfs (g, fstype, device);
12068 char device[] = "/dev/sda1";
12069 char mountpoint[] = "/";
12071 suppress_error = 0;
12072 r = guestfs_mount (g, device, mountpoint);
12076 /* TestOutput for command (1) */
12077 char expected[] = "Result2\n";
12079 char remotefilename[] = "/test-command";
12081 suppress_error = 0;
12082 r = guestfs_upload (g, "test-command", remotefilename);
12087 char path[] = "/test-command";
12089 suppress_error = 0;
12090 r = guestfs_chmod (g, 493, path);
12095 char arguments_0[] = "/test-command";
12096 char arguments_1[] = "2";
12097 char *arguments[] = {
12103 suppress_error = 0;
12104 r = guestfs_command (g, arguments);
12107 if (strcmp (r, expected) != 0) {
12108 fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
12116 static int test_command_2_skip (void)
12120 str = getenv ("TEST_ONLY");
12122 return strstr (str, "command") == NULL;
12123 str = getenv ("SKIP_TEST_COMMAND_2");
12124 if (str && strcmp (str, "1") == 0) return 1;
12125 str = getenv ("SKIP_TEST_COMMAND");
12126 if (str && strcmp (str, "1") == 0) return 1;
12130 static int test_command_2 (void)
12132 if (test_command_2_skip ()) {
12133 printf ("%s skipped (reason: environment variable set)\n", "test_command_2");
12137 /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
12139 char device[] = "/dev/sda";
12141 suppress_error = 0;
12142 r = guestfs_blockdev_setrw (g, device);
12148 suppress_error = 0;
12149 r = guestfs_umount_all (g);
12155 suppress_error = 0;
12156 r = guestfs_lvm_remove_all (g);
12161 char device[] = "/dev/sda";
12162 char lines_0[] = ",";
12168 suppress_error = 0;
12169 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12174 char fstype[] = "ext2";
12175 char device[] = "/dev/sda1";
12177 suppress_error = 0;
12178 r = guestfs_mkfs (g, fstype, device);
12183 char device[] = "/dev/sda1";
12184 char mountpoint[] = "/";
12186 suppress_error = 0;
12187 r = guestfs_mount (g, device, mountpoint);
12191 /* TestOutput for command (2) */
12192 char expected[] = "\nResult3";
12194 char remotefilename[] = "/test-command";
12196 suppress_error = 0;
12197 r = guestfs_upload (g, "test-command", remotefilename);
12202 char path[] = "/test-command";
12204 suppress_error = 0;
12205 r = guestfs_chmod (g, 493, path);
12210 char arguments_0[] = "/test-command";
12211 char arguments_1[] = "3";
12212 char *arguments[] = {
12218 suppress_error = 0;
12219 r = guestfs_command (g, arguments);
12222 if (strcmp (r, expected) != 0) {
12223 fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
12231 static int test_command_3_skip (void)
12235 str = getenv ("TEST_ONLY");
12237 return strstr (str, "command") == NULL;
12238 str = getenv ("SKIP_TEST_COMMAND_3");
12239 if (str && strcmp (str, "1") == 0) return 1;
12240 str = getenv ("SKIP_TEST_COMMAND");
12241 if (str && strcmp (str, "1") == 0) return 1;
12245 static int test_command_3 (void)
12247 if (test_command_3_skip ()) {
12248 printf ("%s skipped (reason: environment variable set)\n", "test_command_3");
12252 /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
12254 char device[] = "/dev/sda";
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 char lines_0[] = ",";
12283 suppress_error = 0;
12284 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12289 char fstype[] = "ext2";
12290 char device[] = "/dev/sda1";
12292 suppress_error = 0;
12293 r = guestfs_mkfs (g, fstype, device);
12298 char device[] = "/dev/sda1";
12299 char mountpoint[] = "/";
12301 suppress_error = 0;
12302 r = guestfs_mount (g, device, mountpoint);
12306 /* TestOutput for command (3) */
12307 char expected[] = "\nResult4\n";
12309 char remotefilename[] = "/test-command";
12311 suppress_error = 0;
12312 r = guestfs_upload (g, "test-command", remotefilename);
12317 char path[] = "/test-command";
12319 suppress_error = 0;
12320 r = guestfs_chmod (g, 493, path);
12325 char arguments_0[] = "/test-command";
12326 char arguments_1[] = "4";
12327 char *arguments[] = {
12333 suppress_error = 0;
12334 r = guestfs_command (g, arguments);
12337 if (strcmp (r, expected) != 0) {
12338 fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
12346 static int test_command_4_skip (void)
12350 str = getenv ("TEST_ONLY");
12352 return strstr (str, "command") == NULL;
12353 str = getenv ("SKIP_TEST_COMMAND_4");
12354 if (str && strcmp (str, "1") == 0) return 1;
12355 str = getenv ("SKIP_TEST_COMMAND");
12356 if (str && strcmp (str, "1") == 0) return 1;
12360 static int test_command_4 (void)
12362 if (test_command_4_skip ()) {
12363 printf ("%s skipped (reason: environment variable set)\n", "test_command_4");
12367 /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
12369 char device[] = "/dev/sda";
12371 suppress_error = 0;
12372 r = guestfs_blockdev_setrw (g, device);
12378 suppress_error = 0;
12379 r = guestfs_umount_all (g);
12385 suppress_error = 0;
12386 r = guestfs_lvm_remove_all (g);
12391 char device[] = "/dev/sda";
12392 char lines_0[] = ",";
12398 suppress_error = 0;
12399 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12404 char fstype[] = "ext2";
12405 char device[] = "/dev/sda1";
12407 suppress_error = 0;
12408 r = guestfs_mkfs (g, fstype, device);
12413 char device[] = "/dev/sda1";
12414 char mountpoint[] = "/";
12416 suppress_error = 0;
12417 r = guestfs_mount (g, device, mountpoint);
12421 /* TestOutput for command (4) */
12422 char expected[] = "\nResult5\n\n";
12424 char remotefilename[] = "/test-command";
12426 suppress_error = 0;
12427 r = guestfs_upload (g, "test-command", remotefilename);
12432 char path[] = "/test-command";
12434 suppress_error = 0;
12435 r = guestfs_chmod (g, 493, path);
12440 char arguments_0[] = "/test-command";
12441 char arguments_1[] = "5";
12442 char *arguments[] = {
12448 suppress_error = 0;
12449 r = guestfs_command (g, arguments);
12452 if (strcmp (r, expected) != 0) {
12453 fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
12461 static int test_command_5_skip (void)
12465 str = getenv ("TEST_ONLY");
12467 return strstr (str, "command") == NULL;
12468 str = getenv ("SKIP_TEST_COMMAND_5");
12469 if (str && strcmp (str, "1") == 0) return 1;
12470 str = getenv ("SKIP_TEST_COMMAND");
12471 if (str && strcmp (str, "1") == 0) return 1;
12475 static int test_command_5 (void)
12477 if (test_command_5_skip ()) {
12478 printf ("%s skipped (reason: environment variable set)\n", "test_command_5");
12482 /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
12484 char device[] = "/dev/sda";
12486 suppress_error = 0;
12487 r = guestfs_blockdev_setrw (g, device);
12493 suppress_error = 0;
12494 r = guestfs_umount_all (g);
12500 suppress_error = 0;
12501 r = guestfs_lvm_remove_all (g);
12506 char device[] = "/dev/sda";
12507 char lines_0[] = ",";
12513 suppress_error = 0;
12514 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12519 char fstype[] = "ext2";
12520 char device[] = "/dev/sda1";
12522 suppress_error = 0;
12523 r = guestfs_mkfs (g, fstype, device);
12528 char device[] = "/dev/sda1";
12529 char mountpoint[] = "/";
12531 suppress_error = 0;
12532 r = guestfs_mount (g, device, mountpoint);
12536 /* TestOutput for command (5) */
12537 char expected[] = "\n\nResult6\n\n";
12539 char remotefilename[] = "/test-command";
12541 suppress_error = 0;
12542 r = guestfs_upload (g, "test-command", remotefilename);
12547 char path[] = "/test-command";
12549 suppress_error = 0;
12550 r = guestfs_chmod (g, 493, path);
12555 char arguments_0[] = "/test-command";
12556 char arguments_1[] = "6";
12557 char *arguments[] = {
12563 suppress_error = 0;
12564 r = guestfs_command (g, arguments);
12567 if (strcmp (r, expected) != 0) {
12568 fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
12576 static int test_command_6_skip (void)
12580 str = getenv ("TEST_ONLY");
12582 return strstr (str, "command") == NULL;
12583 str = getenv ("SKIP_TEST_COMMAND_6");
12584 if (str && strcmp (str, "1") == 0) return 1;
12585 str = getenv ("SKIP_TEST_COMMAND");
12586 if (str && strcmp (str, "1") == 0) return 1;
12590 static int test_command_6 (void)
12592 if (test_command_6_skip ()) {
12593 printf ("%s skipped (reason: environment variable set)\n", "test_command_6");
12597 /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
12599 char device[] = "/dev/sda";
12601 suppress_error = 0;
12602 r = guestfs_blockdev_setrw (g, device);
12608 suppress_error = 0;
12609 r = guestfs_umount_all (g);
12615 suppress_error = 0;
12616 r = guestfs_lvm_remove_all (g);
12621 char device[] = "/dev/sda";
12622 char lines_0[] = ",";
12628 suppress_error = 0;
12629 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12634 char fstype[] = "ext2";
12635 char device[] = "/dev/sda1";
12637 suppress_error = 0;
12638 r = guestfs_mkfs (g, fstype, device);
12643 char device[] = "/dev/sda1";
12644 char mountpoint[] = "/";
12646 suppress_error = 0;
12647 r = guestfs_mount (g, device, mountpoint);
12651 /* TestOutput for command (6) */
12652 char expected[] = "";
12654 char remotefilename[] = "/test-command";
12656 suppress_error = 0;
12657 r = guestfs_upload (g, "test-command", remotefilename);
12662 char path[] = "/test-command";
12664 suppress_error = 0;
12665 r = guestfs_chmod (g, 493, path);
12670 char arguments_0[] = "/test-command";
12671 char arguments_1[] = "7";
12672 char *arguments[] = {
12678 suppress_error = 0;
12679 r = guestfs_command (g, arguments);
12682 if (strcmp (r, expected) != 0) {
12683 fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
12691 static int test_command_7_skip (void)
12695 str = getenv ("TEST_ONLY");
12697 return strstr (str, "command") == NULL;
12698 str = getenv ("SKIP_TEST_COMMAND_7");
12699 if (str && strcmp (str, "1") == 0) return 1;
12700 str = getenv ("SKIP_TEST_COMMAND");
12701 if (str && strcmp (str, "1") == 0) return 1;
12705 static int test_command_7 (void)
12707 if (test_command_7_skip ()) {
12708 printf ("%s skipped (reason: environment variable set)\n", "test_command_7");
12712 /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
12714 char device[] = "/dev/sda";
12716 suppress_error = 0;
12717 r = guestfs_blockdev_setrw (g, device);
12723 suppress_error = 0;
12724 r = guestfs_umount_all (g);
12730 suppress_error = 0;
12731 r = guestfs_lvm_remove_all (g);
12736 char device[] = "/dev/sda";
12737 char lines_0[] = ",";
12743 suppress_error = 0;
12744 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12749 char fstype[] = "ext2";
12750 char device[] = "/dev/sda1";
12752 suppress_error = 0;
12753 r = guestfs_mkfs (g, fstype, device);
12758 char device[] = "/dev/sda1";
12759 char mountpoint[] = "/";
12761 suppress_error = 0;
12762 r = guestfs_mount (g, device, mountpoint);
12766 /* TestOutput for command (7) */
12767 char expected[] = "\n";
12769 char remotefilename[] = "/test-command";
12771 suppress_error = 0;
12772 r = guestfs_upload (g, "test-command", remotefilename);
12777 char path[] = "/test-command";
12779 suppress_error = 0;
12780 r = guestfs_chmod (g, 493, path);
12785 char arguments_0[] = "/test-command";
12786 char arguments_1[] = "8";
12787 char *arguments[] = {
12793 suppress_error = 0;
12794 r = guestfs_command (g, arguments);
12797 if (strcmp (r, expected) != 0) {
12798 fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
12806 static int test_command_8_skip (void)
12810 str = getenv ("TEST_ONLY");
12812 return strstr (str, "command") == NULL;
12813 str = getenv ("SKIP_TEST_COMMAND_8");
12814 if (str && strcmp (str, "1") == 0) return 1;
12815 str = getenv ("SKIP_TEST_COMMAND");
12816 if (str && strcmp (str, "1") == 0) return 1;
12820 static int test_command_8 (void)
12822 if (test_command_8_skip ()) {
12823 printf ("%s skipped (reason: environment variable set)\n", "test_command_8");
12827 /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
12829 char device[] = "/dev/sda";
12831 suppress_error = 0;
12832 r = guestfs_blockdev_setrw (g, device);
12838 suppress_error = 0;
12839 r = guestfs_umount_all (g);
12845 suppress_error = 0;
12846 r = guestfs_lvm_remove_all (g);
12851 char device[] = "/dev/sda";
12852 char lines_0[] = ",";
12858 suppress_error = 0;
12859 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12864 char fstype[] = "ext2";
12865 char device[] = "/dev/sda1";
12867 suppress_error = 0;
12868 r = guestfs_mkfs (g, fstype, device);
12873 char device[] = "/dev/sda1";
12874 char mountpoint[] = "/";
12876 suppress_error = 0;
12877 r = guestfs_mount (g, device, mountpoint);
12881 /* TestOutput for command (8) */
12882 char expected[] = "\n\n";
12884 char remotefilename[] = "/test-command";
12886 suppress_error = 0;
12887 r = guestfs_upload (g, "test-command", remotefilename);
12892 char path[] = "/test-command";
12894 suppress_error = 0;
12895 r = guestfs_chmod (g, 493, path);
12900 char arguments_0[] = "/test-command";
12901 char arguments_1[] = "9";
12902 char *arguments[] = {
12908 suppress_error = 0;
12909 r = guestfs_command (g, arguments);
12912 if (strcmp (r, expected) != 0) {
12913 fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
12921 static int test_command_9_skip (void)
12925 str = getenv ("TEST_ONLY");
12927 return strstr (str, "command") == NULL;
12928 str = getenv ("SKIP_TEST_COMMAND_9");
12929 if (str && strcmp (str, "1") == 0) return 1;
12930 str = getenv ("SKIP_TEST_COMMAND");
12931 if (str && strcmp (str, "1") == 0) return 1;
12935 static int test_command_9 (void)
12937 if (test_command_9_skip ()) {
12938 printf ("%s skipped (reason: environment variable set)\n", "test_command_9");
12942 /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
12944 char device[] = "/dev/sda";
12946 suppress_error = 0;
12947 r = guestfs_blockdev_setrw (g, device);
12953 suppress_error = 0;
12954 r = guestfs_umount_all (g);
12960 suppress_error = 0;
12961 r = guestfs_lvm_remove_all (g);
12966 char device[] = "/dev/sda";
12967 char lines_0[] = ",";
12973 suppress_error = 0;
12974 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12979 char fstype[] = "ext2";
12980 char device[] = "/dev/sda1";
12982 suppress_error = 0;
12983 r = guestfs_mkfs (g, fstype, device);
12988 char device[] = "/dev/sda1";
12989 char mountpoint[] = "/";
12991 suppress_error = 0;
12992 r = guestfs_mount (g, device, mountpoint);
12996 /* TestOutput for command (9) */
12997 char expected[] = "Result10-1\nResult10-2\n";
12999 char remotefilename[] = "/test-command";
13001 suppress_error = 0;
13002 r = guestfs_upload (g, "test-command", remotefilename);
13007 char path[] = "/test-command";
13009 suppress_error = 0;
13010 r = guestfs_chmod (g, 493, path);
13015 char arguments_0[] = "/test-command";
13016 char arguments_1[] = "10";
13017 char *arguments[] = {
13023 suppress_error = 0;
13024 r = guestfs_command (g, arguments);
13027 if (strcmp (r, expected) != 0) {
13028 fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
13036 static int test_command_10_skip (void)
13040 str = getenv ("TEST_ONLY");
13042 return strstr (str, "command") == NULL;
13043 str = getenv ("SKIP_TEST_COMMAND_10");
13044 if (str && strcmp (str, "1") == 0) return 1;
13045 str = getenv ("SKIP_TEST_COMMAND");
13046 if (str && strcmp (str, "1") == 0) return 1;
13050 static int test_command_10 (void)
13052 if (test_command_10_skip ()) {
13053 printf ("%s skipped (reason: environment variable set)\n", "test_command_10");
13057 /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
13059 char device[] = "/dev/sda";
13061 suppress_error = 0;
13062 r = guestfs_blockdev_setrw (g, device);
13068 suppress_error = 0;
13069 r = guestfs_umount_all (g);
13075 suppress_error = 0;
13076 r = guestfs_lvm_remove_all (g);
13081 char device[] = "/dev/sda";
13082 char lines_0[] = ",";
13088 suppress_error = 0;
13089 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13094 char fstype[] = "ext2";
13095 char device[] = "/dev/sda1";
13097 suppress_error = 0;
13098 r = guestfs_mkfs (g, fstype, device);
13103 char device[] = "/dev/sda1";
13104 char mountpoint[] = "/";
13106 suppress_error = 0;
13107 r = guestfs_mount (g, device, mountpoint);
13111 /* TestOutput for command (10) */
13112 char expected[] = "Result11-1\nResult11-2";
13114 char remotefilename[] = "/test-command";
13116 suppress_error = 0;
13117 r = guestfs_upload (g, "test-command", remotefilename);
13122 char path[] = "/test-command";
13124 suppress_error = 0;
13125 r = guestfs_chmod (g, 493, path);
13130 char arguments_0[] = "/test-command";
13131 char arguments_1[] = "11";
13132 char *arguments[] = {
13138 suppress_error = 0;
13139 r = guestfs_command (g, arguments);
13142 if (strcmp (r, expected) != 0) {
13143 fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
13151 static int test_command_11_skip (void)
13155 str = getenv ("TEST_ONLY");
13157 return strstr (str, "command") == NULL;
13158 str = getenv ("SKIP_TEST_COMMAND_11");
13159 if (str && strcmp (str, "1") == 0) return 1;
13160 str = getenv ("SKIP_TEST_COMMAND");
13161 if (str && strcmp (str, "1") == 0) return 1;
13165 static int test_command_11 (void)
13167 if (test_command_11_skip ()) {
13168 printf ("%s skipped (reason: environment variable set)\n", "test_command_11");
13172 /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
13174 char device[] = "/dev/sda";
13176 suppress_error = 0;
13177 r = guestfs_blockdev_setrw (g, device);
13183 suppress_error = 0;
13184 r = guestfs_umount_all (g);
13190 suppress_error = 0;
13191 r = guestfs_lvm_remove_all (g);
13196 char device[] = "/dev/sda";
13197 char lines_0[] = ",";
13203 suppress_error = 0;
13204 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13209 char fstype[] = "ext2";
13210 char device[] = "/dev/sda1";
13212 suppress_error = 0;
13213 r = guestfs_mkfs (g, fstype, device);
13218 char device[] = "/dev/sda1";
13219 char mountpoint[] = "/";
13221 suppress_error = 0;
13222 r = guestfs_mount (g, device, mountpoint);
13226 /* TestLastFail for command (11) */
13228 char remotefilename[] = "/test-command";
13230 suppress_error = 0;
13231 r = guestfs_upload (g, "test-command", remotefilename);
13236 char path[] = "/test-command";
13238 suppress_error = 0;
13239 r = guestfs_chmod (g, 493, path);
13244 char arguments_0[] = "/test-command";
13245 char *arguments[] = {
13250 suppress_error = 1;
13251 r = guestfs_command (g, arguments);
13259 static int test_file_0_skip (void)
13263 str = getenv ("TEST_ONLY");
13265 return strstr (str, "file") == NULL;
13266 str = getenv ("SKIP_TEST_FILE_0");
13267 if (str && strcmp (str, "1") == 0) return 1;
13268 str = getenv ("SKIP_TEST_FILE");
13269 if (str && strcmp (str, "1") == 0) return 1;
13273 static int test_file_0 (void)
13275 if (test_file_0_skip ()) {
13276 printf ("%s skipped (reason: environment variable set)\n", "test_file_0");
13280 /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
13282 char device[] = "/dev/sda";
13284 suppress_error = 0;
13285 r = guestfs_blockdev_setrw (g, device);
13291 suppress_error = 0;
13292 r = guestfs_umount_all (g);
13298 suppress_error = 0;
13299 r = guestfs_lvm_remove_all (g);
13304 char device[] = "/dev/sda";
13305 char lines_0[] = ",";
13311 suppress_error = 0;
13312 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13317 char fstype[] = "ext2";
13318 char device[] = "/dev/sda1";
13320 suppress_error = 0;
13321 r = guestfs_mkfs (g, fstype, device);
13326 char device[] = "/dev/sda1";
13327 char mountpoint[] = "/";
13329 suppress_error = 0;
13330 r = guestfs_mount (g, device, mountpoint);
13334 /* TestOutput for file (0) */
13335 char expected[] = "empty";
13337 char path[] = "/new";
13339 suppress_error = 0;
13340 r = guestfs_touch (g, path);
13345 char path[] = "/new";
13347 suppress_error = 0;
13348 r = guestfs_file (g, path);
13351 if (strcmp (r, expected) != 0) {
13352 fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
13360 static int test_file_1_skip (void)
13364 str = getenv ("TEST_ONLY");
13366 return strstr (str, "file") == NULL;
13367 str = getenv ("SKIP_TEST_FILE_1");
13368 if (str && strcmp (str, "1") == 0) return 1;
13369 str = getenv ("SKIP_TEST_FILE");
13370 if (str && strcmp (str, "1") == 0) return 1;
13374 static int test_file_1 (void)
13376 if (test_file_1_skip ()) {
13377 printf ("%s skipped (reason: environment variable set)\n", "test_file_1");
13381 /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
13383 char device[] = "/dev/sda";
13385 suppress_error = 0;
13386 r = guestfs_blockdev_setrw (g, device);
13392 suppress_error = 0;
13393 r = guestfs_umount_all (g);
13399 suppress_error = 0;
13400 r = guestfs_lvm_remove_all (g);
13405 char device[] = "/dev/sda";
13406 char lines_0[] = ",";
13412 suppress_error = 0;
13413 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13418 char fstype[] = "ext2";
13419 char device[] = "/dev/sda1";
13421 suppress_error = 0;
13422 r = guestfs_mkfs (g, fstype, device);
13427 char device[] = "/dev/sda1";
13428 char mountpoint[] = "/";
13430 suppress_error = 0;
13431 r = guestfs_mount (g, device, mountpoint);
13435 /* TestOutput for file (1) */
13436 char expected[] = "ASCII text";
13438 char path[] = "/new";
13439 char content[] = "some content\n";
13441 suppress_error = 0;
13442 r = guestfs_write_file (g, path, content, 0);
13447 char path[] = "/new";
13449 suppress_error = 0;
13450 r = guestfs_file (g, path);
13453 if (strcmp (r, expected) != 0) {
13454 fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
13462 static int test_file_2_skip (void)
13466 str = getenv ("TEST_ONLY");
13468 return strstr (str, "file") == NULL;
13469 str = getenv ("SKIP_TEST_FILE_2");
13470 if (str && strcmp (str, "1") == 0) return 1;
13471 str = getenv ("SKIP_TEST_FILE");
13472 if (str && strcmp (str, "1") == 0) return 1;
13476 static int test_file_2 (void)
13478 if (test_file_2_skip ()) {
13479 printf ("%s skipped (reason: environment variable set)\n", "test_file_2");
13483 /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
13485 char device[] = "/dev/sda";
13487 suppress_error = 0;
13488 r = guestfs_blockdev_setrw (g, device);
13494 suppress_error = 0;
13495 r = guestfs_umount_all (g);
13501 suppress_error = 0;
13502 r = guestfs_lvm_remove_all (g);
13507 char device[] = "/dev/sda";
13508 char lines_0[] = ",";
13514 suppress_error = 0;
13515 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13520 char fstype[] = "ext2";
13521 char device[] = "/dev/sda1";
13523 suppress_error = 0;
13524 r = guestfs_mkfs (g, fstype, device);
13529 char device[] = "/dev/sda1";
13530 char mountpoint[] = "/";
13532 suppress_error = 0;
13533 r = guestfs_mount (g, device, mountpoint);
13537 /* TestLastFail for file (2) */
13539 char path[] = "/nofile";
13541 suppress_error = 1;
13542 r = guestfs_file (g, path);
13550 static int test_umount_all_0_skip (void)
13554 str = getenv ("TEST_ONLY");
13556 return strstr (str, "umount_all") == NULL;
13557 str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
13558 if (str && strcmp (str, "1") == 0) return 1;
13559 str = getenv ("SKIP_TEST_UMOUNT_ALL");
13560 if (str && strcmp (str, "1") == 0) return 1;
13564 static int test_umount_all_0 (void)
13566 if (test_umount_all_0_skip ()) {
13567 printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_0");
13571 /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
13573 char device[] = "/dev/sda";
13575 suppress_error = 0;
13576 r = guestfs_blockdev_setrw (g, device);
13582 suppress_error = 0;
13583 r = guestfs_umount_all (g);
13589 suppress_error = 0;
13590 r = guestfs_lvm_remove_all (g);
13595 char device[] = "/dev/sda";
13596 char lines_0[] = ",";
13602 suppress_error = 0;
13603 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13608 char fstype[] = "ext2";
13609 char device[] = "/dev/sda1";
13611 suppress_error = 0;
13612 r = guestfs_mkfs (g, fstype, device);
13617 char device[] = "/dev/sda1";
13618 char mountpoint[] = "/";
13620 suppress_error = 0;
13621 r = guestfs_mount (g, device, mountpoint);
13625 /* TestOutputList for umount_all (0) */
13628 suppress_error = 0;
13629 r = guestfs_umount_all (g);
13636 suppress_error = 0;
13637 r = guestfs_mounts (g);
13640 if (r[0] != NULL) {
13641 fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
13645 for (i = 0; r[i] != NULL; ++i)
13652 static int test_umount_all_1_skip (void)
13656 str = getenv ("TEST_ONLY");
13658 return strstr (str, "umount_all") == NULL;
13659 str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
13660 if (str && strcmp (str, "1") == 0) return 1;
13661 str = getenv ("SKIP_TEST_UMOUNT_ALL");
13662 if (str && strcmp (str, "1") == 0) return 1;
13666 static int test_umount_all_1 (void)
13668 if (test_umount_all_1_skip ()) {
13669 printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_1");
13673 /* InitNone|InitEmpty for test_umount_all_1 */
13675 char device[] = "/dev/sda";
13677 suppress_error = 0;
13678 r = guestfs_blockdev_setrw (g, device);
13684 suppress_error = 0;
13685 r = guestfs_umount_all (g);
13691 suppress_error = 0;
13692 r = guestfs_lvm_remove_all (g);
13696 /* TestOutputList for umount_all (1) */
13698 char device[] = "/dev/sda";
13699 char lines_0[] = ",10";
13700 char lines_1[] = ",20";
13701 char lines_2[] = ",";
13709 suppress_error = 0;
13710 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13715 char fstype[] = "ext2";
13716 char device[] = "/dev/sda1";
13718 suppress_error = 0;
13719 r = guestfs_mkfs (g, fstype, device);
13724 char fstype[] = "ext2";
13725 char device[] = "/dev/sda2";
13727 suppress_error = 0;
13728 r = guestfs_mkfs (g, fstype, device);
13733 char fstype[] = "ext2";
13734 char device[] = "/dev/sda3";
13736 suppress_error = 0;
13737 r = guestfs_mkfs (g, fstype, device);
13742 char device[] = "/dev/sda1";
13743 char mountpoint[] = "/";
13745 suppress_error = 0;
13746 r = guestfs_mount (g, device, mountpoint);
13751 char path[] = "/mp1";
13753 suppress_error = 0;
13754 r = guestfs_mkdir (g, path);
13759 char device[] = "/dev/sda2";
13760 char mountpoint[] = "/mp1";
13762 suppress_error = 0;
13763 r = guestfs_mount (g, device, mountpoint);
13768 char path[] = "/mp1/mp2";
13770 suppress_error = 0;
13771 r = guestfs_mkdir (g, path);
13776 char device[] = "/dev/sda3";
13777 char mountpoint[] = "/mp1/mp2";
13779 suppress_error = 0;
13780 r = guestfs_mount (g, device, mountpoint);
13785 char path[] = "/mp1/mp2/mp3";
13787 suppress_error = 0;
13788 r = guestfs_mkdir (g, path);
13794 suppress_error = 0;
13795 r = guestfs_umount_all (g);
13802 suppress_error = 0;
13803 r = guestfs_mounts (g);
13806 if (r[0] != NULL) {
13807 fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
13811 for (i = 0; r[i] != NULL; ++i)
13818 static int test_mounts_0_skip (void)
13822 str = getenv ("TEST_ONLY");
13824 return strstr (str, "mounts") == NULL;
13825 str = getenv ("SKIP_TEST_MOUNTS_0");
13826 if (str && strcmp (str, "1") == 0) return 1;
13827 str = getenv ("SKIP_TEST_MOUNTS");
13828 if (str && strcmp (str, "1") == 0) return 1;
13832 static int test_mounts_0 (void)
13834 if (test_mounts_0_skip ()) {
13835 printf ("%s skipped (reason: environment variable set)\n", "test_mounts_0");
13839 /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
13841 char device[] = "/dev/sda";
13843 suppress_error = 0;
13844 r = guestfs_blockdev_setrw (g, device);
13850 suppress_error = 0;
13851 r = guestfs_umount_all (g);
13857 suppress_error = 0;
13858 r = guestfs_lvm_remove_all (g);
13863 char device[] = "/dev/sda";
13864 char lines_0[] = ",";
13870 suppress_error = 0;
13871 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13876 char fstype[] = "ext2";
13877 char device[] = "/dev/sda1";
13879 suppress_error = 0;
13880 r = guestfs_mkfs (g, fstype, device);
13885 char device[] = "/dev/sda1";
13886 char mountpoint[] = "/";
13888 suppress_error = 0;
13889 r = guestfs_mount (g, device, mountpoint);
13893 /* TestOutputListOfDevices for mounts (0) */
13897 suppress_error = 0;
13898 r = guestfs_mounts (g);
13902 fprintf (stderr, "test_mounts_0: short list returned from command\n");
13907 char expected[] = "/dev/sda1";
13909 if (strcmp (r[0], expected) != 0) {
13910 fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13914 if (r[1] != NULL) {
13915 fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
13919 for (i = 0; r[i] != NULL; ++i)
13926 static int test_umount_0_skip (void)
13930 str = getenv ("TEST_ONLY");
13932 return strstr (str, "umount") == NULL;
13933 str = getenv ("SKIP_TEST_UMOUNT_0");
13934 if (str && strcmp (str, "1") == 0) return 1;
13935 str = getenv ("SKIP_TEST_UMOUNT");
13936 if (str && strcmp (str, "1") == 0) return 1;
13940 static int test_umount_0 (void)
13942 if (test_umount_0_skip ()) {
13943 printf ("%s skipped (reason: environment variable set)\n", "test_umount_0");
13947 /* InitNone|InitEmpty for test_umount_0 */
13949 char device[] = "/dev/sda";
13951 suppress_error = 0;
13952 r = guestfs_blockdev_setrw (g, device);
13958 suppress_error = 0;
13959 r = guestfs_umount_all (g);
13965 suppress_error = 0;
13966 r = guestfs_lvm_remove_all (g);
13970 /* TestOutputListOfDevices for umount (0) */
13972 char device[] = "/dev/sda";
13973 char lines_0[] = ",";
13979 suppress_error = 0;
13980 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13985 char fstype[] = "ext2";
13986 char device[] = "/dev/sda1";
13988 suppress_error = 0;
13989 r = guestfs_mkfs (g, fstype, device);
13994 char device[] = "/dev/sda1";
13995 char mountpoint[] = "/";
13997 suppress_error = 0;
13998 r = guestfs_mount (g, device, mountpoint);
14005 suppress_error = 0;
14006 r = guestfs_mounts (g);
14010 fprintf (stderr, "test_umount_0: short list returned from command\n");
14015 char expected[] = "/dev/sda1";
14017 if (strcmp (r[0], expected) != 0) {
14018 fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14022 if (r[1] != NULL) {
14023 fprintf (stderr, "test_umount_0: extra elements returned from command\n");
14027 for (i = 0; r[i] != NULL; ++i)
14034 static int test_umount_1_skip (void)
14038 str = getenv ("TEST_ONLY");
14040 return strstr (str, "umount") == NULL;
14041 str = getenv ("SKIP_TEST_UMOUNT_1");
14042 if (str && strcmp (str, "1") == 0) return 1;
14043 str = getenv ("SKIP_TEST_UMOUNT");
14044 if (str && strcmp (str, "1") == 0) return 1;
14048 static int test_umount_1 (void)
14050 if (test_umount_1_skip ()) {
14051 printf ("%s skipped (reason: environment variable set)\n", "test_umount_1");
14055 /* InitNone|InitEmpty for test_umount_1 */
14057 char device[] = "/dev/sda";
14059 suppress_error = 0;
14060 r = guestfs_blockdev_setrw (g, device);
14066 suppress_error = 0;
14067 r = guestfs_umount_all (g);
14073 suppress_error = 0;
14074 r = guestfs_lvm_remove_all (g);
14078 /* TestOutputList for umount (1) */
14080 char device[] = "/dev/sda";
14081 char lines_0[] = ",";
14087 suppress_error = 0;
14088 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14093 char fstype[] = "ext2";
14094 char device[] = "/dev/sda1";
14096 suppress_error = 0;
14097 r = guestfs_mkfs (g, fstype, device);
14102 char device[] = "/dev/sda1";
14103 char mountpoint[] = "/";
14105 suppress_error = 0;
14106 r = guestfs_mount (g, device, mountpoint);
14111 char pathordevice[] = "/";
14113 suppress_error = 0;
14114 r = guestfs_umount (g, pathordevice);
14121 suppress_error = 0;
14122 r = guestfs_mounts (g);
14125 if (r[0] != NULL) {
14126 fprintf (stderr, "test_umount_1: extra elements returned from command\n");
14130 for (i = 0; r[i] != NULL; ++i)
14137 static int test_write_file_0_skip (void)
14141 str = getenv ("TEST_ONLY");
14143 return strstr (str, "write_file") == NULL;
14144 str = getenv ("SKIP_TEST_WRITE_FILE_0");
14145 if (str && strcmp (str, "1") == 0) return 1;
14146 str = getenv ("SKIP_TEST_WRITE_FILE");
14147 if (str && strcmp (str, "1") == 0) return 1;
14151 static int test_write_file_0 (void)
14153 if (test_write_file_0_skip ()) {
14154 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_0");
14158 /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
14160 char device[] = "/dev/sda";
14162 suppress_error = 0;
14163 r = guestfs_blockdev_setrw (g, device);
14169 suppress_error = 0;
14170 r = guestfs_umount_all (g);
14176 suppress_error = 0;
14177 r = guestfs_lvm_remove_all (g);
14182 char device[] = "/dev/sda";
14183 char lines_0[] = ",";
14189 suppress_error = 0;
14190 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14195 char fstype[] = "ext2";
14196 char device[] = "/dev/sda1";
14198 suppress_error = 0;
14199 r = guestfs_mkfs (g, fstype, device);
14204 char device[] = "/dev/sda1";
14205 char mountpoint[] = "/";
14207 suppress_error = 0;
14208 r = guestfs_mount (g, device, mountpoint);
14212 /* TestOutput for write_file (0) */
14213 char expected[] = "new file contents";
14215 char path[] = "/new";
14216 char content[] = "new file contents";
14218 suppress_error = 0;
14219 r = guestfs_write_file (g, path, content, 0);
14224 char path[] = "/new";
14226 suppress_error = 0;
14227 r = guestfs_cat (g, path);
14230 if (strcmp (r, expected) != 0) {
14231 fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
14239 static int test_write_file_1_skip (void)
14243 str = getenv ("TEST_ONLY");
14245 return strstr (str, "write_file") == NULL;
14246 str = getenv ("SKIP_TEST_WRITE_FILE_1");
14247 if (str && strcmp (str, "1") == 0) return 1;
14248 str = getenv ("SKIP_TEST_WRITE_FILE");
14249 if (str && strcmp (str, "1") == 0) return 1;
14253 static int test_write_file_1 (void)
14255 if (test_write_file_1_skip ()) {
14256 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_1");
14260 /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
14262 char device[] = "/dev/sda";
14264 suppress_error = 0;
14265 r = guestfs_blockdev_setrw (g, device);
14271 suppress_error = 0;
14272 r = guestfs_umount_all (g);
14278 suppress_error = 0;
14279 r = guestfs_lvm_remove_all (g);
14284 char device[] = "/dev/sda";
14285 char lines_0[] = ",";
14291 suppress_error = 0;
14292 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14297 char fstype[] = "ext2";
14298 char device[] = "/dev/sda1";
14300 suppress_error = 0;
14301 r = guestfs_mkfs (g, fstype, device);
14306 char device[] = "/dev/sda1";
14307 char mountpoint[] = "/";
14309 suppress_error = 0;
14310 r = guestfs_mount (g, device, mountpoint);
14314 /* TestOutput for write_file (1) */
14315 char expected[] = "\nnew file contents\n";
14317 char path[] = "/new";
14318 char content[] = "\nnew file contents\n";
14320 suppress_error = 0;
14321 r = guestfs_write_file (g, path, content, 0);
14326 char path[] = "/new";
14328 suppress_error = 0;
14329 r = guestfs_cat (g, path);
14332 if (strcmp (r, expected) != 0) {
14333 fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
14341 static int test_write_file_2_skip (void)
14345 str = getenv ("TEST_ONLY");
14347 return strstr (str, "write_file") == NULL;
14348 str = getenv ("SKIP_TEST_WRITE_FILE_2");
14349 if (str && strcmp (str, "1") == 0) return 1;
14350 str = getenv ("SKIP_TEST_WRITE_FILE");
14351 if (str && strcmp (str, "1") == 0) return 1;
14355 static int test_write_file_2 (void)
14357 if (test_write_file_2_skip ()) {
14358 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_2");
14362 /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
14364 char device[] = "/dev/sda";
14366 suppress_error = 0;
14367 r = guestfs_blockdev_setrw (g, device);
14373 suppress_error = 0;
14374 r = guestfs_umount_all (g);
14380 suppress_error = 0;
14381 r = guestfs_lvm_remove_all (g);
14386 char device[] = "/dev/sda";
14387 char lines_0[] = ",";
14393 suppress_error = 0;
14394 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14399 char fstype[] = "ext2";
14400 char device[] = "/dev/sda1";
14402 suppress_error = 0;
14403 r = guestfs_mkfs (g, fstype, device);
14408 char device[] = "/dev/sda1";
14409 char mountpoint[] = "/";
14411 suppress_error = 0;
14412 r = guestfs_mount (g, device, mountpoint);
14416 /* TestOutput for write_file (2) */
14417 char expected[] = "\n\n";
14419 char path[] = "/new";
14420 char content[] = "\n\n";
14422 suppress_error = 0;
14423 r = guestfs_write_file (g, path, content, 0);
14428 char path[] = "/new";
14430 suppress_error = 0;
14431 r = guestfs_cat (g, path);
14434 if (strcmp (r, expected) != 0) {
14435 fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
14443 static int test_write_file_3_skip (void)
14447 str = getenv ("TEST_ONLY");
14449 return strstr (str, "write_file") == NULL;
14450 str = getenv ("SKIP_TEST_WRITE_FILE_3");
14451 if (str && strcmp (str, "1") == 0) return 1;
14452 str = getenv ("SKIP_TEST_WRITE_FILE");
14453 if (str && strcmp (str, "1") == 0) return 1;
14457 static int test_write_file_3 (void)
14459 if (test_write_file_3_skip ()) {
14460 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_3");
14464 /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
14466 char device[] = "/dev/sda";
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 char lines_0[] = ",";
14495 suppress_error = 0;
14496 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14501 char fstype[] = "ext2";
14502 char device[] = "/dev/sda1";
14504 suppress_error = 0;
14505 r = guestfs_mkfs (g, fstype, device);
14510 char device[] = "/dev/sda1";
14511 char mountpoint[] = "/";
14513 suppress_error = 0;
14514 r = guestfs_mount (g, device, mountpoint);
14518 /* TestOutput for write_file (3) */
14519 char expected[] = "";
14521 char path[] = "/new";
14522 char content[] = "";
14524 suppress_error = 0;
14525 r = guestfs_write_file (g, path, content, 0);
14530 char path[] = "/new";
14532 suppress_error = 0;
14533 r = guestfs_cat (g, path);
14536 if (strcmp (r, expected) != 0) {
14537 fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
14545 static int test_write_file_4_skip (void)
14549 str = getenv ("TEST_ONLY");
14551 return strstr (str, "write_file") == NULL;
14552 str = getenv ("SKIP_TEST_WRITE_FILE_4");
14553 if (str && strcmp (str, "1") == 0) return 1;
14554 str = getenv ("SKIP_TEST_WRITE_FILE");
14555 if (str && strcmp (str, "1") == 0) return 1;
14559 static int test_write_file_4 (void)
14561 if (test_write_file_4_skip ()) {
14562 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_4");
14566 /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
14568 char device[] = "/dev/sda";
14570 suppress_error = 0;
14571 r = guestfs_blockdev_setrw (g, device);
14577 suppress_error = 0;
14578 r = guestfs_umount_all (g);
14584 suppress_error = 0;
14585 r = guestfs_lvm_remove_all (g);
14590 char device[] = "/dev/sda";
14591 char lines_0[] = ",";
14597 suppress_error = 0;
14598 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14603 char fstype[] = "ext2";
14604 char device[] = "/dev/sda1";
14606 suppress_error = 0;
14607 r = guestfs_mkfs (g, fstype, device);
14612 char device[] = "/dev/sda1";
14613 char mountpoint[] = "/";
14615 suppress_error = 0;
14616 r = guestfs_mount (g, device, mountpoint);
14620 /* TestOutput for write_file (4) */
14621 char expected[] = "\n\n\n";
14623 char path[] = "/new";
14624 char content[] = "\n\n\n";
14626 suppress_error = 0;
14627 r = guestfs_write_file (g, path, content, 0);
14632 char path[] = "/new";
14634 suppress_error = 0;
14635 r = guestfs_cat (g, path);
14638 if (strcmp (r, expected) != 0) {
14639 fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
14647 static int test_write_file_5_skip (void)
14651 str = getenv ("TEST_ONLY");
14653 return strstr (str, "write_file") == NULL;
14654 str = getenv ("SKIP_TEST_WRITE_FILE_5");
14655 if (str && strcmp (str, "1") == 0) return 1;
14656 str = getenv ("SKIP_TEST_WRITE_FILE");
14657 if (str && strcmp (str, "1") == 0) return 1;
14661 static int test_write_file_5 (void)
14663 if (test_write_file_5_skip ()) {
14664 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_5");
14668 /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
14670 char device[] = "/dev/sda";
14672 suppress_error = 0;
14673 r = guestfs_blockdev_setrw (g, device);
14679 suppress_error = 0;
14680 r = guestfs_umount_all (g);
14686 suppress_error = 0;
14687 r = guestfs_lvm_remove_all (g);
14692 char device[] = "/dev/sda";
14693 char lines_0[] = ",";
14699 suppress_error = 0;
14700 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14705 char fstype[] = "ext2";
14706 char device[] = "/dev/sda1";
14708 suppress_error = 0;
14709 r = guestfs_mkfs (g, fstype, device);
14714 char device[] = "/dev/sda1";
14715 char mountpoint[] = "/";
14717 suppress_error = 0;
14718 r = guestfs_mount (g, device, mountpoint);
14722 /* TestOutput for write_file (5) */
14723 char expected[] = "\n";
14725 char path[] = "/new";
14726 char content[] = "\n";
14728 suppress_error = 0;
14729 r = guestfs_write_file (g, path, content, 0);
14734 char path[] = "/new";
14736 suppress_error = 0;
14737 r = guestfs_cat (g, path);
14740 if (strcmp (r, expected) != 0) {
14741 fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
14749 static int test_mkfs_0_skip (void)
14753 str = getenv ("TEST_ONLY");
14755 return strstr (str, "mkfs") == NULL;
14756 str = getenv ("SKIP_TEST_MKFS_0");
14757 if (str && strcmp (str, "1") == 0) return 1;
14758 str = getenv ("SKIP_TEST_MKFS");
14759 if (str && strcmp (str, "1") == 0) return 1;
14763 static int test_mkfs_0 (void)
14765 if (test_mkfs_0_skip ()) {
14766 printf ("%s skipped (reason: environment variable set)\n", "test_mkfs_0");
14770 /* InitNone|InitEmpty for test_mkfs_0 */
14772 char device[] = "/dev/sda";
14774 suppress_error = 0;
14775 r = guestfs_blockdev_setrw (g, device);
14781 suppress_error = 0;
14782 r = guestfs_umount_all (g);
14788 suppress_error = 0;
14789 r = guestfs_lvm_remove_all (g);
14793 /* TestOutput for mkfs (0) */
14794 char expected[] = "new file contents";
14796 char device[] = "/dev/sda";
14797 char lines_0[] = ",";
14803 suppress_error = 0;
14804 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14809 char fstype[] = "ext2";
14810 char device[] = "/dev/sda1";
14812 suppress_error = 0;
14813 r = guestfs_mkfs (g, fstype, device);
14818 char device[] = "/dev/sda1";
14819 char mountpoint[] = "/";
14821 suppress_error = 0;
14822 r = guestfs_mount (g, device, mountpoint);
14827 char path[] = "/new";
14828 char content[] = "new file contents";
14830 suppress_error = 0;
14831 r = guestfs_write_file (g, path, content, 0);
14836 char path[] = "/new";
14838 suppress_error = 0;
14839 r = guestfs_cat (g, path);
14842 if (strcmp (r, expected) != 0) {
14843 fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
14851 static int test_lvcreate_0_skip (void)
14855 str = getenv ("TEST_ONLY");
14857 return strstr (str, "lvcreate") == NULL;
14858 str = getenv ("SKIP_TEST_LVCREATE_0");
14859 if (str && strcmp (str, "1") == 0) return 1;
14860 str = getenv ("SKIP_TEST_LVCREATE");
14861 if (str && strcmp (str, "1") == 0) return 1;
14865 static int test_lvcreate_0 (void)
14867 if (test_lvcreate_0_skip ()) {
14868 printf ("%s skipped (reason: environment variable set)\n", "test_lvcreate_0");
14872 /* InitNone|InitEmpty for test_lvcreate_0 */
14874 char device[] = "/dev/sda";
14876 suppress_error = 0;
14877 r = guestfs_blockdev_setrw (g, device);
14883 suppress_error = 0;
14884 r = guestfs_umount_all (g);
14890 suppress_error = 0;
14891 r = guestfs_lvm_remove_all (g);
14895 /* TestOutputList for lvcreate (0) */
14897 char device[] = "/dev/sda";
14898 char lines_0[] = ",10";
14899 char lines_1[] = ",20";
14900 char lines_2[] = ",";
14908 suppress_error = 0;
14909 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14914 char device[] = "/dev/sda1";
14916 suppress_error = 0;
14917 r = guestfs_pvcreate (g, device);
14922 char device[] = "/dev/sda2";
14924 suppress_error = 0;
14925 r = guestfs_pvcreate (g, device);
14930 char device[] = "/dev/sda3";
14932 suppress_error = 0;
14933 r = guestfs_pvcreate (g, device);
14938 char volgroup[] = "VG1";
14939 char physvols_0[] = "/dev/sda1";
14940 char physvols_1[] = "/dev/sda2";
14941 char *physvols[] = {
14947 suppress_error = 0;
14948 r = guestfs_vgcreate (g, volgroup, physvols);
14953 char volgroup[] = "VG2";
14954 char physvols_0[] = "/dev/sda3";
14955 char *physvols[] = {
14960 suppress_error = 0;
14961 r = guestfs_vgcreate (g, volgroup, physvols);
14966 char logvol[] = "LV1";
14967 char volgroup[] = "VG1";
14969 suppress_error = 0;
14970 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14975 char logvol[] = "LV2";
14976 char volgroup[] = "VG1";
14978 suppress_error = 0;
14979 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14984 char logvol[] = "LV3";
14985 char volgroup[] = "VG2";
14987 suppress_error = 0;
14988 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14993 char logvol[] = "LV4";
14994 char volgroup[] = "VG2";
14996 suppress_error = 0;
14997 r = guestfs_lvcreate (g, logvol, volgroup, 50);
15002 char logvol[] = "LV5";
15003 char volgroup[] = "VG2";
15005 suppress_error = 0;
15006 r = guestfs_lvcreate (g, logvol, volgroup, 50);
15013 suppress_error = 0;
15014 r = guestfs_lvs (g);
15018 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
15023 char expected[] = "/dev/VG1/LV1";
15024 if (strcmp (r[0], expected) != 0) {
15025 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15030 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
15035 char expected[] = "/dev/VG1/LV2";
15036 if (strcmp (r[1], expected) != 0) {
15037 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15042 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
15047 char expected[] = "/dev/VG2/LV3";
15048 if (strcmp (r[2], expected) != 0) {
15049 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15054 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
15059 char expected[] = "/dev/VG2/LV4";
15060 if (strcmp (r[3], expected) != 0) {
15061 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15066 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
15071 char expected[] = "/dev/VG2/LV5";
15072 if (strcmp (r[4], expected) != 0) {
15073 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
15077 if (r[5] != NULL) {
15078 fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
15082 for (i = 0; r[i] != NULL; ++i)
15089 static int test_vgcreate_0_skip (void)
15093 str = getenv ("TEST_ONLY");
15095 return strstr (str, "vgcreate") == NULL;
15096 str = getenv ("SKIP_TEST_VGCREATE_0");
15097 if (str && strcmp (str, "1") == 0) return 1;
15098 str = getenv ("SKIP_TEST_VGCREATE");
15099 if (str && strcmp (str, "1") == 0) return 1;
15103 static int test_vgcreate_0 (void)
15105 if (test_vgcreate_0_skip ()) {
15106 printf ("%s skipped (reason: environment variable set)\n", "test_vgcreate_0");
15110 /* InitNone|InitEmpty for test_vgcreate_0 */
15112 char device[] = "/dev/sda";
15114 suppress_error = 0;
15115 r = guestfs_blockdev_setrw (g, device);
15121 suppress_error = 0;
15122 r = guestfs_umount_all (g);
15128 suppress_error = 0;
15129 r = guestfs_lvm_remove_all (g);
15133 /* TestOutputList for vgcreate (0) */
15135 char device[] = "/dev/sda";
15136 char lines_0[] = ",10";
15137 char lines_1[] = ",20";
15138 char lines_2[] = ",";
15146 suppress_error = 0;
15147 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15152 char device[] = "/dev/sda1";
15154 suppress_error = 0;
15155 r = guestfs_pvcreate (g, device);
15160 char device[] = "/dev/sda2";
15162 suppress_error = 0;
15163 r = guestfs_pvcreate (g, device);
15168 char device[] = "/dev/sda3";
15170 suppress_error = 0;
15171 r = guestfs_pvcreate (g, device);
15176 char volgroup[] = "VG1";
15177 char physvols_0[] = "/dev/sda1";
15178 char physvols_1[] = "/dev/sda2";
15179 char *physvols[] = {
15185 suppress_error = 0;
15186 r = guestfs_vgcreate (g, volgroup, physvols);
15191 char volgroup[] = "VG2";
15192 char physvols_0[] = "/dev/sda3";
15193 char *physvols[] = {
15198 suppress_error = 0;
15199 r = guestfs_vgcreate (g, volgroup, physvols);
15206 suppress_error = 0;
15207 r = guestfs_vgs (g);
15211 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
15216 char expected[] = "VG1";
15217 if (strcmp (r[0], expected) != 0) {
15218 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15223 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
15228 char expected[] = "VG2";
15229 if (strcmp (r[1], expected) != 0) {
15230 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15234 if (r[2] != NULL) {
15235 fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
15239 for (i = 0; r[i] != NULL; ++i)
15246 static int test_pvcreate_0_skip (void)
15250 str = getenv ("TEST_ONLY");
15252 return strstr (str, "pvcreate") == NULL;
15253 str = getenv ("SKIP_TEST_PVCREATE_0");
15254 if (str && strcmp (str, "1") == 0) return 1;
15255 str = getenv ("SKIP_TEST_PVCREATE");
15256 if (str && strcmp (str, "1") == 0) return 1;
15260 static int test_pvcreate_0 (void)
15262 if (test_pvcreate_0_skip ()) {
15263 printf ("%s skipped (reason: environment variable set)\n", "test_pvcreate_0");
15267 /* InitNone|InitEmpty for test_pvcreate_0 */
15269 char device[] = "/dev/sda";
15271 suppress_error = 0;
15272 r = guestfs_blockdev_setrw (g, device);
15278 suppress_error = 0;
15279 r = guestfs_umount_all (g);
15285 suppress_error = 0;
15286 r = guestfs_lvm_remove_all (g);
15290 /* TestOutputListOfDevices for pvcreate (0) */
15292 char device[] = "/dev/sda";
15293 char lines_0[] = ",10";
15294 char lines_1[] = ",20";
15295 char lines_2[] = ",";
15303 suppress_error = 0;
15304 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15309 char device[] = "/dev/sda1";
15311 suppress_error = 0;
15312 r = guestfs_pvcreate (g, device);
15317 char device[] = "/dev/sda2";
15319 suppress_error = 0;
15320 r = guestfs_pvcreate (g, device);
15325 char device[] = "/dev/sda3";
15327 suppress_error = 0;
15328 r = guestfs_pvcreate (g, device);
15335 suppress_error = 0;
15336 r = guestfs_pvs (g);
15340 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
15345 char expected[] = "/dev/sda1";
15347 if (strcmp (r[0], expected) != 0) {
15348 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15353 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
15358 char expected[] = "/dev/sda2";
15360 if (strcmp (r[1], expected) != 0) {
15361 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15366 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
15371 char expected[] = "/dev/sda3";
15373 if (strcmp (r[2], expected) != 0) {
15374 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15378 if (r[3] != NULL) {
15379 fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
15383 for (i = 0; r[i] != NULL; ++i)
15390 static int test_is_dir_0_skip (void)
15394 str = getenv ("TEST_ONLY");
15396 return strstr (str, "is_dir") == NULL;
15397 str = getenv ("SKIP_TEST_IS_DIR_0");
15398 if (str && strcmp (str, "1") == 0) return 1;
15399 str = getenv ("SKIP_TEST_IS_DIR");
15400 if (str && strcmp (str, "1") == 0) return 1;
15404 static int test_is_dir_0 (void)
15406 if (test_is_dir_0_skip ()) {
15407 printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_0");
15411 /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
15413 char device[] = "/dev/sda";
15415 suppress_error = 0;
15416 r = guestfs_blockdev_setrw (g, device);
15422 suppress_error = 0;
15423 r = guestfs_umount_all (g);
15429 suppress_error = 0;
15430 r = guestfs_lvm_remove_all (g);
15435 char device[] = "/dev/sda";
15436 char lines_0[] = ",";
15442 suppress_error = 0;
15443 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15448 char fstype[] = "ext2";
15449 char device[] = "/dev/sda1";
15451 suppress_error = 0;
15452 r = guestfs_mkfs (g, fstype, device);
15457 char device[] = "/dev/sda1";
15458 char mountpoint[] = "/";
15460 suppress_error = 0;
15461 r = guestfs_mount (g, device, mountpoint);
15465 /* TestOutputFalse for is_dir (0) */
15467 char path[] = "/new";
15469 suppress_error = 0;
15470 r = guestfs_touch (g, path);
15475 char path[] = "/new";
15477 suppress_error = 0;
15478 r = guestfs_is_dir (g, path);
15482 fprintf (stderr, "test_is_dir_0: expected false, got true\n");
15489 static int test_is_dir_1_skip (void)
15493 str = getenv ("TEST_ONLY");
15495 return strstr (str, "is_dir") == NULL;
15496 str = getenv ("SKIP_TEST_IS_DIR_1");
15497 if (str && strcmp (str, "1") == 0) return 1;
15498 str = getenv ("SKIP_TEST_IS_DIR");
15499 if (str && strcmp (str, "1") == 0) return 1;
15503 static int test_is_dir_1 (void)
15505 if (test_is_dir_1_skip ()) {
15506 printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_1");
15510 /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
15512 char device[] = "/dev/sda";
15514 suppress_error = 0;
15515 r = guestfs_blockdev_setrw (g, device);
15521 suppress_error = 0;
15522 r = guestfs_umount_all (g);
15528 suppress_error = 0;
15529 r = guestfs_lvm_remove_all (g);
15534 char device[] = "/dev/sda";
15535 char lines_0[] = ",";
15541 suppress_error = 0;
15542 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15547 char fstype[] = "ext2";
15548 char device[] = "/dev/sda1";
15550 suppress_error = 0;
15551 r = guestfs_mkfs (g, fstype, device);
15556 char device[] = "/dev/sda1";
15557 char mountpoint[] = "/";
15559 suppress_error = 0;
15560 r = guestfs_mount (g, device, mountpoint);
15564 /* TestOutputTrue for is_dir (1) */
15566 char path[] = "/new";
15568 suppress_error = 0;
15569 r = guestfs_mkdir (g, path);
15574 char path[] = "/new";
15576 suppress_error = 0;
15577 r = guestfs_is_dir (g, path);
15581 fprintf (stderr, "test_is_dir_1: expected true, got false\n");
15588 static int test_is_file_0_skip (void)
15592 str = getenv ("TEST_ONLY");
15594 return strstr (str, "is_file") == NULL;
15595 str = getenv ("SKIP_TEST_IS_FILE_0");
15596 if (str && strcmp (str, "1") == 0) return 1;
15597 str = getenv ("SKIP_TEST_IS_FILE");
15598 if (str && strcmp (str, "1") == 0) return 1;
15602 static int test_is_file_0 (void)
15604 if (test_is_file_0_skip ()) {
15605 printf ("%s skipped (reason: environment variable set)\n", "test_is_file_0");
15609 /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
15611 char device[] = "/dev/sda";
15613 suppress_error = 0;
15614 r = guestfs_blockdev_setrw (g, device);
15620 suppress_error = 0;
15621 r = guestfs_umount_all (g);
15627 suppress_error = 0;
15628 r = guestfs_lvm_remove_all (g);
15633 char device[] = "/dev/sda";
15634 char lines_0[] = ",";
15640 suppress_error = 0;
15641 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15646 char fstype[] = "ext2";
15647 char device[] = "/dev/sda1";
15649 suppress_error = 0;
15650 r = guestfs_mkfs (g, fstype, device);
15655 char device[] = "/dev/sda1";
15656 char mountpoint[] = "/";
15658 suppress_error = 0;
15659 r = guestfs_mount (g, device, mountpoint);
15663 /* TestOutputTrue for is_file (0) */
15665 char path[] = "/new";
15667 suppress_error = 0;
15668 r = guestfs_touch (g, path);
15673 char path[] = "/new";
15675 suppress_error = 0;
15676 r = guestfs_is_file (g, path);
15680 fprintf (stderr, "test_is_file_0: expected true, got false\n");
15687 static int test_is_file_1_skip (void)
15691 str = getenv ("TEST_ONLY");
15693 return strstr (str, "is_file") == NULL;
15694 str = getenv ("SKIP_TEST_IS_FILE_1");
15695 if (str && strcmp (str, "1") == 0) return 1;
15696 str = getenv ("SKIP_TEST_IS_FILE");
15697 if (str && strcmp (str, "1") == 0) return 1;
15701 static int test_is_file_1 (void)
15703 if (test_is_file_1_skip ()) {
15704 printf ("%s skipped (reason: environment variable set)\n", "test_is_file_1");
15708 /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
15710 char device[] = "/dev/sda";
15712 suppress_error = 0;
15713 r = guestfs_blockdev_setrw (g, device);
15719 suppress_error = 0;
15720 r = guestfs_umount_all (g);
15726 suppress_error = 0;
15727 r = guestfs_lvm_remove_all (g);
15732 char device[] = "/dev/sda";
15733 char lines_0[] = ",";
15739 suppress_error = 0;
15740 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15745 char fstype[] = "ext2";
15746 char device[] = "/dev/sda1";
15748 suppress_error = 0;
15749 r = guestfs_mkfs (g, fstype, device);
15754 char device[] = "/dev/sda1";
15755 char mountpoint[] = "/";
15757 suppress_error = 0;
15758 r = guestfs_mount (g, device, mountpoint);
15762 /* TestOutputFalse for is_file (1) */
15764 char path[] = "/new";
15766 suppress_error = 0;
15767 r = guestfs_mkdir (g, path);
15772 char path[] = "/new";
15774 suppress_error = 0;
15775 r = guestfs_is_file (g, path);
15779 fprintf (stderr, "test_is_file_1: expected false, got true\n");
15786 static int test_exists_0_skip (void)
15790 str = getenv ("TEST_ONLY");
15792 return strstr (str, "exists") == NULL;
15793 str = getenv ("SKIP_TEST_EXISTS_0");
15794 if (str && strcmp (str, "1") == 0) return 1;
15795 str = getenv ("SKIP_TEST_EXISTS");
15796 if (str && strcmp (str, "1") == 0) return 1;
15800 static int test_exists_0 (void)
15802 if (test_exists_0_skip ()) {
15803 printf ("%s skipped (reason: environment variable set)\n", "test_exists_0");
15807 /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
15809 char device[] = "/dev/sda";
15811 suppress_error = 0;
15812 r = guestfs_blockdev_setrw (g, device);
15818 suppress_error = 0;
15819 r = guestfs_umount_all (g);
15825 suppress_error = 0;
15826 r = guestfs_lvm_remove_all (g);
15831 char device[] = "/dev/sda";
15832 char lines_0[] = ",";
15838 suppress_error = 0;
15839 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15844 char fstype[] = "ext2";
15845 char device[] = "/dev/sda1";
15847 suppress_error = 0;
15848 r = guestfs_mkfs (g, fstype, device);
15853 char device[] = "/dev/sda1";
15854 char mountpoint[] = "/";
15856 suppress_error = 0;
15857 r = guestfs_mount (g, device, mountpoint);
15861 /* TestOutputTrue for exists (0) */
15863 char path[] = "/new";
15865 suppress_error = 0;
15866 r = guestfs_touch (g, path);
15871 char path[] = "/new";
15873 suppress_error = 0;
15874 r = guestfs_exists (g, path);
15878 fprintf (stderr, "test_exists_0: expected true, got false\n");
15885 static int test_exists_1_skip (void)
15889 str = getenv ("TEST_ONLY");
15891 return strstr (str, "exists") == NULL;
15892 str = getenv ("SKIP_TEST_EXISTS_1");
15893 if (str && strcmp (str, "1") == 0) return 1;
15894 str = getenv ("SKIP_TEST_EXISTS");
15895 if (str && strcmp (str, "1") == 0) return 1;
15899 static int test_exists_1 (void)
15901 if (test_exists_1_skip ()) {
15902 printf ("%s skipped (reason: environment variable set)\n", "test_exists_1");
15906 /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
15908 char device[] = "/dev/sda";
15910 suppress_error = 0;
15911 r = guestfs_blockdev_setrw (g, device);
15917 suppress_error = 0;
15918 r = guestfs_umount_all (g);
15924 suppress_error = 0;
15925 r = guestfs_lvm_remove_all (g);
15930 char device[] = "/dev/sda";
15931 char lines_0[] = ",";
15937 suppress_error = 0;
15938 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15943 char fstype[] = "ext2";
15944 char device[] = "/dev/sda1";
15946 suppress_error = 0;
15947 r = guestfs_mkfs (g, fstype, device);
15952 char device[] = "/dev/sda1";
15953 char mountpoint[] = "/";
15955 suppress_error = 0;
15956 r = guestfs_mount (g, device, mountpoint);
15960 /* TestOutputTrue for exists (1) */
15962 char path[] = "/new";
15964 suppress_error = 0;
15965 r = guestfs_mkdir (g, path);
15970 char path[] = "/new";
15972 suppress_error = 0;
15973 r = guestfs_exists (g, path);
15977 fprintf (stderr, "test_exists_1: expected true, got false\n");
15984 static int test_mkdir_p_0_skip (void)
15988 str = getenv ("TEST_ONLY");
15990 return strstr (str, "mkdir_p") == NULL;
15991 str = getenv ("SKIP_TEST_MKDIR_P_0");
15992 if (str && strcmp (str, "1") == 0) return 1;
15993 str = getenv ("SKIP_TEST_MKDIR_P");
15994 if (str && strcmp (str, "1") == 0) return 1;
15998 static int test_mkdir_p_0 (void)
16000 if (test_mkdir_p_0_skip ()) {
16001 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_0");
16005 /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
16007 char device[] = "/dev/sda";
16009 suppress_error = 0;
16010 r = guestfs_blockdev_setrw (g, device);
16016 suppress_error = 0;
16017 r = guestfs_umount_all (g);
16023 suppress_error = 0;
16024 r = guestfs_lvm_remove_all (g);
16029 char device[] = "/dev/sda";
16030 char lines_0[] = ",";
16036 suppress_error = 0;
16037 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16042 char fstype[] = "ext2";
16043 char device[] = "/dev/sda1";
16045 suppress_error = 0;
16046 r = guestfs_mkfs (g, fstype, device);
16051 char device[] = "/dev/sda1";
16052 char mountpoint[] = "/";
16054 suppress_error = 0;
16055 r = guestfs_mount (g, device, mountpoint);
16059 /* TestOutputTrue for mkdir_p (0) */
16061 char path[] = "/new/foo/bar";
16063 suppress_error = 0;
16064 r = guestfs_mkdir_p (g, path);
16069 char path[] = "/new/foo/bar";
16071 suppress_error = 0;
16072 r = guestfs_is_dir (g, path);
16076 fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
16083 static int test_mkdir_p_1_skip (void)
16087 str = getenv ("TEST_ONLY");
16089 return strstr (str, "mkdir_p") == NULL;
16090 str = getenv ("SKIP_TEST_MKDIR_P_1");
16091 if (str && strcmp (str, "1") == 0) return 1;
16092 str = getenv ("SKIP_TEST_MKDIR_P");
16093 if (str && strcmp (str, "1") == 0) return 1;
16097 static int test_mkdir_p_1 (void)
16099 if (test_mkdir_p_1_skip ()) {
16100 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_1");
16104 /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
16106 char device[] = "/dev/sda";
16108 suppress_error = 0;
16109 r = guestfs_blockdev_setrw (g, device);
16115 suppress_error = 0;
16116 r = guestfs_umount_all (g);
16122 suppress_error = 0;
16123 r = guestfs_lvm_remove_all (g);
16128 char device[] = "/dev/sda";
16129 char lines_0[] = ",";
16135 suppress_error = 0;
16136 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16141 char fstype[] = "ext2";
16142 char device[] = "/dev/sda1";
16144 suppress_error = 0;
16145 r = guestfs_mkfs (g, fstype, device);
16150 char device[] = "/dev/sda1";
16151 char mountpoint[] = "/";
16153 suppress_error = 0;
16154 r = guestfs_mount (g, device, mountpoint);
16158 /* TestOutputTrue for mkdir_p (1) */
16160 char path[] = "/new/foo/bar";
16162 suppress_error = 0;
16163 r = guestfs_mkdir_p (g, path);
16168 char path[] = "/new/foo";
16170 suppress_error = 0;
16171 r = guestfs_is_dir (g, path);
16175 fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
16182 static int test_mkdir_p_2_skip (void)
16186 str = getenv ("TEST_ONLY");
16188 return strstr (str, "mkdir_p") == NULL;
16189 str = getenv ("SKIP_TEST_MKDIR_P_2");
16190 if (str && strcmp (str, "1") == 0) return 1;
16191 str = getenv ("SKIP_TEST_MKDIR_P");
16192 if (str && strcmp (str, "1") == 0) return 1;
16196 static int test_mkdir_p_2 (void)
16198 if (test_mkdir_p_2_skip ()) {
16199 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_2");
16203 /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
16205 char device[] = "/dev/sda";
16207 suppress_error = 0;
16208 r = guestfs_blockdev_setrw (g, device);
16214 suppress_error = 0;
16215 r = guestfs_umount_all (g);
16221 suppress_error = 0;
16222 r = guestfs_lvm_remove_all (g);
16227 char device[] = "/dev/sda";
16228 char lines_0[] = ",";
16234 suppress_error = 0;
16235 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16240 char fstype[] = "ext2";
16241 char device[] = "/dev/sda1";
16243 suppress_error = 0;
16244 r = guestfs_mkfs (g, fstype, device);
16249 char device[] = "/dev/sda1";
16250 char mountpoint[] = "/";
16252 suppress_error = 0;
16253 r = guestfs_mount (g, device, mountpoint);
16257 /* TestOutputTrue for mkdir_p (2) */
16259 char path[] = "/new/foo/bar";
16261 suppress_error = 0;
16262 r = guestfs_mkdir_p (g, path);
16267 char path[] = "/new";
16269 suppress_error = 0;
16270 r = guestfs_is_dir (g, path);
16274 fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
16281 static int test_mkdir_p_3_skip (void)
16285 str = getenv ("TEST_ONLY");
16287 return strstr (str, "mkdir_p") == NULL;
16288 str = getenv ("SKIP_TEST_MKDIR_P_3");
16289 if (str && strcmp (str, "1") == 0) return 1;
16290 str = getenv ("SKIP_TEST_MKDIR_P");
16291 if (str && strcmp (str, "1") == 0) return 1;
16295 static int test_mkdir_p_3 (void)
16297 if (test_mkdir_p_3_skip ()) {
16298 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_3");
16302 /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
16304 char device[] = "/dev/sda";
16306 suppress_error = 0;
16307 r = guestfs_blockdev_setrw (g, device);
16313 suppress_error = 0;
16314 r = guestfs_umount_all (g);
16320 suppress_error = 0;
16321 r = guestfs_lvm_remove_all (g);
16326 char device[] = "/dev/sda";
16327 char lines_0[] = ",";
16333 suppress_error = 0;
16334 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16339 char fstype[] = "ext2";
16340 char device[] = "/dev/sda1";
16342 suppress_error = 0;
16343 r = guestfs_mkfs (g, fstype, device);
16348 char device[] = "/dev/sda1";
16349 char mountpoint[] = "/";
16351 suppress_error = 0;
16352 r = guestfs_mount (g, device, mountpoint);
16356 /* TestRun for mkdir_p (3) */
16358 char path[] = "/new";
16360 suppress_error = 0;
16361 r = guestfs_mkdir (g, path);
16366 char path[] = "/new";
16368 suppress_error = 0;
16369 r = guestfs_mkdir_p (g, path);
16376 static int test_mkdir_p_4_skip (void)
16380 str = getenv ("TEST_ONLY");
16382 return strstr (str, "mkdir_p") == NULL;
16383 str = getenv ("SKIP_TEST_MKDIR_P_4");
16384 if (str && strcmp (str, "1") == 0) return 1;
16385 str = getenv ("SKIP_TEST_MKDIR_P");
16386 if (str && strcmp (str, "1") == 0) return 1;
16390 static int test_mkdir_p_4 (void)
16392 if (test_mkdir_p_4_skip ()) {
16393 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_4");
16397 /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
16399 char device[] = "/dev/sda";
16401 suppress_error = 0;
16402 r = guestfs_blockdev_setrw (g, device);
16408 suppress_error = 0;
16409 r = guestfs_umount_all (g);
16415 suppress_error = 0;
16416 r = guestfs_lvm_remove_all (g);
16421 char device[] = "/dev/sda";
16422 char lines_0[] = ",";
16428 suppress_error = 0;
16429 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16434 char fstype[] = "ext2";
16435 char device[] = "/dev/sda1";
16437 suppress_error = 0;
16438 r = guestfs_mkfs (g, fstype, device);
16443 char device[] = "/dev/sda1";
16444 char mountpoint[] = "/";
16446 suppress_error = 0;
16447 r = guestfs_mount (g, device, mountpoint);
16451 /* TestLastFail for mkdir_p (4) */
16453 char path[] = "/new";
16455 suppress_error = 0;
16456 r = guestfs_touch (g, path);
16461 char path[] = "/new";
16463 suppress_error = 1;
16464 r = guestfs_mkdir_p (g, path);
16471 static int test_mkdir_0_skip (void)
16475 str = getenv ("TEST_ONLY");
16477 return strstr (str, "mkdir") == NULL;
16478 str = getenv ("SKIP_TEST_MKDIR_0");
16479 if (str && strcmp (str, "1") == 0) return 1;
16480 str = getenv ("SKIP_TEST_MKDIR");
16481 if (str && strcmp (str, "1") == 0) return 1;
16485 static int test_mkdir_0 (void)
16487 if (test_mkdir_0_skip ()) {
16488 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_0");
16492 /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
16494 char device[] = "/dev/sda";
16496 suppress_error = 0;
16497 r = guestfs_blockdev_setrw (g, device);
16503 suppress_error = 0;
16504 r = guestfs_umount_all (g);
16510 suppress_error = 0;
16511 r = guestfs_lvm_remove_all (g);
16516 char device[] = "/dev/sda";
16517 char lines_0[] = ",";
16523 suppress_error = 0;
16524 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16529 char fstype[] = "ext2";
16530 char device[] = "/dev/sda1";
16532 suppress_error = 0;
16533 r = guestfs_mkfs (g, fstype, device);
16538 char device[] = "/dev/sda1";
16539 char mountpoint[] = "/";
16541 suppress_error = 0;
16542 r = guestfs_mount (g, device, mountpoint);
16546 /* TestOutputTrue for mkdir (0) */
16548 char path[] = "/new";
16550 suppress_error = 0;
16551 r = guestfs_mkdir (g, path);
16556 char path[] = "/new";
16558 suppress_error = 0;
16559 r = guestfs_is_dir (g, path);
16563 fprintf (stderr, "test_mkdir_0: expected true, got false\n");
16570 static int test_mkdir_1_skip (void)
16574 str = getenv ("TEST_ONLY");
16576 return strstr (str, "mkdir") == NULL;
16577 str = getenv ("SKIP_TEST_MKDIR_1");
16578 if (str && strcmp (str, "1") == 0) return 1;
16579 str = getenv ("SKIP_TEST_MKDIR");
16580 if (str && strcmp (str, "1") == 0) return 1;
16584 static int test_mkdir_1 (void)
16586 if (test_mkdir_1_skip ()) {
16587 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_1");
16591 /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
16593 char device[] = "/dev/sda";
16595 suppress_error = 0;
16596 r = guestfs_blockdev_setrw (g, device);
16602 suppress_error = 0;
16603 r = guestfs_umount_all (g);
16609 suppress_error = 0;
16610 r = guestfs_lvm_remove_all (g);
16615 char device[] = "/dev/sda";
16616 char lines_0[] = ",";
16622 suppress_error = 0;
16623 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16628 char fstype[] = "ext2";
16629 char device[] = "/dev/sda1";
16631 suppress_error = 0;
16632 r = guestfs_mkfs (g, fstype, device);
16637 char device[] = "/dev/sda1";
16638 char mountpoint[] = "/";
16640 suppress_error = 0;
16641 r = guestfs_mount (g, device, mountpoint);
16645 /* TestLastFail for mkdir (1) */
16647 char path[] = "/new/foo/bar";
16649 suppress_error = 1;
16650 r = guestfs_mkdir (g, path);
16657 static int test_rm_rf_0_skip (void)
16661 str = getenv ("TEST_ONLY");
16663 return strstr (str, "rm_rf") == NULL;
16664 str = getenv ("SKIP_TEST_RM_RF_0");
16665 if (str && strcmp (str, "1") == 0) return 1;
16666 str = getenv ("SKIP_TEST_RM_RF");
16667 if (str && strcmp (str, "1") == 0) return 1;
16671 static int test_rm_rf_0 (void)
16673 if (test_rm_rf_0_skip ()) {
16674 printf ("%s skipped (reason: environment variable set)\n", "test_rm_rf_0");
16678 /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
16680 char device[] = "/dev/sda";
16682 suppress_error = 0;
16683 r = guestfs_blockdev_setrw (g, device);
16689 suppress_error = 0;
16690 r = guestfs_umount_all (g);
16696 suppress_error = 0;
16697 r = guestfs_lvm_remove_all (g);
16702 char device[] = "/dev/sda";
16703 char lines_0[] = ",";
16709 suppress_error = 0;
16710 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16715 char fstype[] = "ext2";
16716 char device[] = "/dev/sda1";
16718 suppress_error = 0;
16719 r = guestfs_mkfs (g, fstype, device);
16724 char device[] = "/dev/sda1";
16725 char mountpoint[] = "/";
16727 suppress_error = 0;
16728 r = guestfs_mount (g, device, mountpoint);
16732 /* TestOutputFalse for rm_rf (0) */
16734 char path[] = "/new";
16736 suppress_error = 0;
16737 r = guestfs_mkdir (g, path);
16742 char path[] = "/new/foo";
16744 suppress_error = 0;
16745 r = guestfs_mkdir (g, path);
16750 char path[] = "/new/foo/bar";
16752 suppress_error = 0;
16753 r = guestfs_touch (g, path);
16758 char path[] = "/new";
16760 suppress_error = 0;
16761 r = guestfs_rm_rf (g, path);
16766 char path[] = "/new";
16768 suppress_error = 0;
16769 r = guestfs_exists (g, path);
16773 fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
16780 static int test_rmdir_0_skip (void)
16784 str = getenv ("TEST_ONLY");
16786 return strstr (str, "rmdir") == NULL;
16787 str = getenv ("SKIP_TEST_RMDIR_0");
16788 if (str && strcmp (str, "1") == 0) return 1;
16789 str = getenv ("SKIP_TEST_RMDIR");
16790 if (str && strcmp (str, "1") == 0) return 1;
16794 static int test_rmdir_0 (void)
16796 if (test_rmdir_0_skip ()) {
16797 printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_0");
16801 /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
16803 char device[] = "/dev/sda";
16805 suppress_error = 0;
16806 r = guestfs_blockdev_setrw (g, device);
16812 suppress_error = 0;
16813 r = guestfs_umount_all (g);
16819 suppress_error = 0;
16820 r = guestfs_lvm_remove_all (g);
16825 char device[] = "/dev/sda";
16826 char lines_0[] = ",";
16832 suppress_error = 0;
16833 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16838 char fstype[] = "ext2";
16839 char device[] = "/dev/sda1";
16841 suppress_error = 0;
16842 r = guestfs_mkfs (g, fstype, device);
16847 char device[] = "/dev/sda1";
16848 char mountpoint[] = "/";
16850 suppress_error = 0;
16851 r = guestfs_mount (g, device, mountpoint);
16855 /* TestRun for rmdir (0) */
16857 char path[] = "/new";
16859 suppress_error = 0;
16860 r = guestfs_mkdir (g, path);
16865 char path[] = "/new";
16867 suppress_error = 0;
16868 r = guestfs_rmdir (g, path);
16875 static int test_rmdir_1_skip (void)
16879 str = getenv ("TEST_ONLY");
16881 return strstr (str, "rmdir") == NULL;
16882 str = getenv ("SKIP_TEST_RMDIR_1");
16883 if (str && strcmp (str, "1") == 0) return 1;
16884 str = getenv ("SKIP_TEST_RMDIR");
16885 if (str && strcmp (str, "1") == 0) return 1;
16889 static int test_rmdir_1 (void)
16891 if (test_rmdir_1_skip ()) {
16892 printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_1");
16896 /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
16898 char device[] = "/dev/sda";
16900 suppress_error = 0;
16901 r = guestfs_blockdev_setrw (g, device);
16907 suppress_error = 0;
16908 r = guestfs_umount_all (g);
16914 suppress_error = 0;
16915 r = guestfs_lvm_remove_all (g);
16920 char device[] = "/dev/sda";
16921 char lines_0[] = ",";
16927 suppress_error = 0;
16928 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16933 char fstype[] = "ext2";
16934 char device[] = "/dev/sda1";
16936 suppress_error = 0;
16937 r = guestfs_mkfs (g, fstype, device);
16942 char device[] = "/dev/sda1";
16943 char mountpoint[] = "/";
16945 suppress_error = 0;
16946 r = guestfs_mount (g, device, mountpoint);
16950 /* TestLastFail for rmdir (1) */
16952 char path[] = "/new";
16954 suppress_error = 1;
16955 r = guestfs_rmdir (g, path);
16962 static int test_rmdir_2_skip (void)
16966 str = getenv ("TEST_ONLY");
16968 return strstr (str, "rmdir") == NULL;
16969 str = getenv ("SKIP_TEST_RMDIR_2");
16970 if (str && strcmp (str, "1") == 0) return 1;
16971 str = getenv ("SKIP_TEST_RMDIR");
16972 if (str && strcmp (str, "1") == 0) return 1;
16976 static int test_rmdir_2 (void)
16978 if (test_rmdir_2_skip ()) {
16979 printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_2");
16983 /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
16985 char device[] = "/dev/sda";
16987 suppress_error = 0;
16988 r = guestfs_blockdev_setrw (g, device);
16994 suppress_error = 0;
16995 r = guestfs_umount_all (g);
17001 suppress_error = 0;
17002 r = guestfs_lvm_remove_all (g);
17007 char device[] = "/dev/sda";
17008 char lines_0[] = ",";
17014 suppress_error = 0;
17015 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17020 char fstype[] = "ext2";
17021 char device[] = "/dev/sda1";
17023 suppress_error = 0;
17024 r = guestfs_mkfs (g, fstype, device);
17029 char device[] = "/dev/sda1";
17030 char mountpoint[] = "/";
17032 suppress_error = 0;
17033 r = guestfs_mount (g, device, mountpoint);
17037 /* TestLastFail for rmdir (2) */
17039 char path[] = "/new";
17041 suppress_error = 0;
17042 r = guestfs_touch (g, path);
17047 char path[] = "/new";
17049 suppress_error = 1;
17050 r = guestfs_rmdir (g, path);
17057 static int test_rm_0_skip (void)
17061 str = getenv ("TEST_ONLY");
17063 return strstr (str, "rm") == NULL;
17064 str = getenv ("SKIP_TEST_RM_0");
17065 if (str && strcmp (str, "1") == 0) return 1;
17066 str = getenv ("SKIP_TEST_RM");
17067 if (str && strcmp (str, "1") == 0) return 1;
17071 static int test_rm_0 (void)
17073 if (test_rm_0_skip ()) {
17074 printf ("%s skipped (reason: environment variable set)\n", "test_rm_0");
17078 /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
17080 char device[] = "/dev/sda";
17082 suppress_error = 0;
17083 r = guestfs_blockdev_setrw (g, device);
17089 suppress_error = 0;
17090 r = guestfs_umount_all (g);
17096 suppress_error = 0;
17097 r = guestfs_lvm_remove_all (g);
17102 char device[] = "/dev/sda";
17103 char lines_0[] = ",";
17109 suppress_error = 0;
17110 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17115 char fstype[] = "ext2";
17116 char device[] = "/dev/sda1";
17118 suppress_error = 0;
17119 r = guestfs_mkfs (g, fstype, device);
17124 char device[] = "/dev/sda1";
17125 char mountpoint[] = "/";
17127 suppress_error = 0;
17128 r = guestfs_mount (g, device, mountpoint);
17132 /* TestRun for rm (0) */
17134 char path[] = "/new";
17136 suppress_error = 0;
17137 r = guestfs_touch (g, path);
17142 char path[] = "/new";
17144 suppress_error = 0;
17145 r = guestfs_rm (g, path);
17152 static int test_rm_1_skip (void)
17156 str = getenv ("TEST_ONLY");
17158 return strstr (str, "rm") == NULL;
17159 str = getenv ("SKIP_TEST_RM_1");
17160 if (str && strcmp (str, "1") == 0) return 1;
17161 str = getenv ("SKIP_TEST_RM");
17162 if (str && strcmp (str, "1") == 0) return 1;
17166 static int test_rm_1 (void)
17168 if (test_rm_1_skip ()) {
17169 printf ("%s skipped (reason: environment variable set)\n", "test_rm_1");
17173 /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
17175 char device[] = "/dev/sda";
17177 suppress_error = 0;
17178 r = guestfs_blockdev_setrw (g, device);
17184 suppress_error = 0;
17185 r = guestfs_umount_all (g);
17191 suppress_error = 0;
17192 r = guestfs_lvm_remove_all (g);
17197 char device[] = "/dev/sda";
17198 char lines_0[] = ",";
17204 suppress_error = 0;
17205 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17210 char fstype[] = "ext2";
17211 char device[] = "/dev/sda1";
17213 suppress_error = 0;
17214 r = guestfs_mkfs (g, fstype, device);
17219 char device[] = "/dev/sda1";
17220 char mountpoint[] = "/";
17222 suppress_error = 0;
17223 r = guestfs_mount (g, device, mountpoint);
17227 /* TestLastFail for rm (1) */
17229 char path[] = "/new";
17231 suppress_error = 1;
17232 r = guestfs_rm (g, path);
17239 static int test_rm_2_skip (void)
17243 str = getenv ("TEST_ONLY");
17245 return strstr (str, "rm") == NULL;
17246 str = getenv ("SKIP_TEST_RM_2");
17247 if (str && strcmp (str, "1") == 0) return 1;
17248 str = getenv ("SKIP_TEST_RM");
17249 if (str && strcmp (str, "1") == 0) return 1;
17253 static int test_rm_2 (void)
17255 if (test_rm_2_skip ()) {
17256 printf ("%s skipped (reason: environment variable set)\n", "test_rm_2");
17260 /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
17262 char device[] = "/dev/sda";
17264 suppress_error = 0;
17265 r = guestfs_blockdev_setrw (g, device);
17271 suppress_error = 0;
17272 r = guestfs_umount_all (g);
17278 suppress_error = 0;
17279 r = guestfs_lvm_remove_all (g);
17284 char device[] = "/dev/sda";
17285 char lines_0[] = ",";
17291 suppress_error = 0;
17292 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17297 char fstype[] = "ext2";
17298 char device[] = "/dev/sda1";
17300 suppress_error = 0;
17301 r = guestfs_mkfs (g, fstype, device);
17306 char device[] = "/dev/sda1";
17307 char mountpoint[] = "/";
17309 suppress_error = 0;
17310 r = guestfs_mount (g, device, mountpoint);
17314 /* TestLastFail for rm (2) */
17316 char path[] = "/new";
17318 suppress_error = 0;
17319 r = guestfs_mkdir (g, path);
17324 char path[] = "/new";
17326 suppress_error = 1;
17327 r = guestfs_rm (g, path);
17334 static int test_read_lines_0_skip (void)
17338 str = getenv ("TEST_ONLY");
17340 return strstr (str, "read_lines") == NULL;
17341 str = getenv ("SKIP_TEST_READ_LINES_0");
17342 if (str && strcmp (str, "1") == 0) return 1;
17343 str = getenv ("SKIP_TEST_READ_LINES");
17344 if (str && strcmp (str, "1") == 0) return 1;
17348 static int test_read_lines_0 (void)
17350 if (test_read_lines_0_skip ()) {
17351 printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_0");
17355 /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
17357 char device[] = "/dev/sda";
17359 suppress_error = 0;
17360 r = guestfs_blockdev_setrw (g, device);
17366 suppress_error = 0;
17367 r = guestfs_umount_all (g);
17373 suppress_error = 0;
17374 r = guestfs_lvm_remove_all (g);
17379 char device[] = "/dev/sda";
17380 char lines_0[] = ",";
17386 suppress_error = 0;
17387 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17392 char fstype[] = "ext2";
17393 char device[] = "/dev/sda1";
17395 suppress_error = 0;
17396 r = guestfs_mkfs (g, fstype, device);
17401 char device[] = "/dev/sda1";
17402 char mountpoint[] = "/";
17404 suppress_error = 0;
17405 r = guestfs_mount (g, device, mountpoint);
17409 /* TestOutputList for read_lines (0) */
17411 char path[] = "/new";
17412 char content[] = "line1\r\nline2\nline3";
17414 suppress_error = 0;
17415 r = guestfs_write_file (g, path, content, 0);
17420 char path[] = "/new";
17423 suppress_error = 0;
17424 r = guestfs_read_lines (g, path);
17428 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
17433 char expected[] = "line1";
17434 if (strcmp (r[0], expected) != 0) {
17435 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17440 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
17445 char expected[] = "line2";
17446 if (strcmp (r[1], expected) != 0) {
17447 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17452 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
17457 char expected[] = "line3";
17458 if (strcmp (r[2], expected) != 0) {
17459 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17463 if (r[3] != NULL) {
17464 fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
17468 for (i = 0; r[i] != NULL; ++i)
17475 static int test_read_lines_1_skip (void)
17479 str = getenv ("TEST_ONLY");
17481 return strstr (str, "read_lines") == NULL;
17482 str = getenv ("SKIP_TEST_READ_LINES_1");
17483 if (str && strcmp (str, "1") == 0) return 1;
17484 str = getenv ("SKIP_TEST_READ_LINES");
17485 if (str && strcmp (str, "1") == 0) return 1;
17489 static int test_read_lines_1 (void)
17491 if (test_read_lines_1_skip ()) {
17492 printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_1");
17496 /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
17498 char device[] = "/dev/sda";
17500 suppress_error = 0;
17501 r = guestfs_blockdev_setrw (g, device);
17507 suppress_error = 0;
17508 r = guestfs_umount_all (g);
17514 suppress_error = 0;
17515 r = guestfs_lvm_remove_all (g);
17520 char device[] = "/dev/sda";
17521 char lines_0[] = ",";
17527 suppress_error = 0;
17528 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17533 char fstype[] = "ext2";
17534 char device[] = "/dev/sda1";
17536 suppress_error = 0;
17537 r = guestfs_mkfs (g, fstype, device);
17542 char device[] = "/dev/sda1";
17543 char mountpoint[] = "/";
17545 suppress_error = 0;
17546 r = guestfs_mount (g, device, mountpoint);
17550 /* TestOutputList for read_lines (1) */
17552 char path[] = "/new";
17553 char content[] = "";
17555 suppress_error = 0;
17556 r = guestfs_write_file (g, path, content, 0);
17561 char path[] = "/new";
17564 suppress_error = 0;
17565 r = guestfs_read_lines (g, path);
17568 if (r[0] != NULL) {
17569 fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
17573 for (i = 0; r[i] != NULL; ++i)
17580 static int test_lvs_0_skip (void)
17584 str = getenv ("TEST_ONLY");
17586 return strstr (str, "lvs") == NULL;
17587 str = getenv ("SKIP_TEST_LVS_0");
17588 if (str && strcmp (str, "1") == 0) return 1;
17589 str = getenv ("SKIP_TEST_LVS");
17590 if (str && strcmp (str, "1") == 0) return 1;
17594 static int test_lvs_0 (void)
17596 if (test_lvs_0_skip ()) {
17597 printf ("%s skipped (reason: environment variable set)\n", "test_lvs_0");
17601 /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
17603 char device[] = "/dev/sda";
17605 suppress_error = 0;
17606 r = guestfs_blockdev_setrw (g, device);
17612 suppress_error = 0;
17613 r = guestfs_umount_all (g);
17619 suppress_error = 0;
17620 r = guestfs_lvm_remove_all (g);
17625 char device[] = "/dev/sda";
17626 char lines_0[] = ",";
17632 suppress_error = 0;
17633 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17638 char device[] = "/dev/sda1";
17640 suppress_error = 0;
17641 r = guestfs_pvcreate (g, device);
17646 char volgroup[] = "VG";
17647 char physvols_0[] = "/dev/sda1";
17648 char *physvols[] = {
17653 suppress_error = 0;
17654 r = guestfs_vgcreate (g, volgroup, physvols);
17659 char logvol[] = "LV";
17660 char volgroup[] = "VG";
17662 suppress_error = 0;
17663 r = guestfs_lvcreate (g, logvol, volgroup, 8);
17668 char fstype[] = "ext2";
17669 char device[] = "/dev/VG/LV";
17671 suppress_error = 0;
17672 r = guestfs_mkfs (g, fstype, device);
17677 char device[] = "/dev/VG/LV";
17678 char mountpoint[] = "/";
17680 suppress_error = 0;
17681 r = guestfs_mount (g, device, mountpoint);
17685 /* TestOutputList for lvs (0) */
17689 suppress_error = 0;
17690 r = guestfs_lvs (g);
17694 fprintf (stderr, "test_lvs_0: short list returned from command\n");
17699 char expected[] = "/dev/VG/LV";
17700 if (strcmp (r[0], expected) != 0) {
17701 fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17705 if (r[1] != NULL) {
17706 fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
17710 for (i = 0; r[i] != NULL; ++i)
17717 static int test_lvs_1_skip (void)
17721 str = getenv ("TEST_ONLY");
17723 return strstr (str, "lvs") == NULL;
17724 str = getenv ("SKIP_TEST_LVS_1");
17725 if (str && strcmp (str, "1") == 0) return 1;
17726 str = getenv ("SKIP_TEST_LVS");
17727 if (str && strcmp (str, "1") == 0) return 1;
17731 static int test_lvs_1 (void)
17733 if (test_lvs_1_skip ()) {
17734 printf ("%s skipped (reason: environment variable set)\n", "test_lvs_1");
17738 /* InitNone|InitEmpty for test_lvs_1 */
17740 char device[] = "/dev/sda";
17742 suppress_error = 0;
17743 r = guestfs_blockdev_setrw (g, device);
17749 suppress_error = 0;
17750 r = guestfs_umount_all (g);
17756 suppress_error = 0;
17757 r = guestfs_lvm_remove_all (g);
17761 /* TestOutputList for lvs (1) */
17763 char device[] = "/dev/sda";
17764 char lines_0[] = ",10";
17765 char lines_1[] = ",20";
17766 char lines_2[] = ",";
17774 suppress_error = 0;
17775 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17780 char device[] = "/dev/sda1";
17782 suppress_error = 0;
17783 r = guestfs_pvcreate (g, device);
17788 char device[] = "/dev/sda2";
17790 suppress_error = 0;
17791 r = guestfs_pvcreate (g, device);
17796 char device[] = "/dev/sda3";
17798 suppress_error = 0;
17799 r = guestfs_pvcreate (g, device);
17804 char volgroup[] = "VG1";
17805 char physvols_0[] = "/dev/sda1";
17806 char physvols_1[] = "/dev/sda2";
17807 char *physvols[] = {
17813 suppress_error = 0;
17814 r = guestfs_vgcreate (g, volgroup, physvols);
17819 char volgroup[] = "VG2";
17820 char physvols_0[] = "/dev/sda3";
17821 char *physvols[] = {
17826 suppress_error = 0;
17827 r = guestfs_vgcreate (g, volgroup, physvols);
17832 char logvol[] = "LV1";
17833 char volgroup[] = "VG1";
17835 suppress_error = 0;
17836 r = guestfs_lvcreate (g, logvol, volgroup, 50);
17841 char logvol[] = "LV2";
17842 char volgroup[] = "VG1";
17844 suppress_error = 0;
17845 r = guestfs_lvcreate (g, logvol, volgroup, 50);
17850 char logvol[] = "LV3";
17851 char volgroup[] = "VG2";
17853 suppress_error = 0;
17854 r = guestfs_lvcreate (g, logvol, volgroup, 50);
17861 suppress_error = 0;
17862 r = guestfs_lvs (g);
17866 fprintf (stderr, "test_lvs_1: short list returned from command\n");
17871 char expected[] = "/dev/VG1/LV1";
17872 if (strcmp (r[0], expected) != 0) {
17873 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17878 fprintf (stderr, "test_lvs_1: short list returned from command\n");
17883 char expected[] = "/dev/VG1/LV2";
17884 if (strcmp (r[1], expected) != 0) {
17885 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17890 fprintf (stderr, "test_lvs_1: short list returned from command\n");
17895 char expected[] = "/dev/VG2/LV3";
17896 if (strcmp (r[2], expected) != 0) {
17897 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17901 if (r[3] != NULL) {
17902 fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
17906 for (i = 0; r[i] != NULL; ++i)
17913 static int test_vgs_0_skip (void)
17917 str = getenv ("TEST_ONLY");
17919 return strstr (str, "vgs") == NULL;
17920 str = getenv ("SKIP_TEST_VGS_0");
17921 if (str && strcmp (str, "1") == 0) return 1;
17922 str = getenv ("SKIP_TEST_VGS");
17923 if (str && strcmp (str, "1") == 0) return 1;
17927 static int test_vgs_0 (void)
17929 if (test_vgs_0_skip ()) {
17930 printf ("%s skipped (reason: environment variable set)\n", "test_vgs_0");
17934 /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
17936 char device[] = "/dev/sda";
17938 suppress_error = 0;
17939 r = guestfs_blockdev_setrw (g, device);
17945 suppress_error = 0;
17946 r = guestfs_umount_all (g);
17952 suppress_error = 0;
17953 r = guestfs_lvm_remove_all (g);
17958 char device[] = "/dev/sda";
17959 char lines_0[] = ",";
17965 suppress_error = 0;
17966 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17971 char device[] = "/dev/sda1";
17973 suppress_error = 0;
17974 r = guestfs_pvcreate (g, device);
17979 char volgroup[] = "VG";
17980 char physvols_0[] = "/dev/sda1";
17981 char *physvols[] = {
17986 suppress_error = 0;
17987 r = guestfs_vgcreate (g, volgroup, physvols);
17992 char logvol[] = "LV";
17993 char volgroup[] = "VG";
17995 suppress_error = 0;
17996 r = guestfs_lvcreate (g, logvol, volgroup, 8);
18001 char fstype[] = "ext2";
18002 char device[] = "/dev/VG/LV";
18004 suppress_error = 0;
18005 r = guestfs_mkfs (g, fstype, device);
18010 char device[] = "/dev/VG/LV";
18011 char mountpoint[] = "/";
18013 suppress_error = 0;
18014 r = guestfs_mount (g, device, mountpoint);
18018 /* TestOutputList for vgs (0) */
18022 suppress_error = 0;
18023 r = guestfs_vgs (g);
18027 fprintf (stderr, "test_vgs_0: short list returned from command\n");
18032 char expected[] = "VG";
18033 if (strcmp (r[0], expected) != 0) {
18034 fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18038 if (r[1] != NULL) {
18039 fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
18043 for (i = 0; r[i] != NULL; ++i)
18050 static int test_vgs_1_skip (void)
18054 str = getenv ("TEST_ONLY");
18056 return strstr (str, "vgs") == NULL;
18057 str = getenv ("SKIP_TEST_VGS_1");
18058 if (str && strcmp (str, "1") == 0) return 1;
18059 str = getenv ("SKIP_TEST_VGS");
18060 if (str && strcmp (str, "1") == 0) return 1;
18064 static int test_vgs_1 (void)
18066 if (test_vgs_1_skip ()) {
18067 printf ("%s skipped (reason: environment variable set)\n", "test_vgs_1");
18071 /* InitNone|InitEmpty for test_vgs_1 */
18073 char device[] = "/dev/sda";
18075 suppress_error = 0;
18076 r = guestfs_blockdev_setrw (g, device);
18082 suppress_error = 0;
18083 r = guestfs_umount_all (g);
18089 suppress_error = 0;
18090 r = guestfs_lvm_remove_all (g);
18094 /* TestOutputList for vgs (1) */
18096 char device[] = "/dev/sda";
18097 char lines_0[] = ",10";
18098 char lines_1[] = ",20";
18099 char lines_2[] = ",";
18107 suppress_error = 0;
18108 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18113 char device[] = "/dev/sda1";
18115 suppress_error = 0;
18116 r = guestfs_pvcreate (g, device);
18121 char device[] = "/dev/sda2";
18123 suppress_error = 0;
18124 r = guestfs_pvcreate (g, device);
18129 char device[] = "/dev/sda3";
18131 suppress_error = 0;
18132 r = guestfs_pvcreate (g, device);
18137 char volgroup[] = "VG1";
18138 char physvols_0[] = "/dev/sda1";
18139 char physvols_1[] = "/dev/sda2";
18140 char *physvols[] = {
18146 suppress_error = 0;
18147 r = guestfs_vgcreate (g, volgroup, physvols);
18152 char volgroup[] = "VG2";
18153 char physvols_0[] = "/dev/sda3";
18154 char *physvols[] = {
18159 suppress_error = 0;
18160 r = guestfs_vgcreate (g, volgroup, physvols);
18167 suppress_error = 0;
18168 r = guestfs_vgs (g);
18172 fprintf (stderr, "test_vgs_1: short list returned from command\n");
18177 char expected[] = "VG1";
18178 if (strcmp (r[0], expected) != 0) {
18179 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18184 fprintf (stderr, "test_vgs_1: short list returned from command\n");
18189 char expected[] = "VG2";
18190 if (strcmp (r[1], expected) != 0) {
18191 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18195 if (r[2] != NULL) {
18196 fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
18200 for (i = 0; r[i] != NULL; ++i)
18207 static int test_pvs_0_skip (void)
18211 str = getenv ("TEST_ONLY");
18213 return strstr (str, "pvs") == NULL;
18214 str = getenv ("SKIP_TEST_PVS_0");
18215 if (str && strcmp (str, "1") == 0) return 1;
18216 str = getenv ("SKIP_TEST_PVS");
18217 if (str && strcmp (str, "1") == 0) return 1;
18221 static int test_pvs_0 (void)
18223 if (test_pvs_0_skip ()) {
18224 printf ("%s skipped (reason: environment variable set)\n", "test_pvs_0");
18228 /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
18230 char device[] = "/dev/sda";
18232 suppress_error = 0;
18233 r = guestfs_blockdev_setrw (g, device);
18239 suppress_error = 0;
18240 r = guestfs_umount_all (g);
18246 suppress_error = 0;
18247 r = guestfs_lvm_remove_all (g);
18252 char device[] = "/dev/sda";
18253 char lines_0[] = ",";
18259 suppress_error = 0;
18260 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18265 char device[] = "/dev/sda1";
18267 suppress_error = 0;
18268 r = guestfs_pvcreate (g, device);
18273 char volgroup[] = "VG";
18274 char physvols_0[] = "/dev/sda1";
18275 char *physvols[] = {
18280 suppress_error = 0;
18281 r = guestfs_vgcreate (g, volgroup, physvols);
18286 char logvol[] = "LV";
18287 char volgroup[] = "VG";
18289 suppress_error = 0;
18290 r = guestfs_lvcreate (g, logvol, volgroup, 8);
18295 char fstype[] = "ext2";
18296 char device[] = "/dev/VG/LV";
18298 suppress_error = 0;
18299 r = guestfs_mkfs (g, fstype, device);
18304 char device[] = "/dev/VG/LV";
18305 char mountpoint[] = "/";
18307 suppress_error = 0;
18308 r = guestfs_mount (g, device, mountpoint);
18312 /* TestOutputListOfDevices for pvs (0) */
18316 suppress_error = 0;
18317 r = guestfs_pvs (g);
18321 fprintf (stderr, "test_pvs_0: short list returned from command\n");
18326 char expected[] = "/dev/sda1";
18328 if (strcmp (r[0], expected) != 0) {
18329 fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18333 if (r[1] != NULL) {
18334 fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
18338 for (i = 0; r[i] != NULL; ++i)
18345 static int test_pvs_1_skip (void)
18349 str = getenv ("TEST_ONLY");
18351 return strstr (str, "pvs") == NULL;
18352 str = getenv ("SKIP_TEST_PVS_1");
18353 if (str && strcmp (str, "1") == 0) return 1;
18354 str = getenv ("SKIP_TEST_PVS");
18355 if (str && strcmp (str, "1") == 0) return 1;
18359 static int test_pvs_1 (void)
18361 if (test_pvs_1_skip ()) {
18362 printf ("%s skipped (reason: environment variable set)\n", "test_pvs_1");
18366 /* InitNone|InitEmpty for test_pvs_1 */
18368 char device[] = "/dev/sda";
18370 suppress_error = 0;
18371 r = guestfs_blockdev_setrw (g, device);
18377 suppress_error = 0;
18378 r = guestfs_umount_all (g);
18384 suppress_error = 0;
18385 r = guestfs_lvm_remove_all (g);
18389 /* TestOutputListOfDevices for pvs (1) */
18391 char device[] = "/dev/sda";
18392 char lines_0[] = ",10";
18393 char lines_1[] = ",20";
18394 char lines_2[] = ",";
18402 suppress_error = 0;
18403 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18408 char device[] = "/dev/sda1";
18410 suppress_error = 0;
18411 r = guestfs_pvcreate (g, device);
18416 char device[] = "/dev/sda2";
18418 suppress_error = 0;
18419 r = guestfs_pvcreate (g, device);
18424 char device[] = "/dev/sda3";
18426 suppress_error = 0;
18427 r = guestfs_pvcreate (g, device);
18434 suppress_error = 0;
18435 r = guestfs_pvs (g);
18439 fprintf (stderr, "test_pvs_1: short list returned from command\n");
18444 char expected[] = "/dev/sda1";
18446 if (strcmp (r[0], expected) != 0) {
18447 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18452 fprintf (stderr, "test_pvs_1: short list returned from command\n");
18457 char expected[] = "/dev/sda2";
18459 if (strcmp (r[1], expected) != 0) {
18460 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18465 fprintf (stderr, "test_pvs_1: short list returned from command\n");
18470 char expected[] = "/dev/sda3";
18472 if (strcmp (r[2], expected) != 0) {
18473 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18477 if (r[3] != NULL) {
18478 fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
18482 for (i = 0; r[i] != NULL; ++i)
18489 static int test_list_partitions_0_skip (void)
18493 str = getenv ("TEST_ONLY");
18495 return strstr (str, "list_partitions") == NULL;
18496 str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
18497 if (str && strcmp (str, "1") == 0) return 1;
18498 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
18499 if (str && strcmp (str, "1") == 0) return 1;
18503 static int test_list_partitions_0 (void)
18505 if (test_list_partitions_0_skip ()) {
18506 printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_0");
18510 /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
18512 char device[] = "/dev/sda";
18514 suppress_error = 0;
18515 r = guestfs_blockdev_setrw (g, device);
18521 suppress_error = 0;
18522 r = guestfs_umount_all (g);
18528 suppress_error = 0;
18529 r = guestfs_lvm_remove_all (g);
18534 char device[] = "/dev/sda";
18535 char lines_0[] = ",";
18541 suppress_error = 0;
18542 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18547 char fstype[] = "ext2";
18548 char device[] = "/dev/sda1";
18550 suppress_error = 0;
18551 r = guestfs_mkfs (g, fstype, device);
18556 char device[] = "/dev/sda1";
18557 char mountpoint[] = "/";
18559 suppress_error = 0;
18560 r = guestfs_mount (g, device, mountpoint);
18564 /* TestOutputListOfDevices for list_partitions (0) */
18568 suppress_error = 0;
18569 r = guestfs_list_partitions (g);
18573 fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
18578 char expected[] = "/dev/sda1";
18580 if (strcmp (r[0], expected) != 0) {
18581 fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18585 if (r[1] != NULL) {
18586 fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
18590 for (i = 0; r[i] != NULL; ++i)
18597 static int test_list_partitions_1_skip (void)
18601 str = getenv ("TEST_ONLY");
18603 return strstr (str, "list_partitions") == NULL;
18604 str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
18605 if (str && strcmp (str, "1") == 0) return 1;
18606 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
18607 if (str && strcmp (str, "1") == 0) return 1;
18611 static int test_list_partitions_1 (void)
18613 if (test_list_partitions_1_skip ()) {
18614 printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_1");
18618 /* InitNone|InitEmpty for test_list_partitions_1 */
18620 char device[] = "/dev/sda";
18622 suppress_error = 0;
18623 r = guestfs_blockdev_setrw (g, device);
18629 suppress_error = 0;
18630 r = guestfs_umount_all (g);
18636 suppress_error = 0;
18637 r = guestfs_lvm_remove_all (g);
18641 /* TestOutputListOfDevices for list_partitions (1) */
18643 char device[] = "/dev/sda";
18644 char lines_0[] = ",10";
18645 char lines_1[] = ",20";
18646 char lines_2[] = ",";
18654 suppress_error = 0;
18655 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18662 suppress_error = 0;
18663 r = guestfs_list_partitions (g);
18667 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
18672 char expected[] = "/dev/sda1";
18674 if (strcmp (r[0], expected) != 0) {
18675 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18680 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
18685 char expected[] = "/dev/sda2";
18687 if (strcmp (r[1], expected) != 0) {
18688 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18693 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
18698 char expected[] = "/dev/sda3";
18700 if (strcmp (r[2], expected) != 0) {
18701 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18705 if (r[3] != NULL) {
18706 fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
18710 for (i = 0; r[i] != NULL; ++i)
18717 static int test_list_devices_0_skip (void)
18721 str = getenv ("TEST_ONLY");
18723 return strstr (str, "list_devices") == NULL;
18724 str = getenv ("SKIP_TEST_LIST_DEVICES_0");
18725 if (str && strcmp (str, "1") == 0) return 1;
18726 str = getenv ("SKIP_TEST_LIST_DEVICES");
18727 if (str && strcmp (str, "1") == 0) return 1;
18731 static int test_list_devices_0 (void)
18733 if (test_list_devices_0_skip ()) {
18734 printf ("%s skipped (reason: environment variable set)\n", "test_list_devices_0");
18738 /* InitNone|InitEmpty for test_list_devices_0 */
18740 char device[] = "/dev/sda";
18742 suppress_error = 0;
18743 r = guestfs_blockdev_setrw (g, device);
18749 suppress_error = 0;
18750 r = guestfs_umount_all (g);
18756 suppress_error = 0;
18757 r = guestfs_lvm_remove_all (g);
18761 /* TestOutputListOfDevices for list_devices (0) */
18765 suppress_error = 0;
18766 r = guestfs_list_devices (g);
18770 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18775 char expected[] = "/dev/sda";
18777 if (strcmp (r[0], expected) != 0) {
18778 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18783 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18788 char expected[] = "/dev/sdb";
18790 if (strcmp (r[1], expected) != 0) {
18791 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18796 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18801 char expected[] = "/dev/sdc";
18803 if (strcmp (r[2], expected) != 0) {
18804 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18809 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18814 char expected[] = "/dev/sdd";
18816 if (strcmp (r[3], expected) != 0) {
18817 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
18821 if (r[4] != NULL) {
18822 fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
18826 for (i = 0; r[i] != NULL; ++i)
18833 static int test_ls_0_skip (void)
18837 str = getenv ("TEST_ONLY");
18839 return strstr (str, "ls") == NULL;
18840 str = getenv ("SKIP_TEST_LS_0");
18841 if (str && strcmp (str, "1") == 0) return 1;
18842 str = getenv ("SKIP_TEST_LS");
18843 if (str && strcmp (str, "1") == 0) return 1;
18847 static int test_ls_0 (void)
18849 if (test_ls_0_skip ()) {
18850 printf ("%s skipped (reason: environment variable set)\n", "test_ls_0");
18854 /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
18856 char device[] = "/dev/sda";
18858 suppress_error = 0;
18859 r = guestfs_blockdev_setrw (g, device);
18865 suppress_error = 0;
18866 r = guestfs_umount_all (g);
18872 suppress_error = 0;
18873 r = guestfs_lvm_remove_all (g);
18878 char device[] = "/dev/sda";
18879 char lines_0[] = ",";
18885 suppress_error = 0;
18886 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18891 char fstype[] = "ext2";
18892 char device[] = "/dev/sda1";
18894 suppress_error = 0;
18895 r = guestfs_mkfs (g, fstype, device);
18900 char device[] = "/dev/sda1";
18901 char mountpoint[] = "/";
18903 suppress_error = 0;
18904 r = guestfs_mount (g, device, mountpoint);
18908 /* TestOutputList for ls (0) */
18910 char path[] = "/new";
18912 suppress_error = 0;
18913 r = guestfs_touch (g, path);
18918 char path[] = "/newer";
18920 suppress_error = 0;
18921 r = guestfs_touch (g, path);
18926 char path[] = "/newest";
18928 suppress_error = 0;
18929 r = guestfs_touch (g, path);
18934 char directory[] = "/";
18937 suppress_error = 0;
18938 r = guestfs_ls (g, directory);
18942 fprintf (stderr, "test_ls_0: short list returned from command\n");
18947 char expected[] = "lost+found";
18948 if (strcmp (r[0], expected) != 0) {
18949 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18954 fprintf (stderr, "test_ls_0: short list returned from command\n");
18959 char expected[] = "new";
18960 if (strcmp (r[1], expected) != 0) {
18961 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18966 fprintf (stderr, "test_ls_0: short list returned from command\n");
18971 char expected[] = "newer";
18972 if (strcmp (r[2], expected) != 0) {
18973 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18978 fprintf (stderr, "test_ls_0: short list returned from command\n");
18983 char expected[] = "newest";
18984 if (strcmp (r[3], expected) != 0) {
18985 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
18989 if (r[4] != NULL) {
18990 fprintf (stderr, "test_ls_0: extra elements returned from command\n");
18994 for (i = 0; r[i] != NULL; ++i)
19001 static int test_cat_0_skip (void)
19005 str = getenv ("TEST_ONLY");
19007 return strstr (str, "cat") == NULL;
19008 str = getenv ("SKIP_TEST_CAT_0");
19009 if (str && strcmp (str, "1") == 0) return 1;
19010 str = getenv ("SKIP_TEST_CAT");
19011 if (str && strcmp (str, "1") == 0) return 1;
19015 static int test_cat_0 (void)
19017 if (test_cat_0_skip ()) {
19018 printf ("%s skipped (reason: environment variable set)\n", "test_cat_0");
19022 /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
19024 char device[] = "/dev/sda";
19026 suppress_error = 0;
19027 r = guestfs_blockdev_setrw (g, device);
19033 suppress_error = 0;
19034 r = guestfs_umount_all (g);
19040 suppress_error = 0;
19041 r = guestfs_lvm_remove_all (g);
19046 char device[] = "/dev/sda";
19047 char lines_0[] = ",";
19053 suppress_error = 0;
19054 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
19059 char fstype[] = "ext2";
19060 char device[] = "/dev/sda1";
19062 suppress_error = 0;
19063 r = guestfs_mkfs (g, fstype, device);
19068 char device[] = "/dev/sda1";
19069 char mountpoint[] = "/";
19071 suppress_error = 0;
19072 r = guestfs_mount (g, device, mountpoint);
19076 /* TestOutput for cat (0) */
19077 char expected[] = "new file contents";
19079 char path[] = "/new";
19080 char content[] = "new file contents";
19082 suppress_error = 0;
19083 r = guestfs_write_file (g, path, content, 0);
19088 char path[] = "/new";
19090 suppress_error = 0;
19091 r = guestfs_cat (g, path);
19094 if (strcmp (r, expected) != 0) {
19095 fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
19103 static int test_touch_0_skip (void)
19107 str = getenv ("TEST_ONLY");
19109 return strstr (str, "touch") == NULL;
19110 str = getenv ("SKIP_TEST_TOUCH_0");
19111 if (str && strcmp (str, "1") == 0) return 1;
19112 str = getenv ("SKIP_TEST_TOUCH");
19113 if (str && strcmp (str, "1") == 0) return 1;
19117 static int test_touch_0 (void)
19119 if (test_touch_0_skip ()) {
19120 printf ("%s skipped (reason: environment variable set)\n", "test_touch_0");
19124 /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
19126 char device[] = "/dev/sda";
19128 suppress_error = 0;
19129 r = guestfs_blockdev_setrw (g, device);
19135 suppress_error = 0;
19136 r = guestfs_umount_all (g);
19142 suppress_error = 0;
19143 r = guestfs_lvm_remove_all (g);
19148 char device[] = "/dev/sda";
19149 char lines_0[] = ",";
19155 suppress_error = 0;
19156 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
19161 char fstype[] = "ext2";
19162 char device[] = "/dev/sda1";
19164 suppress_error = 0;
19165 r = guestfs_mkfs (g, fstype, device);
19170 char device[] = "/dev/sda1";
19171 char mountpoint[] = "/";
19173 suppress_error = 0;
19174 r = guestfs_mount (g, device, mountpoint);
19178 /* TestOutputTrue for touch (0) */
19180 char path[] = "/new";
19182 suppress_error = 0;
19183 r = guestfs_touch (g, path);
19188 char path[] = "/new";
19190 suppress_error = 0;
19191 r = guestfs_exists (g, path);
19195 fprintf (stderr, "test_touch_0: expected true, got false\n");
19202 static int test_sync_0_skip (void)
19206 str = getenv ("TEST_ONLY");
19208 return strstr (str, "sync") == NULL;
19209 str = getenv ("SKIP_TEST_SYNC_0");
19210 if (str && strcmp (str, "1") == 0) return 1;
19211 str = getenv ("SKIP_TEST_SYNC");
19212 if (str && strcmp (str, "1") == 0) return 1;
19216 static int test_sync_0 (void)
19218 if (test_sync_0_skip ()) {
19219 printf ("%s skipped (reason: environment variable set)\n", "test_sync_0");
19223 /* InitNone|InitEmpty for test_sync_0 */
19225 char device[] = "/dev/sda";
19227 suppress_error = 0;
19228 r = guestfs_blockdev_setrw (g, device);
19234 suppress_error = 0;
19235 r = guestfs_umount_all (g);
19241 suppress_error = 0;
19242 r = guestfs_lvm_remove_all (g);
19246 /* TestRun for sync (0) */
19249 suppress_error = 0;
19250 r = guestfs_sync (g);
19257 static int test_mount_0_skip (void)
19261 str = getenv ("TEST_ONLY");
19263 return strstr (str, "mount") == NULL;
19264 str = getenv ("SKIP_TEST_MOUNT_0");
19265 if (str && strcmp (str, "1") == 0) return 1;
19266 str = getenv ("SKIP_TEST_MOUNT");
19267 if (str && strcmp (str, "1") == 0) return 1;
19271 static int test_mount_0 (void)
19273 if (test_mount_0_skip ()) {
19274 printf ("%s skipped (reason: environment variable set)\n", "test_mount_0");
19278 /* InitNone|InitEmpty for test_mount_0 */
19280 char device[] = "/dev/sda";
19282 suppress_error = 0;
19283 r = guestfs_blockdev_setrw (g, device);
19289 suppress_error = 0;
19290 r = guestfs_umount_all (g);
19296 suppress_error = 0;
19297 r = guestfs_lvm_remove_all (g);
19301 /* TestOutput for mount (0) */
19302 char expected[] = "new file contents";
19304 char device[] = "/dev/sda";
19305 char lines_0[] = ",";
19311 suppress_error = 0;
19312 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
19317 char fstype[] = "ext2";
19318 char device[] = "/dev/sda1";
19320 suppress_error = 0;
19321 r = guestfs_mkfs (g, fstype, device);
19326 char device[] = "/dev/sda1";
19327 char mountpoint[] = "/";
19329 suppress_error = 0;
19330 r = guestfs_mount (g, device, mountpoint);
19335 char path[] = "/new";
19336 char content[] = "new file contents";
19338 suppress_error = 0;
19339 r = guestfs_write_file (g, path, content, 0);
19344 char path[] = "/new";
19346 suppress_error = 0;
19347 r = guestfs_cat (g, path);
19350 if (strcmp (r, expected) != 0) {
19351 fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
19359 int main (int argc, char *argv[])
19363 const char *filename;
19365 int nr_tests, test_num = 0;
19367 no_test_warnings ();
19369 g = guestfs_create ();
19371 printf ("guestfs_create FAILED\n");
19375 guestfs_set_error_handler (g, print_error, NULL);
19377 guestfs_set_path (g, "../appliance");
19379 filename = "test1.img";
19380 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
19385 if (lseek (fd, 524288000, SEEK_SET) == -1) {
19391 if (write (fd, &c, 1) == -1) {
19397 if (close (fd) == -1) {
19402 if (guestfs_add_drive (g, filename) == -1) {
19403 printf ("guestfs_add_drive %s FAILED\n", filename);
19407 filename = "test2.img";
19408 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
19413 if (lseek (fd, 52428800, SEEK_SET) == -1) {
19419 if (write (fd, &c, 1) == -1) {
19425 if (close (fd) == -1) {
19430 if (guestfs_add_drive (g, filename) == -1) {
19431 printf ("guestfs_add_drive %s FAILED\n", filename);
19435 filename = "test3.img";
19436 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
19441 if (lseek (fd, 10485760, SEEK_SET) == -1) {
19447 if (write (fd, &c, 1) == -1) {
19453 if (close (fd) == -1) {
19458 if (guestfs_add_drive (g, filename) == -1) {
19459 printf ("guestfs_add_drive %s FAILED\n", filename);
19463 if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
19464 printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
19468 if (guestfs_launch (g) == -1) {
19469 printf ("guestfs_launch FAILED\n");
19473 /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */
19476 if (guestfs_wait_ready (g) == -1) {
19477 printf ("guestfs_wait_ready FAILED\n");
19481 /* Cancel previous alarm. */
19487 printf ("%3d/%3d test_mknod_c_0\n", test_num, nr_tests);
19488 if (test_mknod_c_0 () == -1) {
19489 printf ("test_mknod_c_0 FAILED\n");
19493 printf ("%3d/%3d test_mknod_b_0\n", test_num, nr_tests);
19494 if (test_mknod_b_0 () == -1) {
19495 printf ("test_mknod_b_0 FAILED\n");
19499 printf ("%3d/%3d test_mkfifo_0\n", test_num, nr_tests);
19500 if (test_mkfifo_0 () == -1) {
19501 printf ("test_mkfifo_0 FAILED\n");
19505 printf ("%3d/%3d test_mknod_0\n", test_num, nr_tests);
19506 if (test_mknod_0 () == -1) {
19507 printf ("test_mknod_0 FAILED\n");
19511 printf ("%3d/%3d test_mknod_1\n", test_num, nr_tests);
19512 if (test_mknod_1 () == -1) {
19513 printf ("test_mknod_1 FAILED\n");
19517 printf ("%3d/%3d test_mkswap_U_0\n", test_num, nr_tests);
19518 if (test_mkswap_U_0 () == -1) {
19519 printf ("test_mkswap_U_0 FAILED\n");
19523 printf ("%3d/%3d test_mkswap_L_0\n", test_num, nr_tests);
19524 if (test_mkswap_L_0 () == -1) {
19525 printf ("test_mkswap_L_0 FAILED\n");
19529 printf ("%3d/%3d test_mkswap_0\n", test_num, nr_tests);
19530 if (test_mkswap_0 () == -1) {
19531 printf ("test_mkswap_0 FAILED\n");
19535 printf ("%3d/%3d test_initrd_list_0\n", test_num, nr_tests);
19536 if (test_initrd_list_0 () == -1) {
19537 printf ("test_initrd_list_0 FAILED\n");
19541 printf ("%3d/%3d test_du_0\n", test_num, nr_tests);
19542 if (test_du_0 () == -1) {
19543 printf ("test_du_0 FAILED\n");
19547 printf ("%3d/%3d test_tail_n_0\n", test_num, nr_tests);
19548 if (test_tail_n_0 () == -1) {
19549 printf ("test_tail_n_0 FAILED\n");
19553 printf ("%3d/%3d test_tail_n_1\n", test_num, nr_tests);
19554 if (test_tail_n_1 () == -1) {
19555 printf ("test_tail_n_1 FAILED\n");
19559 printf ("%3d/%3d test_tail_n_2\n", test_num, nr_tests);
19560 if (test_tail_n_2 () == -1) {
19561 printf ("test_tail_n_2 FAILED\n");
19565 printf ("%3d/%3d test_tail_0\n", test_num, nr_tests);
19566 if (test_tail_0 () == -1) {
19567 printf ("test_tail_0 FAILED\n");
19571 printf ("%3d/%3d test_head_n_0\n", test_num, nr_tests);
19572 if (test_head_n_0 () == -1) {
19573 printf ("test_head_n_0 FAILED\n");
19577 printf ("%3d/%3d test_head_n_1\n", test_num, nr_tests);
19578 if (test_head_n_1 () == -1) {
19579 printf ("test_head_n_1 FAILED\n");
19583 printf ("%3d/%3d test_head_n_2\n", test_num, nr_tests);
19584 if (test_head_n_2 () == -1) {
19585 printf ("test_head_n_2 FAILED\n");
19589 printf ("%3d/%3d test_head_0\n", test_num, nr_tests);
19590 if (test_head_0 () == -1) {
19591 printf ("test_head_0 FAILED\n");
19595 printf ("%3d/%3d test_wc_c_0\n", test_num, nr_tests);
19596 if (test_wc_c_0 () == -1) {
19597 printf ("test_wc_c_0 FAILED\n");
19601 printf ("%3d/%3d test_wc_w_0\n", test_num, nr_tests);
19602 if (test_wc_w_0 () == -1) {
19603 printf ("test_wc_w_0 FAILED\n");
19607 printf ("%3d/%3d test_wc_l_0\n", test_num, nr_tests);
19608 if (test_wc_l_0 () == -1) {
19609 printf ("test_wc_l_0 FAILED\n");
19613 printf ("%3d/%3d test_mkdtemp_0\n", test_num, nr_tests);
19614 if (test_mkdtemp_0 () == -1) {
19615 printf ("test_mkdtemp_0 FAILED\n");
19619 printf ("%3d/%3d test_scrub_file_0\n", test_num, nr_tests);
19620 if (test_scrub_file_0 () == -1) {
19621 printf ("test_scrub_file_0 FAILED\n");
19625 printf ("%3d/%3d test_scrub_device_0\n", test_num, nr_tests);
19626 if (test_scrub_device_0 () == -1) {
19627 printf ("test_scrub_device_0 FAILED\n");
19631 printf ("%3d/%3d test_glob_expand_0\n", test_num, nr_tests);
19632 if (test_glob_expand_0 () == -1) {
19633 printf ("test_glob_expand_0 FAILED\n");
19637 printf ("%3d/%3d test_glob_expand_1\n", test_num, nr_tests);
19638 if (test_glob_expand_1 () == -1) {
19639 printf ("test_glob_expand_1 FAILED\n");
19643 printf ("%3d/%3d test_glob_expand_2\n", test_num, nr_tests);
19644 if (test_glob_expand_2 () == -1) {
19645 printf ("test_glob_expand_2 FAILED\n");
19649 printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
19650 if (test_ntfs_3g_probe_0 () == -1) {
19651 printf ("test_ntfs_3g_probe_0 FAILED\n");
19655 printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
19656 if (test_ntfs_3g_probe_1 () == -1) {
19657 printf ("test_ntfs_3g_probe_1 FAILED\n");
19661 printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
19662 if (test_sleep_0 () == -1) {
19663 printf ("test_sleep_0 FAILED\n");
19667 printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
19668 if (test_find_0 () == -1) {
19669 printf ("test_find_0 FAILED\n");
19673 printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
19674 if (test_find_1 () == -1) {
19675 printf ("test_find_1 FAILED\n");
19679 printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
19680 if (test_find_2 () == -1) {
19681 printf ("test_find_2 FAILED\n");
19685 printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
19686 if (test_lvresize_0 () == -1) {
19687 printf ("test_lvresize_0 FAILED\n");
19691 printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
19692 if (test_zerofree_0 () == -1) {
19693 printf ("test_zerofree_0 FAILED\n");
19697 printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
19698 if (test_hexdump_0 () == -1) {
19699 printf ("test_hexdump_0 FAILED\n");
19703 printf ("%3d/%3d test_hexdump_1\n", test_num, nr_tests);
19704 if (test_hexdump_1 () == -1) {
19705 printf ("test_hexdump_1 FAILED\n");
19709 printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
19710 if (test_strings_e_0 () == -1) {
19711 printf ("test_strings_e_0 FAILED\n");
19715 printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
19716 if (test_strings_e_1 () == -1) {
19717 printf ("test_strings_e_1 FAILED\n");
19721 printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
19722 if (test_strings_0 () == -1) {
19723 printf ("test_strings_0 FAILED\n");
19727 printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
19728 if (test_strings_1 () == -1) {
19729 printf ("test_strings_1 FAILED\n");
19733 printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
19734 if (test_equal_0 () == -1) {
19735 printf ("test_equal_0 FAILED\n");
19739 printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
19740 if (test_equal_1 () == -1) {
19741 printf ("test_equal_1 FAILED\n");
19745 printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
19746 if (test_equal_2 () == -1) {
19747 printf ("test_equal_2 FAILED\n");
19751 printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
19752 if (test_ping_daemon_0 () == -1) {
19753 printf ("test_ping_daemon_0 FAILED\n");
19757 printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
19758 if (test_dmesg_0 () == -1) {
19759 printf ("test_dmesg_0 FAILED\n");
19763 printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
19764 if (test_drop_caches_0 () == -1) {
19765 printf ("test_drop_caches_0 FAILED\n");
19769 printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
19770 if (test_mv_0 () == -1) {
19771 printf ("test_mv_0 FAILED\n");
19775 printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
19776 if (test_mv_1 () == -1) {
19777 printf ("test_mv_1 FAILED\n");
19781 printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
19782 if (test_cp_a_0 () == -1) {
19783 printf ("test_cp_a_0 FAILED\n");
19787 printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
19788 if (test_cp_0 () == -1) {
19789 printf ("test_cp_0 FAILED\n");
19793 printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
19794 if (test_cp_1 () == -1) {
19795 printf ("test_cp_1 FAILED\n");
19799 printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
19800 if (test_cp_2 () == -1) {
19801 printf ("test_cp_2 FAILED\n");
19805 printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
19806 if (test_grub_install_0 () == -1) {
19807 printf ("test_grub_install_0 FAILED\n");
19811 printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
19812 if (test_zero_0 () == -1) {
19813 printf ("test_zero_0 FAILED\n");
19817 printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
19818 if (test_fsck_0 () == -1) {
19819 printf ("test_fsck_0 FAILED\n");
19823 printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
19824 if (test_fsck_1 () == -1) {
19825 printf ("test_fsck_1 FAILED\n");
19829 printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
19830 if (test_set_e2uuid_0 () == -1) {
19831 printf ("test_set_e2uuid_0 FAILED\n");
19835 printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
19836 if (test_set_e2uuid_1 () == -1) {
19837 printf ("test_set_e2uuid_1 FAILED\n");
19841 printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
19842 if (test_set_e2uuid_2 () == -1) {
19843 printf ("test_set_e2uuid_2 FAILED\n");
19847 printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
19848 if (test_set_e2uuid_3 () == -1) {
19849 printf ("test_set_e2uuid_3 FAILED\n");
19853 printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
19854 if (test_set_e2label_0 () == -1) {
19855 printf ("test_set_e2label_0 FAILED\n");
19859 printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
19860 if (test_pvremove_0 () == -1) {
19861 printf ("test_pvremove_0 FAILED\n");
19865 printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
19866 if (test_pvremove_1 () == -1) {
19867 printf ("test_pvremove_1 FAILED\n");
19871 printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
19872 if (test_pvremove_2 () == -1) {
19873 printf ("test_pvremove_2 FAILED\n");
19877 printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
19878 if (test_vgremove_0 () == -1) {
19879 printf ("test_vgremove_0 FAILED\n");
19883 printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
19884 if (test_vgremove_1 () == -1) {
19885 printf ("test_vgremove_1 FAILED\n");
19889 printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
19890 if (test_lvremove_0 () == -1) {
19891 printf ("test_lvremove_0 FAILED\n");
19895 printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
19896 if (test_lvremove_1 () == -1) {
19897 printf ("test_lvremove_1 FAILED\n");
19901 printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
19902 if (test_lvremove_2 () == -1) {
19903 printf ("test_lvremove_2 FAILED\n");
19907 printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
19908 if (test_mount_ro_0 () == -1) {
19909 printf ("test_mount_ro_0 FAILED\n");
19913 printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
19914 if (test_mount_ro_1 () == -1) {
19915 printf ("test_mount_ro_1 FAILED\n");
19919 printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
19920 if (test_tgz_in_0 () == -1) {
19921 printf ("test_tgz_in_0 FAILED\n");
19925 printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
19926 if (test_tar_in_0 () == -1) {
19927 printf ("test_tar_in_0 FAILED\n");
19931 printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
19932 if (test_checksum_0 () == -1) {
19933 printf ("test_checksum_0 FAILED\n");
19937 printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
19938 if (test_checksum_1 () == -1) {
19939 printf ("test_checksum_1 FAILED\n");
19943 printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
19944 if (test_checksum_2 () == -1) {
19945 printf ("test_checksum_2 FAILED\n");
19949 printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
19950 if (test_checksum_3 () == -1) {
19951 printf ("test_checksum_3 FAILED\n");
19955 printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
19956 if (test_checksum_4 () == -1) {
19957 printf ("test_checksum_4 FAILED\n");
19961 printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
19962 if (test_checksum_5 () == -1) {
19963 printf ("test_checksum_5 FAILED\n");
19967 printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
19968 if (test_checksum_6 () == -1) {
19969 printf ("test_checksum_6 FAILED\n");
19973 printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
19974 if (test_checksum_7 () == -1) {
19975 printf ("test_checksum_7 FAILED\n");
19979 printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
19980 if (test_checksum_8 () == -1) {
19981 printf ("test_checksum_8 FAILED\n");
19985 printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
19986 if (test_download_0 () == -1) {
19987 printf ("test_download_0 FAILED\n");
19991 printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
19992 if (test_upload_0 () == -1) {
19993 printf ("test_upload_0 FAILED\n");
19997 printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
19998 if (test_blockdev_rereadpt_0 () == -1) {
19999 printf ("test_blockdev_rereadpt_0 FAILED\n");
20003 printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
20004 if (test_blockdev_flushbufs_0 () == -1) {
20005 printf ("test_blockdev_flushbufs_0 FAILED\n");
20009 printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
20010 if (test_blockdev_getsize64_0 () == -1) {
20011 printf ("test_blockdev_getsize64_0 FAILED\n");
20015 printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
20016 if (test_blockdev_getsz_0 () == -1) {
20017 printf ("test_blockdev_getsz_0 FAILED\n");
20021 printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
20022 if (test_blockdev_getbsz_0 () == -1) {
20023 printf ("test_blockdev_getbsz_0 FAILED\n");
20027 printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
20028 if (test_blockdev_getss_0 () == -1) {
20029 printf ("test_blockdev_getss_0 FAILED\n");
20033 printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
20034 if (test_blockdev_getro_0 () == -1) {
20035 printf ("test_blockdev_getro_0 FAILED\n");
20039 printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
20040 if (test_blockdev_setrw_0 () == -1) {
20041 printf ("test_blockdev_setrw_0 FAILED\n");
20045 printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
20046 if (test_blockdev_setro_0 () == -1) {
20047 printf ("test_blockdev_setro_0 FAILED\n");
20051 printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
20052 if (test_statvfs_0 () == -1) {
20053 printf ("test_statvfs_0 FAILED\n");
20057 printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
20058 if (test_lstat_0 () == -1) {
20059 printf ("test_lstat_0 FAILED\n");
20063 printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
20064 if (test_stat_0 () == -1) {
20065 printf ("test_stat_0 FAILED\n");
20069 printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
20070 if (test_command_lines_0 () == -1) {
20071 printf ("test_command_lines_0 FAILED\n");
20075 printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
20076 if (test_command_lines_1 () == -1) {
20077 printf ("test_command_lines_1 FAILED\n");
20081 printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
20082 if (test_command_lines_2 () == -1) {
20083 printf ("test_command_lines_2 FAILED\n");
20087 printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
20088 if (test_command_lines_3 () == -1) {
20089 printf ("test_command_lines_3 FAILED\n");
20093 printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
20094 if (test_command_lines_4 () == -1) {
20095 printf ("test_command_lines_4 FAILED\n");
20099 printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
20100 if (test_command_lines_5 () == -1) {
20101 printf ("test_command_lines_5 FAILED\n");
20105 printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
20106 if (test_command_lines_6 () == -1) {
20107 printf ("test_command_lines_6 FAILED\n");
20111 printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
20112 if (test_command_lines_7 () == -1) {
20113 printf ("test_command_lines_7 FAILED\n");
20117 printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
20118 if (test_command_lines_8 () == -1) {
20119 printf ("test_command_lines_8 FAILED\n");
20123 printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
20124 if (test_command_lines_9 () == -1) {
20125 printf ("test_command_lines_9 FAILED\n");
20129 printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
20130 if (test_command_lines_10 () == -1) {
20131 printf ("test_command_lines_10 FAILED\n");
20135 printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
20136 if (test_command_0 () == -1) {
20137 printf ("test_command_0 FAILED\n");
20141 printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
20142 if (test_command_1 () == -1) {
20143 printf ("test_command_1 FAILED\n");
20147 printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
20148 if (test_command_2 () == -1) {
20149 printf ("test_command_2 FAILED\n");
20153 printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
20154 if (test_command_3 () == -1) {
20155 printf ("test_command_3 FAILED\n");
20159 printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
20160 if (test_command_4 () == -1) {
20161 printf ("test_command_4 FAILED\n");
20165 printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
20166 if (test_command_5 () == -1) {
20167 printf ("test_command_5 FAILED\n");
20171 printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
20172 if (test_command_6 () == -1) {
20173 printf ("test_command_6 FAILED\n");
20177 printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
20178 if (test_command_7 () == -1) {
20179 printf ("test_command_7 FAILED\n");
20183 printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
20184 if (test_command_8 () == -1) {
20185 printf ("test_command_8 FAILED\n");
20189 printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
20190 if (test_command_9 () == -1) {
20191 printf ("test_command_9 FAILED\n");
20195 printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
20196 if (test_command_10 () == -1) {
20197 printf ("test_command_10 FAILED\n");
20201 printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
20202 if (test_command_11 () == -1) {
20203 printf ("test_command_11 FAILED\n");
20207 printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
20208 if (test_file_0 () == -1) {
20209 printf ("test_file_0 FAILED\n");
20213 printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
20214 if (test_file_1 () == -1) {
20215 printf ("test_file_1 FAILED\n");
20219 printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
20220 if (test_file_2 () == -1) {
20221 printf ("test_file_2 FAILED\n");
20225 printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
20226 if (test_umount_all_0 () == -1) {
20227 printf ("test_umount_all_0 FAILED\n");
20231 printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
20232 if (test_umount_all_1 () == -1) {
20233 printf ("test_umount_all_1 FAILED\n");
20237 printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
20238 if (test_mounts_0 () == -1) {
20239 printf ("test_mounts_0 FAILED\n");
20243 printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
20244 if (test_umount_0 () == -1) {
20245 printf ("test_umount_0 FAILED\n");
20249 printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
20250 if (test_umount_1 () == -1) {
20251 printf ("test_umount_1 FAILED\n");
20255 printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
20256 if (test_write_file_0 () == -1) {
20257 printf ("test_write_file_0 FAILED\n");
20261 printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
20262 if (test_write_file_1 () == -1) {
20263 printf ("test_write_file_1 FAILED\n");
20267 printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
20268 if (test_write_file_2 () == -1) {
20269 printf ("test_write_file_2 FAILED\n");
20273 printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
20274 if (test_write_file_3 () == -1) {
20275 printf ("test_write_file_3 FAILED\n");
20279 printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
20280 if (test_write_file_4 () == -1) {
20281 printf ("test_write_file_4 FAILED\n");
20285 printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
20286 if (test_write_file_5 () == -1) {
20287 printf ("test_write_file_5 FAILED\n");
20291 printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
20292 if (test_mkfs_0 () == -1) {
20293 printf ("test_mkfs_0 FAILED\n");
20297 printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
20298 if (test_lvcreate_0 () == -1) {
20299 printf ("test_lvcreate_0 FAILED\n");
20303 printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
20304 if (test_vgcreate_0 () == -1) {
20305 printf ("test_vgcreate_0 FAILED\n");
20309 printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
20310 if (test_pvcreate_0 () == -1) {
20311 printf ("test_pvcreate_0 FAILED\n");
20315 printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
20316 if (test_is_dir_0 () == -1) {
20317 printf ("test_is_dir_0 FAILED\n");
20321 printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
20322 if (test_is_dir_1 () == -1) {
20323 printf ("test_is_dir_1 FAILED\n");
20327 printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
20328 if (test_is_file_0 () == -1) {
20329 printf ("test_is_file_0 FAILED\n");
20333 printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
20334 if (test_is_file_1 () == -1) {
20335 printf ("test_is_file_1 FAILED\n");
20339 printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
20340 if (test_exists_0 () == -1) {
20341 printf ("test_exists_0 FAILED\n");
20345 printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
20346 if (test_exists_1 () == -1) {
20347 printf ("test_exists_1 FAILED\n");
20351 printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
20352 if (test_mkdir_p_0 () == -1) {
20353 printf ("test_mkdir_p_0 FAILED\n");
20357 printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
20358 if (test_mkdir_p_1 () == -1) {
20359 printf ("test_mkdir_p_1 FAILED\n");
20363 printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
20364 if (test_mkdir_p_2 () == -1) {
20365 printf ("test_mkdir_p_2 FAILED\n");
20369 printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
20370 if (test_mkdir_p_3 () == -1) {
20371 printf ("test_mkdir_p_3 FAILED\n");
20375 printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
20376 if (test_mkdir_p_4 () == -1) {
20377 printf ("test_mkdir_p_4 FAILED\n");
20381 printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
20382 if (test_mkdir_0 () == -1) {
20383 printf ("test_mkdir_0 FAILED\n");
20387 printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
20388 if (test_mkdir_1 () == -1) {
20389 printf ("test_mkdir_1 FAILED\n");
20393 printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
20394 if (test_rm_rf_0 () == -1) {
20395 printf ("test_rm_rf_0 FAILED\n");
20399 printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
20400 if (test_rmdir_0 () == -1) {
20401 printf ("test_rmdir_0 FAILED\n");
20405 printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
20406 if (test_rmdir_1 () == -1) {
20407 printf ("test_rmdir_1 FAILED\n");
20411 printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
20412 if (test_rmdir_2 () == -1) {
20413 printf ("test_rmdir_2 FAILED\n");
20417 printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
20418 if (test_rm_0 () == -1) {
20419 printf ("test_rm_0 FAILED\n");
20423 printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
20424 if (test_rm_1 () == -1) {
20425 printf ("test_rm_1 FAILED\n");
20429 printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
20430 if (test_rm_2 () == -1) {
20431 printf ("test_rm_2 FAILED\n");
20435 printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
20436 if (test_read_lines_0 () == -1) {
20437 printf ("test_read_lines_0 FAILED\n");
20441 printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
20442 if (test_read_lines_1 () == -1) {
20443 printf ("test_read_lines_1 FAILED\n");
20447 printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
20448 if (test_lvs_0 () == -1) {
20449 printf ("test_lvs_0 FAILED\n");
20453 printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
20454 if (test_lvs_1 () == -1) {
20455 printf ("test_lvs_1 FAILED\n");
20459 printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
20460 if (test_vgs_0 () == -1) {
20461 printf ("test_vgs_0 FAILED\n");
20465 printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
20466 if (test_vgs_1 () == -1) {
20467 printf ("test_vgs_1 FAILED\n");
20471 printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
20472 if (test_pvs_0 () == -1) {
20473 printf ("test_pvs_0 FAILED\n");
20477 printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
20478 if (test_pvs_1 () == -1) {
20479 printf ("test_pvs_1 FAILED\n");
20483 printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
20484 if (test_list_partitions_0 () == -1) {
20485 printf ("test_list_partitions_0 FAILED\n");
20489 printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
20490 if (test_list_partitions_1 () == -1) {
20491 printf ("test_list_partitions_1 FAILED\n");
20495 printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
20496 if (test_list_devices_0 () == -1) {
20497 printf ("test_list_devices_0 FAILED\n");
20501 printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
20502 if (test_ls_0 () == -1) {
20503 printf ("test_ls_0 FAILED\n");
20507 printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
20508 if (test_cat_0 () == -1) {
20509 printf ("test_cat_0 FAILED\n");
20513 printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
20514 if (test_touch_0 () == -1) {
20515 printf ("test_touch_0 FAILED\n");
20519 printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
20520 if (test_sync_0 () == -1) {
20521 printf ("test_sync_0 FAILED\n");
20525 printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
20526 if (test_mount_0 () == -1) {
20527 printf ("test_mount_0 FAILED\n");
20532 unlink ("test1.img");
20533 unlink ("test2.img");
20534 unlink ("test3.img");
20537 printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);