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");
160 fprintf (stderr, "warning: \"guestfs_readdir\" has no tests\n");
163 static int test_mknod_c_0_skip (void)
167 str = getenv ("TEST_ONLY");
169 return strstr (str, "mknod_c") == NULL;
170 str = getenv ("SKIP_TEST_MKNOD_C_0");
171 if (str && strcmp (str, "1") == 0) return 1;
172 str = getenv ("SKIP_TEST_MKNOD_C");
173 if (str && strcmp (str, "1") == 0) return 1;
177 static int test_mknod_c_0 (void)
179 if (test_mknod_c_0_skip ()) {
180 printf (" %s skipped (reason: environment variable set)\n", "test_mknod_c_0");
184 /* InitBasicFS for test_mknod_c_0: create ext2 on /dev/sda1 */
186 char device[] = "/dev/sda";
189 r = guestfs_blockdev_setrw (g, device);
196 r = guestfs_umount_all (g);
203 r = guestfs_lvm_remove_all (g);
208 char device[] = "/dev/sda";
209 char lines_0[] = ",";
216 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
221 char fstype[] = "ext2";
222 char device[] = "/dev/sda1";
225 r = guestfs_mkfs (g, fstype, device);
230 char device[] = "/dev/sda1";
231 char mountpoint[] = "/";
234 r = guestfs_mount (g, device, mountpoint);
238 /* TestOutputStruct for mknod_c (0) */
240 char path[] = "/node";
243 r = guestfs_mknod_c (g, 511, 99, 66, path);
248 char path[] = "/node";
249 struct guestfs_stat *r;
251 r = guestfs_stat (g, path);
254 if (r->mode != 8685) {
255 fprintf (stderr, "test_mknod_c_0: mode was %d, expected 8685\n",
264 static int test_mknod_b_0_skip (void)
268 str = getenv ("TEST_ONLY");
270 return strstr (str, "mknod_b") == NULL;
271 str = getenv ("SKIP_TEST_MKNOD_B_0");
272 if (str && strcmp (str, "1") == 0) return 1;
273 str = getenv ("SKIP_TEST_MKNOD_B");
274 if (str && strcmp (str, "1") == 0) return 1;
278 static int test_mknod_b_0 (void)
280 if (test_mknod_b_0_skip ()) {
281 printf (" %s skipped (reason: environment variable set)\n", "test_mknod_b_0");
285 /* InitBasicFS for test_mknod_b_0: create ext2 on /dev/sda1 */
287 char device[] = "/dev/sda";
290 r = guestfs_blockdev_setrw (g, device);
297 r = guestfs_umount_all (g);
304 r = guestfs_lvm_remove_all (g);
309 char device[] = "/dev/sda";
310 char lines_0[] = ",";
317 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
322 char fstype[] = "ext2";
323 char device[] = "/dev/sda1";
326 r = guestfs_mkfs (g, fstype, device);
331 char device[] = "/dev/sda1";
332 char mountpoint[] = "/";
335 r = guestfs_mount (g, device, mountpoint);
339 /* TestOutputStruct for mknod_b (0) */
341 char path[] = "/node";
344 r = guestfs_mknod_b (g, 511, 99, 66, path);
349 char path[] = "/node";
350 struct guestfs_stat *r;
352 r = guestfs_stat (g, path);
355 if (r->mode != 25069) {
356 fprintf (stderr, "test_mknod_b_0: mode was %d, expected 25069\n",
365 static int test_mkfifo_0_skip (void)
369 str = getenv ("TEST_ONLY");
371 return strstr (str, "mkfifo") == NULL;
372 str = getenv ("SKIP_TEST_MKFIFO_0");
373 if (str && strcmp (str, "1") == 0) return 1;
374 str = getenv ("SKIP_TEST_MKFIFO");
375 if (str && strcmp (str, "1") == 0) return 1;
379 static int test_mkfifo_0 (void)
381 if (test_mkfifo_0_skip ()) {
382 printf (" %s skipped (reason: environment variable set)\n", "test_mkfifo_0");
386 /* InitBasicFS for test_mkfifo_0: create ext2 on /dev/sda1 */
388 char device[] = "/dev/sda";
391 r = guestfs_blockdev_setrw (g, device);
398 r = guestfs_umount_all (g);
405 r = guestfs_lvm_remove_all (g);
410 char device[] = "/dev/sda";
411 char lines_0[] = ",";
418 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
423 char fstype[] = "ext2";
424 char device[] = "/dev/sda1";
427 r = guestfs_mkfs (g, fstype, device);
432 char device[] = "/dev/sda1";
433 char mountpoint[] = "/";
436 r = guestfs_mount (g, device, mountpoint);
440 /* TestOutputStruct for mkfifo (0) */
442 char path[] = "/node";
445 r = guestfs_mkfifo (g, 511, path);
450 char path[] = "/node";
451 struct guestfs_stat *r;
453 r = guestfs_stat (g, path);
456 if (r->mode != 4589) {
457 fprintf (stderr, "test_mkfifo_0: mode was %d, expected 4589\n",
466 static int test_mknod_0_skip (void)
470 str = getenv ("TEST_ONLY");
472 return strstr (str, "mknod") == NULL;
473 str = getenv ("SKIP_TEST_MKNOD_0");
474 if (str && strcmp (str, "1") == 0) return 1;
475 str = getenv ("SKIP_TEST_MKNOD");
476 if (str && strcmp (str, "1") == 0) return 1;
480 static int test_mknod_0 (void)
482 if (test_mknod_0_skip ()) {
483 printf (" %s skipped (reason: environment variable set)\n", "test_mknod_0");
487 /* InitBasicFS for test_mknod_0: create ext2 on /dev/sda1 */
489 char device[] = "/dev/sda";
492 r = guestfs_blockdev_setrw (g, device);
499 r = guestfs_umount_all (g);
506 r = guestfs_lvm_remove_all (g);
511 char device[] = "/dev/sda";
512 char lines_0[] = ",";
519 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
524 char fstype[] = "ext2";
525 char device[] = "/dev/sda1";
528 r = guestfs_mkfs (g, fstype, device);
533 char device[] = "/dev/sda1";
534 char mountpoint[] = "/";
537 r = guestfs_mount (g, device, mountpoint);
541 /* TestOutputStruct for mknod (0) */
543 char path[] = "/node";
546 r = guestfs_mknod (g, 4607, 0, 0, path);
551 char path[] = "/node";
552 struct guestfs_stat *r;
554 r = guestfs_stat (g, path);
557 if (r->mode != 4589) {
558 fprintf (stderr, "test_mknod_0: mode was %d, expected 4589\n",
567 static int test_mknod_1_skip (void)
571 str = getenv ("TEST_ONLY");
573 return strstr (str, "mknod") == NULL;
574 str = getenv ("SKIP_TEST_MKNOD_1");
575 if (str && strcmp (str, "1") == 0) return 1;
576 str = getenv ("SKIP_TEST_MKNOD");
577 if (str && strcmp (str, "1") == 0) return 1;
581 static int test_mknod_1 (void)
583 if (test_mknod_1_skip ()) {
584 printf (" %s skipped (reason: environment variable set)\n", "test_mknod_1");
588 /* InitBasicFS for test_mknod_1: create ext2 on /dev/sda1 */
590 char device[] = "/dev/sda";
593 r = guestfs_blockdev_setrw (g, device);
600 r = guestfs_umount_all (g);
607 r = guestfs_lvm_remove_all (g);
612 char device[] = "/dev/sda";
613 char lines_0[] = ",";
620 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
625 char fstype[] = "ext2";
626 char device[] = "/dev/sda1";
629 r = guestfs_mkfs (g, fstype, device);
634 char device[] = "/dev/sda1";
635 char mountpoint[] = "/";
638 r = guestfs_mount (g, device, mountpoint);
642 /* TestOutputStruct for mknod (1) */
644 char path[] = "/node";
647 r = guestfs_mknod (g, 25087, 66, 99, path);
652 char path[] = "/node";
653 struct guestfs_stat *r;
655 r = guestfs_stat (g, path);
658 if (r->mode != 25069) {
659 fprintf (stderr, "test_mknod_1: mode was %d, expected 25069\n",
668 static int test_mkswap_U_0_skip (void)
672 str = getenv ("TEST_ONLY");
674 return strstr (str, "mkswap_U") == NULL;
675 str = getenv ("SKIP_TEST_MKSWAP_U_0");
676 if (str && strcmp (str, "1") == 0) return 1;
677 str = getenv ("SKIP_TEST_MKSWAP_U");
678 if (str && strcmp (str, "1") == 0) return 1;
682 static int test_mkswap_U_0 (void)
684 if (test_mkswap_U_0_skip ()) {
685 printf (" %s skipped (reason: environment variable set)\n", "test_mkswap_U_0");
689 /* InitNone|InitEmpty for test_mkswap_U_0 */
691 char device[] = "/dev/sda";
694 r = guestfs_blockdev_setrw (g, device);
701 r = guestfs_umount_all (g);
708 r = guestfs_lvm_remove_all (g);
712 /* TestRun for mkswap_U (0) */
714 char device[] = "/dev/sda";
715 char lines_0[] = ",";
722 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
727 char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
728 char device[] = "/dev/sda1";
731 r = guestfs_mkswap_U (g, uuid, device);
738 static int test_mkswap_L_0_skip (void)
742 str = getenv ("TEST_ONLY");
744 return strstr (str, "mkswap_L") == NULL;
745 str = getenv ("SKIP_TEST_MKSWAP_L_0");
746 if (str && strcmp (str, "1") == 0) return 1;
747 str = getenv ("SKIP_TEST_MKSWAP_L");
748 if (str && strcmp (str, "1") == 0) return 1;
752 static int test_mkswap_L_0 (void)
754 if (test_mkswap_L_0_skip ()) {
755 printf (" %s skipped (reason: environment variable set)\n", "test_mkswap_L_0");
759 /* InitNone|InitEmpty for test_mkswap_L_0 */
761 char device[] = "/dev/sda";
764 r = guestfs_blockdev_setrw (g, device);
771 r = guestfs_umount_all (g);
778 r = guestfs_lvm_remove_all (g);
782 /* TestRun for mkswap_L (0) */
784 char device[] = "/dev/sda";
785 char lines_0[] = ",";
792 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
797 char label[] = "hello";
798 char device[] = "/dev/sda1";
801 r = guestfs_mkswap_L (g, label, device);
808 static int test_mkswap_0_skip (void)
812 str = getenv ("TEST_ONLY");
814 return strstr (str, "mkswap") == NULL;
815 str = getenv ("SKIP_TEST_MKSWAP_0");
816 if (str && strcmp (str, "1") == 0) return 1;
817 str = getenv ("SKIP_TEST_MKSWAP");
818 if (str && strcmp (str, "1") == 0) return 1;
822 static int test_mkswap_0 (void)
824 if (test_mkswap_0_skip ()) {
825 printf (" %s skipped (reason: environment variable set)\n", "test_mkswap_0");
829 /* InitNone|InitEmpty for test_mkswap_0 */
831 char device[] = "/dev/sda";
834 r = guestfs_blockdev_setrw (g, device);
841 r = guestfs_umount_all (g);
848 r = guestfs_lvm_remove_all (g);
852 /* TestRun for mkswap (0) */
854 char device[] = "/dev/sda";
855 char lines_0[] = ",";
862 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
867 char device[] = "/dev/sda1";
870 r = guestfs_mkswap (g, device);
877 static int test_initrd_list_0_skip (void)
881 str = getenv ("TEST_ONLY");
883 return strstr (str, "initrd_list") == NULL;
884 str = getenv ("SKIP_TEST_INITRD_LIST_0");
885 if (str && strcmp (str, "1") == 0) return 1;
886 str = getenv ("SKIP_TEST_INITRD_LIST");
887 if (str && strcmp (str, "1") == 0) return 1;
891 static int test_initrd_list_0 (void)
893 if (test_initrd_list_0_skip ()) {
894 printf (" %s skipped (reason: environment variable set)\n", "test_initrd_list_0");
898 /* InitBasicFS for test_initrd_list_0: create ext2 on /dev/sda1 */
900 char device[] = "/dev/sda";
903 r = guestfs_blockdev_setrw (g, device);
910 r = guestfs_umount_all (g);
917 r = guestfs_lvm_remove_all (g);
922 char device[] = "/dev/sda";
923 char lines_0[] = ",";
930 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
935 char fstype[] = "ext2";
936 char device[] = "/dev/sda1";
939 r = guestfs_mkfs (g, fstype, device);
944 char device[] = "/dev/sda1";
945 char mountpoint[] = "/";
948 r = guestfs_mount (g, device, mountpoint);
952 /* TestOutputList for initrd_list (0) */
954 char options[] = "ro";
955 char vfstype[] = "squashfs";
956 char device[] = "/dev/sdd";
957 char mountpoint[] = "/";
960 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
965 char path[] = "/initrd";
969 r = guestfs_initrd_list (g, path);
973 fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
978 char expected[] = "empty";
979 if (strcmp (r[0], expected) != 0) {
980 fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
985 fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
990 char expected[] = "known-1";
991 if (strcmp (r[1], expected) != 0) {
992 fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
997 fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
1002 char expected[] = "known-2";
1003 if (strcmp (r[2], expected) != 0) {
1004 fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1009 fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
1014 char expected[] = "known-3";
1015 if (strcmp (r[3], expected) != 0) {
1016 fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1021 fprintf (stderr, "test_initrd_list_0: extra elements returned from command\n");
1025 for (i = 0; r[i] != NULL; ++i)
1032 static int test_du_0_skip (void)
1036 str = getenv ("TEST_ONLY");
1038 return strstr (str, "du") == NULL;
1039 str = getenv ("SKIP_TEST_DU_0");
1040 if (str && strcmp (str, "1") == 0) return 1;
1041 str = getenv ("SKIP_TEST_DU");
1042 if (str && strcmp (str, "1") == 0) return 1;
1046 static int test_du_0 (void)
1048 if (test_du_0_skip ()) {
1049 printf (" %s skipped (reason: environment variable set)\n", "test_du_0");
1053 /* InitBasicFS for test_du_0: create ext2 on /dev/sda1 */
1055 char device[] = "/dev/sda";
1058 r = guestfs_blockdev_setrw (g, device);
1065 r = guestfs_umount_all (g);
1072 r = guestfs_lvm_remove_all (g);
1077 char device[] = "/dev/sda";
1078 char lines_0[] = ",";
1085 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1090 char fstype[] = "ext2";
1091 char device[] = "/dev/sda1";
1094 r = guestfs_mkfs (g, fstype, device);
1099 char device[] = "/dev/sda1";
1100 char mountpoint[] = "/";
1103 r = guestfs_mount (g, device, mountpoint);
1107 /* TestOutputInt for du (0) */
1112 r = guestfs_mkdir (g, path);
1120 r = guestfs_du (g, path);
1124 fprintf (stderr, "test_du_0: expected 1 but got %d\n", (int) r);
1131 static int test_tail_n_0_skip (void)
1135 str = getenv ("TEST_ONLY");
1137 return strstr (str, "tail_n") == NULL;
1138 str = getenv ("SKIP_TEST_TAIL_N_0");
1139 if (str && strcmp (str, "1") == 0) return 1;
1140 str = getenv ("SKIP_TEST_TAIL_N");
1141 if (str && strcmp (str, "1") == 0) return 1;
1145 static int test_tail_n_0 (void)
1147 if (test_tail_n_0_skip ()) {
1148 printf (" %s skipped (reason: environment variable set)\n", "test_tail_n_0");
1152 /* InitBasicFS for test_tail_n_0: create ext2 on /dev/sda1 */
1154 char device[] = "/dev/sda";
1157 r = guestfs_blockdev_setrw (g, device);
1164 r = guestfs_umount_all (g);
1171 r = guestfs_lvm_remove_all (g);
1176 char device[] = "/dev/sda";
1177 char lines_0[] = ",";
1184 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1189 char fstype[] = "ext2";
1190 char device[] = "/dev/sda1";
1193 r = guestfs_mkfs (g, fstype, device);
1198 char device[] = "/dev/sda1";
1199 char mountpoint[] = "/";
1202 r = guestfs_mount (g, device, mountpoint);
1206 /* TestOutputList for tail_n (0) */
1208 char options[] = "ro";
1209 char vfstype[] = "squashfs";
1210 char device[] = "/dev/sdd";
1211 char mountpoint[] = "/";
1214 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1219 char path[] = "/10klines";
1223 r = guestfs_tail_n (g, 3, path);
1227 fprintf (stderr, "test_tail_n_0: short list returned from command\n");
1232 char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
1233 if (strcmp (r[0], expected) != 0) {
1234 fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1239 fprintf (stderr, "test_tail_n_0: short list returned from command\n");
1244 char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
1245 if (strcmp (r[1], expected) != 0) {
1246 fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1251 fprintf (stderr, "test_tail_n_0: short list returned from command\n");
1256 char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
1257 if (strcmp (r[2], expected) != 0) {
1258 fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1263 fprintf (stderr, "test_tail_n_0: extra elements returned from command\n");
1267 for (i = 0; r[i] != NULL; ++i)
1274 static int test_tail_n_1_skip (void)
1278 str = getenv ("TEST_ONLY");
1280 return strstr (str, "tail_n") == NULL;
1281 str = getenv ("SKIP_TEST_TAIL_N_1");
1282 if (str && strcmp (str, "1") == 0) return 1;
1283 str = getenv ("SKIP_TEST_TAIL_N");
1284 if (str && strcmp (str, "1") == 0) return 1;
1288 static int test_tail_n_1 (void)
1290 if (test_tail_n_1_skip ()) {
1291 printf (" %s skipped (reason: environment variable set)\n", "test_tail_n_1");
1295 /* InitBasicFS for test_tail_n_1: create ext2 on /dev/sda1 */
1297 char device[] = "/dev/sda";
1300 r = guestfs_blockdev_setrw (g, device);
1307 r = guestfs_umount_all (g);
1314 r = guestfs_lvm_remove_all (g);
1319 char device[] = "/dev/sda";
1320 char lines_0[] = ",";
1327 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1332 char fstype[] = "ext2";
1333 char device[] = "/dev/sda1";
1336 r = guestfs_mkfs (g, fstype, device);
1341 char device[] = "/dev/sda1";
1342 char mountpoint[] = "/";
1345 r = guestfs_mount (g, device, mountpoint);
1349 /* TestOutputList for tail_n (1) */
1351 char options[] = "ro";
1352 char vfstype[] = "squashfs";
1353 char device[] = "/dev/sdd";
1354 char mountpoint[] = "/";
1357 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1362 char path[] = "/10klines";
1366 r = guestfs_tail_n (g, -9998, path);
1370 fprintf (stderr, "test_tail_n_1: short list returned from command\n");
1375 char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
1376 if (strcmp (r[0], expected) != 0) {
1377 fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1382 fprintf (stderr, "test_tail_n_1: short list returned from command\n");
1387 char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
1388 if (strcmp (r[1], expected) != 0) {
1389 fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1394 fprintf (stderr, "test_tail_n_1: short list returned from command\n");
1399 char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
1400 if (strcmp (r[2], expected) != 0) {
1401 fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1406 fprintf (stderr, "test_tail_n_1: extra elements returned from command\n");
1410 for (i = 0; r[i] != NULL; ++i)
1417 static int test_tail_n_2_skip (void)
1421 str = getenv ("TEST_ONLY");
1423 return strstr (str, "tail_n") == NULL;
1424 str = getenv ("SKIP_TEST_TAIL_N_2");
1425 if (str && strcmp (str, "1") == 0) return 1;
1426 str = getenv ("SKIP_TEST_TAIL_N");
1427 if (str && strcmp (str, "1") == 0) return 1;
1431 static int test_tail_n_2 (void)
1433 if (test_tail_n_2_skip ()) {
1434 printf (" %s skipped (reason: environment variable set)\n", "test_tail_n_2");
1438 /* InitBasicFS for test_tail_n_2: create ext2 on /dev/sda1 */
1440 char device[] = "/dev/sda";
1443 r = guestfs_blockdev_setrw (g, device);
1450 r = guestfs_umount_all (g);
1457 r = guestfs_lvm_remove_all (g);
1462 char device[] = "/dev/sda";
1463 char lines_0[] = ",";
1470 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1475 char fstype[] = "ext2";
1476 char device[] = "/dev/sda1";
1479 r = guestfs_mkfs (g, fstype, device);
1484 char device[] = "/dev/sda1";
1485 char mountpoint[] = "/";
1488 r = guestfs_mount (g, device, mountpoint);
1492 /* TestOutputList for tail_n (2) */
1494 char options[] = "ro";
1495 char vfstype[] = "squashfs";
1496 char device[] = "/dev/sdd";
1497 char mountpoint[] = "/";
1500 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1505 char path[] = "/10klines";
1509 r = guestfs_tail_n (g, 0, path);
1513 fprintf (stderr, "test_tail_n_2: extra elements returned from command\n");
1517 for (i = 0; r[i] != NULL; ++i)
1524 static int test_tail_0_skip (void)
1528 str = getenv ("TEST_ONLY");
1530 return strstr (str, "tail") == NULL;
1531 str = getenv ("SKIP_TEST_TAIL_0");
1532 if (str && strcmp (str, "1") == 0) return 1;
1533 str = getenv ("SKIP_TEST_TAIL");
1534 if (str && strcmp (str, "1") == 0) return 1;
1538 static int test_tail_0 (void)
1540 if (test_tail_0_skip ()) {
1541 printf (" %s skipped (reason: environment variable set)\n", "test_tail_0");
1545 /* InitBasicFS for test_tail_0: create ext2 on /dev/sda1 */
1547 char device[] = "/dev/sda";
1550 r = guestfs_blockdev_setrw (g, device);
1557 r = guestfs_umount_all (g);
1564 r = guestfs_lvm_remove_all (g);
1569 char device[] = "/dev/sda";
1570 char lines_0[] = ",";
1577 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1582 char fstype[] = "ext2";
1583 char device[] = "/dev/sda1";
1586 r = guestfs_mkfs (g, fstype, device);
1591 char device[] = "/dev/sda1";
1592 char mountpoint[] = "/";
1595 r = guestfs_mount (g, device, mountpoint);
1599 /* TestOutputList for tail (0) */
1601 char options[] = "ro";
1602 char vfstype[] = "squashfs";
1603 char device[] = "/dev/sdd";
1604 char mountpoint[] = "/";
1607 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1612 char path[] = "/10klines";
1616 r = guestfs_tail (g, path);
1620 fprintf (stderr, "test_tail_0: short list returned from command\n");
1625 char expected[] = "9990abcdefghijklmnopqrstuvwxyz";
1626 if (strcmp (r[0], expected) != 0) {
1627 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1632 fprintf (stderr, "test_tail_0: short list returned from command\n");
1637 char expected[] = "9991abcdefghijklmnopqrstuvwxyz";
1638 if (strcmp (r[1], expected) != 0) {
1639 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1644 fprintf (stderr, "test_tail_0: short list returned from command\n");
1649 char expected[] = "9992abcdefghijklmnopqrstuvwxyz";
1650 if (strcmp (r[2], expected) != 0) {
1651 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1656 fprintf (stderr, "test_tail_0: short list returned from command\n");
1661 char expected[] = "9993abcdefghijklmnopqrstuvwxyz";
1662 if (strcmp (r[3], expected) != 0) {
1663 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1668 fprintf (stderr, "test_tail_0: short list returned from command\n");
1673 char expected[] = "9994abcdefghijklmnopqrstuvwxyz";
1674 if (strcmp (r[4], expected) != 0) {
1675 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
1680 fprintf (stderr, "test_tail_0: short list returned from command\n");
1685 char expected[] = "9995abcdefghijklmnopqrstuvwxyz";
1686 if (strcmp (r[5], expected) != 0) {
1687 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
1692 fprintf (stderr, "test_tail_0: short list returned from command\n");
1697 char expected[] = "9996abcdefghijklmnopqrstuvwxyz";
1698 if (strcmp (r[6], expected) != 0) {
1699 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
1704 fprintf (stderr, "test_tail_0: short list returned from command\n");
1709 char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
1710 if (strcmp (r[7], expected) != 0) {
1711 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
1716 fprintf (stderr, "test_tail_0: short list returned from command\n");
1721 char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
1722 if (strcmp (r[8], expected) != 0) {
1723 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
1728 fprintf (stderr, "test_tail_0: short list returned from command\n");
1733 char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
1734 if (strcmp (r[9], expected) != 0) {
1735 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
1739 if (r[10] != NULL) {
1740 fprintf (stderr, "test_tail_0: extra elements returned from command\n");
1744 for (i = 0; r[i] != NULL; ++i)
1751 static int test_head_n_0_skip (void)
1755 str = getenv ("TEST_ONLY");
1757 return strstr (str, "head_n") == NULL;
1758 str = getenv ("SKIP_TEST_HEAD_N_0");
1759 if (str && strcmp (str, "1") == 0) return 1;
1760 str = getenv ("SKIP_TEST_HEAD_N");
1761 if (str && strcmp (str, "1") == 0) return 1;
1765 static int test_head_n_0 (void)
1767 if (test_head_n_0_skip ()) {
1768 printf (" %s skipped (reason: environment variable set)\n", "test_head_n_0");
1772 /* InitBasicFS for test_head_n_0: create ext2 on /dev/sda1 */
1774 char device[] = "/dev/sda";
1777 r = guestfs_blockdev_setrw (g, device);
1784 r = guestfs_umount_all (g);
1791 r = guestfs_lvm_remove_all (g);
1796 char device[] = "/dev/sda";
1797 char lines_0[] = ",";
1804 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1809 char fstype[] = "ext2";
1810 char device[] = "/dev/sda1";
1813 r = guestfs_mkfs (g, fstype, device);
1818 char device[] = "/dev/sda1";
1819 char mountpoint[] = "/";
1822 r = guestfs_mount (g, device, mountpoint);
1826 /* TestOutputList for head_n (0) */
1828 char options[] = "ro";
1829 char vfstype[] = "squashfs";
1830 char device[] = "/dev/sdd";
1831 char mountpoint[] = "/";
1834 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1839 char path[] = "/10klines";
1843 r = guestfs_head_n (g, 3, path);
1847 fprintf (stderr, "test_head_n_0: short list returned from command\n");
1852 char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1853 if (strcmp (r[0], expected) != 0) {
1854 fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1859 fprintf (stderr, "test_head_n_0: short list returned from command\n");
1864 char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1865 if (strcmp (r[1], expected) != 0) {
1866 fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1871 fprintf (stderr, "test_head_n_0: short list returned from command\n");
1876 char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1877 if (strcmp (r[2], expected) != 0) {
1878 fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1883 fprintf (stderr, "test_head_n_0: extra elements returned from command\n");
1887 for (i = 0; r[i] != NULL; ++i)
1894 static int test_head_n_1_skip (void)
1898 str = getenv ("TEST_ONLY");
1900 return strstr (str, "head_n") == NULL;
1901 str = getenv ("SKIP_TEST_HEAD_N_1");
1902 if (str && strcmp (str, "1") == 0) return 1;
1903 str = getenv ("SKIP_TEST_HEAD_N");
1904 if (str && strcmp (str, "1") == 0) return 1;
1908 static int test_head_n_1 (void)
1910 if (test_head_n_1_skip ()) {
1911 printf (" %s skipped (reason: environment variable set)\n", "test_head_n_1");
1915 /* InitBasicFS for test_head_n_1: create ext2 on /dev/sda1 */
1917 char device[] = "/dev/sda";
1920 r = guestfs_blockdev_setrw (g, device);
1927 r = guestfs_umount_all (g);
1934 r = guestfs_lvm_remove_all (g);
1939 char device[] = "/dev/sda";
1940 char lines_0[] = ",";
1947 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1952 char fstype[] = "ext2";
1953 char device[] = "/dev/sda1";
1956 r = guestfs_mkfs (g, fstype, device);
1961 char device[] = "/dev/sda1";
1962 char mountpoint[] = "/";
1965 r = guestfs_mount (g, device, mountpoint);
1969 /* TestOutputList for head_n (1) */
1971 char options[] = "ro";
1972 char vfstype[] = "squashfs";
1973 char device[] = "/dev/sdd";
1974 char mountpoint[] = "/";
1977 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1982 char path[] = "/10klines";
1986 r = guestfs_head_n (g, -9997, path);
1990 fprintf (stderr, "test_head_n_1: short list returned from command\n");
1995 char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1996 if (strcmp (r[0], expected) != 0) {
1997 fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2002 fprintf (stderr, "test_head_n_1: short list returned from command\n");
2007 char expected[] = "1abcdefghijklmnopqrstuvwxyz";
2008 if (strcmp (r[1], expected) != 0) {
2009 fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2014 fprintf (stderr, "test_head_n_1: short list returned from command\n");
2019 char expected[] = "2abcdefghijklmnopqrstuvwxyz";
2020 if (strcmp (r[2], expected) != 0) {
2021 fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
2026 fprintf (stderr, "test_head_n_1: extra elements returned from command\n");
2030 for (i = 0; r[i] != NULL; ++i)
2037 static int test_head_n_2_skip (void)
2041 str = getenv ("TEST_ONLY");
2043 return strstr (str, "head_n") == NULL;
2044 str = getenv ("SKIP_TEST_HEAD_N_2");
2045 if (str && strcmp (str, "1") == 0) return 1;
2046 str = getenv ("SKIP_TEST_HEAD_N");
2047 if (str && strcmp (str, "1") == 0) return 1;
2051 static int test_head_n_2 (void)
2053 if (test_head_n_2_skip ()) {
2054 printf (" %s skipped (reason: environment variable set)\n", "test_head_n_2");
2058 /* InitBasicFS for test_head_n_2: create ext2 on /dev/sda1 */
2060 char device[] = "/dev/sda";
2063 r = guestfs_blockdev_setrw (g, device);
2070 r = guestfs_umount_all (g);
2077 r = guestfs_lvm_remove_all (g);
2082 char device[] = "/dev/sda";
2083 char lines_0[] = ",";
2090 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2095 char fstype[] = "ext2";
2096 char device[] = "/dev/sda1";
2099 r = guestfs_mkfs (g, fstype, device);
2104 char device[] = "/dev/sda1";
2105 char mountpoint[] = "/";
2108 r = guestfs_mount (g, device, mountpoint);
2112 /* TestOutputList for head_n (2) */
2114 char options[] = "ro";
2115 char vfstype[] = "squashfs";
2116 char device[] = "/dev/sdd";
2117 char mountpoint[] = "/";
2120 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2125 char path[] = "/10klines";
2129 r = guestfs_head_n (g, 0, path);
2133 fprintf (stderr, "test_head_n_2: extra elements returned from command\n");
2137 for (i = 0; r[i] != NULL; ++i)
2144 static int test_head_0_skip (void)
2148 str = getenv ("TEST_ONLY");
2150 return strstr (str, "head") == NULL;
2151 str = getenv ("SKIP_TEST_HEAD_0");
2152 if (str && strcmp (str, "1") == 0) return 1;
2153 str = getenv ("SKIP_TEST_HEAD");
2154 if (str && strcmp (str, "1") == 0) return 1;
2158 static int test_head_0 (void)
2160 if (test_head_0_skip ()) {
2161 printf (" %s skipped (reason: environment variable set)\n", "test_head_0");
2165 /* InitBasicFS for test_head_0: create ext2 on /dev/sda1 */
2167 char device[] = "/dev/sda";
2170 r = guestfs_blockdev_setrw (g, device);
2177 r = guestfs_umount_all (g);
2184 r = guestfs_lvm_remove_all (g);
2189 char device[] = "/dev/sda";
2190 char lines_0[] = ",";
2197 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2202 char fstype[] = "ext2";
2203 char device[] = "/dev/sda1";
2206 r = guestfs_mkfs (g, fstype, device);
2211 char device[] = "/dev/sda1";
2212 char mountpoint[] = "/";
2215 r = guestfs_mount (g, device, mountpoint);
2219 /* TestOutputList for head (0) */
2221 char options[] = "ro";
2222 char vfstype[] = "squashfs";
2223 char device[] = "/dev/sdd";
2224 char mountpoint[] = "/";
2227 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2232 char path[] = "/10klines";
2236 r = guestfs_head (g, path);
2240 fprintf (stderr, "test_head_0: short list returned from command\n");
2245 char expected[] = "0abcdefghijklmnopqrstuvwxyz";
2246 if (strcmp (r[0], expected) != 0) {
2247 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2252 fprintf (stderr, "test_head_0: short list returned from command\n");
2257 char expected[] = "1abcdefghijklmnopqrstuvwxyz";
2258 if (strcmp (r[1], expected) != 0) {
2259 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2264 fprintf (stderr, "test_head_0: short list returned from command\n");
2269 char expected[] = "2abcdefghijklmnopqrstuvwxyz";
2270 if (strcmp (r[2], expected) != 0) {
2271 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
2276 fprintf (stderr, "test_head_0: short list returned from command\n");
2281 char expected[] = "3abcdefghijklmnopqrstuvwxyz";
2282 if (strcmp (r[3], expected) != 0) {
2283 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
2288 fprintf (stderr, "test_head_0: short list returned from command\n");
2293 char expected[] = "4abcdefghijklmnopqrstuvwxyz";
2294 if (strcmp (r[4], expected) != 0) {
2295 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
2300 fprintf (stderr, "test_head_0: short list returned from command\n");
2305 char expected[] = "5abcdefghijklmnopqrstuvwxyz";
2306 if (strcmp (r[5], expected) != 0) {
2307 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
2312 fprintf (stderr, "test_head_0: short list returned from command\n");
2317 char expected[] = "6abcdefghijklmnopqrstuvwxyz";
2318 if (strcmp (r[6], expected) != 0) {
2319 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
2324 fprintf (stderr, "test_head_0: short list returned from command\n");
2329 char expected[] = "7abcdefghijklmnopqrstuvwxyz";
2330 if (strcmp (r[7], expected) != 0) {
2331 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
2336 fprintf (stderr, "test_head_0: short list returned from command\n");
2341 char expected[] = "8abcdefghijklmnopqrstuvwxyz";
2342 if (strcmp (r[8], expected) != 0) {
2343 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
2348 fprintf (stderr, "test_head_0: short list returned from command\n");
2353 char expected[] = "9abcdefghijklmnopqrstuvwxyz";
2354 if (strcmp (r[9], expected) != 0) {
2355 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
2359 if (r[10] != NULL) {
2360 fprintf (stderr, "test_head_0: extra elements returned from command\n");
2364 for (i = 0; r[i] != NULL; ++i)
2371 static int test_wc_c_0_skip (void)
2375 str = getenv ("TEST_ONLY");
2377 return strstr (str, "wc_c") == NULL;
2378 str = getenv ("SKIP_TEST_WC_C_0");
2379 if (str && strcmp (str, "1") == 0) return 1;
2380 str = getenv ("SKIP_TEST_WC_C");
2381 if (str && strcmp (str, "1") == 0) return 1;
2385 static int test_wc_c_0 (void)
2387 if (test_wc_c_0_skip ()) {
2388 printf (" %s skipped (reason: environment variable set)\n", "test_wc_c_0");
2392 /* InitBasicFS for test_wc_c_0: create ext2 on /dev/sda1 */
2394 char device[] = "/dev/sda";
2397 r = guestfs_blockdev_setrw (g, device);
2404 r = guestfs_umount_all (g);
2411 r = guestfs_lvm_remove_all (g);
2416 char device[] = "/dev/sda";
2417 char lines_0[] = ",";
2424 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2429 char fstype[] = "ext2";
2430 char device[] = "/dev/sda1";
2433 r = guestfs_mkfs (g, fstype, device);
2438 char device[] = "/dev/sda1";
2439 char mountpoint[] = "/";
2442 r = guestfs_mount (g, device, mountpoint);
2446 /* TestOutputInt for wc_c (0) */
2448 char options[] = "ro";
2449 char vfstype[] = "squashfs";
2450 char device[] = "/dev/sdd";
2451 char mountpoint[] = "/";
2454 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2459 char path[] = "/100kallspaces";
2462 r = guestfs_wc_c (g, path);
2466 fprintf (stderr, "test_wc_c_0: expected 102400 but got %d\n", (int) r);
2473 static int test_wc_w_0_skip (void)
2477 str = getenv ("TEST_ONLY");
2479 return strstr (str, "wc_w") == NULL;
2480 str = getenv ("SKIP_TEST_WC_W_0");
2481 if (str && strcmp (str, "1") == 0) return 1;
2482 str = getenv ("SKIP_TEST_WC_W");
2483 if (str && strcmp (str, "1") == 0) return 1;
2487 static int test_wc_w_0 (void)
2489 if (test_wc_w_0_skip ()) {
2490 printf (" %s skipped (reason: environment variable set)\n", "test_wc_w_0");
2494 /* InitBasicFS for test_wc_w_0: create ext2 on /dev/sda1 */
2496 char device[] = "/dev/sda";
2499 r = guestfs_blockdev_setrw (g, device);
2506 r = guestfs_umount_all (g);
2513 r = guestfs_lvm_remove_all (g);
2518 char device[] = "/dev/sda";
2519 char lines_0[] = ",";
2526 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2531 char fstype[] = "ext2";
2532 char device[] = "/dev/sda1";
2535 r = guestfs_mkfs (g, fstype, device);
2540 char device[] = "/dev/sda1";
2541 char mountpoint[] = "/";
2544 r = guestfs_mount (g, device, mountpoint);
2548 /* TestOutputInt for wc_w (0) */
2550 char options[] = "ro";
2551 char vfstype[] = "squashfs";
2552 char device[] = "/dev/sdd";
2553 char mountpoint[] = "/";
2556 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2561 char path[] = "/10klines";
2564 r = guestfs_wc_w (g, path);
2568 fprintf (stderr, "test_wc_w_0: expected 10000 but got %d\n", (int) r);
2575 static int test_wc_l_0_skip (void)
2579 str = getenv ("TEST_ONLY");
2581 return strstr (str, "wc_l") == NULL;
2582 str = getenv ("SKIP_TEST_WC_L_0");
2583 if (str && strcmp (str, "1") == 0) return 1;
2584 str = getenv ("SKIP_TEST_WC_L");
2585 if (str && strcmp (str, "1") == 0) return 1;
2589 static int test_wc_l_0 (void)
2591 if (test_wc_l_0_skip ()) {
2592 printf (" %s skipped (reason: environment variable set)\n", "test_wc_l_0");
2596 /* InitBasicFS for test_wc_l_0: create ext2 on /dev/sda1 */
2598 char device[] = "/dev/sda";
2601 r = guestfs_blockdev_setrw (g, device);
2608 r = guestfs_umount_all (g);
2615 r = guestfs_lvm_remove_all (g);
2620 char device[] = "/dev/sda";
2621 char lines_0[] = ",";
2628 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2633 char fstype[] = "ext2";
2634 char device[] = "/dev/sda1";
2637 r = guestfs_mkfs (g, fstype, device);
2642 char device[] = "/dev/sda1";
2643 char mountpoint[] = "/";
2646 r = guestfs_mount (g, device, mountpoint);
2650 /* TestOutputInt for wc_l (0) */
2652 char options[] = "ro";
2653 char vfstype[] = "squashfs";
2654 char device[] = "/dev/sdd";
2655 char mountpoint[] = "/";
2658 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2663 char path[] = "/10klines";
2666 r = guestfs_wc_l (g, path);
2670 fprintf (stderr, "test_wc_l_0: expected 10000 but got %d\n", (int) r);
2677 static int test_mkdtemp_0_skip (void)
2681 str = getenv ("TEST_ONLY");
2683 return strstr (str, "mkdtemp") == NULL;
2684 str = getenv ("SKIP_TEST_MKDTEMP_0");
2685 if (str && strcmp (str, "1") == 0) return 1;
2686 str = getenv ("SKIP_TEST_MKDTEMP");
2687 if (str && strcmp (str, "1") == 0) return 1;
2691 static int test_mkdtemp_0 (void)
2693 if (test_mkdtemp_0_skip ()) {
2694 printf (" %s skipped (reason: environment variable set)\n", "test_mkdtemp_0");
2698 /* InitBasicFS for test_mkdtemp_0: create ext2 on /dev/sda1 */
2700 char device[] = "/dev/sda";
2703 r = guestfs_blockdev_setrw (g, device);
2710 r = guestfs_umount_all (g);
2717 r = guestfs_lvm_remove_all (g);
2722 char device[] = "/dev/sda";
2723 char lines_0[] = ",";
2730 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2735 char fstype[] = "ext2";
2736 char device[] = "/dev/sda1";
2739 r = guestfs_mkfs (g, fstype, device);
2744 char device[] = "/dev/sda1";
2745 char mountpoint[] = "/";
2748 r = guestfs_mount (g, device, mountpoint);
2752 /* TestRun for mkdtemp (0) */
2754 char path[] = "/tmp";
2757 r = guestfs_mkdir (g, path);
2762 char template[] = "/tmp/tmpXXXXXX";
2765 r = guestfs_mkdtemp (g, template);
2773 static int test_scrub_file_0_skip (void)
2777 str = getenv ("TEST_ONLY");
2779 return strstr (str, "scrub_file") == NULL;
2780 str = getenv ("SKIP_TEST_SCRUB_FILE_0");
2781 if (str && strcmp (str, "1") == 0) return 1;
2782 str = getenv ("SKIP_TEST_SCRUB_FILE");
2783 if (str && strcmp (str, "1") == 0) return 1;
2787 static int test_scrub_file_0 (void)
2789 if (test_scrub_file_0_skip ()) {
2790 printf (" %s skipped (reason: environment variable set)\n", "test_scrub_file_0");
2794 /* InitBasicFS for test_scrub_file_0: create ext2 on /dev/sda1 */
2796 char device[] = "/dev/sda";
2799 r = guestfs_blockdev_setrw (g, device);
2806 r = guestfs_umount_all (g);
2813 r = guestfs_lvm_remove_all (g);
2818 char device[] = "/dev/sda";
2819 char lines_0[] = ",";
2826 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2831 char fstype[] = "ext2";
2832 char device[] = "/dev/sda1";
2835 r = guestfs_mkfs (g, fstype, device);
2840 char device[] = "/dev/sda1";
2841 char mountpoint[] = "/";
2844 r = guestfs_mount (g, device, mountpoint);
2848 /* TestRun for scrub_file (0) */
2850 char path[] = "/file";
2851 char content[] = "content";
2854 r = guestfs_write_file (g, path, content, 0);
2859 char file[] = "/file";
2862 r = guestfs_scrub_file (g, file);
2869 static int test_scrub_device_0_skip (void)
2873 str = getenv ("TEST_ONLY");
2875 return strstr (str, "scrub_device") == NULL;
2876 str = getenv ("SKIP_TEST_SCRUB_DEVICE_0");
2877 if (str && strcmp (str, "1") == 0) return 1;
2878 str = getenv ("SKIP_TEST_SCRUB_DEVICE");
2879 if (str && strcmp (str, "1") == 0) return 1;
2883 static int test_scrub_device_0 (void)
2885 if (test_scrub_device_0_skip ()) {
2886 printf (" %s skipped (reason: environment variable set)\n", "test_scrub_device_0");
2890 /* InitNone|InitEmpty for test_scrub_device_0 */
2892 char device[] = "/dev/sda";
2895 r = guestfs_blockdev_setrw (g, device);
2902 r = guestfs_umount_all (g);
2909 r = guestfs_lvm_remove_all (g);
2913 /* TestRun for scrub_device (0) */
2915 char device[] = "/dev/sdc";
2918 r = guestfs_scrub_device (g, device);
2925 static int test_glob_expand_0_skip (void)
2929 str = getenv ("TEST_ONLY");
2931 return strstr (str, "glob_expand") == NULL;
2932 str = getenv ("SKIP_TEST_GLOB_EXPAND_0");
2933 if (str && strcmp (str, "1") == 0) return 1;
2934 str = getenv ("SKIP_TEST_GLOB_EXPAND");
2935 if (str && strcmp (str, "1") == 0) return 1;
2939 static int test_glob_expand_0 (void)
2941 if (test_glob_expand_0_skip ()) {
2942 printf (" %s skipped (reason: environment variable set)\n", "test_glob_expand_0");
2946 /* InitBasicFS for test_glob_expand_0: create ext2 on /dev/sda1 */
2948 char device[] = "/dev/sda";
2951 r = guestfs_blockdev_setrw (g, device);
2958 r = guestfs_umount_all (g);
2965 r = guestfs_lvm_remove_all (g);
2970 char device[] = "/dev/sda";
2971 char lines_0[] = ",";
2978 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2983 char fstype[] = "ext2";
2984 char device[] = "/dev/sda1";
2987 r = guestfs_mkfs (g, fstype, device);
2992 char device[] = "/dev/sda1";
2993 char mountpoint[] = "/";
2996 r = guestfs_mount (g, device, mountpoint);
3000 /* TestOutputList for glob_expand (0) */
3002 char path[] = "/a/b/c";
3005 r = guestfs_mkdir_p (g, path);
3010 char path[] = "/a/b/c/d";
3013 r = guestfs_touch (g, path);
3018 char path[] = "/a/b/c/e";
3021 r = guestfs_touch (g, path);
3026 char pattern[] = "/a/b/c/*";
3030 r = guestfs_glob_expand (g, pattern);
3034 fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
3039 char expected[] = "/a/b/c/d";
3040 if (strcmp (r[0], expected) != 0) {
3041 fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3046 fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
3051 char expected[] = "/a/b/c/e";
3052 if (strcmp (r[1], expected) != 0) {
3053 fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3058 fprintf (stderr, "test_glob_expand_0: extra elements returned from command\n");
3062 for (i = 0; r[i] != NULL; ++i)
3069 static int test_glob_expand_1_skip (void)
3073 str = getenv ("TEST_ONLY");
3075 return strstr (str, "glob_expand") == NULL;
3076 str = getenv ("SKIP_TEST_GLOB_EXPAND_1");
3077 if (str && strcmp (str, "1") == 0) return 1;
3078 str = getenv ("SKIP_TEST_GLOB_EXPAND");
3079 if (str && strcmp (str, "1") == 0) return 1;
3083 static int test_glob_expand_1 (void)
3085 if (test_glob_expand_1_skip ()) {
3086 printf (" %s skipped (reason: environment variable set)\n", "test_glob_expand_1");
3090 /* InitBasicFS for test_glob_expand_1: create ext2 on /dev/sda1 */
3092 char device[] = "/dev/sda";
3095 r = guestfs_blockdev_setrw (g, device);
3102 r = guestfs_umount_all (g);
3109 r = guestfs_lvm_remove_all (g);
3114 char device[] = "/dev/sda";
3115 char lines_0[] = ",";
3122 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3127 char fstype[] = "ext2";
3128 char device[] = "/dev/sda1";
3131 r = guestfs_mkfs (g, fstype, device);
3136 char device[] = "/dev/sda1";
3137 char mountpoint[] = "/";
3140 r = guestfs_mount (g, device, mountpoint);
3144 /* TestOutputList for glob_expand (1) */
3146 char path[] = "/a/b/c";
3149 r = guestfs_mkdir_p (g, path);
3154 char path[] = "/a/b/c/d";
3157 r = guestfs_touch (g, path);
3162 char path[] = "/a/b/c/e";
3165 r = guestfs_touch (g, path);
3170 char pattern[] = "/a/*/c/*";
3174 r = guestfs_glob_expand (g, pattern);
3178 fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
3183 char expected[] = "/a/b/c/d";
3184 if (strcmp (r[0], expected) != 0) {
3185 fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3190 fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
3195 char expected[] = "/a/b/c/e";
3196 if (strcmp (r[1], expected) != 0) {
3197 fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3202 fprintf (stderr, "test_glob_expand_1: extra elements returned from command\n");
3206 for (i = 0; r[i] != NULL; ++i)
3213 static int test_glob_expand_2_skip (void)
3217 str = getenv ("TEST_ONLY");
3219 return strstr (str, "glob_expand") == NULL;
3220 str = getenv ("SKIP_TEST_GLOB_EXPAND_2");
3221 if (str && strcmp (str, "1") == 0) return 1;
3222 str = getenv ("SKIP_TEST_GLOB_EXPAND");
3223 if (str && strcmp (str, "1") == 0) return 1;
3227 static int test_glob_expand_2 (void)
3229 if (test_glob_expand_2_skip ()) {
3230 printf (" %s skipped (reason: environment variable set)\n", "test_glob_expand_2");
3234 /* InitBasicFS for test_glob_expand_2: create ext2 on /dev/sda1 */
3236 char device[] = "/dev/sda";
3239 r = guestfs_blockdev_setrw (g, device);
3246 r = guestfs_umount_all (g);
3253 r = guestfs_lvm_remove_all (g);
3258 char device[] = "/dev/sda";
3259 char lines_0[] = ",";
3266 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3271 char fstype[] = "ext2";
3272 char device[] = "/dev/sda1";
3275 r = guestfs_mkfs (g, fstype, device);
3280 char device[] = "/dev/sda1";
3281 char mountpoint[] = "/";
3284 r = guestfs_mount (g, device, mountpoint);
3288 /* TestOutputList for glob_expand (2) */
3290 char path[] = "/a/b/c";
3293 r = guestfs_mkdir_p (g, path);
3298 char path[] = "/a/b/c/d";
3301 r = guestfs_touch (g, path);
3306 char path[] = "/a/b/c/e";
3309 r = guestfs_touch (g, path);
3314 char pattern[] = "/a/*/x/*";
3318 r = guestfs_glob_expand (g, pattern);
3322 fprintf (stderr, "test_glob_expand_2: extra elements returned from command\n");
3326 for (i = 0; r[i] != NULL; ++i)
3333 static int test_ntfs_3g_probe_0_skip (void)
3337 str = getenv ("TEST_ONLY");
3339 return strstr (str, "ntfs_3g_probe") == NULL;
3340 str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0");
3341 if (str && strcmp (str, "1") == 0) return 1;
3342 str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
3343 if (str && strcmp (str, "1") == 0) return 1;
3347 static int test_ntfs_3g_probe_0 (void)
3349 if (test_ntfs_3g_probe_0_skip ()) {
3350 printf (" %s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_0");
3354 /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
3356 char device[] = "/dev/sda";
3359 r = guestfs_blockdev_setrw (g, device);
3366 r = guestfs_umount_all (g);
3373 r = guestfs_lvm_remove_all (g);
3377 /* TestOutputInt for ntfs_3g_probe (0) */
3379 char device[] = "/dev/sda";
3380 char lines_0[] = ",";
3387 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3392 char fstype[] = "ntfs";
3393 char device[] = "/dev/sda1";
3396 r = guestfs_mkfs (g, fstype, device);
3401 char device[] = "/dev/sda1";
3404 r = guestfs_ntfs_3g_probe (g, 1, device);
3408 fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n", (int) r);
3415 static int test_ntfs_3g_probe_1_skip (void)
3419 str = getenv ("TEST_ONLY");
3421 return strstr (str, "ntfs_3g_probe") == NULL;
3422 str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
3423 if (str && strcmp (str, "1") == 0) return 1;
3424 str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
3425 if (str && strcmp (str, "1") == 0) return 1;
3429 static int test_ntfs_3g_probe_1 (void)
3431 if (test_ntfs_3g_probe_1_skip ()) {
3432 printf (" %s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_1");
3436 /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
3438 char device[] = "/dev/sda";
3441 r = guestfs_blockdev_setrw (g, device);
3448 r = guestfs_umount_all (g);
3455 r = guestfs_lvm_remove_all (g);
3459 /* TestOutputInt for ntfs_3g_probe (1) */
3461 char device[] = "/dev/sda";
3462 char lines_0[] = ",";
3469 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3474 char fstype[] = "ext2";
3475 char device[] = "/dev/sda1";
3478 r = guestfs_mkfs (g, fstype, device);
3483 char device[] = "/dev/sda1";
3486 r = guestfs_ntfs_3g_probe (g, 1, device);
3490 fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n", (int) r);
3497 static int test_sleep_0_skip (void)
3501 str = getenv ("TEST_ONLY");
3503 return strstr (str, "sleep") == NULL;
3504 str = getenv ("SKIP_TEST_SLEEP_0");
3505 if (str && strcmp (str, "1") == 0) return 1;
3506 str = getenv ("SKIP_TEST_SLEEP");
3507 if (str && strcmp (str, "1") == 0) return 1;
3511 static int test_sleep_0 (void)
3513 if (test_sleep_0_skip ()) {
3514 printf (" %s skipped (reason: environment variable set)\n", "test_sleep_0");
3518 /* InitNone|InitEmpty for test_sleep_0 */
3520 char device[] = "/dev/sda";
3523 r = guestfs_blockdev_setrw (g, device);
3530 r = guestfs_umount_all (g);
3537 r = guestfs_lvm_remove_all (g);
3541 /* TestRun for sleep (0) */
3545 r = guestfs_sleep (g, 1);
3552 static int test_find_0_skip (void)
3556 str = getenv ("TEST_ONLY");
3558 return strstr (str, "find") == NULL;
3559 str = getenv ("SKIP_TEST_FIND_0");
3560 if (str && strcmp (str, "1") == 0) return 1;
3561 str = getenv ("SKIP_TEST_FIND");
3562 if (str && strcmp (str, "1") == 0) return 1;
3566 static int test_find_0 (void)
3568 if (test_find_0_skip ()) {
3569 printf (" %s skipped (reason: environment variable set)\n", "test_find_0");
3573 /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
3575 char device[] = "/dev/sda";
3578 r = guestfs_blockdev_setrw (g, device);
3585 r = guestfs_umount_all (g);
3592 r = guestfs_lvm_remove_all (g);
3597 char device[] = "/dev/sda";
3598 char lines_0[] = ",";
3605 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3610 char fstype[] = "ext2";
3611 char device[] = "/dev/sda1";
3614 r = guestfs_mkfs (g, fstype, device);
3619 char device[] = "/dev/sda1";
3620 char mountpoint[] = "/";
3623 r = guestfs_mount (g, device, mountpoint);
3627 /* TestOutputList for find (0) */
3629 char directory[] = "/";
3633 r = guestfs_find (g, directory);
3637 fprintf (stderr, "test_find_0: short list returned from command\n");
3642 char expected[] = "lost+found";
3643 if (strcmp (r[0], expected) != 0) {
3644 fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3649 fprintf (stderr, "test_find_0: extra elements returned from command\n");
3653 for (i = 0; r[i] != NULL; ++i)
3660 static int test_find_1_skip (void)
3664 str = getenv ("TEST_ONLY");
3666 return strstr (str, "find") == NULL;
3667 str = getenv ("SKIP_TEST_FIND_1");
3668 if (str && strcmp (str, "1") == 0) return 1;
3669 str = getenv ("SKIP_TEST_FIND");
3670 if (str && strcmp (str, "1") == 0) return 1;
3674 static int test_find_1 (void)
3676 if (test_find_1_skip ()) {
3677 printf (" %s skipped (reason: environment variable set)\n", "test_find_1");
3681 /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
3683 char device[] = "/dev/sda";
3686 r = guestfs_blockdev_setrw (g, device);
3693 r = guestfs_umount_all (g);
3700 r = guestfs_lvm_remove_all (g);
3705 char device[] = "/dev/sda";
3706 char lines_0[] = ",";
3713 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3718 char fstype[] = "ext2";
3719 char device[] = "/dev/sda1";
3722 r = guestfs_mkfs (g, fstype, device);
3727 char device[] = "/dev/sda1";
3728 char mountpoint[] = "/";
3731 r = guestfs_mount (g, device, mountpoint);
3735 /* TestOutputList for find (1) */
3740 r = guestfs_touch (g, path);
3748 r = guestfs_mkdir (g, path);
3753 char path[] = "/b/c";
3756 r = guestfs_touch (g, path);
3761 char directory[] = "/";
3765 r = guestfs_find (g, directory);
3769 fprintf (stderr, "test_find_1: short list returned from command\n");
3774 char expected[] = "a";
3775 if (strcmp (r[0], expected) != 0) {
3776 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3781 fprintf (stderr, "test_find_1: short list returned from command\n");
3786 char expected[] = "b";
3787 if (strcmp (r[1], expected) != 0) {
3788 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3793 fprintf (stderr, "test_find_1: short list returned from command\n");
3798 char expected[] = "b/c";
3799 if (strcmp (r[2], expected) != 0) {
3800 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
3805 fprintf (stderr, "test_find_1: short list returned from command\n");
3810 char expected[] = "lost+found";
3811 if (strcmp (r[3], expected) != 0) {
3812 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
3817 fprintf (stderr, "test_find_1: extra elements returned from command\n");
3821 for (i = 0; r[i] != NULL; ++i)
3828 static int test_find_2_skip (void)
3832 str = getenv ("TEST_ONLY");
3834 return strstr (str, "find") == NULL;
3835 str = getenv ("SKIP_TEST_FIND_2");
3836 if (str && strcmp (str, "1") == 0) return 1;
3837 str = getenv ("SKIP_TEST_FIND");
3838 if (str && strcmp (str, "1") == 0) return 1;
3842 static int test_find_2 (void)
3844 if (test_find_2_skip ()) {
3845 printf (" %s skipped (reason: environment variable set)\n", "test_find_2");
3849 /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
3851 char device[] = "/dev/sda";
3854 r = guestfs_blockdev_setrw (g, device);
3861 r = guestfs_umount_all (g);
3868 r = guestfs_lvm_remove_all (g);
3873 char device[] = "/dev/sda";
3874 char lines_0[] = ",";
3881 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3886 char fstype[] = "ext2";
3887 char device[] = "/dev/sda1";
3890 r = guestfs_mkfs (g, fstype, device);
3895 char device[] = "/dev/sda1";
3896 char mountpoint[] = "/";
3899 r = guestfs_mount (g, device, mountpoint);
3903 /* TestOutputList for find (2) */
3905 char path[] = "/a/b/c";
3908 r = guestfs_mkdir_p (g, path);
3913 char path[] = "/a/b/c/d";
3916 r = guestfs_touch (g, path);
3921 char directory[] = "/a/b/";
3925 r = guestfs_find (g, directory);
3929 fprintf (stderr, "test_find_2: short list returned from command\n");
3934 char expected[] = "c";
3935 if (strcmp (r[0], expected) != 0) {
3936 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3941 fprintf (stderr, "test_find_2: short list returned from command\n");
3946 char expected[] = "c/d";
3947 if (strcmp (r[1], expected) != 0) {
3948 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3953 fprintf (stderr, "test_find_2: extra elements returned from command\n");
3957 for (i = 0; r[i] != NULL; ++i)
3964 static int test_lvresize_0_skip (void)
3968 str = getenv ("TEST_ONLY");
3970 return strstr (str, "lvresize") == NULL;
3971 str = getenv ("SKIP_TEST_LVRESIZE_0");
3972 if (str && strcmp (str, "1") == 0) return 1;
3973 str = getenv ("SKIP_TEST_LVRESIZE");
3974 if (str && strcmp (str, "1") == 0) return 1;
3978 static int test_lvresize_0 (void)
3980 if (test_lvresize_0_skip ()) {
3981 printf (" %s skipped (reason: environment variable set)\n", "test_lvresize_0");
3985 /* InitNone|InitEmpty for test_lvresize_0 */
3987 char device[] = "/dev/sda";
3990 r = guestfs_blockdev_setrw (g, device);
3997 r = guestfs_umount_all (g);
4004 r = guestfs_lvm_remove_all (g);
4008 /* TestOutput for lvresize (0) */
4009 char expected[] = "test content";
4011 char device[] = "/dev/sda";
4012 char lines_0[] = ",";
4019 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4024 char device[] = "/dev/sda1";
4027 r = guestfs_pvcreate (g, device);
4032 char volgroup[] = "VG";
4033 char physvols_0[] = "/dev/sda1";
4034 char *physvols[] = {
4040 r = guestfs_vgcreate (g, volgroup, physvols);
4045 char logvol[] = "LV";
4046 char volgroup[] = "VG";
4049 r = guestfs_lvcreate (g, logvol, volgroup, 10);
4054 char fstype[] = "ext2";
4055 char device[] = "/dev/VG/LV";
4058 r = guestfs_mkfs (g, fstype, device);
4063 char device[] = "/dev/VG/LV";
4064 char mountpoint[] = "/";
4067 r = guestfs_mount (g, device, mountpoint);
4072 char path[] = "/new";
4073 char content[] = "test content";
4076 r = guestfs_write_file (g, path, content, 0);
4081 char pathordevice[] = "/";
4084 r = guestfs_umount (g, pathordevice);
4089 char device[] = "/dev/VG/LV";
4092 r = guestfs_lvresize (g, device, 20);
4097 char device[] = "/dev/VG/LV";
4100 r = guestfs_e2fsck_f (g, device);
4105 char device[] = "/dev/VG/LV";
4108 r = guestfs_resize2fs (g, device);
4113 char device[] = "/dev/VG/LV";
4114 char mountpoint[] = "/";
4117 r = guestfs_mount (g, device, mountpoint);
4122 char path[] = "/new";
4125 r = guestfs_cat (g, path);
4128 if (strcmp (r, expected) != 0) {
4129 fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
4137 static int test_zerofree_0_skip (void)
4141 str = getenv ("TEST_ONLY");
4143 return strstr (str, "zerofree") == NULL;
4144 str = getenv ("SKIP_TEST_ZEROFREE_0");
4145 if (str && strcmp (str, "1") == 0) return 1;
4146 str = getenv ("SKIP_TEST_ZEROFREE");
4147 if (str && strcmp (str, "1") == 0) return 1;
4151 static int test_zerofree_0 (void)
4153 if (test_zerofree_0_skip ()) {
4154 printf (" %s skipped (reason: environment variable set)\n", "test_zerofree_0");
4158 /* InitNone|InitEmpty for test_zerofree_0 */
4160 char device[] = "/dev/sda";
4163 r = guestfs_blockdev_setrw (g, device);
4170 r = guestfs_umount_all (g);
4177 r = guestfs_lvm_remove_all (g);
4181 /* TestOutput for zerofree (0) */
4182 char expected[] = "test file";
4184 char device[] = "/dev/sda";
4185 char lines_0[] = ",";
4192 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4197 char fstype[] = "ext3";
4198 char device[] = "/dev/sda1";
4201 r = guestfs_mkfs (g, fstype, device);
4206 char device[] = "/dev/sda1";
4207 char mountpoint[] = "/";
4210 r = guestfs_mount (g, device, mountpoint);
4215 char path[] = "/new";
4216 char content[] = "test file";
4219 r = guestfs_write_file (g, path, content, 0);
4224 char pathordevice[] = "/dev/sda1";
4227 r = guestfs_umount (g, pathordevice);
4232 char device[] = "/dev/sda1";
4235 r = guestfs_zerofree (g, device);
4240 char device[] = "/dev/sda1";
4241 char mountpoint[] = "/";
4244 r = guestfs_mount (g, device, mountpoint);
4249 char path[] = "/new";
4252 r = guestfs_cat (g, path);
4255 if (strcmp (r, expected) != 0) {
4256 fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
4264 static int test_hexdump_0_skip (void)
4268 str = getenv ("TEST_ONLY");
4270 return strstr (str, "hexdump") == NULL;
4271 str = getenv ("SKIP_TEST_HEXDUMP_0");
4272 if (str && strcmp (str, "1") == 0) return 1;
4273 str = getenv ("SKIP_TEST_HEXDUMP");
4274 if (str && strcmp (str, "1") == 0) return 1;
4278 static int test_hexdump_0 (void)
4280 if (test_hexdump_0_skip ()) {
4281 printf (" %s skipped (reason: environment variable set)\n", "test_hexdump_0");
4285 /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
4287 char device[] = "/dev/sda";
4290 r = guestfs_blockdev_setrw (g, device);
4297 r = guestfs_umount_all (g);
4304 r = guestfs_lvm_remove_all (g);
4309 char device[] = "/dev/sda";
4310 char lines_0[] = ",";
4317 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4322 char fstype[] = "ext2";
4323 char device[] = "/dev/sda1";
4326 r = guestfs_mkfs (g, fstype, device);
4331 char device[] = "/dev/sda1";
4332 char mountpoint[] = "/";
4335 r = guestfs_mount (g, device, mountpoint);
4339 /* TestOutput for hexdump (0) */
4340 char expected[] = "00000000 68 65 6c 6c 6f 0a 77 6f 72 6c 64 0a |hello.world.|\n0000000c\n";
4342 char path[] = "/new";
4343 char content[] = "hello\nworld\n";
4346 r = guestfs_write_file (g, path, content, 12);
4351 char path[] = "/new";
4354 r = guestfs_hexdump (g, path);
4357 if (strcmp (r, expected) != 0) {
4358 fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
4366 static int test_hexdump_1_skip (void)
4370 str = getenv ("TEST_ONLY");
4372 return strstr (str, "hexdump") == NULL;
4373 str = getenv ("SKIP_TEST_HEXDUMP_1");
4374 if (str && strcmp (str, "1") == 0) return 1;
4375 str = getenv ("SKIP_TEST_HEXDUMP");
4376 if (str && strcmp (str, "1") == 0) return 1;
4380 static int test_hexdump_1 (void)
4382 if (test_hexdump_1_skip ()) {
4383 printf (" %s skipped (reason: environment variable set)\n", "test_hexdump_1");
4387 /* InitBasicFS for test_hexdump_1: create ext2 on /dev/sda1 */
4389 char device[] = "/dev/sda";
4392 r = guestfs_blockdev_setrw (g, device);
4399 r = guestfs_umount_all (g);
4406 r = guestfs_lvm_remove_all (g);
4411 char device[] = "/dev/sda";
4412 char lines_0[] = ",";
4419 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4424 char fstype[] = "ext2";
4425 char device[] = "/dev/sda1";
4428 r = guestfs_mkfs (g, fstype, device);
4433 char device[] = "/dev/sda1";
4434 char mountpoint[] = "/";
4437 r = guestfs_mount (g, device, mountpoint);
4441 /* TestRun for hexdump (1) */
4443 char options[] = "ro";
4444 char vfstype[] = "squashfs";
4445 char device[] = "/dev/sdd";
4446 char mountpoint[] = "/";
4449 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
4454 char path[] = "/100krandom";
4457 r = guestfs_hexdump (g, path);
4465 static int test_strings_e_0_skip (void)
4469 str = getenv ("TEST_ONLY");
4471 return strstr (str, "strings_e") == NULL;
4472 str = getenv ("SKIP_TEST_STRINGS_E_0");
4473 if (str && strcmp (str, "1") == 0) return 1;
4474 str = getenv ("SKIP_TEST_STRINGS_E");
4475 if (str && strcmp (str, "1") == 0) return 1;
4479 static int test_strings_e_0 (void)
4481 if (test_strings_e_0_skip ()) {
4482 printf (" %s skipped (reason: environment variable set)\n", "test_strings_e_0");
4486 /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
4488 char device[] = "/dev/sda";
4491 r = guestfs_blockdev_setrw (g, device);
4498 r = guestfs_umount_all (g);
4505 r = guestfs_lvm_remove_all (g);
4510 char device[] = "/dev/sda";
4511 char lines_0[] = ",";
4518 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4523 char fstype[] = "ext2";
4524 char device[] = "/dev/sda1";
4527 r = guestfs_mkfs (g, fstype, device);
4532 char device[] = "/dev/sda1";
4533 char mountpoint[] = "/";
4536 r = guestfs_mount (g, device, mountpoint);
4540 /* TestOutputList for strings_e (0) */
4542 char path[] = "/new";
4543 char content[] = "hello\nworld\n";
4546 r = guestfs_write_file (g, path, content, 0);
4551 char encoding[] = "b";
4552 char path[] = "/new";
4556 r = guestfs_strings_e (g, encoding, path);
4560 fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
4564 for (i = 0; r[i] != NULL; ++i)
4571 static int test_strings_e_1_skip (void)
4575 str = getenv ("TEST_ONLY");
4577 return strstr (str, "strings_e") == NULL;
4578 str = getenv ("SKIP_TEST_STRINGS_E_1");
4579 if (str && strcmp (str, "1") == 0) return 1;
4580 str = getenv ("SKIP_TEST_STRINGS_E");
4581 if (str && strcmp (str, "1") == 0) return 1;
4585 static int test_strings_e_1 (void)
4587 if (test_strings_e_1_skip ()) {
4588 printf (" %s skipped (reason: environment variable set)\n", "test_strings_e_1");
4592 printf (" %s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
4596 static int test_strings_0_skip (void)
4600 str = getenv ("TEST_ONLY");
4602 return strstr (str, "strings") == NULL;
4603 str = getenv ("SKIP_TEST_STRINGS_0");
4604 if (str && strcmp (str, "1") == 0) return 1;
4605 str = getenv ("SKIP_TEST_STRINGS");
4606 if (str && strcmp (str, "1") == 0) return 1;
4610 static int test_strings_0 (void)
4612 if (test_strings_0_skip ()) {
4613 printf (" %s skipped (reason: environment variable set)\n", "test_strings_0");
4617 /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
4619 char device[] = "/dev/sda";
4622 r = guestfs_blockdev_setrw (g, device);
4629 r = guestfs_umount_all (g);
4636 r = guestfs_lvm_remove_all (g);
4641 char device[] = "/dev/sda";
4642 char lines_0[] = ",";
4649 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4654 char fstype[] = "ext2";
4655 char device[] = "/dev/sda1";
4658 r = guestfs_mkfs (g, fstype, device);
4663 char device[] = "/dev/sda1";
4664 char mountpoint[] = "/";
4667 r = guestfs_mount (g, device, mountpoint);
4671 /* TestOutputList for strings (0) */
4673 char path[] = "/new";
4674 char content[] = "hello\nworld\n";
4677 r = guestfs_write_file (g, path, content, 0);
4682 char path[] = "/new";
4686 r = guestfs_strings (g, path);
4690 fprintf (stderr, "test_strings_0: short list returned from command\n");
4695 char expected[] = "hello";
4696 if (strcmp (r[0], expected) != 0) {
4697 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4702 fprintf (stderr, "test_strings_0: short list returned from command\n");
4707 char expected[] = "world";
4708 if (strcmp (r[1], expected) != 0) {
4709 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
4714 fprintf (stderr, "test_strings_0: extra elements returned from command\n");
4718 for (i = 0; r[i] != NULL; ++i)
4725 static int test_strings_1_skip (void)
4729 str = getenv ("TEST_ONLY");
4731 return strstr (str, "strings") == NULL;
4732 str = getenv ("SKIP_TEST_STRINGS_1");
4733 if (str && strcmp (str, "1") == 0) return 1;
4734 str = getenv ("SKIP_TEST_STRINGS");
4735 if (str && strcmp (str, "1") == 0) return 1;
4739 static int test_strings_1 (void)
4741 if (test_strings_1_skip ()) {
4742 printf (" %s skipped (reason: environment variable set)\n", "test_strings_1");
4746 /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
4748 char device[] = "/dev/sda";
4751 r = guestfs_blockdev_setrw (g, device);
4758 r = guestfs_umount_all (g);
4765 r = guestfs_lvm_remove_all (g);
4770 char device[] = "/dev/sda";
4771 char lines_0[] = ",";
4778 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4783 char fstype[] = "ext2";
4784 char device[] = "/dev/sda1";
4787 r = guestfs_mkfs (g, fstype, device);
4792 char device[] = "/dev/sda1";
4793 char mountpoint[] = "/";
4796 r = guestfs_mount (g, device, mountpoint);
4800 /* TestOutputList for strings (1) */
4802 char path[] = "/new";
4805 r = guestfs_touch (g, path);
4810 char path[] = "/new";
4814 r = guestfs_strings (g, path);
4818 fprintf (stderr, "test_strings_1: extra elements returned from command\n");
4822 for (i = 0; r[i] != NULL; ++i)
4829 static int test_equal_0_skip (void)
4833 str = getenv ("TEST_ONLY");
4835 return strstr (str, "equal") == NULL;
4836 str = getenv ("SKIP_TEST_EQUAL_0");
4837 if (str && strcmp (str, "1") == 0) return 1;
4838 str = getenv ("SKIP_TEST_EQUAL");
4839 if (str && strcmp (str, "1") == 0) return 1;
4843 static int test_equal_0 (void)
4845 if (test_equal_0_skip ()) {
4846 printf (" %s skipped (reason: environment variable set)\n", "test_equal_0");
4850 /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
4852 char device[] = "/dev/sda";
4855 r = guestfs_blockdev_setrw (g, device);
4862 r = guestfs_umount_all (g);
4869 r = guestfs_lvm_remove_all (g);
4874 char device[] = "/dev/sda";
4875 char lines_0[] = ",";
4882 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4887 char fstype[] = "ext2";
4888 char device[] = "/dev/sda1";
4891 r = guestfs_mkfs (g, fstype, device);
4896 char device[] = "/dev/sda1";
4897 char mountpoint[] = "/";
4900 r = guestfs_mount (g, device, mountpoint);
4904 /* TestOutputTrue for equal (0) */
4906 char path[] = "/file1";
4907 char content[] = "contents of a file";
4910 r = guestfs_write_file (g, path, content, 0);
4915 char src[] = "/file1";
4916 char dest[] = "/file2";
4919 r = guestfs_cp (g, src, dest);
4924 char file1[] = "/file1";
4925 char file2[] = "/file2";
4928 r = guestfs_equal (g, file1, file2);
4932 fprintf (stderr, "test_equal_0: expected true, got false\n");
4939 static int test_equal_1_skip (void)
4943 str = getenv ("TEST_ONLY");
4945 return strstr (str, "equal") == NULL;
4946 str = getenv ("SKIP_TEST_EQUAL_1");
4947 if (str && strcmp (str, "1") == 0) return 1;
4948 str = getenv ("SKIP_TEST_EQUAL");
4949 if (str && strcmp (str, "1") == 0) return 1;
4953 static int test_equal_1 (void)
4955 if (test_equal_1_skip ()) {
4956 printf (" %s skipped (reason: environment variable set)\n", "test_equal_1");
4960 /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
4962 char device[] = "/dev/sda";
4965 r = guestfs_blockdev_setrw (g, device);
4972 r = guestfs_umount_all (g);
4979 r = guestfs_lvm_remove_all (g);
4984 char device[] = "/dev/sda";
4985 char lines_0[] = ",";
4992 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4997 char fstype[] = "ext2";
4998 char device[] = "/dev/sda1";
5001 r = guestfs_mkfs (g, fstype, device);
5006 char device[] = "/dev/sda1";
5007 char mountpoint[] = "/";
5010 r = guestfs_mount (g, device, mountpoint);
5014 /* TestOutputFalse for equal (1) */
5016 char path[] = "/file1";
5017 char content[] = "contents of a file";
5020 r = guestfs_write_file (g, path, content, 0);
5025 char path[] = "/file2";
5026 char content[] = "contents of another file";
5029 r = guestfs_write_file (g, path, content, 0);
5034 char file1[] = "/file1";
5035 char file2[] = "/file2";
5038 r = guestfs_equal (g, file1, file2);
5042 fprintf (stderr, "test_equal_1: expected false, got true\n");
5049 static int test_equal_2_skip (void)
5053 str = getenv ("TEST_ONLY");
5055 return strstr (str, "equal") == NULL;
5056 str = getenv ("SKIP_TEST_EQUAL_2");
5057 if (str && strcmp (str, "1") == 0) return 1;
5058 str = getenv ("SKIP_TEST_EQUAL");
5059 if (str && strcmp (str, "1") == 0) return 1;
5063 static int test_equal_2 (void)
5065 if (test_equal_2_skip ()) {
5066 printf (" %s skipped (reason: environment variable set)\n", "test_equal_2");
5070 /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
5072 char device[] = "/dev/sda";
5075 r = guestfs_blockdev_setrw (g, device);
5082 r = guestfs_umount_all (g);
5089 r = guestfs_lvm_remove_all (g);
5094 char device[] = "/dev/sda";
5095 char lines_0[] = ",";
5102 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5107 char fstype[] = "ext2";
5108 char device[] = "/dev/sda1";
5111 r = guestfs_mkfs (g, fstype, device);
5116 char device[] = "/dev/sda1";
5117 char mountpoint[] = "/";
5120 r = guestfs_mount (g, device, mountpoint);
5124 /* TestLastFail for equal (2) */
5126 char file1[] = "/file1";
5127 char file2[] = "/file2";
5130 r = guestfs_equal (g, file1, file2);
5137 static int test_ping_daemon_0_skip (void)
5141 str = getenv ("TEST_ONLY");
5143 return strstr (str, "ping_daemon") == NULL;
5144 str = getenv ("SKIP_TEST_PING_DAEMON_0");
5145 if (str && strcmp (str, "1") == 0) return 1;
5146 str = getenv ("SKIP_TEST_PING_DAEMON");
5147 if (str && strcmp (str, "1") == 0) return 1;
5151 static int test_ping_daemon_0 (void)
5153 if (test_ping_daemon_0_skip ()) {
5154 printf (" %s skipped (reason: environment variable set)\n", "test_ping_daemon_0");
5158 /* InitNone|InitEmpty for test_ping_daemon_0 */
5160 char device[] = "/dev/sda";
5163 r = guestfs_blockdev_setrw (g, device);
5170 r = guestfs_umount_all (g);
5177 r = guestfs_lvm_remove_all (g);
5181 /* TestRun for ping_daemon (0) */
5185 r = guestfs_ping_daemon (g);
5192 static int test_dmesg_0_skip (void)
5196 str = getenv ("TEST_ONLY");
5198 return strstr (str, "dmesg") == NULL;
5199 str = getenv ("SKIP_TEST_DMESG_0");
5200 if (str && strcmp (str, "1") == 0) return 1;
5201 str = getenv ("SKIP_TEST_DMESG");
5202 if (str && strcmp (str, "1") == 0) return 1;
5206 static int test_dmesg_0 (void)
5208 if (test_dmesg_0_skip ()) {
5209 printf (" %s skipped (reason: environment variable set)\n", "test_dmesg_0");
5213 /* InitNone|InitEmpty for test_dmesg_0 */
5215 char device[] = "/dev/sda";
5218 r = guestfs_blockdev_setrw (g, device);
5225 r = guestfs_umount_all (g);
5232 r = guestfs_lvm_remove_all (g);
5236 /* TestRun for dmesg (0) */
5240 r = guestfs_dmesg (g);
5248 static int test_drop_caches_0_skip (void)
5252 str = getenv ("TEST_ONLY");
5254 return strstr (str, "drop_caches") == NULL;
5255 str = getenv ("SKIP_TEST_DROP_CACHES_0");
5256 if (str && strcmp (str, "1") == 0) return 1;
5257 str = getenv ("SKIP_TEST_DROP_CACHES");
5258 if (str && strcmp (str, "1") == 0) return 1;
5262 static int test_drop_caches_0 (void)
5264 if (test_drop_caches_0_skip ()) {
5265 printf (" %s skipped (reason: environment variable set)\n", "test_drop_caches_0");
5269 /* InitNone|InitEmpty for test_drop_caches_0 */
5271 char device[] = "/dev/sda";
5274 r = guestfs_blockdev_setrw (g, device);
5281 r = guestfs_umount_all (g);
5288 r = guestfs_lvm_remove_all (g);
5292 /* TestRun for drop_caches (0) */
5296 r = guestfs_drop_caches (g, 3);
5303 static int test_mv_0_skip (void)
5307 str = getenv ("TEST_ONLY");
5309 return strstr (str, "mv") == NULL;
5310 str = getenv ("SKIP_TEST_MV_0");
5311 if (str && strcmp (str, "1") == 0) return 1;
5312 str = getenv ("SKIP_TEST_MV");
5313 if (str && strcmp (str, "1") == 0) return 1;
5317 static int test_mv_0 (void)
5319 if (test_mv_0_skip ()) {
5320 printf (" %s skipped (reason: environment variable set)\n", "test_mv_0");
5324 /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
5326 char device[] = "/dev/sda";
5329 r = guestfs_blockdev_setrw (g, device);
5336 r = guestfs_umount_all (g);
5343 r = guestfs_lvm_remove_all (g);
5348 char device[] = "/dev/sda";
5349 char lines_0[] = ",";
5356 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5361 char fstype[] = "ext2";
5362 char device[] = "/dev/sda1";
5365 r = guestfs_mkfs (g, fstype, device);
5370 char device[] = "/dev/sda1";
5371 char mountpoint[] = "/";
5374 r = guestfs_mount (g, device, mountpoint);
5378 /* TestOutput for mv (0) */
5379 char expected[] = "file content";
5381 char path[] = "/old";
5382 char content[] = "file content";
5385 r = guestfs_write_file (g, path, content, 0);
5390 char src[] = "/old";
5391 char dest[] = "/new";
5394 r = guestfs_mv (g, src, dest);
5399 char path[] = "/new";
5402 r = guestfs_cat (g, path);
5405 if (strcmp (r, expected) != 0) {
5406 fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
5414 static int test_mv_1_skip (void)
5418 str = getenv ("TEST_ONLY");
5420 return strstr (str, "mv") == NULL;
5421 str = getenv ("SKIP_TEST_MV_1");
5422 if (str && strcmp (str, "1") == 0) return 1;
5423 str = getenv ("SKIP_TEST_MV");
5424 if (str && strcmp (str, "1") == 0) return 1;
5428 static int test_mv_1 (void)
5430 if (test_mv_1_skip ()) {
5431 printf (" %s skipped (reason: environment variable set)\n", "test_mv_1");
5435 /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
5437 char device[] = "/dev/sda";
5440 r = guestfs_blockdev_setrw (g, device);
5447 r = guestfs_umount_all (g);
5454 r = guestfs_lvm_remove_all (g);
5459 char device[] = "/dev/sda";
5460 char lines_0[] = ",";
5467 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5472 char fstype[] = "ext2";
5473 char device[] = "/dev/sda1";
5476 r = guestfs_mkfs (g, fstype, device);
5481 char device[] = "/dev/sda1";
5482 char mountpoint[] = "/";
5485 r = guestfs_mount (g, device, mountpoint);
5489 /* TestOutputFalse for mv (1) */
5491 char path[] = "/old";
5492 char content[] = "file content";
5495 r = guestfs_write_file (g, path, content, 0);
5500 char src[] = "/old";
5501 char dest[] = "/new";
5504 r = guestfs_mv (g, src, dest);
5509 char path[] = "/old";
5512 r = guestfs_is_file (g, path);
5516 fprintf (stderr, "test_mv_1: expected false, got true\n");
5523 static int test_cp_a_0_skip (void)
5527 str = getenv ("TEST_ONLY");
5529 return strstr (str, "cp_a") == NULL;
5530 str = getenv ("SKIP_TEST_CP_A_0");
5531 if (str && strcmp (str, "1") == 0) return 1;
5532 str = getenv ("SKIP_TEST_CP_A");
5533 if (str && strcmp (str, "1") == 0) return 1;
5537 static int test_cp_a_0 (void)
5539 if (test_cp_a_0_skip ()) {
5540 printf (" %s skipped (reason: environment variable set)\n", "test_cp_a_0");
5544 /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
5546 char device[] = "/dev/sda";
5549 r = guestfs_blockdev_setrw (g, device);
5556 r = guestfs_umount_all (g);
5563 r = guestfs_lvm_remove_all (g);
5568 char device[] = "/dev/sda";
5569 char lines_0[] = ",";
5576 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5581 char fstype[] = "ext2";
5582 char device[] = "/dev/sda1";
5585 r = guestfs_mkfs (g, fstype, device);
5590 char device[] = "/dev/sda1";
5591 char mountpoint[] = "/";
5594 r = guestfs_mount (g, device, mountpoint);
5598 /* TestOutput for cp_a (0) */
5599 char expected[] = "file content";
5601 char path[] = "/olddir";
5604 r = guestfs_mkdir (g, path);
5609 char path[] = "/newdir";
5612 r = guestfs_mkdir (g, path);
5617 char path[] = "/olddir/file";
5618 char content[] = "file content";
5621 r = guestfs_write_file (g, path, content, 0);
5626 char src[] = "/olddir";
5627 char dest[] = "/newdir";
5630 r = guestfs_cp_a (g, src, dest);
5635 char path[] = "/newdir/olddir/file";
5638 r = guestfs_cat (g, path);
5641 if (strcmp (r, expected) != 0) {
5642 fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
5650 static int test_cp_0_skip (void)
5654 str = getenv ("TEST_ONLY");
5656 return strstr (str, "cp") == NULL;
5657 str = getenv ("SKIP_TEST_CP_0");
5658 if (str && strcmp (str, "1") == 0) return 1;
5659 str = getenv ("SKIP_TEST_CP");
5660 if (str && strcmp (str, "1") == 0) return 1;
5664 static int test_cp_0 (void)
5666 if (test_cp_0_skip ()) {
5667 printf (" %s skipped (reason: environment variable set)\n", "test_cp_0");
5671 /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
5673 char device[] = "/dev/sda";
5676 r = guestfs_blockdev_setrw (g, device);
5683 r = guestfs_umount_all (g);
5690 r = guestfs_lvm_remove_all (g);
5695 char device[] = "/dev/sda";
5696 char lines_0[] = ",";
5703 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5708 char fstype[] = "ext2";
5709 char device[] = "/dev/sda1";
5712 r = guestfs_mkfs (g, fstype, device);
5717 char device[] = "/dev/sda1";
5718 char mountpoint[] = "/";
5721 r = guestfs_mount (g, device, mountpoint);
5725 /* TestOutput for cp (0) */
5726 char expected[] = "file content";
5728 char path[] = "/old";
5729 char content[] = "file content";
5732 r = guestfs_write_file (g, path, content, 0);
5737 char src[] = "/old";
5738 char dest[] = "/new";
5741 r = guestfs_cp (g, src, dest);
5746 char path[] = "/new";
5749 r = guestfs_cat (g, path);
5752 if (strcmp (r, expected) != 0) {
5753 fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
5761 static int test_cp_1_skip (void)
5765 str = getenv ("TEST_ONLY");
5767 return strstr (str, "cp") == NULL;
5768 str = getenv ("SKIP_TEST_CP_1");
5769 if (str && strcmp (str, "1") == 0) return 1;
5770 str = getenv ("SKIP_TEST_CP");
5771 if (str && strcmp (str, "1") == 0) return 1;
5775 static int test_cp_1 (void)
5777 if (test_cp_1_skip ()) {
5778 printf (" %s skipped (reason: environment variable set)\n", "test_cp_1");
5782 /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
5784 char device[] = "/dev/sda";
5787 r = guestfs_blockdev_setrw (g, device);
5794 r = guestfs_umount_all (g);
5801 r = guestfs_lvm_remove_all (g);
5806 char device[] = "/dev/sda";
5807 char lines_0[] = ",";
5814 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5819 char fstype[] = "ext2";
5820 char device[] = "/dev/sda1";
5823 r = guestfs_mkfs (g, fstype, device);
5828 char device[] = "/dev/sda1";
5829 char mountpoint[] = "/";
5832 r = guestfs_mount (g, device, mountpoint);
5836 /* TestOutputTrue for cp (1) */
5838 char path[] = "/old";
5839 char content[] = "file content";
5842 r = guestfs_write_file (g, path, content, 0);
5847 char src[] = "/old";
5848 char dest[] = "/new";
5851 r = guestfs_cp (g, src, dest);
5856 char path[] = "/old";
5859 r = guestfs_is_file (g, path);
5863 fprintf (stderr, "test_cp_1: expected true, got false\n");
5870 static int test_cp_2_skip (void)
5874 str = getenv ("TEST_ONLY");
5876 return strstr (str, "cp") == NULL;
5877 str = getenv ("SKIP_TEST_CP_2");
5878 if (str && strcmp (str, "1") == 0) return 1;
5879 str = getenv ("SKIP_TEST_CP");
5880 if (str && strcmp (str, "1") == 0) return 1;
5884 static int test_cp_2 (void)
5886 if (test_cp_2_skip ()) {
5887 printf (" %s skipped (reason: environment variable set)\n", "test_cp_2");
5891 /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
5893 char device[] = "/dev/sda";
5896 r = guestfs_blockdev_setrw (g, device);
5903 r = guestfs_umount_all (g);
5910 r = guestfs_lvm_remove_all (g);
5915 char device[] = "/dev/sda";
5916 char lines_0[] = ",";
5923 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5928 char fstype[] = "ext2";
5929 char device[] = "/dev/sda1";
5932 r = guestfs_mkfs (g, fstype, device);
5937 char device[] = "/dev/sda1";
5938 char mountpoint[] = "/";
5941 r = guestfs_mount (g, device, mountpoint);
5945 /* TestOutput for cp (2) */
5946 char expected[] = "file content";
5948 char path[] = "/old";
5949 char content[] = "file content";
5952 r = guestfs_write_file (g, path, content, 0);
5957 char path[] = "/dir";
5960 r = guestfs_mkdir (g, path);
5965 char src[] = "/old";
5966 char dest[] = "/dir/new";
5969 r = guestfs_cp (g, src, dest);
5974 char path[] = "/dir/new";
5977 r = guestfs_cat (g, path);
5980 if (strcmp (r, expected) != 0) {
5981 fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
5989 static int test_grub_install_0_skip (void)
5993 str = getenv ("TEST_ONLY");
5995 return strstr (str, "grub_install") == NULL;
5996 str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
5997 if (str && strcmp (str, "1") == 0) return 1;
5998 str = getenv ("SKIP_TEST_GRUB_INSTALL");
5999 if (str && strcmp (str, "1") == 0) return 1;
6003 static int test_grub_install_0 (void)
6005 if (test_grub_install_0_skip ()) {
6006 printf (" %s skipped (reason: environment variable set)\n", "test_grub_install_0");
6010 printf (" %s skipped (reason: test disabled in generator)\n", "test_grub_install_0");
6014 static int test_zero_0_skip (void)
6018 str = getenv ("TEST_ONLY");
6020 return strstr (str, "zero") == NULL;
6021 str = getenv ("SKIP_TEST_ZERO_0");
6022 if (str && strcmp (str, "1") == 0) return 1;
6023 str = getenv ("SKIP_TEST_ZERO");
6024 if (str && strcmp (str, "1") == 0) return 1;
6028 static int test_zero_0 (void)
6030 if (test_zero_0_skip ()) {
6031 printf (" %s skipped (reason: environment variable set)\n", "test_zero_0");
6035 /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
6037 char device[] = "/dev/sda";
6040 r = guestfs_blockdev_setrw (g, device);
6047 r = guestfs_umount_all (g);
6054 r = guestfs_lvm_remove_all (g);
6059 char device[] = "/dev/sda";
6060 char lines_0[] = ",";
6067 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6072 char fstype[] = "ext2";
6073 char device[] = "/dev/sda1";
6076 r = guestfs_mkfs (g, fstype, device);
6081 char device[] = "/dev/sda1";
6082 char mountpoint[] = "/";
6085 r = guestfs_mount (g, device, mountpoint);
6089 /* TestOutput for zero (0) */
6090 char expected[] = "data";
6092 char pathordevice[] = "/dev/sda1";
6095 r = guestfs_umount (g, pathordevice);
6100 char device[] = "/dev/sda1";
6103 r = guestfs_zero (g, device);
6108 char path[] = "/dev/sda1";
6111 r = guestfs_file (g, path);
6114 if (strcmp (r, expected) != 0) {
6115 fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
6123 static int test_fsck_0_skip (void)
6127 str = getenv ("TEST_ONLY");
6129 return strstr (str, "fsck") == NULL;
6130 str = getenv ("SKIP_TEST_FSCK_0");
6131 if (str && strcmp (str, "1") == 0) return 1;
6132 str = getenv ("SKIP_TEST_FSCK");
6133 if (str && strcmp (str, "1") == 0) return 1;
6137 static int test_fsck_0 (void)
6139 if (test_fsck_0_skip ()) {
6140 printf (" %s skipped (reason: environment variable set)\n", "test_fsck_0");
6144 /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
6146 char device[] = "/dev/sda";
6149 r = guestfs_blockdev_setrw (g, device);
6156 r = guestfs_umount_all (g);
6163 r = guestfs_lvm_remove_all (g);
6168 char device[] = "/dev/sda";
6169 char lines_0[] = ",";
6176 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6181 char fstype[] = "ext2";
6182 char device[] = "/dev/sda1";
6185 r = guestfs_mkfs (g, fstype, device);
6190 char device[] = "/dev/sda1";
6191 char mountpoint[] = "/";
6194 r = guestfs_mount (g, device, mountpoint);
6198 /* TestOutputInt for fsck (0) */
6200 char pathordevice[] = "/dev/sda1";
6203 r = guestfs_umount (g, pathordevice);
6208 char fstype[] = "ext2";
6209 char device[] = "/dev/sda1";
6212 r = guestfs_fsck (g, fstype, device);
6216 fprintf (stderr, "test_fsck_0: expected 0 but got %d\n", (int) r);
6223 static int test_fsck_1_skip (void)
6227 str = getenv ("TEST_ONLY");
6229 return strstr (str, "fsck") == NULL;
6230 str = getenv ("SKIP_TEST_FSCK_1");
6231 if (str && strcmp (str, "1") == 0) return 1;
6232 str = getenv ("SKIP_TEST_FSCK");
6233 if (str && strcmp (str, "1") == 0) return 1;
6237 static int test_fsck_1 (void)
6239 if (test_fsck_1_skip ()) {
6240 printf (" %s skipped (reason: environment variable set)\n", "test_fsck_1");
6244 /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
6246 char device[] = "/dev/sda";
6249 r = guestfs_blockdev_setrw (g, device);
6256 r = guestfs_umount_all (g);
6263 r = guestfs_lvm_remove_all (g);
6268 char device[] = "/dev/sda";
6269 char lines_0[] = ",";
6276 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6281 char fstype[] = "ext2";
6282 char device[] = "/dev/sda1";
6285 r = guestfs_mkfs (g, fstype, device);
6290 char device[] = "/dev/sda1";
6291 char mountpoint[] = "/";
6294 r = guestfs_mount (g, device, mountpoint);
6298 /* TestOutputInt for fsck (1) */
6300 char pathordevice[] = "/dev/sda1";
6303 r = guestfs_umount (g, pathordevice);
6308 char device[] = "/dev/sda1";
6311 r = guestfs_zero (g, device);
6316 char fstype[] = "ext2";
6317 char device[] = "/dev/sda1";
6320 r = guestfs_fsck (g, fstype, device);
6324 fprintf (stderr, "test_fsck_1: expected 8 but got %d\n", (int) r);
6331 static int test_set_e2uuid_0_skip (void)
6335 str = getenv ("TEST_ONLY");
6337 return strstr (str, "set_e2uuid") == NULL;
6338 str = getenv ("SKIP_TEST_SET_E2UUID_0");
6339 if (str && strcmp (str, "1") == 0) return 1;
6340 str = getenv ("SKIP_TEST_SET_E2UUID");
6341 if (str && strcmp (str, "1") == 0) return 1;
6345 static int test_set_e2uuid_0 (void)
6347 if (test_set_e2uuid_0_skip ()) {
6348 printf (" %s skipped (reason: environment variable set)\n", "test_set_e2uuid_0");
6352 /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
6354 char device[] = "/dev/sda";
6357 r = guestfs_blockdev_setrw (g, device);
6364 r = guestfs_umount_all (g);
6371 r = guestfs_lvm_remove_all (g);
6376 char device[] = "/dev/sda";
6377 char lines_0[] = ",";
6384 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6389 char fstype[] = "ext2";
6390 char device[] = "/dev/sda1";
6393 r = guestfs_mkfs (g, fstype, device);
6398 char device[] = "/dev/sda1";
6399 char mountpoint[] = "/";
6402 r = guestfs_mount (g, device, mountpoint);
6406 /* TestOutput for set_e2uuid (0) */
6407 char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
6409 char device[] = "/dev/sda1";
6410 char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
6413 r = guestfs_set_e2uuid (g, device, uuid);
6418 char device[] = "/dev/sda1";
6421 r = guestfs_get_e2uuid (g, device);
6424 if (strcmp (r, expected) != 0) {
6425 fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
6433 static int test_set_e2uuid_1_skip (void)
6437 str = getenv ("TEST_ONLY");
6439 return strstr (str, "set_e2uuid") == NULL;
6440 str = getenv ("SKIP_TEST_SET_E2UUID_1");
6441 if (str && strcmp (str, "1") == 0) return 1;
6442 str = getenv ("SKIP_TEST_SET_E2UUID");
6443 if (str && strcmp (str, "1") == 0) return 1;
6447 static int test_set_e2uuid_1 (void)
6449 if (test_set_e2uuid_1_skip ()) {
6450 printf (" %s skipped (reason: environment variable set)\n", "test_set_e2uuid_1");
6454 /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
6456 char device[] = "/dev/sda";
6459 r = guestfs_blockdev_setrw (g, device);
6466 r = guestfs_umount_all (g);
6473 r = guestfs_lvm_remove_all (g);
6478 char device[] = "/dev/sda";
6479 char lines_0[] = ",";
6486 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6491 char fstype[] = "ext2";
6492 char device[] = "/dev/sda1";
6495 r = guestfs_mkfs (g, fstype, device);
6500 char device[] = "/dev/sda1";
6501 char mountpoint[] = "/";
6504 r = guestfs_mount (g, device, mountpoint);
6508 /* TestOutput for set_e2uuid (1) */
6509 char expected[] = "";
6511 char device[] = "/dev/sda1";
6512 char uuid[] = "clear";
6515 r = guestfs_set_e2uuid (g, device, uuid);
6520 char device[] = "/dev/sda1";
6523 r = guestfs_get_e2uuid (g, device);
6526 if (strcmp (r, expected) != 0) {
6527 fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
6535 static int test_set_e2uuid_2_skip (void)
6539 str = getenv ("TEST_ONLY");
6541 return strstr (str, "set_e2uuid") == NULL;
6542 str = getenv ("SKIP_TEST_SET_E2UUID_2");
6543 if (str && strcmp (str, "1") == 0) return 1;
6544 str = getenv ("SKIP_TEST_SET_E2UUID");
6545 if (str && strcmp (str, "1") == 0) return 1;
6549 static int test_set_e2uuid_2 (void)
6551 if (test_set_e2uuid_2_skip ()) {
6552 printf (" %s skipped (reason: environment variable set)\n", "test_set_e2uuid_2");
6556 /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
6558 char device[] = "/dev/sda";
6561 r = guestfs_blockdev_setrw (g, device);
6568 r = guestfs_umount_all (g);
6575 r = guestfs_lvm_remove_all (g);
6580 char device[] = "/dev/sda";
6581 char lines_0[] = ",";
6588 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6593 char fstype[] = "ext2";
6594 char device[] = "/dev/sda1";
6597 r = guestfs_mkfs (g, fstype, device);
6602 char device[] = "/dev/sda1";
6603 char mountpoint[] = "/";
6606 r = guestfs_mount (g, device, mountpoint);
6610 /* TestRun for set_e2uuid (2) */
6612 char device[] = "/dev/sda1";
6613 char uuid[] = "random";
6616 r = guestfs_set_e2uuid (g, device, uuid);
6623 static int test_set_e2uuid_3_skip (void)
6627 str = getenv ("TEST_ONLY");
6629 return strstr (str, "set_e2uuid") == NULL;
6630 str = getenv ("SKIP_TEST_SET_E2UUID_3");
6631 if (str && strcmp (str, "1") == 0) return 1;
6632 str = getenv ("SKIP_TEST_SET_E2UUID");
6633 if (str && strcmp (str, "1") == 0) return 1;
6637 static int test_set_e2uuid_3 (void)
6639 if (test_set_e2uuid_3_skip ()) {
6640 printf (" %s skipped (reason: environment variable set)\n", "test_set_e2uuid_3");
6644 /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
6646 char device[] = "/dev/sda";
6649 r = guestfs_blockdev_setrw (g, device);
6656 r = guestfs_umount_all (g);
6663 r = guestfs_lvm_remove_all (g);
6668 char device[] = "/dev/sda";
6669 char lines_0[] = ",";
6676 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6681 char fstype[] = "ext2";
6682 char device[] = "/dev/sda1";
6685 r = guestfs_mkfs (g, fstype, device);
6690 char device[] = "/dev/sda1";
6691 char mountpoint[] = "/";
6694 r = guestfs_mount (g, device, mountpoint);
6698 /* TestRun for set_e2uuid (3) */
6700 char device[] = "/dev/sda1";
6701 char uuid[] = "time";
6704 r = guestfs_set_e2uuid (g, device, uuid);
6711 static int test_set_e2label_0_skip (void)
6715 str = getenv ("TEST_ONLY");
6717 return strstr (str, "set_e2label") == NULL;
6718 str = getenv ("SKIP_TEST_SET_E2LABEL_0");
6719 if (str && strcmp (str, "1") == 0) return 1;
6720 str = getenv ("SKIP_TEST_SET_E2LABEL");
6721 if (str && strcmp (str, "1") == 0) return 1;
6725 static int test_set_e2label_0 (void)
6727 if (test_set_e2label_0_skip ()) {
6728 printf (" %s skipped (reason: environment variable set)\n", "test_set_e2label_0");
6732 /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
6734 char device[] = "/dev/sda";
6737 r = guestfs_blockdev_setrw (g, device);
6744 r = guestfs_umount_all (g);
6751 r = guestfs_lvm_remove_all (g);
6756 char device[] = "/dev/sda";
6757 char lines_0[] = ",";
6764 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6769 char fstype[] = "ext2";
6770 char device[] = "/dev/sda1";
6773 r = guestfs_mkfs (g, fstype, device);
6778 char device[] = "/dev/sda1";
6779 char mountpoint[] = "/";
6782 r = guestfs_mount (g, device, mountpoint);
6786 /* TestOutput for set_e2label (0) */
6787 char expected[] = "testlabel";
6789 char device[] = "/dev/sda1";
6790 char label[] = "testlabel";
6793 r = guestfs_set_e2label (g, device, label);
6798 char device[] = "/dev/sda1";
6801 r = guestfs_get_e2label (g, device);
6804 if (strcmp (r, expected) != 0) {
6805 fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
6813 static int test_pvremove_0_skip (void)
6817 str = getenv ("TEST_ONLY");
6819 return strstr (str, "pvremove") == NULL;
6820 str = getenv ("SKIP_TEST_PVREMOVE_0");
6821 if (str && strcmp (str, "1") == 0) return 1;
6822 str = getenv ("SKIP_TEST_PVREMOVE");
6823 if (str && strcmp (str, "1") == 0) return 1;
6827 static int test_pvremove_0 (void)
6829 if (test_pvremove_0_skip ()) {
6830 printf (" %s skipped (reason: environment variable set)\n", "test_pvremove_0");
6834 /* InitNone|InitEmpty for test_pvremove_0 */
6836 char device[] = "/dev/sda";
6839 r = guestfs_blockdev_setrw (g, device);
6846 r = guestfs_umount_all (g);
6853 r = guestfs_lvm_remove_all (g);
6857 /* TestOutputListOfDevices for pvremove (0) */
6859 char device[] = "/dev/sda";
6860 char lines_0[] = ",";
6867 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6872 char device[] = "/dev/sda1";
6875 r = guestfs_pvcreate (g, device);
6880 char volgroup[] = "VG";
6881 char physvols_0[] = "/dev/sda1";
6882 char *physvols[] = {
6888 r = guestfs_vgcreate (g, volgroup, physvols);
6893 char logvol[] = "LV1";
6894 char volgroup[] = "VG";
6897 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6902 char logvol[] = "LV2";
6903 char volgroup[] = "VG";
6906 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6911 char vgname[] = "VG";
6914 r = guestfs_vgremove (g, vgname);
6919 char device[] = "/dev/sda1";
6922 r = guestfs_pvremove (g, device);
6930 r = guestfs_lvs (g);
6934 fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
6938 for (i = 0; r[i] != NULL; ++i)
6945 static int test_pvremove_1_skip (void)
6949 str = getenv ("TEST_ONLY");
6951 return strstr (str, "pvremove") == NULL;
6952 str = getenv ("SKIP_TEST_PVREMOVE_1");
6953 if (str && strcmp (str, "1") == 0) return 1;
6954 str = getenv ("SKIP_TEST_PVREMOVE");
6955 if (str && strcmp (str, "1") == 0) return 1;
6959 static int test_pvremove_1 (void)
6961 if (test_pvremove_1_skip ()) {
6962 printf (" %s skipped (reason: environment variable set)\n", "test_pvremove_1");
6966 /* InitNone|InitEmpty for test_pvremove_1 */
6968 char device[] = "/dev/sda";
6971 r = guestfs_blockdev_setrw (g, device);
6978 r = guestfs_umount_all (g);
6985 r = guestfs_lvm_remove_all (g);
6989 /* TestOutputListOfDevices for pvremove (1) */
6991 char device[] = "/dev/sda";
6992 char lines_0[] = ",";
6999 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7004 char device[] = "/dev/sda1";
7007 r = guestfs_pvcreate (g, device);
7012 char volgroup[] = "VG";
7013 char physvols_0[] = "/dev/sda1";
7014 char *physvols[] = {
7020 r = guestfs_vgcreate (g, volgroup, physvols);
7025 char logvol[] = "LV1";
7026 char volgroup[] = "VG";
7029 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7034 char logvol[] = "LV2";
7035 char volgroup[] = "VG";
7038 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7043 char vgname[] = "VG";
7046 r = guestfs_vgremove (g, vgname);
7051 char device[] = "/dev/sda1";
7054 r = guestfs_pvremove (g, device);
7062 r = guestfs_vgs (g);
7066 fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
7070 for (i = 0; r[i] != NULL; ++i)
7077 static int test_pvremove_2_skip (void)
7081 str = getenv ("TEST_ONLY");
7083 return strstr (str, "pvremove") == NULL;
7084 str = getenv ("SKIP_TEST_PVREMOVE_2");
7085 if (str && strcmp (str, "1") == 0) return 1;
7086 str = getenv ("SKIP_TEST_PVREMOVE");
7087 if (str && strcmp (str, "1") == 0) return 1;
7091 static int test_pvremove_2 (void)
7093 if (test_pvremove_2_skip ()) {
7094 printf (" %s skipped (reason: environment variable set)\n", "test_pvremove_2");
7098 /* InitNone|InitEmpty for test_pvremove_2 */
7100 char device[] = "/dev/sda";
7103 r = guestfs_blockdev_setrw (g, device);
7110 r = guestfs_umount_all (g);
7117 r = guestfs_lvm_remove_all (g);
7121 /* TestOutputListOfDevices for pvremove (2) */
7123 char device[] = "/dev/sda";
7124 char lines_0[] = ",";
7131 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7136 char device[] = "/dev/sda1";
7139 r = guestfs_pvcreate (g, device);
7144 char volgroup[] = "VG";
7145 char physvols_0[] = "/dev/sda1";
7146 char *physvols[] = {
7152 r = guestfs_vgcreate (g, volgroup, physvols);
7157 char logvol[] = "LV1";
7158 char volgroup[] = "VG";
7161 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7166 char logvol[] = "LV2";
7167 char volgroup[] = "VG";
7170 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7175 char vgname[] = "VG";
7178 r = guestfs_vgremove (g, vgname);
7183 char device[] = "/dev/sda1";
7186 r = guestfs_pvremove (g, device);
7194 r = guestfs_pvs (g);
7198 fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
7202 for (i = 0; r[i] != NULL; ++i)
7209 static int test_vgremove_0_skip (void)
7213 str = getenv ("TEST_ONLY");
7215 return strstr (str, "vgremove") == NULL;
7216 str = getenv ("SKIP_TEST_VGREMOVE_0");
7217 if (str && strcmp (str, "1") == 0) return 1;
7218 str = getenv ("SKIP_TEST_VGREMOVE");
7219 if (str && strcmp (str, "1") == 0) return 1;
7223 static int test_vgremove_0 (void)
7225 if (test_vgremove_0_skip ()) {
7226 printf (" %s skipped (reason: environment variable set)\n", "test_vgremove_0");
7230 /* InitNone|InitEmpty for test_vgremove_0 */
7232 char device[] = "/dev/sda";
7235 r = guestfs_blockdev_setrw (g, device);
7242 r = guestfs_umount_all (g);
7249 r = guestfs_lvm_remove_all (g);
7253 /* TestOutputList for vgremove (0) */
7255 char device[] = "/dev/sda";
7256 char lines_0[] = ",";
7263 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7268 char device[] = "/dev/sda1";
7271 r = guestfs_pvcreate (g, device);
7276 char volgroup[] = "VG";
7277 char physvols_0[] = "/dev/sda1";
7278 char *physvols[] = {
7284 r = guestfs_vgcreate (g, volgroup, physvols);
7289 char logvol[] = "LV1";
7290 char volgroup[] = "VG";
7293 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7298 char logvol[] = "LV2";
7299 char volgroup[] = "VG";
7302 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7307 char vgname[] = "VG";
7310 r = guestfs_vgremove (g, vgname);
7318 r = guestfs_lvs (g);
7322 fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
7326 for (i = 0; r[i] != NULL; ++i)
7333 static int test_vgremove_1_skip (void)
7337 str = getenv ("TEST_ONLY");
7339 return strstr (str, "vgremove") == NULL;
7340 str = getenv ("SKIP_TEST_VGREMOVE_1");
7341 if (str && strcmp (str, "1") == 0) return 1;
7342 str = getenv ("SKIP_TEST_VGREMOVE");
7343 if (str && strcmp (str, "1") == 0) return 1;
7347 static int test_vgremove_1 (void)
7349 if (test_vgremove_1_skip ()) {
7350 printf (" %s skipped (reason: environment variable set)\n", "test_vgremove_1");
7354 /* InitNone|InitEmpty for test_vgremove_1 */
7356 char device[] = "/dev/sda";
7359 r = guestfs_blockdev_setrw (g, device);
7366 r = guestfs_umount_all (g);
7373 r = guestfs_lvm_remove_all (g);
7377 /* TestOutputList for vgremove (1) */
7379 char device[] = "/dev/sda";
7380 char lines_0[] = ",";
7387 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7392 char device[] = "/dev/sda1";
7395 r = guestfs_pvcreate (g, device);
7400 char volgroup[] = "VG";
7401 char physvols_0[] = "/dev/sda1";
7402 char *physvols[] = {
7408 r = guestfs_vgcreate (g, volgroup, physvols);
7413 char logvol[] = "LV1";
7414 char volgroup[] = "VG";
7417 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7422 char logvol[] = "LV2";
7423 char volgroup[] = "VG";
7426 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7431 char vgname[] = "VG";
7434 r = guestfs_vgremove (g, vgname);
7442 r = guestfs_vgs (g);
7446 fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
7450 for (i = 0; r[i] != NULL; ++i)
7457 static int test_lvremove_0_skip (void)
7461 str = getenv ("TEST_ONLY");
7463 return strstr (str, "lvremove") == NULL;
7464 str = getenv ("SKIP_TEST_LVREMOVE_0");
7465 if (str && strcmp (str, "1") == 0) return 1;
7466 str = getenv ("SKIP_TEST_LVREMOVE");
7467 if (str && strcmp (str, "1") == 0) return 1;
7471 static int test_lvremove_0 (void)
7473 if (test_lvremove_0_skip ()) {
7474 printf (" %s skipped (reason: environment variable set)\n", "test_lvremove_0");
7478 /* InitNone|InitEmpty for test_lvremove_0 */
7480 char device[] = "/dev/sda";
7483 r = guestfs_blockdev_setrw (g, device);
7490 r = guestfs_umount_all (g);
7497 r = guestfs_lvm_remove_all (g);
7501 /* TestOutputList for lvremove (0) */
7503 char device[] = "/dev/sda";
7504 char lines_0[] = ",";
7511 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7516 char device[] = "/dev/sda1";
7519 r = guestfs_pvcreate (g, device);
7524 char volgroup[] = "VG";
7525 char physvols_0[] = "/dev/sda1";
7526 char *physvols[] = {
7532 r = guestfs_vgcreate (g, volgroup, physvols);
7537 char logvol[] = "LV1";
7538 char volgroup[] = "VG";
7541 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7546 char logvol[] = "LV2";
7547 char volgroup[] = "VG";
7550 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7555 char device[] = "/dev/VG/LV1";
7558 r = guestfs_lvremove (g, device);
7566 r = guestfs_lvs (g);
7570 fprintf (stderr, "test_lvremove_0: short list returned from command\n");
7575 char expected[] = "/dev/VG/LV2";
7576 if (strcmp (r[0], expected) != 0) {
7577 fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7582 fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
7586 for (i = 0; r[i] != NULL; ++i)
7593 static int test_lvremove_1_skip (void)
7597 str = getenv ("TEST_ONLY");
7599 return strstr (str, "lvremove") == NULL;
7600 str = getenv ("SKIP_TEST_LVREMOVE_1");
7601 if (str && strcmp (str, "1") == 0) return 1;
7602 str = getenv ("SKIP_TEST_LVREMOVE");
7603 if (str && strcmp (str, "1") == 0) return 1;
7607 static int test_lvremove_1 (void)
7609 if (test_lvremove_1_skip ()) {
7610 printf (" %s skipped (reason: environment variable set)\n", "test_lvremove_1");
7614 /* InitNone|InitEmpty for test_lvremove_1 */
7616 char device[] = "/dev/sda";
7619 r = guestfs_blockdev_setrw (g, device);
7626 r = guestfs_umount_all (g);
7633 r = guestfs_lvm_remove_all (g);
7637 /* TestOutputList for lvremove (1) */
7639 char device[] = "/dev/sda";
7640 char lines_0[] = ",";
7647 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7652 char device[] = "/dev/sda1";
7655 r = guestfs_pvcreate (g, device);
7660 char volgroup[] = "VG";
7661 char physvols_0[] = "/dev/sda1";
7662 char *physvols[] = {
7668 r = guestfs_vgcreate (g, volgroup, physvols);
7673 char logvol[] = "LV1";
7674 char volgroup[] = "VG";
7677 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7682 char logvol[] = "LV2";
7683 char volgroup[] = "VG";
7686 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7691 char device[] = "/dev/VG";
7694 r = guestfs_lvremove (g, device);
7702 r = guestfs_lvs (g);
7706 fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
7710 for (i = 0; r[i] != NULL; ++i)
7717 static int test_lvremove_2_skip (void)
7721 str = getenv ("TEST_ONLY");
7723 return strstr (str, "lvremove") == NULL;
7724 str = getenv ("SKIP_TEST_LVREMOVE_2");
7725 if (str && strcmp (str, "1") == 0) return 1;
7726 str = getenv ("SKIP_TEST_LVREMOVE");
7727 if (str && strcmp (str, "1") == 0) return 1;
7731 static int test_lvremove_2 (void)
7733 if (test_lvremove_2_skip ()) {
7734 printf (" %s skipped (reason: environment variable set)\n", "test_lvremove_2");
7738 /* InitNone|InitEmpty for test_lvremove_2 */
7740 char device[] = "/dev/sda";
7743 r = guestfs_blockdev_setrw (g, device);
7750 r = guestfs_umount_all (g);
7757 r = guestfs_lvm_remove_all (g);
7761 /* TestOutputList for lvremove (2) */
7763 char device[] = "/dev/sda";
7764 char lines_0[] = ",";
7771 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7776 char device[] = "/dev/sda1";
7779 r = guestfs_pvcreate (g, device);
7784 char volgroup[] = "VG";
7785 char physvols_0[] = "/dev/sda1";
7786 char *physvols[] = {
7792 r = guestfs_vgcreate (g, volgroup, physvols);
7797 char logvol[] = "LV1";
7798 char volgroup[] = "VG";
7801 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7806 char logvol[] = "LV2";
7807 char volgroup[] = "VG";
7810 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7815 char device[] = "/dev/VG";
7818 r = guestfs_lvremove (g, device);
7826 r = guestfs_vgs (g);
7830 fprintf (stderr, "test_lvremove_2: short list returned from command\n");
7835 char expected[] = "VG";
7836 if (strcmp (r[0], expected) != 0) {
7837 fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7842 fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
7846 for (i = 0; r[i] != NULL; ++i)
7853 static int test_mount_ro_0_skip (void)
7857 str = getenv ("TEST_ONLY");
7859 return strstr (str, "mount_ro") == NULL;
7860 str = getenv ("SKIP_TEST_MOUNT_RO_0");
7861 if (str && strcmp (str, "1") == 0) return 1;
7862 str = getenv ("SKIP_TEST_MOUNT_RO");
7863 if (str && strcmp (str, "1") == 0) return 1;
7867 static int test_mount_ro_0 (void)
7869 if (test_mount_ro_0_skip ()) {
7870 printf (" %s skipped (reason: environment variable set)\n", "test_mount_ro_0");
7874 /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
7876 char device[] = "/dev/sda";
7879 r = guestfs_blockdev_setrw (g, device);
7886 r = guestfs_umount_all (g);
7893 r = guestfs_lvm_remove_all (g);
7898 char device[] = "/dev/sda";
7899 char lines_0[] = ",";
7906 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7911 char fstype[] = "ext2";
7912 char device[] = "/dev/sda1";
7915 r = guestfs_mkfs (g, fstype, device);
7920 char device[] = "/dev/sda1";
7921 char mountpoint[] = "/";
7924 r = guestfs_mount (g, device, mountpoint);
7928 /* TestLastFail for mount_ro (0) */
7930 char pathordevice[] = "/";
7933 r = guestfs_umount (g, pathordevice);
7938 char device[] = "/dev/sda1";
7939 char mountpoint[] = "/";
7942 r = guestfs_mount_ro (g, device, mountpoint);
7947 char path[] = "/new";
7950 r = guestfs_touch (g, path);
7957 static int test_mount_ro_1_skip (void)
7961 str = getenv ("TEST_ONLY");
7963 return strstr (str, "mount_ro") == NULL;
7964 str = getenv ("SKIP_TEST_MOUNT_RO_1");
7965 if (str && strcmp (str, "1") == 0) return 1;
7966 str = getenv ("SKIP_TEST_MOUNT_RO");
7967 if (str && strcmp (str, "1") == 0) return 1;
7971 static int test_mount_ro_1 (void)
7973 if (test_mount_ro_1_skip ()) {
7974 printf (" %s skipped (reason: environment variable set)\n", "test_mount_ro_1");
7978 /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
7980 char device[] = "/dev/sda";
7983 r = guestfs_blockdev_setrw (g, device);
7990 r = guestfs_umount_all (g);
7997 r = guestfs_lvm_remove_all (g);
8002 char device[] = "/dev/sda";
8003 char lines_0[] = ",";
8010 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8015 char fstype[] = "ext2";
8016 char device[] = "/dev/sda1";
8019 r = guestfs_mkfs (g, fstype, device);
8024 char device[] = "/dev/sda1";
8025 char mountpoint[] = "/";
8028 r = guestfs_mount (g, device, mountpoint);
8032 /* TestOutput for mount_ro (1) */
8033 char expected[] = "data";
8035 char path[] = "/new";
8036 char content[] = "data";
8039 r = guestfs_write_file (g, path, content, 0);
8044 char pathordevice[] = "/";
8047 r = guestfs_umount (g, pathordevice);
8052 char device[] = "/dev/sda1";
8053 char mountpoint[] = "/";
8056 r = guestfs_mount_ro (g, device, mountpoint);
8061 char path[] = "/new";
8064 r = guestfs_cat (g, path);
8067 if (strcmp (r, expected) != 0) {
8068 fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
8076 static int test_tgz_in_0_skip (void)
8080 str = getenv ("TEST_ONLY");
8082 return strstr (str, "tgz_in") == NULL;
8083 str = getenv ("SKIP_TEST_TGZ_IN_0");
8084 if (str && strcmp (str, "1") == 0) return 1;
8085 str = getenv ("SKIP_TEST_TGZ_IN");
8086 if (str && strcmp (str, "1") == 0) return 1;
8090 static int test_tgz_in_0 (void)
8092 if (test_tgz_in_0_skip ()) {
8093 printf (" %s skipped (reason: environment variable set)\n", "test_tgz_in_0");
8097 /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
8099 char device[] = "/dev/sda";
8102 r = guestfs_blockdev_setrw (g, device);
8109 r = guestfs_umount_all (g);
8116 r = guestfs_lvm_remove_all (g);
8121 char device[] = "/dev/sda";
8122 char lines_0[] = ",";
8129 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8134 char fstype[] = "ext2";
8135 char device[] = "/dev/sda1";
8138 r = guestfs_mkfs (g, fstype, device);
8143 char device[] = "/dev/sda1";
8144 char mountpoint[] = "/";
8147 r = guestfs_mount (g, device, mountpoint);
8151 /* TestOutput for tgz_in (0) */
8152 char expected[] = "hello\n";
8154 char directory[] = "/";
8157 r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
8162 char path[] = "/hello";
8165 r = guestfs_cat (g, path);
8168 if (strcmp (r, expected) != 0) {
8169 fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
8177 static int test_tar_in_0_skip (void)
8181 str = getenv ("TEST_ONLY");
8183 return strstr (str, "tar_in") == NULL;
8184 str = getenv ("SKIP_TEST_TAR_IN_0");
8185 if (str && strcmp (str, "1") == 0) return 1;
8186 str = getenv ("SKIP_TEST_TAR_IN");
8187 if (str && strcmp (str, "1") == 0) return 1;
8191 static int test_tar_in_0 (void)
8193 if (test_tar_in_0_skip ()) {
8194 printf (" %s skipped (reason: environment variable set)\n", "test_tar_in_0");
8198 /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
8200 char device[] = "/dev/sda";
8203 r = guestfs_blockdev_setrw (g, device);
8210 r = guestfs_umount_all (g);
8217 r = guestfs_lvm_remove_all (g);
8222 char device[] = "/dev/sda";
8223 char lines_0[] = ",";
8230 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8235 char fstype[] = "ext2";
8236 char device[] = "/dev/sda1";
8239 r = guestfs_mkfs (g, fstype, device);
8244 char device[] = "/dev/sda1";
8245 char mountpoint[] = "/";
8248 r = guestfs_mount (g, device, mountpoint);
8252 /* TestOutput for tar_in (0) */
8253 char expected[] = "hello\n";
8255 char directory[] = "/";
8258 r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
8263 char path[] = "/hello";
8266 r = guestfs_cat (g, path);
8269 if (strcmp (r, expected) != 0) {
8270 fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
8278 static int test_checksum_0_skip (void)
8282 str = getenv ("TEST_ONLY");
8284 return strstr (str, "checksum") == NULL;
8285 str = getenv ("SKIP_TEST_CHECKSUM_0");
8286 if (str && strcmp (str, "1") == 0) return 1;
8287 str = getenv ("SKIP_TEST_CHECKSUM");
8288 if (str && strcmp (str, "1") == 0) return 1;
8292 static int test_checksum_0 (void)
8294 if (test_checksum_0_skip ()) {
8295 printf (" %s skipped (reason: environment variable set)\n", "test_checksum_0");
8299 /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
8301 char device[] = "/dev/sda";
8304 r = guestfs_blockdev_setrw (g, device);
8311 r = guestfs_umount_all (g);
8318 r = guestfs_lvm_remove_all (g);
8323 char device[] = "/dev/sda";
8324 char lines_0[] = ",";
8331 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8336 char fstype[] = "ext2";
8337 char device[] = "/dev/sda1";
8340 r = guestfs_mkfs (g, fstype, device);
8345 char device[] = "/dev/sda1";
8346 char mountpoint[] = "/";
8349 r = guestfs_mount (g, device, mountpoint);
8353 /* TestOutput for checksum (0) */
8354 char expected[] = "935282863";
8356 char path[] = "/new";
8357 char content[] = "test\n";
8360 r = guestfs_write_file (g, path, content, 0);
8365 char csumtype[] = "crc";
8366 char path[] = "/new";
8369 r = guestfs_checksum (g, csumtype, path);
8372 if (strcmp (r, expected) != 0) {
8373 fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
8381 static int test_checksum_1_skip (void)
8385 str = getenv ("TEST_ONLY");
8387 return strstr (str, "checksum") == NULL;
8388 str = getenv ("SKIP_TEST_CHECKSUM_1");
8389 if (str && strcmp (str, "1") == 0) return 1;
8390 str = getenv ("SKIP_TEST_CHECKSUM");
8391 if (str && strcmp (str, "1") == 0) return 1;
8395 static int test_checksum_1 (void)
8397 if (test_checksum_1_skip ()) {
8398 printf (" %s skipped (reason: environment variable set)\n", "test_checksum_1");
8402 /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
8404 char device[] = "/dev/sda";
8407 r = guestfs_blockdev_setrw (g, device);
8414 r = guestfs_umount_all (g);
8421 r = guestfs_lvm_remove_all (g);
8426 char device[] = "/dev/sda";
8427 char lines_0[] = ",";
8434 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8439 char fstype[] = "ext2";
8440 char device[] = "/dev/sda1";
8443 r = guestfs_mkfs (g, fstype, device);
8448 char device[] = "/dev/sda1";
8449 char mountpoint[] = "/";
8452 r = guestfs_mount (g, device, mountpoint);
8456 /* TestLastFail for checksum (1) */
8458 char csumtype[] = "crc";
8459 char path[] = "/new";
8462 r = guestfs_checksum (g, csumtype, path);
8470 static int test_checksum_2_skip (void)
8474 str = getenv ("TEST_ONLY");
8476 return strstr (str, "checksum") == NULL;
8477 str = getenv ("SKIP_TEST_CHECKSUM_2");
8478 if (str && strcmp (str, "1") == 0) return 1;
8479 str = getenv ("SKIP_TEST_CHECKSUM");
8480 if (str && strcmp (str, "1") == 0) return 1;
8484 static int test_checksum_2 (void)
8486 if (test_checksum_2_skip ()) {
8487 printf (" %s skipped (reason: environment variable set)\n", "test_checksum_2");
8491 /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
8493 char device[] = "/dev/sda";
8496 r = guestfs_blockdev_setrw (g, device);
8503 r = guestfs_umount_all (g);
8510 r = guestfs_lvm_remove_all (g);
8515 char device[] = "/dev/sda";
8516 char lines_0[] = ",";
8523 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8528 char fstype[] = "ext2";
8529 char device[] = "/dev/sda1";
8532 r = guestfs_mkfs (g, fstype, device);
8537 char device[] = "/dev/sda1";
8538 char mountpoint[] = "/";
8541 r = guestfs_mount (g, device, mountpoint);
8545 /* TestOutput for checksum (2) */
8546 char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
8548 char path[] = "/new";
8549 char content[] = "test\n";
8552 r = guestfs_write_file (g, path, content, 0);
8557 char csumtype[] = "md5";
8558 char path[] = "/new";
8561 r = guestfs_checksum (g, csumtype, path);
8564 if (strcmp (r, expected) != 0) {
8565 fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
8573 static int test_checksum_3_skip (void)
8577 str = getenv ("TEST_ONLY");
8579 return strstr (str, "checksum") == NULL;
8580 str = getenv ("SKIP_TEST_CHECKSUM_3");
8581 if (str && strcmp (str, "1") == 0) return 1;
8582 str = getenv ("SKIP_TEST_CHECKSUM");
8583 if (str && strcmp (str, "1") == 0) return 1;
8587 static int test_checksum_3 (void)
8589 if (test_checksum_3_skip ()) {
8590 printf (" %s skipped (reason: environment variable set)\n", "test_checksum_3");
8594 /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
8596 char device[] = "/dev/sda";
8599 r = guestfs_blockdev_setrw (g, device);
8606 r = guestfs_umount_all (g);
8613 r = guestfs_lvm_remove_all (g);
8618 char device[] = "/dev/sda";
8619 char lines_0[] = ",";
8626 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8631 char fstype[] = "ext2";
8632 char device[] = "/dev/sda1";
8635 r = guestfs_mkfs (g, fstype, device);
8640 char device[] = "/dev/sda1";
8641 char mountpoint[] = "/";
8644 r = guestfs_mount (g, device, mountpoint);
8648 /* TestOutput for checksum (3) */
8649 char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
8651 char path[] = "/new";
8652 char content[] = "test\n";
8655 r = guestfs_write_file (g, path, content, 0);
8660 char csumtype[] = "sha1";
8661 char path[] = "/new";
8664 r = guestfs_checksum (g, csumtype, path);
8667 if (strcmp (r, expected) != 0) {
8668 fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
8676 static int test_checksum_4_skip (void)
8680 str = getenv ("TEST_ONLY");
8682 return strstr (str, "checksum") == NULL;
8683 str = getenv ("SKIP_TEST_CHECKSUM_4");
8684 if (str && strcmp (str, "1") == 0) return 1;
8685 str = getenv ("SKIP_TEST_CHECKSUM");
8686 if (str && strcmp (str, "1") == 0) return 1;
8690 static int test_checksum_4 (void)
8692 if (test_checksum_4_skip ()) {
8693 printf (" %s skipped (reason: environment variable set)\n", "test_checksum_4");
8697 /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
8699 char device[] = "/dev/sda";
8702 r = guestfs_blockdev_setrw (g, device);
8709 r = guestfs_umount_all (g);
8716 r = guestfs_lvm_remove_all (g);
8721 char device[] = "/dev/sda";
8722 char lines_0[] = ",";
8729 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8734 char fstype[] = "ext2";
8735 char device[] = "/dev/sda1";
8738 r = guestfs_mkfs (g, fstype, device);
8743 char device[] = "/dev/sda1";
8744 char mountpoint[] = "/";
8747 r = guestfs_mount (g, device, mountpoint);
8751 /* TestOutput for checksum (4) */
8752 char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
8754 char path[] = "/new";
8755 char content[] = "test\n";
8758 r = guestfs_write_file (g, path, content, 0);
8763 char csumtype[] = "sha224";
8764 char path[] = "/new";
8767 r = guestfs_checksum (g, csumtype, path);
8770 if (strcmp (r, expected) != 0) {
8771 fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
8779 static int test_checksum_5_skip (void)
8783 str = getenv ("TEST_ONLY");
8785 return strstr (str, "checksum") == NULL;
8786 str = getenv ("SKIP_TEST_CHECKSUM_5");
8787 if (str && strcmp (str, "1") == 0) return 1;
8788 str = getenv ("SKIP_TEST_CHECKSUM");
8789 if (str && strcmp (str, "1") == 0) return 1;
8793 static int test_checksum_5 (void)
8795 if (test_checksum_5_skip ()) {
8796 printf (" %s skipped (reason: environment variable set)\n", "test_checksum_5");
8800 /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
8802 char device[] = "/dev/sda";
8805 r = guestfs_blockdev_setrw (g, device);
8812 r = guestfs_umount_all (g);
8819 r = guestfs_lvm_remove_all (g);
8824 char device[] = "/dev/sda";
8825 char lines_0[] = ",";
8832 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8837 char fstype[] = "ext2";
8838 char device[] = "/dev/sda1";
8841 r = guestfs_mkfs (g, fstype, device);
8846 char device[] = "/dev/sda1";
8847 char mountpoint[] = "/";
8850 r = guestfs_mount (g, device, mountpoint);
8854 /* TestOutput for checksum (5) */
8855 char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
8857 char path[] = "/new";
8858 char content[] = "test\n";
8861 r = guestfs_write_file (g, path, content, 0);
8866 char csumtype[] = "sha256";
8867 char path[] = "/new";
8870 r = guestfs_checksum (g, csumtype, path);
8873 if (strcmp (r, expected) != 0) {
8874 fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
8882 static int test_checksum_6_skip (void)
8886 str = getenv ("TEST_ONLY");
8888 return strstr (str, "checksum") == NULL;
8889 str = getenv ("SKIP_TEST_CHECKSUM_6");
8890 if (str && strcmp (str, "1") == 0) return 1;
8891 str = getenv ("SKIP_TEST_CHECKSUM");
8892 if (str && strcmp (str, "1") == 0) return 1;
8896 static int test_checksum_6 (void)
8898 if (test_checksum_6_skip ()) {
8899 printf (" %s skipped (reason: environment variable set)\n", "test_checksum_6");
8903 /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
8905 char device[] = "/dev/sda";
8908 r = guestfs_blockdev_setrw (g, device);
8915 r = guestfs_umount_all (g);
8922 r = guestfs_lvm_remove_all (g);
8927 char device[] = "/dev/sda";
8928 char lines_0[] = ",";
8935 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8940 char fstype[] = "ext2";
8941 char device[] = "/dev/sda1";
8944 r = guestfs_mkfs (g, fstype, device);
8949 char device[] = "/dev/sda1";
8950 char mountpoint[] = "/";
8953 r = guestfs_mount (g, device, mountpoint);
8957 /* TestOutput for checksum (6) */
8958 char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
8960 char path[] = "/new";
8961 char content[] = "test\n";
8964 r = guestfs_write_file (g, path, content, 0);
8969 char csumtype[] = "sha384";
8970 char path[] = "/new";
8973 r = guestfs_checksum (g, csumtype, path);
8976 if (strcmp (r, expected) != 0) {
8977 fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
8985 static int test_checksum_7_skip (void)
8989 str = getenv ("TEST_ONLY");
8991 return strstr (str, "checksum") == NULL;
8992 str = getenv ("SKIP_TEST_CHECKSUM_7");
8993 if (str && strcmp (str, "1") == 0) return 1;
8994 str = getenv ("SKIP_TEST_CHECKSUM");
8995 if (str && strcmp (str, "1") == 0) return 1;
8999 static int test_checksum_7 (void)
9001 if (test_checksum_7_skip ()) {
9002 printf (" %s skipped (reason: environment variable set)\n", "test_checksum_7");
9006 /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
9008 char device[] = "/dev/sda";
9011 r = guestfs_blockdev_setrw (g, device);
9018 r = guestfs_umount_all (g);
9025 r = guestfs_lvm_remove_all (g);
9030 char device[] = "/dev/sda";
9031 char lines_0[] = ",";
9038 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9043 char fstype[] = "ext2";
9044 char device[] = "/dev/sda1";
9047 r = guestfs_mkfs (g, fstype, device);
9052 char device[] = "/dev/sda1";
9053 char mountpoint[] = "/";
9056 r = guestfs_mount (g, device, mountpoint);
9060 /* TestOutput for checksum (7) */
9061 char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
9063 char path[] = "/new";
9064 char content[] = "test\n";
9067 r = guestfs_write_file (g, path, content, 0);
9072 char csumtype[] = "sha512";
9073 char path[] = "/new";
9076 r = guestfs_checksum (g, csumtype, path);
9079 if (strcmp (r, expected) != 0) {
9080 fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
9088 static int test_checksum_8_skip (void)
9092 str = getenv ("TEST_ONLY");
9094 return strstr (str, "checksum") == NULL;
9095 str = getenv ("SKIP_TEST_CHECKSUM_8");
9096 if (str && strcmp (str, "1") == 0) return 1;
9097 str = getenv ("SKIP_TEST_CHECKSUM");
9098 if (str && strcmp (str, "1") == 0) return 1;
9102 static int test_checksum_8 (void)
9104 if (test_checksum_8_skip ()) {
9105 printf (" %s skipped (reason: environment variable set)\n", "test_checksum_8");
9109 /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
9111 char device[] = "/dev/sda";
9114 r = guestfs_blockdev_setrw (g, device);
9121 r = guestfs_umount_all (g);
9128 r = guestfs_lvm_remove_all (g);
9133 char device[] = "/dev/sda";
9134 char lines_0[] = ",";
9141 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9146 char fstype[] = "ext2";
9147 char device[] = "/dev/sda1";
9150 r = guestfs_mkfs (g, fstype, device);
9155 char device[] = "/dev/sda1";
9156 char mountpoint[] = "/";
9159 r = guestfs_mount (g, device, mountpoint);
9163 /* TestOutput for checksum (8) */
9164 char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
9166 char options[] = "ro";
9167 char vfstype[] = "squashfs";
9168 char device[] = "/dev/sdd";
9169 char mountpoint[] = "/";
9172 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
9177 char csumtype[] = "md5";
9178 char path[] = "/known-3";
9181 r = guestfs_checksum (g, csumtype, path);
9184 if (strcmp (r, expected) != 0) {
9185 fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
9193 static int test_download_0_skip (void)
9197 str = getenv ("TEST_ONLY");
9199 return strstr (str, "download") == NULL;
9200 str = getenv ("SKIP_TEST_DOWNLOAD_0");
9201 if (str && strcmp (str, "1") == 0) return 1;
9202 str = getenv ("SKIP_TEST_DOWNLOAD");
9203 if (str && strcmp (str, "1") == 0) return 1;
9207 static int test_download_0 (void)
9209 if (test_download_0_skip ()) {
9210 printf (" %s skipped (reason: environment variable set)\n", "test_download_0");
9214 /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
9216 char device[] = "/dev/sda";
9219 r = guestfs_blockdev_setrw (g, device);
9226 r = guestfs_umount_all (g);
9233 r = guestfs_lvm_remove_all (g);
9238 char device[] = "/dev/sda";
9239 char lines_0[] = ",";
9246 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9251 char fstype[] = "ext2";
9252 char device[] = "/dev/sda1";
9255 r = guestfs_mkfs (g, fstype, device);
9260 char device[] = "/dev/sda1";
9261 char mountpoint[] = "/";
9264 r = guestfs_mount (g, device, mountpoint);
9268 /* TestOutput for download (0) */
9269 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
9271 char remotefilename[] = "/COPYING.LIB";
9274 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
9279 char remotefilename[] = "/COPYING.LIB";
9282 r = guestfs_download (g, remotefilename, "testdownload.tmp");
9287 char remotefilename[] = "/upload";
9290 r = guestfs_upload (g, "testdownload.tmp", remotefilename);
9295 char csumtype[] = "md5";
9296 char path[] = "/upload";
9299 r = guestfs_checksum (g, csumtype, path);
9302 if (strcmp (r, expected) != 0) {
9303 fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
9311 static int test_upload_0_skip (void)
9315 str = getenv ("TEST_ONLY");
9317 return strstr (str, "upload") == NULL;
9318 str = getenv ("SKIP_TEST_UPLOAD_0");
9319 if (str && strcmp (str, "1") == 0) return 1;
9320 str = getenv ("SKIP_TEST_UPLOAD");
9321 if (str && strcmp (str, "1") == 0) return 1;
9325 static int test_upload_0 (void)
9327 if (test_upload_0_skip ()) {
9328 printf (" %s skipped (reason: environment variable set)\n", "test_upload_0");
9332 /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
9334 char device[] = "/dev/sda";
9337 r = guestfs_blockdev_setrw (g, device);
9344 r = guestfs_umount_all (g);
9351 r = guestfs_lvm_remove_all (g);
9356 char device[] = "/dev/sda";
9357 char lines_0[] = ",";
9364 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9369 char fstype[] = "ext2";
9370 char device[] = "/dev/sda1";
9373 r = guestfs_mkfs (g, fstype, device);
9378 char device[] = "/dev/sda1";
9379 char mountpoint[] = "/";
9382 r = guestfs_mount (g, device, mountpoint);
9386 /* TestOutput for upload (0) */
9387 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
9389 char remotefilename[] = "/COPYING.LIB";
9392 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
9397 char csumtype[] = "md5";
9398 char path[] = "/COPYING.LIB";
9401 r = guestfs_checksum (g, csumtype, path);
9404 if (strcmp (r, expected) != 0) {
9405 fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
9413 static int test_blockdev_rereadpt_0_skip (void)
9417 str = getenv ("TEST_ONLY");
9419 return strstr (str, "blockdev_rereadpt") == NULL;
9420 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
9421 if (str && strcmp (str, "1") == 0) return 1;
9422 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
9423 if (str && strcmp (str, "1") == 0) return 1;
9427 static int test_blockdev_rereadpt_0 (void)
9429 if (test_blockdev_rereadpt_0_skip ()) {
9430 printf (" %s skipped (reason: environment variable set)\n", "test_blockdev_rereadpt_0");
9434 /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
9436 char device[] = "/dev/sda";
9439 r = guestfs_blockdev_setrw (g, device);
9446 r = guestfs_umount_all (g);
9453 r = guestfs_lvm_remove_all (g);
9457 /* TestRun for blockdev_rereadpt (0) */
9459 char device[] = "/dev/sda";
9462 r = guestfs_blockdev_rereadpt (g, device);
9469 static int test_blockdev_flushbufs_0_skip (void)
9473 str = getenv ("TEST_ONLY");
9475 return strstr (str, "blockdev_flushbufs") == NULL;
9476 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
9477 if (str && strcmp (str, "1") == 0) return 1;
9478 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
9479 if (str && strcmp (str, "1") == 0) return 1;
9483 static int test_blockdev_flushbufs_0 (void)
9485 if (test_blockdev_flushbufs_0_skip ()) {
9486 printf (" %s skipped (reason: environment variable set)\n", "test_blockdev_flushbufs_0");
9490 /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
9492 char device[] = "/dev/sda";
9495 r = guestfs_blockdev_setrw (g, device);
9502 r = guestfs_umount_all (g);
9509 r = guestfs_lvm_remove_all (g);
9513 /* TestRun for blockdev_flushbufs (0) */
9515 char device[] = "/dev/sda";
9518 r = guestfs_blockdev_flushbufs (g, device);
9525 static int test_blockdev_getsize64_0_skip (void)
9529 str = getenv ("TEST_ONLY");
9531 return strstr (str, "blockdev_getsize64") == NULL;
9532 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
9533 if (str && strcmp (str, "1") == 0) return 1;
9534 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
9535 if (str && strcmp (str, "1") == 0) return 1;
9539 static int test_blockdev_getsize64_0 (void)
9541 if (test_blockdev_getsize64_0_skip ()) {
9542 printf (" %s skipped (reason: environment variable set)\n", "test_blockdev_getsize64_0");
9546 /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
9548 char device[] = "/dev/sda";
9551 r = guestfs_blockdev_setrw (g, device);
9558 r = guestfs_umount_all (g);
9565 r = guestfs_lvm_remove_all (g);
9569 /* TestOutputInt for blockdev_getsize64 (0) */
9571 char device[] = "/dev/sda";
9574 r = guestfs_blockdev_getsize64 (g, device);
9577 if (r != 524288000) {
9578 fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n", (int) r);
9585 static int test_blockdev_getsz_0_skip (void)
9589 str = getenv ("TEST_ONLY");
9591 return strstr (str, "blockdev_getsz") == NULL;
9592 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
9593 if (str && strcmp (str, "1") == 0) return 1;
9594 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
9595 if (str && strcmp (str, "1") == 0) return 1;
9599 static int test_blockdev_getsz_0 (void)
9601 if (test_blockdev_getsz_0_skip ()) {
9602 printf (" %s skipped (reason: environment variable set)\n", "test_blockdev_getsz_0");
9606 /* InitNone|InitEmpty for test_blockdev_getsz_0 */
9608 char device[] = "/dev/sda";
9611 r = guestfs_blockdev_setrw (g, device);
9618 r = guestfs_umount_all (g);
9625 r = guestfs_lvm_remove_all (g);
9629 /* TestOutputInt for blockdev_getsz (0) */
9631 char device[] = "/dev/sda";
9634 r = guestfs_blockdev_getsz (g, device);
9638 fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n", (int) r);
9645 static int test_blockdev_getbsz_0_skip (void)
9649 str = getenv ("TEST_ONLY");
9651 return strstr (str, "blockdev_getbsz") == NULL;
9652 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
9653 if (str && strcmp (str, "1") == 0) return 1;
9654 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
9655 if (str && strcmp (str, "1") == 0) return 1;
9659 static int test_blockdev_getbsz_0 (void)
9661 if (test_blockdev_getbsz_0_skip ()) {
9662 printf (" %s skipped (reason: environment variable set)\n", "test_blockdev_getbsz_0");
9666 /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
9668 char device[] = "/dev/sda";
9671 r = guestfs_blockdev_setrw (g, device);
9678 r = guestfs_umount_all (g);
9685 r = guestfs_lvm_remove_all (g);
9689 /* TestOutputInt for blockdev_getbsz (0) */
9691 char device[] = "/dev/sda";
9694 r = guestfs_blockdev_getbsz (g, device);
9698 fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n", (int) r);
9705 static int test_blockdev_getss_0_skip (void)
9709 str = getenv ("TEST_ONLY");
9711 return strstr (str, "blockdev_getss") == NULL;
9712 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
9713 if (str && strcmp (str, "1") == 0) return 1;
9714 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
9715 if (str && strcmp (str, "1") == 0) return 1;
9719 static int test_blockdev_getss_0 (void)
9721 if (test_blockdev_getss_0_skip ()) {
9722 printf (" %s skipped (reason: environment variable set)\n", "test_blockdev_getss_0");
9726 /* InitNone|InitEmpty for test_blockdev_getss_0 */
9728 char device[] = "/dev/sda";
9731 r = guestfs_blockdev_setrw (g, device);
9738 r = guestfs_umount_all (g);
9745 r = guestfs_lvm_remove_all (g);
9749 /* TestOutputInt for blockdev_getss (0) */
9751 char device[] = "/dev/sda";
9754 r = guestfs_blockdev_getss (g, device);
9758 fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n", (int) r);
9765 static int test_blockdev_getro_0_skip (void)
9769 str = getenv ("TEST_ONLY");
9771 return strstr (str, "blockdev_getro") == NULL;
9772 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
9773 if (str && strcmp (str, "1") == 0) return 1;
9774 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
9775 if (str && strcmp (str, "1") == 0) return 1;
9779 static int test_blockdev_getro_0 (void)
9781 if (test_blockdev_getro_0_skip ()) {
9782 printf (" %s skipped (reason: environment variable set)\n", "test_blockdev_getro_0");
9786 /* InitNone|InitEmpty for test_blockdev_getro_0 */
9788 char device[] = "/dev/sda";
9791 r = guestfs_blockdev_setrw (g, device);
9798 r = guestfs_umount_all (g);
9805 r = guestfs_lvm_remove_all (g);
9809 /* TestOutputTrue for blockdev_getro (0) */
9811 char device[] = "/dev/sda";
9814 r = guestfs_blockdev_setro (g, device);
9819 char device[] = "/dev/sda";
9822 r = guestfs_blockdev_getro (g, device);
9826 fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
9833 static int test_blockdev_setrw_0_skip (void)
9837 str = getenv ("TEST_ONLY");
9839 return strstr (str, "blockdev_setrw") == NULL;
9840 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
9841 if (str && strcmp (str, "1") == 0) return 1;
9842 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
9843 if (str && strcmp (str, "1") == 0) return 1;
9847 static int test_blockdev_setrw_0 (void)
9849 if (test_blockdev_setrw_0_skip ()) {
9850 printf (" %s skipped (reason: environment variable set)\n", "test_blockdev_setrw_0");
9854 /* InitNone|InitEmpty for test_blockdev_setrw_0 */
9856 char device[] = "/dev/sda";
9859 r = guestfs_blockdev_setrw (g, device);
9866 r = guestfs_umount_all (g);
9873 r = guestfs_lvm_remove_all (g);
9877 /* TestOutputFalse for blockdev_setrw (0) */
9879 char device[] = "/dev/sda";
9882 r = guestfs_blockdev_setrw (g, device);
9887 char device[] = "/dev/sda";
9890 r = guestfs_blockdev_getro (g, device);
9894 fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
9901 static int test_blockdev_setro_0_skip (void)
9905 str = getenv ("TEST_ONLY");
9907 return strstr (str, "blockdev_setro") == NULL;
9908 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
9909 if (str && strcmp (str, "1") == 0) return 1;
9910 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
9911 if (str && strcmp (str, "1") == 0) return 1;
9915 static int test_blockdev_setro_0 (void)
9917 if (test_blockdev_setro_0_skip ()) {
9918 printf (" %s skipped (reason: environment variable set)\n", "test_blockdev_setro_0");
9922 /* InitNone|InitEmpty for test_blockdev_setro_0 */
9924 char device[] = "/dev/sda";
9927 r = guestfs_blockdev_setrw (g, device);
9934 r = guestfs_umount_all (g);
9941 r = guestfs_lvm_remove_all (g);
9945 /* TestOutputTrue for blockdev_setro (0) */
9947 char device[] = "/dev/sda";
9950 r = guestfs_blockdev_setro (g, device);
9955 char device[] = "/dev/sda";
9958 r = guestfs_blockdev_getro (g, device);
9962 fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
9969 static int test_statvfs_0_skip (void)
9973 str = getenv ("TEST_ONLY");
9975 return strstr (str, "statvfs") == NULL;
9976 str = getenv ("SKIP_TEST_STATVFS_0");
9977 if (str && strcmp (str, "1") == 0) return 1;
9978 str = getenv ("SKIP_TEST_STATVFS");
9979 if (str && strcmp (str, "1") == 0) return 1;
9983 static int test_statvfs_0 (void)
9985 if (test_statvfs_0_skip ()) {
9986 printf (" %s skipped (reason: environment variable set)\n", "test_statvfs_0");
9990 /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
9992 char device[] = "/dev/sda";
9995 r = guestfs_blockdev_setrw (g, device);
10001 suppress_error = 0;
10002 r = guestfs_umount_all (g);
10008 suppress_error = 0;
10009 r = guestfs_lvm_remove_all (g);
10014 char device[] = "/dev/sda";
10015 char lines_0[] = ",";
10021 suppress_error = 0;
10022 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10027 char fstype[] = "ext2";
10028 char device[] = "/dev/sda1";
10030 suppress_error = 0;
10031 r = guestfs_mkfs (g, fstype, device);
10036 char device[] = "/dev/sda1";
10037 char mountpoint[] = "/";
10039 suppress_error = 0;
10040 r = guestfs_mount (g, device, mountpoint);
10044 /* TestOutputStruct for statvfs (0) */
10047 struct guestfs_statvfs *r;
10048 suppress_error = 0;
10049 r = guestfs_statvfs (g, path);
10052 if (r->namemax != 255) {
10053 fprintf (stderr, "test_statvfs_0: namemax was %d, expected 255\n",
10057 if (r->bsize != 1024) {
10058 fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
10067 static int test_lstat_0_skip (void)
10071 str = getenv ("TEST_ONLY");
10073 return strstr (str, "lstat") == NULL;
10074 str = getenv ("SKIP_TEST_LSTAT_0");
10075 if (str && strcmp (str, "1") == 0) return 1;
10076 str = getenv ("SKIP_TEST_LSTAT");
10077 if (str && strcmp (str, "1") == 0) return 1;
10081 static int test_lstat_0 (void)
10083 if (test_lstat_0_skip ()) {
10084 printf (" %s skipped (reason: environment variable set)\n", "test_lstat_0");
10088 /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
10090 char device[] = "/dev/sda";
10092 suppress_error = 0;
10093 r = guestfs_blockdev_setrw (g, device);
10099 suppress_error = 0;
10100 r = guestfs_umount_all (g);
10106 suppress_error = 0;
10107 r = guestfs_lvm_remove_all (g);
10112 char device[] = "/dev/sda";
10113 char lines_0[] = ",";
10119 suppress_error = 0;
10120 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10125 char fstype[] = "ext2";
10126 char device[] = "/dev/sda1";
10128 suppress_error = 0;
10129 r = guestfs_mkfs (g, fstype, device);
10134 char device[] = "/dev/sda1";
10135 char mountpoint[] = "/";
10137 suppress_error = 0;
10138 r = guestfs_mount (g, device, mountpoint);
10142 /* TestOutputStruct for lstat (0) */
10144 char path[] = "/new";
10146 suppress_error = 0;
10147 r = guestfs_touch (g, path);
10152 char path[] = "/new";
10153 struct guestfs_stat *r;
10154 suppress_error = 0;
10155 r = guestfs_lstat (g, path);
10158 if (r->size != 0) {
10159 fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
10168 static int test_stat_0_skip (void)
10172 str = getenv ("TEST_ONLY");
10174 return strstr (str, "stat") == NULL;
10175 str = getenv ("SKIP_TEST_STAT_0");
10176 if (str && strcmp (str, "1") == 0) return 1;
10177 str = getenv ("SKIP_TEST_STAT");
10178 if (str && strcmp (str, "1") == 0) return 1;
10182 static int test_stat_0 (void)
10184 if (test_stat_0_skip ()) {
10185 printf (" %s skipped (reason: environment variable set)\n", "test_stat_0");
10189 /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
10191 char device[] = "/dev/sda";
10193 suppress_error = 0;
10194 r = guestfs_blockdev_setrw (g, device);
10200 suppress_error = 0;
10201 r = guestfs_umount_all (g);
10207 suppress_error = 0;
10208 r = guestfs_lvm_remove_all (g);
10213 char device[] = "/dev/sda";
10214 char lines_0[] = ",";
10220 suppress_error = 0;
10221 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10226 char fstype[] = "ext2";
10227 char device[] = "/dev/sda1";
10229 suppress_error = 0;
10230 r = guestfs_mkfs (g, fstype, device);
10235 char device[] = "/dev/sda1";
10236 char mountpoint[] = "/";
10238 suppress_error = 0;
10239 r = guestfs_mount (g, device, mountpoint);
10243 /* TestOutputStruct for stat (0) */
10245 char path[] = "/new";
10247 suppress_error = 0;
10248 r = guestfs_touch (g, path);
10253 char path[] = "/new";
10254 struct guestfs_stat *r;
10255 suppress_error = 0;
10256 r = guestfs_stat (g, path);
10259 if (r->size != 0) {
10260 fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
10269 static int test_command_lines_0_skip (void)
10273 str = getenv ("TEST_ONLY");
10275 return strstr (str, "command_lines") == NULL;
10276 str = getenv ("SKIP_TEST_COMMAND_LINES_0");
10277 if (str && strcmp (str, "1") == 0) return 1;
10278 str = getenv ("SKIP_TEST_COMMAND_LINES");
10279 if (str && strcmp (str, "1") == 0) return 1;
10283 static int test_command_lines_0 (void)
10285 if (test_command_lines_0_skip ()) {
10286 printf (" %s skipped (reason: environment variable set)\n", "test_command_lines_0");
10290 /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
10292 char device[] = "/dev/sda";
10294 suppress_error = 0;
10295 r = guestfs_blockdev_setrw (g, device);
10301 suppress_error = 0;
10302 r = guestfs_umount_all (g);
10308 suppress_error = 0;
10309 r = guestfs_lvm_remove_all (g);
10314 char device[] = "/dev/sda";
10315 char lines_0[] = ",";
10321 suppress_error = 0;
10322 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10327 char fstype[] = "ext2";
10328 char device[] = "/dev/sda1";
10330 suppress_error = 0;
10331 r = guestfs_mkfs (g, fstype, device);
10336 char device[] = "/dev/sda1";
10337 char mountpoint[] = "/";
10339 suppress_error = 0;
10340 r = guestfs_mount (g, device, mountpoint);
10344 /* TestOutputList for command_lines (0) */
10346 char remotefilename[] = "/test-command";
10348 suppress_error = 0;
10349 r = guestfs_upload (g, "test-command", remotefilename);
10354 char path[] = "/test-command";
10356 suppress_error = 0;
10357 r = guestfs_chmod (g, 493, path);
10362 char arguments_0[] = "/test-command";
10363 char arguments_1[] = "1";
10364 char *arguments[] = {
10371 suppress_error = 0;
10372 r = guestfs_command_lines (g, arguments);
10376 fprintf (stderr, "test_command_lines_0: short list returned from command\n");
10381 char expected[] = "Result1";
10382 if (strcmp (r[0], expected) != 0) {
10383 fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10387 if (r[1] != NULL) {
10388 fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
10392 for (i = 0; r[i] != NULL; ++i)
10399 static int test_command_lines_1_skip (void)
10403 str = getenv ("TEST_ONLY");
10405 return strstr (str, "command_lines") == NULL;
10406 str = getenv ("SKIP_TEST_COMMAND_LINES_1");
10407 if (str && strcmp (str, "1") == 0) return 1;
10408 str = getenv ("SKIP_TEST_COMMAND_LINES");
10409 if (str && strcmp (str, "1") == 0) return 1;
10413 static int test_command_lines_1 (void)
10415 if (test_command_lines_1_skip ()) {
10416 printf (" %s skipped (reason: environment variable set)\n", "test_command_lines_1");
10420 /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
10422 char device[] = "/dev/sda";
10424 suppress_error = 0;
10425 r = guestfs_blockdev_setrw (g, device);
10431 suppress_error = 0;
10432 r = guestfs_umount_all (g);
10438 suppress_error = 0;
10439 r = guestfs_lvm_remove_all (g);
10444 char device[] = "/dev/sda";
10445 char lines_0[] = ",";
10451 suppress_error = 0;
10452 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10457 char fstype[] = "ext2";
10458 char device[] = "/dev/sda1";
10460 suppress_error = 0;
10461 r = guestfs_mkfs (g, fstype, device);
10466 char device[] = "/dev/sda1";
10467 char mountpoint[] = "/";
10469 suppress_error = 0;
10470 r = guestfs_mount (g, device, mountpoint);
10474 /* TestOutputList for command_lines (1) */
10476 char remotefilename[] = "/test-command";
10478 suppress_error = 0;
10479 r = guestfs_upload (g, "test-command", remotefilename);
10484 char path[] = "/test-command";
10486 suppress_error = 0;
10487 r = guestfs_chmod (g, 493, path);
10492 char arguments_0[] = "/test-command";
10493 char arguments_1[] = "2";
10494 char *arguments[] = {
10501 suppress_error = 0;
10502 r = guestfs_command_lines (g, arguments);
10506 fprintf (stderr, "test_command_lines_1: short list returned from command\n");
10511 char expected[] = "Result2";
10512 if (strcmp (r[0], expected) != 0) {
10513 fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10517 if (r[1] != NULL) {
10518 fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
10522 for (i = 0; r[i] != NULL; ++i)
10529 static int test_command_lines_2_skip (void)
10533 str = getenv ("TEST_ONLY");
10535 return strstr (str, "command_lines") == NULL;
10536 str = getenv ("SKIP_TEST_COMMAND_LINES_2");
10537 if (str && strcmp (str, "1") == 0) return 1;
10538 str = getenv ("SKIP_TEST_COMMAND_LINES");
10539 if (str && strcmp (str, "1") == 0) return 1;
10543 static int test_command_lines_2 (void)
10545 if (test_command_lines_2_skip ()) {
10546 printf (" %s skipped (reason: environment variable set)\n", "test_command_lines_2");
10550 /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
10552 char device[] = "/dev/sda";
10554 suppress_error = 0;
10555 r = guestfs_blockdev_setrw (g, device);
10561 suppress_error = 0;
10562 r = guestfs_umount_all (g);
10568 suppress_error = 0;
10569 r = guestfs_lvm_remove_all (g);
10574 char device[] = "/dev/sda";
10575 char lines_0[] = ",";
10581 suppress_error = 0;
10582 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10587 char fstype[] = "ext2";
10588 char device[] = "/dev/sda1";
10590 suppress_error = 0;
10591 r = guestfs_mkfs (g, fstype, device);
10596 char device[] = "/dev/sda1";
10597 char mountpoint[] = "/";
10599 suppress_error = 0;
10600 r = guestfs_mount (g, device, mountpoint);
10604 /* TestOutputList for command_lines (2) */
10606 char remotefilename[] = "/test-command";
10608 suppress_error = 0;
10609 r = guestfs_upload (g, "test-command", remotefilename);
10614 char path[] = "/test-command";
10616 suppress_error = 0;
10617 r = guestfs_chmod (g, 493, path);
10622 char arguments_0[] = "/test-command";
10623 char arguments_1[] = "3";
10624 char *arguments[] = {
10631 suppress_error = 0;
10632 r = guestfs_command_lines (g, arguments);
10636 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
10641 char expected[] = "";
10642 if (strcmp (r[0], expected) != 0) {
10643 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10648 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
10653 char expected[] = "Result3";
10654 if (strcmp (r[1], expected) != 0) {
10655 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10659 if (r[2] != NULL) {
10660 fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
10664 for (i = 0; r[i] != NULL; ++i)
10671 static int test_command_lines_3_skip (void)
10675 str = getenv ("TEST_ONLY");
10677 return strstr (str, "command_lines") == NULL;
10678 str = getenv ("SKIP_TEST_COMMAND_LINES_3");
10679 if (str && strcmp (str, "1") == 0) return 1;
10680 str = getenv ("SKIP_TEST_COMMAND_LINES");
10681 if (str && strcmp (str, "1") == 0) return 1;
10685 static int test_command_lines_3 (void)
10687 if (test_command_lines_3_skip ()) {
10688 printf (" %s skipped (reason: environment variable set)\n", "test_command_lines_3");
10692 /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
10694 char device[] = "/dev/sda";
10696 suppress_error = 0;
10697 r = guestfs_blockdev_setrw (g, device);
10703 suppress_error = 0;
10704 r = guestfs_umount_all (g);
10710 suppress_error = 0;
10711 r = guestfs_lvm_remove_all (g);
10716 char device[] = "/dev/sda";
10717 char lines_0[] = ",";
10723 suppress_error = 0;
10724 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10729 char fstype[] = "ext2";
10730 char device[] = "/dev/sda1";
10732 suppress_error = 0;
10733 r = guestfs_mkfs (g, fstype, device);
10738 char device[] = "/dev/sda1";
10739 char mountpoint[] = "/";
10741 suppress_error = 0;
10742 r = guestfs_mount (g, device, mountpoint);
10746 /* TestOutputList for command_lines (3) */
10748 char remotefilename[] = "/test-command";
10750 suppress_error = 0;
10751 r = guestfs_upload (g, "test-command", remotefilename);
10756 char path[] = "/test-command";
10758 suppress_error = 0;
10759 r = guestfs_chmod (g, 493, path);
10764 char arguments_0[] = "/test-command";
10765 char arguments_1[] = "4";
10766 char *arguments[] = {
10773 suppress_error = 0;
10774 r = guestfs_command_lines (g, arguments);
10778 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
10783 char expected[] = "";
10784 if (strcmp (r[0], expected) != 0) {
10785 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10790 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
10795 char expected[] = "Result4";
10796 if (strcmp (r[1], expected) != 0) {
10797 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10801 if (r[2] != NULL) {
10802 fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
10806 for (i = 0; r[i] != NULL; ++i)
10813 static int test_command_lines_4_skip (void)
10817 str = getenv ("TEST_ONLY");
10819 return strstr (str, "command_lines") == NULL;
10820 str = getenv ("SKIP_TEST_COMMAND_LINES_4");
10821 if (str && strcmp (str, "1") == 0) return 1;
10822 str = getenv ("SKIP_TEST_COMMAND_LINES");
10823 if (str && strcmp (str, "1") == 0) return 1;
10827 static int test_command_lines_4 (void)
10829 if (test_command_lines_4_skip ()) {
10830 printf (" %s skipped (reason: environment variable set)\n", "test_command_lines_4");
10834 /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
10836 char device[] = "/dev/sda";
10838 suppress_error = 0;
10839 r = guestfs_blockdev_setrw (g, device);
10845 suppress_error = 0;
10846 r = guestfs_umount_all (g);
10852 suppress_error = 0;
10853 r = guestfs_lvm_remove_all (g);
10858 char device[] = "/dev/sda";
10859 char lines_0[] = ",";
10865 suppress_error = 0;
10866 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10871 char fstype[] = "ext2";
10872 char device[] = "/dev/sda1";
10874 suppress_error = 0;
10875 r = guestfs_mkfs (g, fstype, device);
10880 char device[] = "/dev/sda1";
10881 char mountpoint[] = "/";
10883 suppress_error = 0;
10884 r = guestfs_mount (g, device, mountpoint);
10888 /* TestOutputList for command_lines (4) */
10890 char remotefilename[] = "/test-command";
10892 suppress_error = 0;
10893 r = guestfs_upload (g, "test-command", remotefilename);
10898 char path[] = "/test-command";
10900 suppress_error = 0;
10901 r = guestfs_chmod (g, 493, path);
10906 char arguments_0[] = "/test-command";
10907 char arguments_1[] = "5";
10908 char *arguments[] = {
10915 suppress_error = 0;
10916 r = guestfs_command_lines (g, arguments);
10920 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10925 char expected[] = "";
10926 if (strcmp (r[0], expected) != 0) {
10927 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10932 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10937 char expected[] = "Result5";
10938 if (strcmp (r[1], expected) != 0) {
10939 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10944 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10949 char expected[] = "";
10950 if (strcmp (r[2], expected) != 0) {
10951 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10955 if (r[3] != NULL) {
10956 fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
10960 for (i = 0; r[i] != NULL; ++i)
10967 static int test_command_lines_5_skip (void)
10971 str = getenv ("TEST_ONLY");
10973 return strstr (str, "command_lines") == NULL;
10974 str = getenv ("SKIP_TEST_COMMAND_LINES_5");
10975 if (str && strcmp (str, "1") == 0) return 1;
10976 str = getenv ("SKIP_TEST_COMMAND_LINES");
10977 if (str && strcmp (str, "1") == 0) return 1;
10981 static int test_command_lines_5 (void)
10983 if (test_command_lines_5_skip ()) {
10984 printf (" %s skipped (reason: environment variable set)\n", "test_command_lines_5");
10988 /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
10990 char device[] = "/dev/sda";
10992 suppress_error = 0;
10993 r = guestfs_blockdev_setrw (g, device);
10999 suppress_error = 0;
11000 r = guestfs_umount_all (g);
11006 suppress_error = 0;
11007 r = guestfs_lvm_remove_all (g);
11012 char device[] = "/dev/sda";
11013 char lines_0[] = ",";
11019 suppress_error = 0;
11020 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11025 char fstype[] = "ext2";
11026 char device[] = "/dev/sda1";
11028 suppress_error = 0;
11029 r = guestfs_mkfs (g, fstype, device);
11034 char device[] = "/dev/sda1";
11035 char mountpoint[] = "/";
11037 suppress_error = 0;
11038 r = guestfs_mount (g, device, mountpoint);
11042 /* TestOutputList for command_lines (5) */
11044 char remotefilename[] = "/test-command";
11046 suppress_error = 0;
11047 r = guestfs_upload (g, "test-command", remotefilename);
11052 char path[] = "/test-command";
11054 suppress_error = 0;
11055 r = guestfs_chmod (g, 493, path);
11060 char arguments_0[] = "/test-command";
11061 char arguments_1[] = "6";
11062 char *arguments[] = {
11069 suppress_error = 0;
11070 r = guestfs_command_lines (g, arguments);
11074 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
11079 char expected[] = "";
11080 if (strcmp (r[0], expected) != 0) {
11081 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11086 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
11091 char expected[] = "";
11092 if (strcmp (r[1], expected) != 0) {
11093 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11098 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
11103 char expected[] = "Result6";
11104 if (strcmp (r[2], expected) != 0) {
11105 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11110 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
11115 char expected[] = "";
11116 if (strcmp (r[3], expected) != 0) {
11117 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
11121 if (r[4] != NULL) {
11122 fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
11126 for (i = 0; r[i] != NULL; ++i)
11133 static int test_command_lines_6_skip (void)
11137 str = getenv ("TEST_ONLY");
11139 return strstr (str, "command_lines") == NULL;
11140 str = getenv ("SKIP_TEST_COMMAND_LINES_6");
11141 if (str && strcmp (str, "1") == 0) return 1;
11142 str = getenv ("SKIP_TEST_COMMAND_LINES");
11143 if (str && strcmp (str, "1") == 0) return 1;
11147 static int test_command_lines_6 (void)
11149 if (test_command_lines_6_skip ()) {
11150 printf (" %s skipped (reason: environment variable set)\n", "test_command_lines_6");
11154 /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
11156 char device[] = "/dev/sda";
11158 suppress_error = 0;
11159 r = guestfs_blockdev_setrw (g, device);
11165 suppress_error = 0;
11166 r = guestfs_umount_all (g);
11172 suppress_error = 0;
11173 r = guestfs_lvm_remove_all (g);
11178 char device[] = "/dev/sda";
11179 char lines_0[] = ",";
11185 suppress_error = 0;
11186 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11191 char fstype[] = "ext2";
11192 char device[] = "/dev/sda1";
11194 suppress_error = 0;
11195 r = guestfs_mkfs (g, fstype, device);
11200 char device[] = "/dev/sda1";
11201 char mountpoint[] = "/";
11203 suppress_error = 0;
11204 r = guestfs_mount (g, device, mountpoint);
11208 /* TestOutputList for command_lines (6) */
11210 char remotefilename[] = "/test-command";
11212 suppress_error = 0;
11213 r = guestfs_upload (g, "test-command", remotefilename);
11218 char path[] = "/test-command";
11220 suppress_error = 0;
11221 r = guestfs_chmod (g, 493, path);
11226 char arguments_0[] = "/test-command";
11227 char arguments_1[] = "7";
11228 char *arguments[] = {
11235 suppress_error = 0;
11236 r = guestfs_command_lines (g, arguments);
11239 if (r[0] != NULL) {
11240 fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
11244 for (i = 0; r[i] != NULL; ++i)
11251 static int test_command_lines_7_skip (void)
11255 str = getenv ("TEST_ONLY");
11257 return strstr (str, "command_lines") == NULL;
11258 str = getenv ("SKIP_TEST_COMMAND_LINES_7");
11259 if (str && strcmp (str, "1") == 0) return 1;
11260 str = getenv ("SKIP_TEST_COMMAND_LINES");
11261 if (str && strcmp (str, "1") == 0) return 1;
11265 static int test_command_lines_7 (void)
11267 if (test_command_lines_7_skip ()) {
11268 printf (" %s skipped (reason: environment variable set)\n", "test_command_lines_7");
11272 /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
11274 char device[] = "/dev/sda";
11276 suppress_error = 0;
11277 r = guestfs_blockdev_setrw (g, device);
11283 suppress_error = 0;
11284 r = guestfs_umount_all (g);
11290 suppress_error = 0;
11291 r = guestfs_lvm_remove_all (g);
11296 char device[] = "/dev/sda";
11297 char lines_0[] = ",";
11303 suppress_error = 0;
11304 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11309 char fstype[] = "ext2";
11310 char device[] = "/dev/sda1";
11312 suppress_error = 0;
11313 r = guestfs_mkfs (g, fstype, device);
11318 char device[] = "/dev/sda1";
11319 char mountpoint[] = "/";
11321 suppress_error = 0;
11322 r = guestfs_mount (g, device, mountpoint);
11326 /* TestOutputList for command_lines (7) */
11328 char remotefilename[] = "/test-command";
11330 suppress_error = 0;
11331 r = guestfs_upload (g, "test-command", remotefilename);
11336 char path[] = "/test-command";
11338 suppress_error = 0;
11339 r = guestfs_chmod (g, 493, path);
11344 char arguments_0[] = "/test-command";
11345 char arguments_1[] = "8";
11346 char *arguments[] = {
11353 suppress_error = 0;
11354 r = guestfs_command_lines (g, arguments);
11358 fprintf (stderr, "test_command_lines_7: short list returned from command\n");
11363 char expected[] = "";
11364 if (strcmp (r[0], expected) != 0) {
11365 fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11369 if (r[1] != NULL) {
11370 fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
11374 for (i = 0; r[i] != NULL; ++i)
11381 static int test_command_lines_8_skip (void)
11385 str = getenv ("TEST_ONLY");
11387 return strstr (str, "command_lines") == NULL;
11388 str = getenv ("SKIP_TEST_COMMAND_LINES_8");
11389 if (str && strcmp (str, "1") == 0) return 1;
11390 str = getenv ("SKIP_TEST_COMMAND_LINES");
11391 if (str && strcmp (str, "1") == 0) return 1;
11395 static int test_command_lines_8 (void)
11397 if (test_command_lines_8_skip ()) {
11398 printf (" %s skipped (reason: environment variable set)\n", "test_command_lines_8");
11402 /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
11404 char device[] = "/dev/sda";
11406 suppress_error = 0;
11407 r = guestfs_blockdev_setrw (g, device);
11413 suppress_error = 0;
11414 r = guestfs_umount_all (g);
11420 suppress_error = 0;
11421 r = guestfs_lvm_remove_all (g);
11426 char device[] = "/dev/sda";
11427 char lines_0[] = ",";
11433 suppress_error = 0;
11434 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11439 char fstype[] = "ext2";
11440 char device[] = "/dev/sda1";
11442 suppress_error = 0;
11443 r = guestfs_mkfs (g, fstype, device);
11448 char device[] = "/dev/sda1";
11449 char mountpoint[] = "/";
11451 suppress_error = 0;
11452 r = guestfs_mount (g, device, mountpoint);
11456 /* TestOutputList for command_lines (8) */
11458 char remotefilename[] = "/test-command";
11460 suppress_error = 0;
11461 r = guestfs_upload (g, "test-command", remotefilename);
11466 char path[] = "/test-command";
11468 suppress_error = 0;
11469 r = guestfs_chmod (g, 493, path);
11474 char arguments_0[] = "/test-command";
11475 char arguments_1[] = "9";
11476 char *arguments[] = {
11483 suppress_error = 0;
11484 r = guestfs_command_lines (g, arguments);
11488 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
11493 char expected[] = "";
11494 if (strcmp (r[0], expected) != 0) {
11495 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11500 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
11505 char expected[] = "";
11506 if (strcmp (r[1], expected) != 0) {
11507 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11511 if (r[2] != NULL) {
11512 fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
11516 for (i = 0; r[i] != NULL; ++i)
11523 static int test_command_lines_9_skip (void)
11527 str = getenv ("TEST_ONLY");
11529 return strstr (str, "command_lines") == NULL;
11530 str = getenv ("SKIP_TEST_COMMAND_LINES_9");
11531 if (str && strcmp (str, "1") == 0) return 1;
11532 str = getenv ("SKIP_TEST_COMMAND_LINES");
11533 if (str && strcmp (str, "1") == 0) return 1;
11537 static int test_command_lines_9 (void)
11539 if (test_command_lines_9_skip ()) {
11540 printf (" %s skipped (reason: environment variable set)\n", "test_command_lines_9");
11544 /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
11546 char device[] = "/dev/sda";
11548 suppress_error = 0;
11549 r = guestfs_blockdev_setrw (g, device);
11555 suppress_error = 0;
11556 r = guestfs_umount_all (g);
11562 suppress_error = 0;
11563 r = guestfs_lvm_remove_all (g);
11568 char device[] = "/dev/sda";
11569 char lines_0[] = ",";
11575 suppress_error = 0;
11576 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11581 char fstype[] = "ext2";
11582 char device[] = "/dev/sda1";
11584 suppress_error = 0;
11585 r = guestfs_mkfs (g, fstype, device);
11590 char device[] = "/dev/sda1";
11591 char mountpoint[] = "/";
11593 suppress_error = 0;
11594 r = guestfs_mount (g, device, mountpoint);
11598 /* TestOutputList for command_lines (9) */
11600 char remotefilename[] = "/test-command";
11602 suppress_error = 0;
11603 r = guestfs_upload (g, "test-command", remotefilename);
11608 char path[] = "/test-command";
11610 suppress_error = 0;
11611 r = guestfs_chmod (g, 493, path);
11616 char arguments_0[] = "/test-command";
11617 char arguments_1[] = "10";
11618 char *arguments[] = {
11625 suppress_error = 0;
11626 r = guestfs_command_lines (g, arguments);
11630 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
11635 char expected[] = "Result10-1";
11636 if (strcmp (r[0], expected) != 0) {
11637 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11642 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
11647 char expected[] = "Result10-2";
11648 if (strcmp (r[1], expected) != 0) {
11649 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11653 if (r[2] != NULL) {
11654 fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
11658 for (i = 0; r[i] != NULL; ++i)
11665 static int test_command_lines_10_skip (void)
11669 str = getenv ("TEST_ONLY");
11671 return strstr (str, "command_lines") == NULL;
11672 str = getenv ("SKIP_TEST_COMMAND_LINES_10");
11673 if (str && strcmp (str, "1") == 0) return 1;
11674 str = getenv ("SKIP_TEST_COMMAND_LINES");
11675 if (str && strcmp (str, "1") == 0) return 1;
11679 static int test_command_lines_10 (void)
11681 if (test_command_lines_10_skip ()) {
11682 printf (" %s skipped (reason: environment variable set)\n", "test_command_lines_10");
11686 /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
11688 char device[] = "/dev/sda";
11690 suppress_error = 0;
11691 r = guestfs_blockdev_setrw (g, device);
11697 suppress_error = 0;
11698 r = guestfs_umount_all (g);
11704 suppress_error = 0;
11705 r = guestfs_lvm_remove_all (g);
11710 char device[] = "/dev/sda";
11711 char lines_0[] = ",";
11717 suppress_error = 0;
11718 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11723 char fstype[] = "ext2";
11724 char device[] = "/dev/sda1";
11726 suppress_error = 0;
11727 r = guestfs_mkfs (g, fstype, device);
11732 char device[] = "/dev/sda1";
11733 char mountpoint[] = "/";
11735 suppress_error = 0;
11736 r = guestfs_mount (g, device, mountpoint);
11740 /* TestOutputList for command_lines (10) */
11742 char remotefilename[] = "/test-command";
11744 suppress_error = 0;
11745 r = guestfs_upload (g, "test-command", remotefilename);
11750 char path[] = "/test-command";
11752 suppress_error = 0;
11753 r = guestfs_chmod (g, 493, path);
11758 char arguments_0[] = "/test-command";
11759 char arguments_1[] = "11";
11760 char *arguments[] = {
11767 suppress_error = 0;
11768 r = guestfs_command_lines (g, arguments);
11772 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
11777 char expected[] = "Result11-1";
11778 if (strcmp (r[0], expected) != 0) {
11779 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11784 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
11789 char expected[] = "Result11-2";
11790 if (strcmp (r[1], expected) != 0) {
11791 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11795 if (r[2] != NULL) {
11796 fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
11800 for (i = 0; r[i] != NULL; ++i)
11807 static int test_command_0_skip (void)
11811 str = getenv ("TEST_ONLY");
11813 return strstr (str, "command") == NULL;
11814 str = getenv ("SKIP_TEST_COMMAND_0");
11815 if (str && strcmp (str, "1") == 0) return 1;
11816 str = getenv ("SKIP_TEST_COMMAND");
11817 if (str && strcmp (str, "1") == 0) return 1;
11821 static int test_command_0 (void)
11823 if (test_command_0_skip ()) {
11824 printf (" %s skipped (reason: environment variable set)\n", "test_command_0");
11828 /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
11830 char device[] = "/dev/sda";
11832 suppress_error = 0;
11833 r = guestfs_blockdev_setrw (g, device);
11839 suppress_error = 0;
11840 r = guestfs_umount_all (g);
11846 suppress_error = 0;
11847 r = guestfs_lvm_remove_all (g);
11852 char device[] = "/dev/sda";
11853 char lines_0[] = ",";
11859 suppress_error = 0;
11860 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11865 char fstype[] = "ext2";
11866 char device[] = "/dev/sda1";
11868 suppress_error = 0;
11869 r = guestfs_mkfs (g, fstype, device);
11874 char device[] = "/dev/sda1";
11875 char mountpoint[] = "/";
11877 suppress_error = 0;
11878 r = guestfs_mount (g, device, mountpoint);
11882 /* TestOutput for command (0) */
11883 char expected[] = "Result1";
11885 char remotefilename[] = "/test-command";
11887 suppress_error = 0;
11888 r = guestfs_upload (g, "test-command", remotefilename);
11893 char path[] = "/test-command";
11895 suppress_error = 0;
11896 r = guestfs_chmod (g, 493, path);
11901 char arguments_0[] = "/test-command";
11902 char arguments_1[] = "1";
11903 char *arguments[] = {
11909 suppress_error = 0;
11910 r = guestfs_command (g, arguments);
11913 if (strcmp (r, expected) != 0) {
11914 fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
11922 static int test_command_1_skip (void)
11926 str = getenv ("TEST_ONLY");
11928 return strstr (str, "command") == NULL;
11929 str = getenv ("SKIP_TEST_COMMAND_1");
11930 if (str && strcmp (str, "1") == 0) return 1;
11931 str = getenv ("SKIP_TEST_COMMAND");
11932 if (str && strcmp (str, "1") == 0) return 1;
11936 static int test_command_1 (void)
11938 if (test_command_1_skip ()) {
11939 printf (" %s skipped (reason: environment variable set)\n", "test_command_1");
11943 /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
11945 char device[] = "/dev/sda";
11947 suppress_error = 0;
11948 r = guestfs_blockdev_setrw (g, device);
11954 suppress_error = 0;
11955 r = guestfs_umount_all (g);
11961 suppress_error = 0;
11962 r = guestfs_lvm_remove_all (g);
11967 char device[] = "/dev/sda";
11968 char lines_0[] = ",";
11974 suppress_error = 0;
11975 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11980 char fstype[] = "ext2";
11981 char device[] = "/dev/sda1";
11983 suppress_error = 0;
11984 r = guestfs_mkfs (g, fstype, device);
11989 char device[] = "/dev/sda1";
11990 char mountpoint[] = "/";
11992 suppress_error = 0;
11993 r = guestfs_mount (g, device, mountpoint);
11997 /* TestOutput for command (1) */
11998 char expected[] = "Result2\n";
12000 char remotefilename[] = "/test-command";
12002 suppress_error = 0;
12003 r = guestfs_upload (g, "test-command", remotefilename);
12008 char path[] = "/test-command";
12010 suppress_error = 0;
12011 r = guestfs_chmod (g, 493, path);
12016 char arguments_0[] = "/test-command";
12017 char arguments_1[] = "2";
12018 char *arguments[] = {
12024 suppress_error = 0;
12025 r = guestfs_command (g, arguments);
12028 if (strcmp (r, expected) != 0) {
12029 fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
12037 static int test_command_2_skip (void)
12041 str = getenv ("TEST_ONLY");
12043 return strstr (str, "command") == NULL;
12044 str = getenv ("SKIP_TEST_COMMAND_2");
12045 if (str && strcmp (str, "1") == 0) return 1;
12046 str = getenv ("SKIP_TEST_COMMAND");
12047 if (str && strcmp (str, "1") == 0) return 1;
12051 static int test_command_2 (void)
12053 if (test_command_2_skip ()) {
12054 printf (" %s skipped (reason: environment variable set)\n", "test_command_2");
12058 /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
12060 char device[] = "/dev/sda";
12062 suppress_error = 0;
12063 r = guestfs_blockdev_setrw (g, device);
12069 suppress_error = 0;
12070 r = guestfs_umount_all (g);
12076 suppress_error = 0;
12077 r = guestfs_lvm_remove_all (g);
12082 char device[] = "/dev/sda";
12083 char lines_0[] = ",";
12089 suppress_error = 0;
12090 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12095 char fstype[] = "ext2";
12096 char device[] = "/dev/sda1";
12098 suppress_error = 0;
12099 r = guestfs_mkfs (g, fstype, device);
12104 char device[] = "/dev/sda1";
12105 char mountpoint[] = "/";
12107 suppress_error = 0;
12108 r = guestfs_mount (g, device, mountpoint);
12112 /* TestOutput for command (2) */
12113 char expected[] = "\nResult3";
12115 char remotefilename[] = "/test-command";
12117 suppress_error = 0;
12118 r = guestfs_upload (g, "test-command", remotefilename);
12123 char path[] = "/test-command";
12125 suppress_error = 0;
12126 r = guestfs_chmod (g, 493, path);
12131 char arguments_0[] = "/test-command";
12132 char arguments_1[] = "3";
12133 char *arguments[] = {
12139 suppress_error = 0;
12140 r = guestfs_command (g, arguments);
12143 if (strcmp (r, expected) != 0) {
12144 fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
12152 static int test_command_3_skip (void)
12156 str = getenv ("TEST_ONLY");
12158 return strstr (str, "command") == NULL;
12159 str = getenv ("SKIP_TEST_COMMAND_3");
12160 if (str && strcmp (str, "1") == 0) return 1;
12161 str = getenv ("SKIP_TEST_COMMAND");
12162 if (str && strcmp (str, "1") == 0) return 1;
12166 static int test_command_3 (void)
12168 if (test_command_3_skip ()) {
12169 printf (" %s skipped (reason: environment variable set)\n", "test_command_3");
12173 /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
12175 char device[] = "/dev/sda";
12177 suppress_error = 0;
12178 r = guestfs_blockdev_setrw (g, device);
12184 suppress_error = 0;
12185 r = guestfs_umount_all (g);
12191 suppress_error = 0;
12192 r = guestfs_lvm_remove_all (g);
12197 char device[] = "/dev/sda";
12198 char lines_0[] = ",";
12204 suppress_error = 0;
12205 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12210 char fstype[] = "ext2";
12211 char device[] = "/dev/sda1";
12213 suppress_error = 0;
12214 r = guestfs_mkfs (g, fstype, device);
12219 char device[] = "/dev/sda1";
12220 char mountpoint[] = "/";
12222 suppress_error = 0;
12223 r = guestfs_mount (g, device, mountpoint);
12227 /* TestOutput for command (3) */
12228 char expected[] = "\nResult4\n";
12230 char remotefilename[] = "/test-command";
12232 suppress_error = 0;
12233 r = guestfs_upload (g, "test-command", remotefilename);
12238 char path[] = "/test-command";
12240 suppress_error = 0;
12241 r = guestfs_chmod (g, 493, path);
12246 char arguments_0[] = "/test-command";
12247 char arguments_1[] = "4";
12248 char *arguments[] = {
12254 suppress_error = 0;
12255 r = guestfs_command (g, arguments);
12258 if (strcmp (r, expected) != 0) {
12259 fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
12267 static int test_command_4_skip (void)
12271 str = getenv ("TEST_ONLY");
12273 return strstr (str, "command") == NULL;
12274 str = getenv ("SKIP_TEST_COMMAND_4");
12275 if (str && strcmp (str, "1") == 0) return 1;
12276 str = getenv ("SKIP_TEST_COMMAND");
12277 if (str && strcmp (str, "1") == 0) return 1;
12281 static int test_command_4 (void)
12283 if (test_command_4_skip ()) {
12284 printf (" %s skipped (reason: environment variable set)\n", "test_command_4");
12288 /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
12290 char device[] = "/dev/sda";
12292 suppress_error = 0;
12293 r = guestfs_blockdev_setrw (g, device);
12299 suppress_error = 0;
12300 r = guestfs_umount_all (g);
12306 suppress_error = 0;
12307 r = guestfs_lvm_remove_all (g);
12312 char device[] = "/dev/sda";
12313 char lines_0[] = ",";
12319 suppress_error = 0;
12320 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12325 char fstype[] = "ext2";
12326 char device[] = "/dev/sda1";
12328 suppress_error = 0;
12329 r = guestfs_mkfs (g, fstype, device);
12334 char device[] = "/dev/sda1";
12335 char mountpoint[] = "/";
12337 suppress_error = 0;
12338 r = guestfs_mount (g, device, mountpoint);
12342 /* TestOutput for command (4) */
12343 char expected[] = "\nResult5\n\n";
12345 char remotefilename[] = "/test-command";
12347 suppress_error = 0;
12348 r = guestfs_upload (g, "test-command", remotefilename);
12353 char path[] = "/test-command";
12355 suppress_error = 0;
12356 r = guestfs_chmod (g, 493, path);
12361 char arguments_0[] = "/test-command";
12362 char arguments_1[] = "5";
12363 char *arguments[] = {
12369 suppress_error = 0;
12370 r = guestfs_command (g, arguments);
12373 if (strcmp (r, expected) != 0) {
12374 fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
12382 static int test_command_5_skip (void)
12386 str = getenv ("TEST_ONLY");
12388 return strstr (str, "command") == NULL;
12389 str = getenv ("SKIP_TEST_COMMAND_5");
12390 if (str && strcmp (str, "1") == 0) return 1;
12391 str = getenv ("SKIP_TEST_COMMAND");
12392 if (str && strcmp (str, "1") == 0) return 1;
12396 static int test_command_5 (void)
12398 if (test_command_5_skip ()) {
12399 printf (" %s skipped (reason: environment variable set)\n", "test_command_5");
12403 /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
12405 char device[] = "/dev/sda";
12407 suppress_error = 0;
12408 r = guestfs_blockdev_setrw (g, device);
12414 suppress_error = 0;
12415 r = guestfs_umount_all (g);
12421 suppress_error = 0;
12422 r = guestfs_lvm_remove_all (g);
12427 char device[] = "/dev/sda";
12428 char lines_0[] = ",";
12434 suppress_error = 0;
12435 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12440 char fstype[] = "ext2";
12441 char device[] = "/dev/sda1";
12443 suppress_error = 0;
12444 r = guestfs_mkfs (g, fstype, device);
12449 char device[] = "/dev/sda1";
12450 char mountpoint[] = "/";
12452 suppress_error = 0;
12453 r = guestfs_mount (g, device, mountpoint);
12457 /* TestOutput for command (5) */
12458 char expected[] = "\n\nResult6\n\n";
12460 char remotefilename[] = "/test-command";
12462 suppress_error = 0;
12463 r = guestfs_upload (g, "test-command", remotefilename);
12468 char path[] = "/test-command";
12470 suppress_error = 0;
12471 r = guestfs_chmod (g, 493, path);
12476 char arguments_0[] = "/test-command";
12477 char arguments_1[] = "6";
12478 char *arguments[] = {
12484 suppress_error = 0;
12485 r = guestfs_command (g, arguments);
12488 if (strcmp (r, expected) != 0) {
12489 fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
12497 static int test_command_6_skip (void)
12501 str = getenv ("TEST_ONLY");
12503 return strstr (str, "command") == NULL;
12504 str = getenv ("SKIP_TEST_COMMAND_6");
12505 if (str && strcmp (str, "1") == 0) return 1;
12506 str = getenv ("SKIP_TEST_COMMAND");
12507 if (str && strcmp (str, "1") == 0) return 1;
12511 static int test_command_6 (void)
12513 if (test_command_6_skip ()) {
12514 printf (" %s skipped (reason: environment variable set)\n", "test_command_6");
12518 /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
12520 char device[] = "/dev/sda";
12522 suppress_error = 0;
12523 r = guestfs_blockdev_setrw (g, device);
12529 suppress_error = 0;
12530 r = guestfs_umount_all (g);
12536 suppress_error = 0;
12537 r = guestfs_lvm_remove_all (g);
12542 char device[] = "/dev/sda";
12543 char lines_0[] = ",";
12549 suppress_error = 0;
12550 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12555 char fstype[] = "ext2";
12556 char device[] = "/dev/sda1";
12558 suppress_error = 0;
12559 r = guestfs_mkfs (g, fstype, device);
12564 char device[] = "/dev/sda1";
12565 char mountpoint[] = "/";
12567 suppress_error = 0;
12568 r = guestfs_mount (g, device, mountpoint);
12572 /* TestOutput for command (6) */
12573 char expected[] = "";
12575 char remotefilename[] = "/test-command";
12577 suppress_error = 0;
12578 r = guestfs_upload (g, "test-command", remotefilename);
12583 char path[] = "/test-command";
12585 suppress_error = 0;
12586 r = guestfs_chmod (g, 493, path);
12591 char arguments_0[] = "/test-command";
12592 char arguments_1[] = "7";
12593 char *arguments[] = {
12599 suppress_error = 0;
12600 r = guestfs_command (g, arguments);
12603 if (strcmp (r, expected) != 0) {
12604 fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
12612 static int test_command_7_skip (void)
12616 str = getenv ("TEST_ONLY");
12618 return strstr (str, "command") == NULL;
12619 str = getenv ("SKIP_TEST_COMMAND_7");
12620 if (str && strcmp (str, "1") == 0) return 1;
12621 str = getenv ("SKIP_TEST_COMMAND");
12622 if (str && strcmp (str, "1") == 0) return 1;
12626 static int test_command_7 (void)
12628 if (test_command_7_skip ()) {
12629 printf (" %s skipped (reason: environment variable set)\n", "test_command_7");
12633 /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
12635 char device[] = "/dev/sda";
12637 suppress_error = 0;
12638 r = guestfs_blockdev_setrw (g, device);
12644 suppress_error = 0;
12645 r = guestfs_umount_all (g);
12651 suppress_error = 0;
12652 r = guestfs_lvm_remove_all (g);
12657 char device[] = "/dev/sda";
12658 char lines_0[] = ",";
12664 suppress_error = 0;
12665 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12670 char fstype[] = "ext2";
12671 char device[] = "/dev/sda1";
12673 suppress_error = 0;
12674 r = guestfs_mkfs (g, fstype, device);
12679 char device[] = "/dev/sda1";
12680 char mountpoint[] = "/";
12682 suppress_error = 0;
12683 r = guestfs_mount (g, device, mountpoint);
12687 /* TestOutput for command (7) */
12688 char expected[] = "\n";
12690 char remotefilename[] = "/test-command";
12692 suppress_error = 0;
12693 r = guestfs_upload (g, "test-command", remotefilename);
12698 char path[] = "/test-command";
12700 suppress_error = 0;
12701 r = guestfs_chmod (g, 493, path);
12706 char arguments_0[] = "/test-command";
12707 char arguments_1[] = "8";
12708 char *arguments[] = {
12714 suppress_error = 0;
12715 r = guestfs_command (g, arguments);
12718 if (strcmp (r, expected) != 0) {
12719 fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
12727 static int test_command_8_skip (void)
12731 str = getenv ("TEST_ONLY");
12733 return strstr (str, "command") == NULL;
12734 str = getenv ("SKIP_TEST_COMMAND_8");
12735 if (str && strcmp (str, "1") == 0) return 1;
12736 str = getenv ("SKIP_TEST_COMMAND");
12737 if (str && strcmp (str, "1") == 0) return 1;
12741 static int test_command_8 (void)
12743 if (test_command_8_skip ()) {
12744 printf (" %s skipped (reason: environment variable set)\n", "test_command_8");
12748 /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
12750 char device[] = "/dev/sda";
12752 suppress_error = 0;
12753 r = guestfs_blockdev_setrw (g, device);
12759 suppress_error = 0;
12760 r = guestfs_umount_all (g);
12766 suppress_error = 0;
12767 r = guestfs_lvm_remove_all (g);
12772 char device[] = "/dev/sda";
12773 char lines_0[] = ",";
12779 suppress_error = 0;
12780 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12785 char fstype[] = "ext2";
12786 char device[] = "/dev/sda1";
12788 suppress_error = 0;
12789 r = guestfs_mkfs (g, fstype, device);
12794 char device[] = "/dev/sda1";
12795 char mountpoint[] = "/";
12797 suppress_error = 0;
12798 r = guestfs_mount (g, device, mountpoint);
12802 /* TestOutput for command (8) */
12803 char expected[] = "\n\n";
12805 char remotefilename[] = "/test-command";
12807 suppress_error = 0;
12808 r = guestfs_upload (g, "test-command", remotefilename);
12813 char path[] = "/test-command";
12815 suppress_error = 0;
12816 r = guestfs_chmod (g, 493, path);
12821 char arguments_0[] = "/test-command";
12822 char arguments_1[] = "9";
12823 char *arguments[] = {
12829 suppress_error = 0;
12830 r = guestfs_command (g, arguments);
12833 if (strcmp (r, expected) != 0) {
12834 fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
12842 static int test_command_9_skip (void)
12846 str = getenv ("TEST_ONLY");
12848 return strstr (str, "command") == NULL;
12849 str = getenv ("SKIP_TEST_COMMAND_9");
12850 if (str && strcmp (str, "1") == 0) return 1;
12851 str = getenv ("SKIP_TEST_COMMAND");
12852 if (str && strcmp (str, "1") == 0) return 1;
12856 static int test_command_9 (void)
12858 if (test_command_9_skip ()) {
12859 printf (" %s skipped (reason: environment variable set)\n", "test_command_9");
12863 /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
12865 char device[] = "/dev/sda";
12867 suppress_error = 0;
12868 r = guestfs_blockdev_setrw (g, device);
12874 suppress_error = 0;
12875 r = guestfs_umount_all (g);
12881 suppress_error = 0;
12882 r = guestfs_lvm_remove_all (g);
12887 char device[] = "/dev/sda";
12888 char lines_0[] = ",";
12894 suppress_error = 0;
12895 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12900 char fstype[] = "ext2";
12901 char device[] = "/dev/sda1";
12903 suppress_error = 0;
12904 r = guestfs_mkfs (g, fstype, device);
12909 char device[] = "/dev/sda1";
12910 char mountpoint[] = "/";
12912 suppress_error = 0;
12913 r = guestfs_mount (g, device, mountpoint);
12917 /* TestOutput for command (9) */
12918 char expected[] = "Result10-1\nResult10-2\n";
12920 char remotefilename[] = "/test-command";
12922 suppress_error = 0;
12923 r = guestfs_upload (g, "test-command", remotefilename);
12928 char path[] = "/test-command";
12930 suppress_error = 0;
12931 r = guestfs_chmod (g, 493, path);
12936 char arguments_0[] = "/test-command";
12937 char arguments_1[] = "10";
12938 char *arguments[] = {
12944 suppress_error = 0;
12945 r = guestfs_command (g, arguments);
12948 if (strcmp (r, expected) != 0) {
12949 fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
12957 static int test_command_10_skip (void)
12961 str = getenv ("TEST_ONLY");
12963 return strstr (str, "command") == NULL;
12964 str = getenv ("SKIP_TEST_COMMAND_10");
12965 if (str && strcmp (str, "1") == 0) return 1;
12966 str = getenv ("SKIP_TEST_COMMAND");
12967 if (str && strcmp (str, "1") == 0) return 1;
12971 static int test_command_10 (void)
12973 if (test_command_10_skip ()) {
12974 printf (" %s skipped (reason: environment variable set)\n", "test_command_10");
12978 /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
12980 char device[] = "/dev/sda";
12982 suppress_error = 0;
12983 r = guestfs_blockdev_setrw (g, device);
12989 suppress_error = 0;
12990 r = guestfs_umount_all (g);
12996 suppress_error = 0;
12997 r = guestfs_lvm_remove_all (g);
13002 char device[] = "/dev/sda";
13003 char lines_0[] = ",";
13009 suppress_error = 0;
13010 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13015 char fstype[] = "ext2";
13016 char device[] = "/dev/sda1";
13018 suppress_error = 0;
13019 r = guestfs_mkfs (g, fstype, device);
13024 char device[] = "/dev/sda1";
13025 char mountpoint[] = "/";
13027 suppress_error = 0;
13028 r = guestfs_mount (g, device, mountpoint);
13032 /* TestOutput for command (10) */
13033 char expected[] = "Result11-1\nResult11-2";
13035 char remotefilename[] = "/test-command";
13037 suppress_error = 0;
13038 r = guestfs_upload (g, "test-command", remotefilename);
13043 char path[] = "/test-command";
13045 suppress_error = 0;
13046 r = guestfs_chmod (g, 493, path);
13051 char arguments_0[] = "/test-command";
13052 char arguments_1[] = "11";
13053 char *arguments[] = {
13059 suppress_error = 0;
13060 r = guestfs_command (g, arguments);
13063 if (strcmp (r, expected) != 0) {
13064 fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
13072 static int test_command_11_skip (void)
13076 str = getenv ("TEST_ONLY");
13078 return strstr (str, "command") == NULL;
13079 str = getenv ("SKIP_TEST_COMMAND_11");
13080 if (str && strcmp (str, "1") == 0) return 1;
13081 str = getenv ("SKIP_TEST_COMMAND");
13082 if (str && strcmp (str, "1") == 0) return 1;
13086 static int test_command_11 (void)
13088 if (test_command_11_skip ()) {
13089 printf (" %s skipped (reason: environment variable set)\n", "test_command_11");
13093 /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
13095 char device[] = "/dev/sda";
13097 suppress_error = 0;
13098 r = guestfs_blockdev_setrw (g, device);
13104 suppress_error = 0;
13105 r = guestfs_umount_all (g);
13111 suppress_error = 0;
13112 r = guestfs_lvm_remove_all (g);
13117 char device[] = "/dev/sda";
13118 char lines_0[] = ",";
13124 suppress_error = 0;
13125 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13130 char fstype[] = "ext2";
13131 char device[] = "/dev/sda1";
13133 suppress_error = 0;
13134 r = guestfs_mkfs (g, fstype, device);
13139 char device[] = "/dev/sda1";
13140 char mountpoint[] = "/";
13142 suppress_error = 0;
13143 r = guestfs_mount (g, device, mountpoint);
13147 /* TestLastFail for command (11) */
13149 char remotefilename[] = "/test-command";
13151 suppress_error = 0;
13152 r = guestfs_upload (g, "test-command", remotefilename);
13157 char path[] = "/test-command";
13159 suppress_error = 0;
13160 r = guestfs_chmod (g, 493, path);
13165 char arguments_0[] = "/test-command";
13166 char *arguments[] = {
13171 suppress_error = 1;
13172 r = guestfs_command (g, arguments);
13180 static int test_file_0_skip (void)
13184 str = getenv ("TEST_ONLY");
13186 return strstr (str, "file") == NULL;
13187 str = getenv ("SKIP_TEST_FILE_0");
13188 if (str && strcmp (str, "1") == 0) return 1;
13189 str = getenv ("SKIP_TEST_FILE");
13190 if (str && strcmp (str, "1") == 0) return 1;
13194 static int test_file_0 (void)
13196 if (test_file_0_skip ()) {
13197 printf (" %s skipped (reason: environment variable set)\n", "test_file_0");
13201 /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
13203 char device[] = "/dev/sda";
13205 suppress_error = 0;
13206 r = guestfs_blockdev_setrw (g, device);
13212 suppress_error = 0;
13213 r = guestfs_umount_all (g);
13219 suppress_error = 0;
13220 r = guestfs_lvm_remove_all (g);
13225 char device[] = "/dev/sda";
13226 char lines_0[] = ",";
13232 suppress_error = 0;
13233 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13238 char fstype[] = "ext2";
13239 char device[] = "/dev/sda1";
13241 suppress_error = 0;
13242 r = guestfs_mkfs (g, fstype, device);
13247 char device[] = "/dev/sda1";
13248 char mountpoint[] = "/";
13250 suppress_error = 0;
13251 r = guestfs_mount (g, device, mountpoint);
13255 /* TestOutput for file (0) */
13256 char expected[] = "empty";
13258 char path[] = "/new";
13260 suppress_error = 0;
13261 r = guestfs_touch (g, path);
13266 char path[] = "/new";
13268 suppress_error = 0;
13269 r = guestfs_file (g, path);
13272 if (strcmp (r, expected) != 0) {
13273 fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
13281 static int test_file_1_skip (void)
13285 str = getenv ("TEST_ONLY");
13287 return strstr (str, "file") == NULL;
13288 str = getenv ("SKIP_TEST_FILE_1");
13289 if (str && strcmp (str, "1") == 0) return 1;
13290 str = getenv ("SKIP_TEST_FILE");
13291 if (str && strcmp (str, "1") == 0) return 1;
13295 static int test_file_1 (void)
13297 if (test_file_1_skip ()) {
13298 printf (" %s skipped (reason: environment variable set)\n", "test_file_1");
13302 /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
13304 char device[] = "/dev/sda";
13306 suppress_error = 0;
13307 r = guestfs_blockdev_setrw (g, device);
13313 suppress_error = 0;
13314 r = guestfs_umount_all (g);
13320 suppress_error = 0;
13321 r = guestfs_lvm_remove_all (g);
13326 char device[] = "/dev/sda";
13327 char lines_0[] = ",";
13333 suppress_error = 0;
13334 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13339 char fstype[] = "ext2";
13340 char device[] = "/dev/sda1";
13342 suppress_error = 0;
13343 r = guestfs_mkfs (g, fstype, device);
13348 char device[] = "/dev/sda1";
13349 char mountpoint[] = "/";
13351 suppress_error = 0;
13352 r = guestfs_mount (g, device, mountpoint);
13356 /* TestOutput for file (1) */
13357 char expected[] = "ASCII text";
13359 char path[] = "/new";
13360 char content[] = "some content\n";
13362 suppress_error = 0;
13363 r = guestfs_write_file (g, path, content, 0);
13368 char path[] = "/new";
13370 suppress_error = 0;
13371 r = guestfs_file (g, path);
13374 if (strcmp (r, expected) != 0) {
13375 fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
13383 static int test_file_2_skip (void)
13387 str = getenv ("TEST_ONLY");
13389 return strstr (str, "file") == NULL;
13390 str = getenv ("SKIP_TEST_FILE_2");
13391 if (str && strcmp (str, "1") == 0) return 1;
13392 str = getenv ("SKIP_TEST_FILE");
13393 if (str && strcmp (str, "1") == 0) return 1;
13397 static int test_file_2 (void)
13399 if (test_file_2_skip ()) {
13400 printf (" %s skipped (reason: environment variable set)\n", "test_file_2");
13404 /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
13406 char device[] = "/dev/sda";
13408 suppress_error = 0;
13409 r = guestfs_blockdev_setrw (g, device);
13415 suppress_error = 0;
13416 r = guestfs_umount_all (g);
13422 suppress_error = 0;
13423 r = guestfs_lvm_remove_all (g);
13428 char device[] = "/dev/sda";
13429 char lines_0[] = ",";
13435 suppress_error = 0;
13436 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13441 char fstype[] = "ext2";
13442 char device[] = "/dev/sda1";
13444 suppress_error = 0;
13445 r = guestfs_mkfs (g, fstype, device);
13450 char device[] = "/dev/sda1";
13451 char mountpoint[] = "/";
13453 suppress_error = 0;
13454 r = guestfs_mount (g, device, mountpoint);
13458 /* TestLastFail for file (2) */
13460 char path[] = "/nofile";
13462 suppress_error = 1;
13463 r = guestfs_file (g, path);
13471 static int test_umount_all_0_skip (void)
13475 str = getenv ("TEST_ONLY");
13477 return strstr (str, "umount_all") == NULL;
13478 str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
13479 if (str && strcmp (str, "1") == 0) return 1;
13480 str = getenv ("SKIP_TEST_UMOUNT_ALL");
13481 if (str && strcmp (str, "1") == 0) return 1;
13485 static int test_umount_all_0 (void)
13487 if (test_umount_all_0_skip ()) {
13488 printf (" %s skipped (reason: environment variable set)\n", "test_umount_all_0");
13492 /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
13494 char device[] = "/dev/sda";
13496 suppress_error = 0;
13497 r = guestfs_blockdev_setrw (g, device);
13503 suppress_error = 0;
13504 r = guestfs_umount_all (g);
13510 suppress_error = 0;
13511 r = guestfs_lvm_remove_all (g);
13516 char device[] = "/dev/sda";
13517 char lines_0[] = ",";
13523 suppress_error = 0;
13524 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13529 char fstype[] = "ext2";
13530 char device[] = "/dev/sda1";
13532 suppress_error = 0;
13533 r = guestfs_mkfs (g, fstype, device);
13538 char device[] = "/dev/sda1";
13539 char mountpoint[] = "/";
13541 suppress_error = 0;
13542 r = guestfs_mount (g, device, mountpoint);
13546 /* TestOutputList for umount_all (0) */
13549 suppress_error = 0;
13550 r = guestfs_umount_all (g);
13557 suppress_error = 0;
13558 r = guestfs_mounts (g);
13561 if (r[0] != NULL) {
13562 fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
13566 for (i = 0; r[i] != NULL; ++i)
13573 static int test_umount_all_1_skip (void)
13577 str = getenv ("TEST_ONLY");
13579 return strstr (str, "umount_all") == NULL;
13580 str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
13581 if (str && strcmp (str, "1") == 0) return 1;
13582 str = getenv ("SKIP_TEST_UMOUNT_ALL");
13583 if (str && strcmp (str, "1") == 0) return 1;
13587 static int test_umount_all_1 (void)
13589 if (test_umount_all_1_skip ()) {
13590 printf (" %s skipped (reason: environment variable set)\n", "test_umount_all_1");
13594 /* InitNone|InitEmpty for test_umount_all_1 */
13596 char device[] = "/dev/sda";
13598 suppress_error = 0;
13599 r = guestfs_blockdev_setrw (g, device);
13605 suppress_error = 0;
13606 r = guestfs_umount_all (g);
13612 suppress_error = 0;
13613 r = guestfs_lvm_remove_all (g);
13617 /* TestOutputList for umount_all (1) */
13619 char device[] = "/dev/sda";
13620 char lines_0[] = ",200";
13621 char lines_1[] = ",400";
13622 char lines_2[] = ",";
13630 suppress_error = 0;
13631 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13636 char fstype[] = "ext2";
13637 char device[] = "/dev/sda1";
13639 suppress_error = 0;
13640 r = guestfs_mkfs (g, fstype, device);
13645 char fstype[] = "ext2";
13646 char device[] = "/dev/sda2";
13648 suppress_error = 0;
13649 r = guestfs_mkfs (g, fstype, device);
13654 char fstype[] = "ext2";
13655 char device[] = "/dev/sda3";
13657 suppress_error = 0;
13658 r = guestfs_mkfs (g, fstype, device);
13663 char device[] = "/dev/sda1";
13664 char mountpoint[] = "/";
13666 suppress_error = 0;
13667 r = guestfs_mount (g, device, mountpoint);
13672 char path[] = "/mp1";
13674 suppress_error = 0;
13675 r = guestfs_mkdir (g, path);
13680 char device[] = "/dev/sda2";
13681 char mountpoint[] = "/mp1";
13683 suppress_error = 0;
13684 r = guestfs_mount (g, device, mountpoint);
13689 char path[] = "/mp1/mp2";
13691 suppress_error = 0;
13692 r = guestfs_mkdir (g, path);
13697 char device[] = "/dev/sda3";
13698 char mountpoint[] = "/mp1/mp2";
13700 suppress_error = 0;
13701 r = guestfs_mount (g, device, mountpoint);
13706 char path[] = "/mp1/mp2/mp3";
13708 suppress_error = 0;
13709 r = guestfs_mkdir (g, path);
13715 suppress_error = 0;
13716 r = guestfs_umount_all (g);
13723 suppress_error = 0;
13724 r = guestfs_mounts (g);
13727 if (r[0] != NULL) {
13728 fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
13732 for (i = 0; r[i] != NULL; ++i)
13739 static int test_mounts_0_skip (void)
13743 str = getenv ("TEST_ONLY");
13745 return strstr (str, "mounts") == NULL;
13746 str = getenv ("SKIP_TEST_MOUNTS_0");
13747 if (str && strcmp (str, "1") == 0) return 1;
13748 str = getenv ("SKIP_TEST_MOUNTS");
13749 if (str && strcmp (str, "1") == 0) return 1;
13753 static int test_mounts_0 (void)
13755 if (test_mounts_0_skip ()) {
13756 printf (" %s skipped (reason: environment variable set)\n", "test_mounts_0");
13760 /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
13762 char device[] = "/dev/sda";
13764 suppress_error = 0;
13765 r = guestfs_blockdev_setrw (g, device);
13771 suppress_error = 0;
13772 r = guestfs_umount_all (g);
13778 suppress_error = 0;
13779 r = guestfs_lvm_remove_all (g);
13784 char device[] = "/dev/sda";
13785 char lines_0[] = ",";
13791 suppress_error = 0;
13792 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13797 char fstype[] = "ext2";
13798 char device[] = "/dev/sda1";
13800 suppress_error = 0;
13801 r = guestfs_mkfs (g, fstype, device);
13806 char device[] = "/dev/sda1";
13807 char mountpoint[] = "/";
13809 suppress_error = 0;
13810 r = guestfs_mount (g, device, mountpoint);
13814 /* TestOutputListOfDevices for mounts (0) */
13818 suppress_error = 0;
13819 r = guestfs_mounts (g);
13823 fprintf (stderr, "test_mounts_0: short list returned from command\n");
13828 char expected[] = "/dev/sda1";
13830 if (strcmp (r[0], expected) != 0) {
13831 fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13835 if (r[1] != NULL) {
13836 fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
13840 for (i = 0; r[i] != NULL; ++i)
13847 static int test_umount_0_skip (void)
13851 str = getenv ("TEST_ONLY");
13853 return strstr (str, "umount") == NULL;
13854 str = getenv ("SKIP_TEST_UMOUNT_0");
13855 if (str && strcmp (str, "1") == 0) return 1;
13856 str = getenv ("SKIP_TEST_UMOUNT");
13857 if (str && strcmp (str, "1") == 0) return 1;
13861 static int test_umount_0 (void)
13863 if (test_umount_0_skip ()) {
13864 printf (" %s skipped (reason: environment variable set)\n", "test_umount_0");
13868 /* InitNone|InitEmpty for test_umount_0 */
13870 char device[] = "/dev/sda";
13872 suppress_error = 0;
13873 r = guestfs_blockdev_setrw (g, device);
13879 suppress_error = 0;
13880 r = guestfs_umount_all (g);
13886 suppress_error = 0;
13887 r = guestfs_lvm_remove_all (g);
13891 /* TestOutputListOfDevices for umount (0) */
13893 char device[] = "/dev/sda";
13894 char lines_0[] = ",";
13900 suppress_error = 0;
13901 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13906 char fstype[] = "ext2";
13907 char device[] = "/dev/sda1";
13909 suppress_error = 0;
13910 r = guestfs_mkfs (g, fstype, device);
13915 char device[] = "/dev/sda1";
13916 char mountpoint[] = "/";
13918 suppress_error = 0;
13919 r = guestfs_mount (g, device, mountpoint);
13926 suppress_error = 0;
13927 r = guestfs_mounts (g);
13931 fprintf (stderr, "test_umount_0: short list returned from command\n");
13936 char expected[] = "/dev/sda1";
13938 if (strcmp (r[0], expected) != 0) {
13939 fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13943 if (r[1] != NULL) {
13944 fprintf (stderr, "test_umount_0: extra elements returned from command\n");
13948 for (i = 0; r[i] != NULL; ++i)
13955 static int test_umount_1_skip (void)
13959 str = getenv ("TEST_ONLY");
13961 return strstr (str, "umount") == NULL;
13962 str = getenv ("SKIP_TEST_UMOUNT_1");
13963 if (str && strcmp (str, "1") == 0) return 1;
13964 str = getenv ("SKIP_TEST_UMOUNT");
13965 if (str && strcmp (str, "1") == 0) return 1;
13969 static int test_umount_1 (void)
13971 if (test_umount_1_skip ()) {
13972 printf (" %s skipped (reason: environment variable set)\n", "test_umount_1");
13976 /* InitNone|InitEmpty for test_umount_1 */
13978 char device[] = "/dev/sda";
13980 suppress_error = 0;
13981 r = guestfs_blockdev_setrw (g, device);
13987 suppress_error = 0;
13988 r = guestfs_umount_all (g);
13994 suppress_error = 0;
13995 r = guestfs_lvm_remove_all (g);
13999 /* TestOutputList for umount (1) */
14001 char device[] = "/dev/sda";
14002 char lines_0[] = ",";
14008 suppress_error = 0;
14009 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14014 char fstype[] = "ext2";
14015 char device[] = "/dev/sda1";
14017 suppress_error = 0;
14018 r = guestfs_mkfs (g, fstype, device);
14023 char device[] = "/dev/sda1";
14024 char mountpoint[] = "/";
14026 suppress_error = 0;
14027 r = guestfs_mount (g, device, mountpoint);
14032 char pathordevice[] = "/";
14034 suppress_error = 0;
14035 r = guestfs_umount (g, pathordevice);
14042 suppress_error = 0;
14043 r = guestfs_mounts (g);
14046 if (r[0] != NULL) {
14047 fprintf (stderr, "test_umount_1: extra elements returned from command\n");
14051 for (i = 0; r[i] != NULL; ++i)
14058 static int test_write_file_0_skip (void)
14062 str = getenv ("TEST_ONLY");
14064 return strstr (str, "write_file") == NULL;
14065 str = getenv ("SKIP_TEST_WRITE_FILE_0");
14066 if (str && strcmp (str, "1") == 0) return 1;
14067 str = getenv ("SKIP_TEST_WRITE_FILE");
14068 if (str && strcmp (str, "1") == 0) return 1;
14072 static int test_write_file_0 (void)
14074 if (test_write_file_0_skip ()) {
14075 printf (" %s skipped (reason: environment variable set)\n", "test_write_file_0");
14079 /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
14081 char device[] = "/dev/sda";
14083 suppress_error = 0;
14084 r = guestfs_blockdev_setrw (g, device);
14090 suppress_error = 0;
14091 r = guestfs_umount_all (g);
14097 suppress_error = 0;
14098 r = guestfs_lvm_remove_all (g);
14103 char device[] = "/dev/sda";
14104 char lines_0[] = ",";
14110 suppress_error = 0;
14111 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14116 char fstype[] = "ext2";
14117 char device[] = "/dev/sda1";
14119 suppress_error = 0;
14120 r = guestfs_mkfs (g, fstype, device);
14125 char device[] = "/dev/sda1";
14126 char mountpoint[] = "/";
14128 suppress_error = 0;
14129 r = guestfs_mount (g, device, mountpoint);
14133 /* TestOutput for write_file (0) */
14134 char expected[] = "new file contents";
14136 char path[] = "/new";
14137 char content[] = "new file contents";
14139 suppress_error = 0;
14140 r = guestfs_write_file (g, path, content, 0);
14145 char path[] = "/new";
14147 suppress_error = 0;
14148 r = guestfs_cat (g, path);
14151 if (strcmp (r, expected) != 0) {
14152 fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
14160 static int test_write_file_1_skip (void)
14164 str = getenv ("TEST_ONLY");
14166 return strstr (str, "write_file") == NULL;
14167 str = getenv ("SKIP_TEST_WRITE_FILE_1");
14168 if (str && strcmp (str, "1") == 0) return 1;
14169 str = getenv ("SKIP_TEST_WRITE_FILE");
14170 if (str && strcmp (str, "1") == 0) return 1;
14174 static int test_write_file_1 (void)
14176 if (test_write_file_1_skip ()) {
14177 printf (" %s skipped (reason: environment variable set)\n", "test_write_file_1");
14181 /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
14183 char device[] = "/dev/sda";
14185 suppress_error = 0;
14186 r = guestfs_blockdev_setrw (g, device);
14192 suppress_error = 0;
14193 r = guestfs_umount_all (g);
14199 suppress_error = 0;
14200 r = guestfs_lvm_remove_all (g);
14205 char device[] = "/dev/sda";
14206 char lines_0[] = ",";
14212 suppress_error = 0;
14213 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14218 char fstype[] = "ext2";
14219 char device[] = "/dev/sda1";
14221 suppress_error = 0;
14222 r = guestfs_mkfs (g, fstype, device);
14227 char device[] = "/dev/sda1";
14228 char mountpoint[] = "/";
14230 suppress_error = 0;
14231 r = guestfs_mount (g, device, mountpoint);
14235 /* TestOutput for write_file (1) */
14236 char expected[] = "\nnew file contents\n";
14238 char path[] = "/new";
14239 char content[] = "\nnew file contents\n";
14241 suppress_error = 0;
14242 r = guestfs_write_file (g, path, content, 0);
14247 char path[] = "/new";
14249 suppress_error = 0;
14250 r = guestfs_cat (g, path);
14253 if (strcmp (r, expected) != 0) {
14254 fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
14262 static int test_write_file_2_skip (void)
14266 str = getenv ("TEST_ONLY");
14268 return strstr (str, "write_file") == NULL;
14269 str = getenv ("SKIP_TEST_WRITE_FILE_2");
14270 if (str && strcmp (str, "1") == 0) return 1;
14271 str = getenv ("SKIP_TEST_WRITE_FILE");
14272 if (str && strcmp (str, "1") == 0) return 1;
14276 static int test_write_file_2 (void)
14278 if (test_write_file_2_skip ()) {
14279 printf (" %s skipped (reason: environment variable set)\n", "test_write_file_2");
14283 /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
14285 char device[] = "/dev/sda";
14287 suppress_error = 0;
14288 r = guestfs_blockdev_setrw (g, device);
14294 suppress_error = 0;
14295 r = guestfs_umount_all (g);
14301 suppress_error = 0;
14302 r = guestfs_lvm_remove_all (g);
14307 char device[] = "/dev/sda";
14308 char lines_0[] = ",";
14314 suppress_error = 0;
14315 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14320 char fstype[] = "ext2";
14321 char device[] = "/dev/sda1";
14323 suppress_error = 0;
14324 r = guestfs_mkfs (g, fstype, device);
14329 char device[] = "/dev/sda1";
14330 char mountpoint[] = "/";
14332 suppress_error = 0;
14333 r = guestfs_mount (g, device, mountpoint);
14337 /* TestOutput for write_file (2) */
14338 char expected[] = "\n\n";
14340 char path[] = "/new";
14341 char content[] = "\n\n";
14343 suppress_error = 0;
14344 r = guestfs_write_file (g, path, content, 0);
14349 char path[] = "/new";
14351 suppress_error = 0;
14352 r = guestfs_cat (g, path);
14355 if (strcmp (r, expected) != 0) {
14356 fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
14364 static int test_write_file_3_skip (void)
14368 str = getenv ("TEST_ONLY");
14370 return strstr (str, "write_file") == NULL;
14371 str = getenv ("SKIP_TEST_WRITE_FILE_3");
14372 if (str && strcmp (str, "1") == 0) return 1;
14373 str = getenv ("SKIP_TEST_WRITE_FILE");
14374 if (str && strcmp (str, "1") == 0) return 1;
14378 static int test_write_file_3 (void)
14380 if (test_write_file_3_skip ()) {
14381 printf (" %s skipped (reason: environment variable set)\n", "test_write_file_3");
14385 /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
14387 char device[] = "/dev/sda";
14389 suppress_error = 0;
14390 r = guestfs_blockdev_setrw (g, device);
14396 suppress_error = 0;
14397 r = guestfs_umount_all (g);
14403 suppress_error = 0;
14404 r = guestfs_lvm_remove_all (g);
14409 char device[] = "/dev/sda";
14410 char lines_0[] = ",";
14416 suppress_error = 0;
14417 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14422 char fstype[] = "ext2";
14423 char device[] = "/dev/sda1";
14425 suppress_error = 0;
14426 r = guestfs_mkfs (g, fstype, device);
14431 char device[] = "/dev/sda1";
14432 char mountpoint[] = "/";
14434 suppress_error = 0;
14435 r = guestfs_mount (g, device, mountpoint);
14439 /* TestOutput for write_file (3) */
14440 char expected[] = "";
14442 char path[] = "/new";
14443 char content[] = "";
14445 suppress_error = 0;
14446 r = guestfs_write_file (g, path, content, 0);
14451 char path[] = "/new";
14453 suppress_error = 0;
14454 r = guestfs_cat (g, path);
14457 if (strcmp (r, expected) != 0) {
14458 fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
14466 static int test_write_file_4_skip (void)
14470 str = getenv ("TEST_ONLY");
14472 return strstr (str, "write_file") == NULL;
14473 str = getenv ("SKIP_TEST_WRITE_FILE_4");
14474 if (str && strcmp (str, "1") == 0) return 1;
14475 str = getenv ("SKIP_TEST_WRITE_FILE");
14476 if (str && strcmp (str, "1") == 0) return 1;
14480 static int test_write_file_4 (void)
14482 if (test_write_file_4_skip ()) {
14483 printf (" %s skipped (reason: environment variable set)\n", "test_write_file_4");
14487 /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
14489 char device[] = "/dev/sda";
14491 suppress_error = 0;
14492 r = guestfs_blockdev_setrw (g, device);
14498 suppress_error = 0;
14499 r = guestfs_umount_all (g);
14505 suppress_error = 0;
14506 r = guestfs_lvm_remove_all (g);
14511 char device[] = "/dev/sda";
14512 char lines_0[] = ",";
14518 suppress_error = 0;
14519 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14524 char fstype[] = "ext2";
14525 char device[] = "/dev/sda1";
14527 suppress_error = 0;
14528 r = guestfs_mkfs (g, fstype, device);
14533 char device[] = "/dev/sda1";
14534 char mountpoint[] = "/";
14536 suppress_error = 0;
14537 r = guestfs_mount (g, device, mountpoint);
14541 /* TestOutput for write_file (4) */
14542 char expected[] = "\n\n\n";
14544 char path[] = "/new";
14545 char content[] = "\n\n\n";
14547 suppress_error = 0;
14548 r = guestfs_write_file (g, path, content, 0);
14553 char path[] = "/new";
14555 suppress_error = 0;
14556 r = guestfs_cat (g, path);
14559 if (strcmp (r, expected) != 0) {
14560 fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
14568 static int test_write_file_5_skip (void)
14572 str = getenv ("TEST_ONLY");
14574 return strstr (str, "write_file") == NULL;
14575 str = getenv ("SKIP_TEST_WRITE_FILE_5");
14576 if (str && strcmp (str, "1") == 0) return 1;
14577 str = getenv ("SKIP_TEST_WRITE_FILE");
14578 if (str && strcmp (str, "1") == 0) return 1;
14582 static int test_write_file_5 (void)
14584 if (test_write_file_5_skip ()) {
14585 printf (" %s skipped (reason: environment variable set)\n", "test_write_file_5");
14589 /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
14591 char device[] = "/dev/sda";
14593 suppress_error = 0;
14594 r = guestfs_blockdev_setrw (g, device);
14600 suppress_error = 0;
14601 r = guestfs_umount_all (g);
14607 suppress_error = 0;
14608 r = guestfs_lvm_remove_all (g);
14613 char device[] = "/dev/sda";
14614 char lines_0[] = ",";
14620 suppress_error = 0;
14621 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14626 char fstype[] = "ext2";
14627 char device[] = "/dev/sda1";
14629 suppress_error = 0;
14630 r = guestfs_mkfs (g, fstype, device);
14635 char device[] = "/dev/sda1";
14636 char mountpoint[] = "/";
14638 suppress_error = 0;
14639 r = guestfs_mount (g, device, mountpoint);
14643 /* TestOutput for write_file (5) */
14644 char expected[] = "\n";
14646 char path[] = "/new";
14647 char content[] = "\n";
14649 suppress_error = 0;
14650 r = guestfs_write_file (g, path, content, 0);
14655 char path[] = "/new";
14657 suppress_error = 0;
14658 r = guestfs_cat (g, path);
14661 if (strcmp (r, expected) != 0) {
14662 fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
14670 static int test_mkfs_0_skip (void)
14674 str = getenv ("TEST_ONLY");
14676 return strstr (str, "mkfs") == NULL;
14677 str = getenv ("SKIP_TEST_MKFS_0");
14678 if (str && strcmp (str, "1") == 0) return 1;
14679 str = getenv ("SKIP_TEST_MKFS");
14680 if (str && strcmp (str, "1") == 0) return 1;
14684 static int test_mkfs_0 (void)
14686 if (test_mkfs_0_skip ()) {
14687 printf (" %s skipped (reason: environment variable set)\n", "test_mkfs_0");
14691 /* InitNone|InitEmpty for test_mkfs_0 */
14693 char device[] = "/dev/sda";
14695 suppress_error = 0;
14696 r = guestfs_blockdev_setrw (g, device);
14702 suppress_error = 0;
14703 r = guestfs_umount_all (g);
14709 suppress_error = 0;
14710 r = guestfs_lvm_remove_all (g);
14714 /* TestOutput for mkfs (0) */
14715 char expected[] = "new file contents";
14717 char device[] = "/dev/sda";
14718 char lines_0[] = ",";
14724 suppress_error = 0;
14725 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14730 char fstype[] = "ext2";
14731 char device[] = "/dev/sda1";
14733 suppress_error = 0;
14734 r = guestfs_mkfs (g, fstype, device);
14739 char device[] = "/dev/sda1";
14740 char mountpoint[] = "/";
14742 suppress_error = 0;
14743 r = guestfs_mount (g, device, mountpoint);
14748 char path[] = "/new";
14749 char content[] = "new file contents";
14751 suppress_error = 0;
14752 r = guestfs_write_file (g, path, content, 0);
14757 char path[] = "/new";
14759 suppress_error = 0;
14760 r = guestfs_cat (g, path);
14763 if (strcmp (r, expected) != 0) {
14764 fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
14772 static int test_lvcreate_0_skip (void)
14776 str = getenv ("TEST_ONLY");
14778 return strstr (str, "lvcreate") == NULL;
14779 str = getenv ("SKIP_TEST_LVCREATE_0");
14780 if (str && strcmp (str, "1") == 0) return 1;
14781 str = getenv ("SKIP_TEST_LVCREATE");
14782 if (str && strcmp (str, "1") == 0) return 1;
14786 static int test_lvcreate_0 (void)
14788 if (test_lvcreate_0_skip ()) {
14789 printf (" %s skipped (reason: environment variable set)\n", "test_lvcreate_0");
14793 /* InitNone|InitEmpty for test_lvcreate_0 */
14795 char device[] = "/dev/sda";
14797 suppress_error = 0;
14798 r = guestfs_blockdev_setrw (g, device);
14804 suppress_error = 0;
14805 r = guestfs_umount_all (g);
14811 suppress_error = 0;
14812 r = guestfs_lvm_remove_all (g);
14816 /* TestOutputList for lvcreate (0) */
14818 char device[] = "/dev/sda";
14819 char lines_0[] = ",200";
14820 char lines_1[] = ",400";
14821 char lines_2[] = ",";
14829 suppress_error = 0;
14830 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14835 char device[] = "/dev/sda1";
14837 suppress_error = 0;
14838 r = guestfs_pvcreate (g, device);
14843 char device[] = "/dev/sda2";
14845 suppress_error = 0;
14846 r = guestfs_pvcreate (g, device);
14851 char device[] = "/dev/sda3";
14853 suppress_error = 0;
14854 r = guestfs_pvcreate (g, device);
14859 char volgroup[] = "VG1";
14860 char physvols_0[] = "/dev/sda1";
14861 char physvols_1[] = "/dev/sda2";
14862 char *physvols[] = {
14868 suppress_error = 0;
14869 r = guestfs_vgcreate (g, volgroup, physvols);
14874 char volgroup[] = "VG2";
14875 char physvols_0[] = "/dev/sda3";
14876 char *physvols[] = {
14881 suppress_error = 0;
14882 r = guestfs_vgcreate (g, volgroup, physvols);
14887 char logvol[] = "LV1";
14888 char volgroup[] = "VG1";
14890 suppress_error = 0;
14891 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14896 char logvol[] = "LV2";
14897 char volgroup[] = "VG1";
14899 suppress_error = 0;
14900 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14905 char logvol[] = "LV3";
14906 char volgroup[] = "VG2";
14908 suppress_error = 0;
14909 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14914 char logvol[] = "LV4";
14915 char volgroup[] = "VG2";
14917 suppress_error = 0;
14918 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14923 char logvol[] = "LV5";
14924 char volgroup[] = "VG2";
14926 suppress_error = 0;
14927 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14934 suppress_error = 0;
14935 r = guestfs_lvs (g);
14939 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14944 char expected[] = "/dev/VG1/LV1";
14945 if (strcmp (r[0], expected) != 0) {
14946 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14951 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14956 char expected[] = "/dev/VG1/LV2";
14957 if (strcmp (r[1], expected) != 0) {
14958 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14963 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14968 char expected[] = "/dev/VG2/LV3";
14969 if (strcmp (r[2], expected) != 0) {
14970 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14975 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14980 char expected[] = "/dev/VG2/LV4";
14981 if (strcmp (r[3], expected) != 0) {
14982 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
14987 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14992 char expected[] = "/dev/VG2/LV5";
14993 if (strcmp (r[4], expected) != 0) {
14994 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
14998 if (r[5] != NULL) {
14999 fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
15003 for (i = 0; r[i] != NULL; ++i)
15010 static int test_vgcreate_0_skip (void)
15014 str = getenv ("TEST_ONLY");
15016 return strstr (str, "vgcreate") == NULL;
15017 str = getenv ("SKIP_TEST_VGCREATE_0");
15018 if (str && strcmp (str, "1") == 0) return 1;
15019 str = getenv ("SKIP_TEST_VGCREATE");
15020 if (str && strcmp (str, "1") == 0) return 1;
15024 static int test_vgcreate_0 (void)
15026 if (test_vgcreate_0_skip ()) {
15027 printf (" %s skipped (reason: environment variable set)\n", "test_vgcreate_0");
15031 /* InitNone|InitEmpty for test_vgcreate_0 */
15033 char device[] = "/dev/sda";
15035 suppress_error = 0;
15036 r = guestfs_blockdev_setrw (g, device);
15042 suppress_error = 0;
15043 r = guestfs_umount_all (g);
15049 suppress_error = 0;
15050 r = guestfs_lvm_remove_all (g);
15054 /* TestOutputList for vgcreate (0) */
15056 char device[] = "/dev/sda";
15057 char lines_0[] = ",200";
15058 char lines_1[] = ",400";
15059 char lines_2[] = ",";
15067 suppress_error = 0;
15068 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15073 char device[] = "/dev/sda1";
15075 suppress_error = 0;
15076 r = guestfs_pvcreate (g, device);
15081 char device[] = "/dev/sda2";
15083 suppress_error = 0;
15084 r = guestfs_pvcreate (g, device);
15089 char device[] = "/dev/sda3";
15091 suppress_error = 0;
15092 r = guestfs_pvcreate (g, device);
15097 char volgroup[] = "VG1";
15098 char physvols_0[] = "/dev/sda1";
15099 char physvols_1[] = "/dev/sda2";
15100 char *physvols[] = {
15106 suppress_error = 0;
15107 r = guestfs_vgcreate (g, volgroup, physvols);
15112 char volgroup[] = "VG2";
15113 char physvols_0[] = "/dev/sda3";
15114 char *physvols[] = {
15119 suppress_error = 0;
15120 r = guestfs_vgcreate (g, volgroup, physvols);
15127 suppress_error = 0;
15128 r = guestfs_vgs (g);
15132 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
15137 char expected[] = "VG1";
15138 if (strcmp (r[0], expected) != 0) {
15139 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15144 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
15149 char expected[] = "VG2";
15150 if (strcmp (r[1], expected) != 0) {
15151 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15155 if (r[2] != NULL) {
15156 fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
15160 for (i = 0; r[i] != NULL; ++i)
15167 static int test_pvcreate_0_skip (void)
15171 str = getenv ("TEST_ONLY");
15173 return strstr (str, "pvcreate") == NULL;
15174 str = getenv ("SKIP_TEST_PVCREATE_0");
15175 if (str && strcmp (str, "1") == 0) return 1;
15176 str = getenv ("SKIP_TEST_PVCREATE");
15177 if (str && strcmp (str, "1") == 0) return 1;
15181 static int test_pvcreate_0 (void)
15183 if (test_pvcreate_0_skip ()) {
15184 printf (" %s skipped (reason: environment variable set)\n", "test_pvcreate_0");
15188 /* InitNone|InitEmpty for test_pvcreate_0 */
15190 char device[] = "/dev/sda";
15192 suppress_error = 0;
15193 r = guestfs_blockdev_setrw (g, device);
15199 suppress_error = 0;
15200 r = guestfs_umount_all (g);
15206 suppress_error = 0;
15207 r = guestfs_lvm_remove_all (g);
15211 /* TestOutputListOfDevices for pvcreate (0) */
15213 char device[] = "/dev/sda";
15214 char lines_0[] = ",200";
15215 char lines_1[] = ",400";
15216 char lines_2[] = ",";
15224 suppress_error = 0;
15225 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15230 char device[] = "/dev/sda1";
15232 suppress_error = 0;
15233 r = guestfs_pvcreate (g, device);
15238 char device[] = "/dev/sda2";
15240 suppress_error = 0;
15241 r = guestfs_pvcreate (g, device);
15246 char device[] = "/dev/sda3";
15248 suppress_error = 0;
15249 r = guestfs_pvcreate (g, device);
15256 suppress_error = 0;
15257 r = guestfs_pvs (g);
15261 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
15266 char expected[] = "/dev/sda1";
15268 if (strcmp (r[0], expected) != 0) {
15269 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15274 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
15279 char expected[] = "/dev/sda2";
15281 if (strcmp (r[1], expected) != 0) {
15282 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15287 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
15292 char expected[] = "/dev/sda3";
15294 if (strcmp (r[2], expected) != 0) {
15295 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15299 if (r[3] != NULL) {
15300 fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
15304 for (i = 0; r[i] != NULL; ++i)
15311 static int test_is_dir_0_skip (void)
15315 str = getenv ("TEST_ONLY");
15317 return strstr (str, "is_dir") == NULL;
15318 str = getenv ("SKIP_TEST_IS_DIR_0");
15319 if (str && strcmp (str, "1") == 0) return 1;
15320 str = getenv ("SKIP_TEST_IS_DIR");
15321 if (str && strcmp (str, "1") == 0) return 1;
15325 static int test_is_dir_0 (void)
15327 if (test_is_dir_0_skip ()) {
15328 printf (" %s skipped (reason: environment variable set)\n", "test_is_dir_0");
15332 /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
15334 char device[] = "/dev/sda";
15336 suppress_error = 0;
15337 r = guestfs_blockdev_setrw (g, device);
15343 suppress_error = 0;
15344 r = guestfs_umount_all (g);
15350 suppress_error = 0;
15351 r = guestfs_lvm_remove_all (g);
15356 char device[] = "/dev/sda";
15357 char lines_0[] = ",";
15363 suppress_error = 0;
15364 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15369 char fstype[] = "ext2";
15370 char device[] = "/dev/sda1";
15372 suppress_error = 0;
15373 r = guestfs_mkfs (g, fstype, device);
15378 char device[] = "/dev/sda1";
15379 char mountpoint[] = "/";
15381 suppress_error = 0;
15382 r = guestfs_mount (g, device, mountpoint);
15386 /* TestOutputFalse for is_dir (0) */
15388 char path[] = "/new";
15390 suppress_error = 0;
15391 r = guestfs_touch (g, path);
15396 char path[] = "/new";
15398 suppress_error = 0;
15399 r = guestfs_is_dir (g, path);
15403 fprintf (stderr, "test_is_dir_0: expected false, got true\n");
15410 static int test_is_dir_1_skip (void)
15414 str = getenv ("TEST_ONLY");
15416 return strstr (str, "is_dir") == NULL;
15417 str = getenv ("SKIP_TEST_IS_DIR_1");
15418 if (str && strcmp (str, "1") == 0) return 1;
15419 str = getenv ("SKIP_TEST_IS_DIR");
15420 if (str && strcmp (str, "1") == 0) return 1;
15424 static int test_is_dir_1 (void)
15426 if (test_is_dir_1_skip ()) {
15427 printf (" %s skipped (reason: environment variable set)\n", "test_is_dir_1");
15431 /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
15433 char device[] = "/dev/sda";
15435 suppress_error = 0;
15436 r = guestfs_blockdev_setrw (g, device);
15442 suppress_error = 0;
15443 r = guestfs_umount_all (g);
15449 suppress_error = 0;
15450 r = guestfs_lvm_remove_all (g);
15455 char device[] = "/dev/sda";
15456 char lines_0[] = ",";
15462 suppress_error = 0;
15463 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15468 char fstype[] = "ext2";
15469 char device[] = "/dev/sda1";
15471 suppress_error = 0;
15472 r = guestfs_mkfs (g, fstype, device);
15477 char device[] = "/dev/sda1";
15478 char mountpoint[] = "/";
15480 suppress_error = 0;
15481 r = guestfs_mount (g, device, mountpoint);
15485 /* TestOutputTrue for is_dir (1) */
15487 char path[] = "/new";
15489 suppress_error = 0;
15490 r = guestfs_mkdir (g, path);
15495 char path[] = "/new";
15497 suppress_error = 0;
15498 r = guestfs_is_dir (g, path);
15502 fprintf (stderr, "test_is_dir_1: expected true, got false\n");
15509 static int test_is_file_0_skip (void)
15513 str = getenv ("TEST_ONLY");
15515 return strstr (str, "is_file") == NULL;
15516 str = getenv ("SKIP_TEST_IS_FILE_0");
15517 if (str && strcmp (str, "1") == 0) return 1;
15518 str = getenv ("SKIP_TEST_IS_FILE");
15519 if (str && strcmp (str, "1") == 0) return 1;
15523 static int test_is_file_0 (void)
15525 if (test_is_file_0_skip ()) {
15526 printf (" %s skipped (reason: environment variable set)\n", "test_is_file_0");
15530 /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
15532 char device[] = "/dev/sda";
15534 suppress_error = 0;
15535 r = guestfs_blockdev_setrw (g, device);
15541 suppress_error = 0;
15542 r = guestfs_umount_all (g);
15548 suppress_error = 0;
15549 r = guestfs_lvm_remove_all (g);
15554 char device[] = "/dev/sda";
15555 char lines_0[] = ",";
15561 suppress_error = 0;
15562 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15567 char fstype[] = "ext2";
15568 char device[] = "/dev/sda1";
15570 suppress_error = 0;
15571 r = guestfs_mkfs (g, fstype, device);
15576 char device[] = "/dev/sda1";
15577 char mountpoint[] = "/";
15579 suppress_error = 0;
15580 r = guestfs_mount (g, device, mountpoint);
15584 /* TestOutputTrue for is_file (0) */
15586 char path[] = "/new";
15588 suppress_error = 0;
15589 r = guestfs_touch (g, path);
15594 char path[] = "/new";
15596 suppress_error = 0;
15597 r = guestfs_is_file (g, path);
15601 fprintf (stderr, "test_is_file_0: expected true, got false\n");
15608 static int test_is_file_1_skip (void)
15612 str = getenv ("TEST_ONLY");
15614 return strstr (str, "is_file") == NULL;
15615 str = getenv ("SKIP_TEST_IS_FILE_1");
15616 if (str && strcmp (str, "1") == 0) return 1;
15617 str = getenv ("SKIP_TEST_IS_FILE");
15618 if (str && strcmp (str, "1") == 0) return 1;
15622 static int test_is_file_1 (void)
15624 if (test_is_file_1_skip ()) {
15625 printf (" %s skipped (reason: environment variable set)\n", "test_is_file_1");
15629 /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
15631 char device[] = "/dev/sda";
15633 suppress_error = 0;
15634 r = guestfs_blockdev_setrw (g, device);
15640 suppress_error = 0;
15641 r = guestfs_umount_all (g);
15647 suppress_error = 0;
15648 r = guestfs_lvm_remove_all (g);
15653 char device[] = "/dev/sda";
15654 char lines_0[] = ",";
15660 suppress_error = 0;
15661 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15666 char fstype[] = "ext2";
15667 char device[] = "/dev/sda1";
15669 suppress_error = 0;
15670 r = guestfs_mkfs (g, fstype, device);
15675 char device[] = "/dev/sda1";
15676 char mountpoint[] = "/";
15678 suppress_error = 0;
15679 r = guestfs_mount (g, device, mountpoint);
15683 /* TestOutputFalse for is_file (1) */
15685 char path[] = "/new";
15687 suppress_error = 0;
15688 r = guestfs_mkdir (g, path);
15693 char path[] = "/new";
15695 suppress_error = 0;
15696 r = guestfs_is_file (g, path);
15700 fprintf (stderr, "test_is_file_1: expected false, got true\n");
15707 static int test_exists_0_skip (void)
15711 str = getenv ("TEST_ONLY");
15713 return strstr (str, "exists") == NULL;
15714 str = getenv ("SKIP_TEST_EXISTS_0");
15715 if (str && strcmp (str, "1") == 0) return 1;
15716 str = getenv ("SKIP_TEST_EXISTS");
15717 if (str && strcmp (str, "1") == 0) return 1;
15721 static int test_exists_0 (void)
15723 if (test_exists_0_skip ()) {
15724 printf (" %s skipped (reason: environment variable set)\n", "test_exists_0");
15728 /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
15730 char device[] = "/dev/sda";
15732 suppress_error = 0;
15733 r = guestfs_blockdev_setrw (g, device);
15739 suppress_error = 0;
15740 r = guestfs_umount_all (g);
15746 suppress_error = 0;
15747 r = guestfs_lvm_remove_all (g);
15752 char device[] = "/dev/sda";
15753 char lines_0[] = ",";
15759 suppress_error = 0;
15760 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15765 char fstype[] = "ext2";
15766 char device[] = "/dev/sda1";
15768 suppress_error = 0;
15769 r = guestfs_mkfs (g, fstype, device);
15774 char device[] = "/dev/sda1";
15775 char mountpoint[] = "/";
15777 suppress_error = 0;
15778 r = guestfs_mount (g, device, mountpoint);
15782 /* TestOutputTrue for exists (0) */
15784 char path[] = "/new";
15786 suppress_error = 0;
15787 r = guestfs_touch (g, path);
15792 char path[] = "/new";
15794 suppress_error = 0;
15795 r = guestfs_exists (g, path);
15799 fprintf (stderr, "test_exists_0: expected true, got false\n");
15806 static int test_exists_1_skip (void)
15810 str = getenv ("TEST_ONLY");
15812 return strstr (str, "exists") == NULL;
15813 str = getenv ("SKIP_TEST_EXISTS_1");
15814 if (str && strcmp (str, "1") == 0) return 1;
15815 str = getenv ("SKIP_TEST_EXISTS");
15816 if (str && strcmp (str, "1") == 0) return 1;
15820 static int test_exists_1 (void)
15822 if (test_exists_1_skip ()) {
15823 printf (" %s skipped (reason: environment variable set)\n", "test_exists_1");
15827 /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
15829 char device[] = "/dev/sda";
15831 suppress_error = 0;
15832 r = guestfs_blockdev_setrw (g, device);
15838 suppress_error = 0;
15839 r = guestfs_umount_all (g);
15845 suppress_error = 0;
15846 r = guestfs_lvm_remove_all (g);
15851 char device[] = "/dev/sda";
15852 char lines_0[] = ",";
15858 suppress_error = 0;
15859 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15864 char fstype[] = "ext2";
15865 char device[] = "/dev/sda1";
15867 suppress_error = 0;
15868 r = guestfs_mkfs (g, fstype, device);
15873 char device[] = "/dev/sda1";
15874 char mountpoint[] = "/";
15876 suppress_error = 0;
15877 r = guestfs_mount (g, device, mountpoint);
15881 /* TestOutputTrue for exists (1) */
15883 char path[] = "/new";
15885 suppress_error = 0;
15886 r = guestfs_mkdir (g, path);
15891 char path[] = "/new";
15893 suppress_error = 0;
15894 r = guestfs_exists (g, path);
15898 fprintf (stderr, "test_exists_1: expected true, got false\n");
15905 static int test_mkdir_p_0_skip (void)
15909 str = getenv ("TEST_ONLY");
15911 return strstr (str, "mkdir_p") == NULL;
15912 str = getenv ("SKIP_TEST_MKDIR_P_0");
15913 if (str && strcmp (str, "1") == 0) return 1;
15914 str = getenv ("SKIP_TEST_MKDIR_P");
15915 if (str && strcmp (str, "1") == 0) return 1;
15919 static int test_mkdir_p_0 (void)
15921 if (test_mkdir_p_0_skip ()) {
15922 printf (" %s skipped (reason: environment variable set)\n", "test_mkdir_p_0");
15926 /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
15928 char device[] = "/dev/sda";
15930 suppress_error = 0;
15931 r = guestfs_blockdev_setrw (g, device);
15937 suppress_error = 0;
15938 r = guestfs_umount_all (g);
15944 suppress_error = 0;
15945 r = guestfs_lvm_remove_all (g);
15950 char device[] = "/dev/sda";
15951 char lines_0[] = ",";
15957 suppress_error = 0;
15958 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15963 char fstype[] = "ext2";
15964 char device[] = "/dev/sda1";
15966 suppress_error = 0;
15967 r = guestfs_mkfs (g, fstype, device);
15972 char device[] = "/dev/sda1";
15973 char mountpoint[] = "/";
15975 suppress_error = 0;
15976 r = guestfs_mount (g, device, mountpoint);
15980 /* TestOutputTrue for mkdir_p (0) */
15982 char path[] = "/new/foo/bar";
15984 suppress_error = 0;
15985 r = guestfs_mkdir_p (g, path);
15990 char path[] = "/new/foo/bar";
15992 suppress_error = 0;
15993 r = guestfs_is_dir (g, path);
15997 fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
16004 static int test_mkdir_p_1_skip (void)
16008 str = getenv ("TEST_ONLY");
16010 return strstr (str, "mkdir_p") == NULL;
16011 str = getenv ("SKIP_TEST_MKDIR_P_1");
16012 if (str && strcmp (str, "1") == 0) return 1;
16013 str = getenv ("SKIP_TEST_MKDIR_P");
16014 if (str && strcmp (str, "1") == 0) return 1;
16018 static int test_mkdir_p_1 (void)
16020 if (test_mkdir_p_1_skip ()) {
16021 printf (" %s skipped (reason: environment variable set)\n", "test_mkdir_p_1");
16025 /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
16027 char device[] = "/dev/sda";
16029 suppress_error = 0;
16030 r = guestfs_blockdev_setrw (g, device);
16036 suppress_error = 0;
16037 r = guestfs_umount_all (g);
16043 suppress_error = 0;
16044 r = guestfs_lvm_remove_all (g);
16049 char device[] = "/dev/sda";
16050 char lines_0[] = ",";
16056 suppress_error = 0;
16057 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16062 char fstype[] = "ext2";
16063 char device[] = "/dev/sda1";
16065 suppress_error = 0;
16066 r = guestfs_mkfs (g, fstype, device);
16071 char device[] = "/dev/sda1";
16072 char mountpoint[] = "/";
16074 suppress_error = 0;
16075 r = guestfs_mount (g, device, mountpoint);
16079 /* TestOutputTrue for mkdir_p (1) */
16081 char path[] = "/new/foo/bar";
16083 suppress_error = 0;
16084 r = guestfs_mkdir_p (g, path);
16089 char path[] = "/new/foo";
16091 suppress_error = 0;
16092 r = guestfs_is_dir (g, path);
16096 fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
16103 static int test_mkdir_p_2_skip (void)
16107 str = getenv ("TEST_ONLY");
16109 return strstr (str, "mkdir_p") == NULL;
16110 str = getenv ("SKIP_TEST_MKDIR_P_2");
16111 if (str && strcmp (str, "1") == 0) return 1;
16112 str = getenv ("SKIP_TEST_MKDIR_P");
16113 if (str && strcmp (str, "1") == 0) return 1;
16117 static int test_mkdir_p_2 (void)
16119 if (test_mkdir_p_2_skip ()) {
16120 printf (" %s skipped (reason: environment variable set)\n", "test_mkdir_p_2");
16124 /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
16126 char device[] = "/dev/sda";
16128 suppress_error = 0;
16129 r = guestfs_blockdev_setrw (g, device);
16135 suppress_error = 0;
16136 r = guestfs_umount_all (g);
16142 suppress_error = 0;
16143 r = guestfs_lvm_remove_all (g);
16148 char device[] = "/dev/sda";
16149 char lines_0[] = ",";
16155 suppress_error = 0;
16156 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16161 char fstype[] = "ext2";
16162 char device[] = "/dev/sda1";
16164 suppress_error = 0;
16165 r = guestfs_mkfs (g, fstype, device);
16170 char device[] = "/dev/sda1";
16171 char mountpoint[] = "/";
16173 suppress_error = 0;
16174 r = guestfs_mount (g, device, mountpoint);
16178 /* TestOutputTrue for mkdir_p (2) */
16180 char path[] = "/new/foo/bar";
16182 suppress_error = 0;
16183 r = guestfs_mkdir_p (g, path);
16188 char path[] = "/new";
16190 suppress_error = 0;
16191 r = guestfs_is_dir (g, path);
16195 fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
16202 static int test_mkdir_p_3_skip (void)
16206 str = getenv ("TEST_ONLY");
16208 return strstr (str, "mkdir_p") == NULL;
16209 str = getenv ("SKIP_TEST_MKDIR_P_3");
16210 if (str && strcmp (str, "1") == 0) return 1;
16211 str = getenv ("SKIP_TEST_MKDIR_P");
16212 if (str && strcmp (str, "1") == 0) return 1;
16216 static int test_mkdir_p_3 (void)
16218 if (test_mkdir_p_3_skip ()) {
16219 printf (" %s skipped (reason: environment variable set)\n", "test_mkdir_p_3");
16223 /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
16225 char device[] = "/dev/sda";
16227 suppress_error = 0;
16228 r = guestfs_blockdev_setrw (g, device);
16234 suppress_error = 0;
16235 r = guestfs_umount_all (g);
16241 suppress_error = 0;
16242 r = guestfs_lvm_remove_all (g);
16247 char device[] = "/dev/sda";
16248 char lines_0[] = ",";
16254 suppress_error = 0;
16255 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16260 char fstype[] = "ext2";
16261 char device[] = "/dev/sda1";
16263 suppress_error = 0;
16264 r = guestfs_mkfs (g, fstype, device);
16269 char device[] = "/dev/sda1";
16270 char mountpoint[] = "/";
16272 suppress_error = 0;
16273 r = guestfs_mount (g, device, mountpoint);
16277 /* TestRun for mkdir_p (3) */
16279 char path[] = "/new";
16281 suppress_error = 0;
16282 r = guestfs_mkdir (g, path);
16287 char path[] = "/new";
16289 suppress_error = 0;
16290 r = guestfs_mkdir_p (g, path);
16297 static int test_mkdir_p_4_skip (void)
16301 str = getenv ("TEST_ONLY");
16303 return strstr (str, "mkdir_p") == NULL;
16304 str = getenv ("SKIP_TEST_MKDIR_P_4");
16305 if (str && strcmp (str, "1") == 0) return 1;
16306 str = getenv ("SKIP_TEST_MKDIR_P");
16307 if (str && strcmp (str, "1") == 0) return 1;
16311 static int test_mkdir_p_4 (void)
16313 if (test_mkdir_p_4_skip ()) {
16314 printf (" %s skipped (reason: environment variable set)\n", "test_mkdir_p_4");
16318 /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
16320 char device[] = "/dev/sda";
16322 suppress_error = 0;
16323 r = guestfs_blockdev_setrw (g, device);
16329 suppress_error = 0;
16330 r = guestfs_umount_all (g);
16336 suppress_error = 0;
16337 r = guestfs_lvm_remove_all (g);
16342 char device[] = "/dev/sda";
16343 char lines_0[] = ",";
16349 suppress_error = 0;
16350 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16355 char fstype[] = "ext2";
16356 char device[] = "/dev/sda1";
16358 suppress_error = 0;
16359 r = guestfs_mkfs (g, fstype, device);
16364 char device[] = "/dev/sda1";
16365 char mountpoint[] = "/";
16367 suppress_error = 0;
16368 r = guestfs_mount (g, device, mountpoint);
16372 /* TestLastFail for mkdir_p (4) */
16374 char path[] = "/new";
16376 suppress_error = 0;
16377 r = guestfs_touch (g, path);
16382 char path[] = "/new";
16384 suppress_error = 1;
16385 r = guestfs_mkdir_p (g, path);
16392 static int test_mkdir_0_skip (void)
16396 str = getenv ("TEST_ONLY");
16398 return strstr (str, "mkdir") == NULL;
16399 str = getenv ("SKIP_TEST_MKDIR_0");
16400 if (str && strcmp (str, "1") == 0) return 1;
16401 str = getenv ("SKIP_TEST_MKDIR");
16402 if (str && strcmp (str, "1") == 0) return 1;
16406 static int test_mkdir_0 (void)
16408 if (test_mkdir_0_skip ()) {
16409 printf (" %s skipped (reason: environment variable set)\n", "test_mkdir_0");
16413 /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
16415 char device[] = "/dev/sda";
16417 suppress_error = 0;
16418 r = guestfs_blockdev_setrw (g, device);
16424 suppress_error = 0;
16425 r = guestfs_umount_all (g);
16431 suppress_error = 0;
16432 r = guestfs_lvm_remove_all (g);
16437 char device[] = "/dev/sda";
16438 char lines_0[] = ",";
16444 suppress_error = 0;
16445 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16450 char fstype[] = "ext2";
16451 char device[] = "/dev/sda1";
16453 suppress_error = 0;
16454 r = guestfs_mkfs (g, fstype, device);
16459 char device[] = "/dev/sda1";
16460 char mountpoint[] = "/";
16462 suppress_error = 0;
16463 r = guestfs_mount (g, device, mountpoint);
16467 /* TestOutputTrue for mkdir (0) */
16469 char path[] = "/new";
16471 suppress_error = 0;
16472 r = guestfs_mkdir (g, path);
16477 char path[] = "/new";
16479 suppress_error = 0;
16480 r = guestfs_is_dir (g, path);
16484 fprintf (stderr, "test_mkdir_0: expected true, got false\n");
16491 static int test_mkdir_1_skip (void)
16495 str = getenv ("TEST_ONLY");
16497 return strstr (str, "mkdir") == NULL;
16498 str = getenv ("SKIP_TEST_MKDIR_1");
16499 if (str && strcmp (str, "1") == 0) return 1;
16500 str = getenv ("SKIP_TEST_MKDIR");
16501 if (str && strcmp (str, "1") == 0) return 1;
16505 static int test_mkdir_1 (void)
16507 if (test_mkdir_1_skip ()) {
16508 printf (" %s skipped (reason: environment variable set)\n", "test_mkdir_1");
16512 /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
16514 char device[] = "/dev/sda";
16516 suppress_error = 0;
16517 r = guestfs_blockdev_setrw (g, device);
16523 suppress_error = 0;
16524 r = guestfs_umount_all (g);
16530 suppress_error = 0;
16531 r = guestfs_lvm_remove_all (g);
16536 char device[] = "/dev/sda";
16537 char lines_0[] = ",";
16543 suppress_error = 0;
16544 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16549 char fstype[] = "ext2";
16550 char device[] = "/dev/sda1";
16552 suppress_error = 0;
16553 r = guestfs_mkfs (g, fstype, device);
16558 char device[] = "/dev/sda1";
16559 char mountpoint[] = "/";
16561 suppress_error = 0;
16562 r = guestfs_mount (g, device, mountpoint);
16566 /* TestLastFail for mkdir (1) */
16568 char path[] = "/new/foo/bar";
16570 suppress_error = 1;
16571 r = guestfs_mkdir (g, path);
16578 static int test_rm_rf_0_skip (void)
16582 str = getenv ("TEST_ONLY");
16584 return strstr (str, "rm_rf") == NULL;
16585 str = getenv ("SKIP_TEST_RM_RF_0");
16586 if (str && strcmp (str, "1") == 0) return 1;
16587 str = getenv ("SKIP_TEST_RM_RF");
16588 if (str && strcmp (str, "1") == 0) return 1;
16592 static int test_rm_rf_0 (void)
16594 if (test_rm_rf_0_skip ()) {
16595 printf (" %s skipped (reason: environment variable set)\n", "test_rm_rf_0");
16599 /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
16601 char device[] = "/dev/sda";
16603 suppress_error = 0;
16604 r = guestfs_blockdev_setrw (g, device);
16610 suppress_error = 0;
16611 r = guestfs_umount_all (g);
16617 suppress_error = 0;
16618 r = guestfs_lvm_remove_all (g);
16623 char device[] = "/dev/sda";
16624 char lines_0[] = ",";
16630 suppress_error = 0;
16631 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16636 char fstype[] = "ext2";
16637 char device[] = "/dev/sda1";
16639 suppress_error = 0;
16640 r = guestfs_mkfs (g, fstype, device);
16645 char device[] = "/dev/sda1";
16646 char mountpoint[] = "/";
16648 suppress_error = 0;
16649 r = guestfs_mount (g, device, mountpoint);
16653 /* TestOutputFalse for rm_rf (0) */
16655 char path[] = "/new";
16657 suppress_error = 0;
16658 r = guestfs_mkdir (g, path);
16663 char path[] = "/new/foo";
16665 suppress_error = 0;
16666 r = guestfs_mkdir (g, path);
16671 char path[] = "/new/foo/bar";
16673 suppress_error = 0;
16674 r = guestfs_touch (g, path);
16679 char path[] = "/new";
16681 suppress_error = 0;
16682 r = guestfs_rm_rf (g, path);
16687 char path[] = "/new";
16689 suppress_error = 0;
16690 r = guestfs_exists (g, path);
16694 fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
16701 static int test_rmdir_0_skip (void)
16705 str = getenv ("TEST_ONLY");
16707 return strstr (str, "rmdir") == NULL;
16708 str = getenv ("SKIP_TEST_RMDIR_0");
16709 if (str && strcmp (str, "1") == 0) return 1;
16710 str = getenv ("SKIP_TEST_RMDIR");
16711 if (str && strcmp (str, "1") == 0) return 1;
16715 static int test_rmdir_0 (void)
16717 if (test_rmdir_0_skip ()) {
16718 printf (" %s skipped (reason: environment variable set)\n", "test_rmdir_0");
16722 /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
16724 char device[] = "/dev/sda";
16726 suppress_error = 0;
16727 r = guestfs_blockdev_setrw (g, device);
16733 suppress_error = 0;
16734 r = guestfs_umount_all (g);
16740 suppress_error = 0;
16741 r = guestfs_lvm_remove_all (g);
16746 char device[] = "/dev/sda";
16747 char lines_0[] = ",";
16753 suppress_error = 0;
16754 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16759 char fstype[] = "ext2";
16760 char device[] = "/dev/sda1";
16762 suppress_error = 0;
16763 r = guestfs_mkfs (g, fstype, device);
16768 char device[] = "/dev/sda1";
16769 char mountpoint[] = "/";
16771 suppress_error = 0;
16772 r = guestfs_mount (g, device, mountpoint);
16776 /* TestRun for rmdir (0) */
16778 char path[] = "/new";
16780 suppress_error = 0;
16781 r = guestfs_mkdir (g, path);
16786 char path[] = "/new";
16788 suppress_error = 0;
16789 r = guestfs_rmdir (g, path);
16796 static int test_rmdir_1_skip (void)
16800 str = getenv ("TEST_ONLY");
16802 return strstr (str, "rmdir") == NULL;
16803 str = getenv ("SKIP_TEST_RMDIR_1");
16804 if (str && strcmp (str, "1") == 0) return 1;
16805 str = getenv ("SKIP_TEST_RMDIR");
16806 if (str && strcmp (str, "1") == 0) return 1;
16810 static int test_rmdir_1 (void)
16812 if (test_rmdir_1_skip ()) {
16813 printf (" %s skipped (reason: environment variable set)\n", "test_rmdir_1");
16817 /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
16819 char device[] = "/dev/sda";
16821 suppress_error = 0;
16822 r = guestfs_blockdev_setrw (g, device);
16828 suppress_error = 0;
16829 r = guestfs_umount_all (g);
16835 suppress_error = 0;
16836 r = guestfs_lvm_remove_all (g);
16841 char device[] = "/dev/sda";
16842 char lines_0[] = ",";
16848 suppress_error = 0;
16849 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16854 char fstype[] = "ext2";
16855 char device[] = "/dev/sda1";
16857 suppress_error = 0;
16858 r = guestfs_mkfs (g, fstype, device);
16863 char device[] = "/dev/sda1";
16864 char mountpoint[] = "/";
16866 suppress_error = 0;
16867 r = guestfs_mount (g, device, mountpoint);
16871 /* TestLastFail for rmdir (1) */
16873 char path[] = "/new";
16875 suppress_error = 1;
16876 r = guestfs_rmdir (g, path);
16883 static int test_rmdir_2_skip (void)
16887 str = getenv ("TEST_ONLY");
16889 return strstr (str, "rmdir") == NULL;
16890 str = getenv ("SKIP_TEST_RMDIR_2");
16891 if (str && strcmp (str, "1") == 0) return 1;
16892 str = getenv ("SKIP_TEST_RMDIR");
16893 if (str && strcmp (str, "1") == 0) return 1;
16897 static int test_rmdir_2 (void)
16899 if (test_rmdir_2_skip ()) {
16900 printf (" %s skipped (reason: environment variable set)\n", "test_rmdir_2");
16904 /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
16906 char device[] = "/dev/sda";
16908 suppress_error = 0;
16909 r = guestfs_blockdev_setrw (g, device);
16915 suppress_error = 0;
16916 r = guestfs_umount_all (g);
16922 suppress_error = 0;
16923 r = guestfs_lvm_remove_all (g);
16928 char device[] = "/dev/sda";
16929 char lines_0[] = ",";
16935 suppress_error = 0;
16936 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16941 char fstype[] = "ext2";
16942 char device[] = "/dev/sda1";
16944 suppress_error = 0;
16945 r = guestfs_mkfs (g, fstype, device);
16950 char device[] = "/dev/sda1";
16951 char mountpoint[] = "/";
16953 suppress_error = 0;
16954 r = guestfs_mount (g, device, mountpoint);
16958 /* TestLastFail for rmdir (2) */
16960 char path[] = "/new";
16962 suppress_error = 0;
16963 r = guestfs_touch (g, path);
16968 char path[] = "/new";
16970 suppress_error = 1;
16971 r = guestfs_rmdir (g, path);
16978 static int test_rm_0_skip (void)
16982 str = getenv ("TEST_ONLY");
16984 return strstr (str, "rm") == NULL;
16985 str = getenv ("SKIP_TEST_RM_0");
16986 if (str && strcmp (str, "1") == 0) return 1;
16987 str = getenv ("SKIP_TEST_RM");
16988 if (str && strcmp (str, "1") == 0) return 1;
16992 static int test_rm_0 (void)
16994 if (test_rm_0_skip ()) {
16995 printf (" %s skipped (reason: environment variable set)\n", "test_rm_0");
16999 /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
17001 char device[] = "/dev/sda";
17003 suppress_error = 0;
17004 r = guestfs_blockdev_setrw (g, device);
17010 suppress_error = 0;
17011 r = guestfs_umount_all (g);
17017 suppress_error = 0;
17018 r = guestfs_lvm_remove_all (g);
17023 char device[] = "/dev/sda";
17024 char lines_0[] = ",";
17030 suppress_error = 0;
17031 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17036 char fstype[] = "ext2";
17037 char device[] = "/dev/sda1";
17039 suppress_error = 0;
17040 r = guestfs_mkfs (g, fstype, device);
17045 char device[] = "/dev/sda1";
17046 char mountpoint[] = "/";
17048 suppress_error = 0;
17049 r = guestfs_mount (g, device, mountpoint);
17053 /* TestRun for rm (0) */
17055 char path[] = "/new";
17057 suppress_error = 0;
17058 r = guestfs_touch (g, path);
17063 char path[] = "/new";
17065 suppress_error = 0;
17066 r = guestfs_rm (g, path);
17073 static int test_rm_1_skip (void)
17077 str = getenv ("TEST_ONLY");
17079 return strstr (str, "rm") == NULL;
17080 str = getenv ("SKIP_TEST_RM_1");
17081 if (str && strcmp (str, "1") == 0) return 1;
17082 str = getenv ("SKIP_TEST_RM");
17083 if (str && strcmp (str, "1") == 0) return 1;
17087 static int test_rm_1 (void)
17089 if (test_rm_1_skip ()) {
17090 printf (" %s skipped (reason: environment variable set)\n", "test_rm_1");
17094 /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
17096 char device[] = "/dev/sda";
17098 suppress_error = 0;
17099 r = guestfs_blockdev_setrw (g, device);
17105 suppress_error = 0;
17106 r = guestfs_umount_all (g);
17112 suppress_error = 0;
17113 r = guestfs_lvm_remove_all (g);
17118 char device[] = "/dev/sda";
17119 char lines_0[] = ",";
17125 suppress_error = 0;
17126 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17131 char fstype[] = "ext2";
17132 char device[] = "/dev/sda1";
17134 suppress_error = 0;
17135 r = guestfs_mkfs (g, fstype, device);
17140 char device[] = "/dev/sda1";
17141 char mountpoint[] = "/";
17143 suppress_error = 0;
17144 r = guestfs_mount (g, device, mountpoint);
17148 /* TestLastFail for rm (1) */
17150 char path[] = "/new";
17152 suppress_error = 1;
17153 r = guestfs_rm (g, path);
17160 static int test_rm_2_skip (void)
17164 str = getenv ("TEST_ONLY");
17166 return strstr (str, "rm") == NULL;
17167 str = getenv ("SKIP_TEST_RM_2");
17168 if (str && strcmp (str, "1") == 0) return 1;
17169 str = getenv ("SKIP_TEST_RM");
17170 if (str && strcmp (str, "1") == 0) return 1;
17174 static int test_rm_2 (void)
17176 if (test_rm_2_skip ()) {
17177 printf (" %s skipped (reason: environment variable set)\n", "test_rm_2");
17181 /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
17183 char device[] = "/dev/sda";
17185 suppress_error = 0;
17186 r = guestfs_blockdev_setrw (g, device);
17192 suppress_error = 0;
17193 r = guestfs_umount_all (g);
17199 suppress_error = 0;
17200 r = guestfs_lvm_remove_all (g);
17205 char device[] = "/dev/sda";
17206 char lines_0[] = ",";
17212 suppress_error = 0;
17213 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17218 char fstype[] = "ext2";
17219 char device[] = "/dev/sda1";
17221 suppress_error = 0;
17222 r = guestfs_mkfs (g, fstype, device);
17227 char device[] = "/dev/sda1";
17228 char mountpoint[] = "/";
17230 suppress_error = 0;
17231 r = guestfs_mount (g, device, mountpoint);
17235 /* TestLastFail for rm (2) */
17237 char path[] = "/new";
17239 suppress_error = 0;
17240 r = guestfs_mkdir (g, path);
17245 char path[] = "/new";
17247 suppress_error = 1;
17248 r = guestfs_rm (g, path);
17255 static int test_read_lines_0_skip (void)
17259 str = getenv ("TEST_ONLY");
17261 return strstr (str, "read_lines") == NULL;
17262 str = getenv ("SKIP_TEST_READ_LINES_0");
17263 if (str && strcmp (str, "1") == 0) return 1;
17264 str = getenv ("SKIP_TEST_READ_LINES");
17265 if (str && strcmp (str, "1") == 0) return 1;
17269 static int test_read_lines_0 (void)
17271 if (test_read_lines_0_skip ()) {
17272 printf (" %s skipped (reason: environment variable set)\n", "test_read_lines_0");
17276 /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
17278 char device[] = "/dev/sda";
17280 suppress_error = 0;
17281 r = guestfs_blockdev_setrw (g, device);
17287 suppress_error = 0;
17288 r = guestfs_umount_all (g);
17294 suppress_error = 0;
17295 r = guestfs_lvm_remove_all (g);
17300 char device[] = "/dev/sda";
17301 char lines_0[] = ",";
17307 suppress_error = 0;
17308 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17313 char fstype[] = "ext2";
17314 char device[] = "/dev/sda1";
17316 suppress_error = 0;
17317 r = guestfs_mkfs (g, fstype, device);
17322 char device[] = "/dev/sda1";
17323 char mountpoint[] = "/";
17325 suppress_error = 0;
17326 r = guestfs_mount (g, device, mountpoint);
17330 /* TestOutputList for read_lines (0) */
17332 char path[] = "/new";
17333 char content[] = "line1\r\nline2\nline3";
17335 suppress_error = 0;
17336 r = guestfs_write_file (g, path, content, 0);
17341 char path[] = "/new";
17344 suppress_error = 0;
17345 r = guestfs_read_lines (g, path);
17349 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
17354 char expected[] = "line1";
17355 if (strcmp (r[0], expected) != 0) {
17356 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17361 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
17366 char expected[] = "line2";
17367 if (strcmp (r[1], expected) != 0) {
17368 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17373 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
17378 char expected[] = "line3";
17379 if (strcmp (r[2], expected) != 0) {
17380 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17384 if (r[3] != NULL) {
17385 fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
17389 for (i = 0; r[i] != NULL; ++i)
17396 static int test_read_lines_1_skip (void)
17400 str = getenv ("TEST_ONLY");
17402 return strstr (str, "read_lines") == NULL;
17403 str = getenv ("SKIP_TEST_READ_LINES_1");
17404 if (str && strcmp (str, "1") == 0) return 1;
17405 str = getenv ("SKIP_TEST_READ_LINES");
17406 if (str && strcmp (str, "1") == 0) return 1;
17410 static int test_read_lines_1 (void)
17412 if (test_read_lines_1_skip ()) {
17413 printf (" %s skipped (reason: environment variable set)\n", "test_read_lines_1");
17417 /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
17419 char device[] = "/dev/sda";
17421 suppress_error = 0;
17422 r = guestfs_blockdev_setrw (g, device);
17428 suppress_error = 0;
17429 r = guestfs_umount_all (g);
17435 suppress_error = 0;
17436 r = guestfs_lvm_remove_all (g);
17441 char device[] = "/dev/sda";
17442 char lines_0[] = ",";
17448 suppress_error = 0;
17449 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17454 char fstype[] = "ext2";
17455 char device[] = "/dev/sda1";
17457 suppress_error = 0;
17458 r = guestfs_mkfs (g, fstype, device);
17463 char device[] = "/dev/sda1";
17464 char mountpoint[] = "/";
17466 suppress_error = 0;
17467 r = guestfs_mount (g, device, mountpoint);
17471 /* TestOutputList for read_lines (1) */
17473 char path[] = "/new";
17474 char content[] = "";
17476 suppress_error = 0;
17477 r = guestfs_write_file (g, path, content, 0);
17482 char path[] = "/new";
17485 suppress_error = 0;
17486 r = guestfs_read_lines (g, path);
17489 if (r[0] != NULL) {
17490 fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
17494 for (i = 0; r[i] != NULL; ++i)
17501 static int test_lvs_0_skip (void)
17505 str = getenv ("TEST_ONLY");
17507 return strstr (str, "lvs") == NULL;
17508 str = getenv ("SKIP_TEST_LVS_0");
17509 if (str && strcmp (str, "1") == 0) return 1;
17510 str = getenv ("SKIP_TEST_LVS");
17511 if (str && strcmp (str, "1") == 0) return 1;
17515 static int test_lvs_0 (void)
17517 if (test_lvs_0_skip ()) {
17518 printf (" %s skipped (reason: environment variable set)\n", "test_lvs_0");
17522 /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
17524 char device[] = "/dev/sda";
17526 suppress_error = 0;
17527 r = guestfs_blockdev_setrw (g, device);
17533 suppress_error = 0;
17534 r = guestfs_umount_all (g);
17540 suppress_error = 0;
17541 r = guestfs_lvm_remove_all (g);
17546 char device[] = "/dev/sda";
17547 char lines_0[] = ",";
17553 suppress_error = 0;
17554 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17559 char device[] = "/dev/sda1";
17561 suppress_error = 0;
17562 r = guestfs_pvcreate (g, device);
17567 char volgroup[] = "VG";
17568 char physvols_0[] = "/dev/sda1";
17569 char *physvols[] = {
17574 suppress_error = 0;
17575 r = guestfs_vgcreate (g, volgroup, physvols);
17580 char logvol[] = "LV";
17581 char volgroup[] = "VG";
17583 suppress_error = 0;
17584 r = guestfs_lvcreate (g, logvol, volgroup, 8);
17589 char fstype[] = "ext2";
17590 char device[] = "/dev/VG/LV";
17592 suppress_error = 0;
17593 r = guestfs_mkfs (g, fstype, device);
17598 char device[] = "/dev/VG/LV";
17599 char mountpoint[] = "/";
17601 suppress_error = 0;
17602 r = guestfs_mount (g, device, mountpoint);
17606 /* TestOutputList for lvs (0) */
17610 suppress_error = 0;
17611 r = guestfs_lvs (g);
17615 fprintf (stderr, "test_lvs_0: short list returned from command\n");
17620 char expected[] = "/dev/VG/LV";
17621 if (strcmp (r[0], expected) != 0) {
17622 fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17626 if (r[1] != NULL) {
17627 fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
17631 for (i = 0; r[i] != NULL; ++i)
17638 static int test_lvs_1_skip (void)
17642 str = getenv ("TEST_ONLY");
17644 return strstr (str, "lvs") == NULL;
17645 str = getenv ("SKIP_TEST_LVS_1");
17646 if (str && strcmp (str, "1") == 0) return 1;
17647 str = getenv ("SKIP_TEST_LVS");
17648 if (str && strcmp (str, "1") == 0) return 1;
17652 static int test_lvs_1 (void)
17654 if (test_lvs_1_skip ()) {
17655 printf (" %s skipped (reason: environment variable set)\n", "test_lvs_1");
17659 /* InitNone|InitEmpty for test_lvs_1 */
17661 char device[] = "/dev/sda";
17663 suppress_error = 0;
17664 r = guestfs_blockdev_setrw (g, device);
17670 suppress_error = 0;
17671 r = guestfs_umount_all (g);
17677 suppress_error = 0;
17678 r = guestfs_lvm_remove_all (g);
17682 /* TestOutputList for lvs (1) */
17684 char device[] = "/dev/sda";
17685 char lines_0[] = ",200";
17686 char lines_1[] = ",400";
17687 char lines_2[] = ",";
17695 suppress_error = 0;
17696 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17701 char device[] = "/dev/sda1";
17703 suppress_error = 0;
17704 r = guestfs_pvcreate (g, device);
17709 char device[] = "/dev/sda2";
17711 suppress_error = 0;
17712 r = guestfs_pvcreate (g, device);
17717 char device[] = "/dev/sda3";
17719 suppress_error = 0;
17720 r = guestfs_pvcreate (g, device);
17725 char volgroup[] = "VG1";
17726 char physvols_0[] = "/dev/sda1";
17727 char physvols_1[] = "/dev/sda2";
17728 char *physvols[] = {
17734 suppress_error = 0;
17735 r = guestfs_vgcreate (g, volgroup, physvols);
17740 char volgroup[] = "VG2";
17741 char physvols_0[] = "/dev/sda3";
17742 char *physvols[] = {
17747 suppress_error = 0;
17748 r = guestfs_vgcreate (g, volgroup, physvols);
17753 char logvol[] = "LV1";
17754 char volgroup[] = "VG1";
17756 suppress_error = 0;
17757 r = guestfs_lvcreate (g, logvol, volgroup, 50);
17762 char logvol[] = "LV2";
17763 char volgroup[] = "VG1";
17765 suppress_error = 0;
17766 r = guestfs_lvcreate (g, logvol, volgroup, 50);
17771 char logvol[] = "LV3";
17772 char volgroup[] = "VG2";
17774 suppress_error = 0;
17775 r = guestfs_lvcreate (g, logvol, volgroup, 50);
17782 suppress_error = 0;
17783 r = guestfs_lvs (g);
17787 fprintf (stderr, "test_lvs_1: short list returned from command\n");
17792 char expected[] = "/dev/VG1/LV1";
17793 if (strcmp (r[0], expected) != 0) {
17794 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17799 fprintf (stderr, "test_lvs_1: short list returned from command\n");
17804 char expected[] = "/dev/VG1/LV2";
17805 if (strcmp (r[1], expected) != 0) {
17806 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17811 fprintf (stderr, "test_lvs_1: short list returned from command\n");
17816 char expected[] = "/dev/VG2/LV3";
17817 if (strcmp (r[2], expected) != 0) {
17818 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17822 if (r[3] != NULL) {
17823 fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
17827 for (i = 0; r[i] != NULL; ++i)
17834 static int test_vgs_0_skip (void)
17838 str = getenv ("TEST_ONLY");
17840 return strstr (str, "vgs") == NULL;
17841 str = getenv ("SKIP_TEST_VGS_0");
17842 if (str && strcmp (str, "1") == 0) return 1;
17843 str = getenv ("SKIP_TEST_VGS");
17844 if (str && strcmp (str, "1") == 0) return 1;
17848 static int test_vgs_0 (void)
17850 if (test_vgs_0_skip ()) {
17851 printf (" %s skipped (reason: environment variable set)\n", "test_vgs_0");
17855 /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
17857 char device[] = "/dev/sda";
17859 suppress_error = 0;
17860 r = guestfs_blockdev_setrw (g, device);
17866 suppress_error = 0;
17867 r = guestfs_umount_all (g);
17873 suppress_error = 0;
17874 r = guestfs_lvm_remove_all (g);
17879 char device[] = "/dev/sda";
17880 char lines_0[] = ",";
17886 suppress_error = 0;
17887 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17892 char device[] = "/dev/sda1";
17894 suppress_error = 0;
17895 r = guestfs_pvcreate (g, device);
17900 char volgroup[] = "VG";
17901 char physvols_0[] = "/dev/sda1";
17902 char *physvols[] = {
17907 suppress_error = 0;
17908 r = guestfs_vgcreate (g, volgroup, physvols);
17913 char logvol[] = "LV";
17914 char volgroup[] = "VG";
17916 suppress_error = 0;
17917 r = guestfs_lvcreate (g, logvol, volgroup, 8);
17922 char fstype[] = "ext2";
17923 char device[] = "/dev/VG/LV";
17925 suppress_error = 0;
17926 r = guestfs_mkfs (g, fstype, device);
17931 char device[] = "/dev/VG/LV";
17932 char mountpoint[] = "/";
17934 suppress_error = 0;
17935 r = guestfs_mount (g, device, mountpoint);
17939 /* TestOutputList for vgs (0) */
17943 suppress_error = 0;
17944 r = guestfs_vgs (g);
17948 fprintf (stderr, "test_vgs_0: short list returned from command\n");
17953 char expected[] = "VG";
17954 if (strcmp (r[0], expected) != 0) {
17955 fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17959 if (r[1] != NULL) {
17960 fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
17964 for (i = 0; r[i] != NULL; ++i)
17971 static int test_vgs_1_skip (void)
17975 str = getenv ("TEST_ONLY");
17977 return strstr (str, "vgs") == NULL;
17978 str = getenv ("SKIP_TEST_VGS_1");
17979 if (str && strcmp (str, "1") == 0) return 1;
17980 str = getenv ("SKIP_TEST_VGS");
17981 if (str && strcmp (str, "1") == 0) return 1;
17985 static int test_vgs_1 (void)
17987 if (test_vgs_1_skip ()) {
17988 printf (" %s skipped (reason: environment variable set)\n", "test_vgs_1");
17992 /* InitNone|InitEmpty for test_vgs_1 */
17994 char device[] = "/dev/sda";
17996 suppress_error = 0;
17997 r = guestfs_blockdev_setrw (g, device);
18003 suppress_error = 0;
18004 r = guestfs_umount_all (g);
18010 suppress_error = 0;
18011 r = guestfs_lvm_remove_all (g);
18015 /* TestOutputList for vgs (1) */
18017 char device[] = "/dev/sda";
18018 char lines_0[] = ",200";
18019 char lines_1[] = ",400";
18020 char lines_2[] = ",";
18028 suppress_error = 0;
18029 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18034 char device[] = "/dev/sda1";
18036 suppress_error = 0;
18037 r = guestfs_pvcreate (g, device);
18042 char device[] = "/dev/sda2";
18044 suppress_error = 0;
18045 r = guestfs_pvcreate (g, device);
18050 char device[] = "/dev/sda3";
18052 suppress_error = 0;
18053 r = guestfs_pvcreate (g, device);
18058 char volgroup[] = "VG1";
18059 char physvols_0[] = "/dev/sda1";
18060 char physvols_1[] = "/dev/sda2";
18061 char *physvols[] = {
18067 suppress_error = 0;
18068 r = guestfs_vgcreate (g, volgroup, physvols);
18073 char volgroup[] = "VG2";
18074 char physvols_0[] = "/dev/sda3";
18075 char *physvols[] = {
18080 suppress_error = 0;
18081 r = guestfs_vgcreate (g, volgroup, physvols);
18088 suppress_error = 0;
18089 r = guestfs_vgs (g);
18093 fprintf (stderr, "test_vgs_1: short list returned from command\n");
18098 char expected[] = "VG1";
18099 if (strcmp (r[0], expected) != 0) {
18100 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18105 fprintf (stderr, "test_vgs_1: short list returned from command\n");
18110 char expected[] = "VG2";
18111 if (strcmp (r[1], expected) != 0) {
18112 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18116 if (r[2] != NULL) {
18117 fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
18121 for (i = 0; r[i] != NULL; ++i)
18128 static int test_pvs_0_skip (void)
18132 str = getenv ("TEST_ONLY");
18134 return strstr (str, "pvs") == NULL;
18135 str = getenv ("SKIP_TEST_PVS_0");
18136 if (str && strcmp (str, "1") == 0) return 1;
18137 str = getenv ("SKIP_TEST_PVS");
18138 if (str && strcmp (str, "1") == 0) return 1;
18142 static int test_pvs_0 (void)
18144 if (test_pvs_0_skip ()) {
18145 printf (" %s skipped (reason: environment variable set)\n", "test_pvs_0");
18149 /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
18151 char device[] = "/dev/sda";
18153 suppress_error = 0;
18154 r = guestfs_blockdev_setrw (g, device);
18160 suppress_error = 0;
18161 r = guestfs_umount_all (g);
18167 suppress_error = 0;
18168 r = guestfs_lvm_remove_all (g);
18173 char device[] = "/dev/sda";
18174 char lines_0[] = ",";
18180 suppress_error = 0;
18181 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18186 char device[] = "/dev/sda1";
18188 suppress_error = 0;
18189 r = guestfs_pvcreate (g, device);
18194 char volgroup[] = "VG";
18195 char physvols_0[] = "/dev/sda1";
18196 char *physvols[] = {
18201 suppress_error = 0;
18202 r = guestfs_vgcreate (g, volgroup, physvols);
18207 char logvol[] = "LV";
18208 char volgroup[] = "VG";
18210 suppress_error = 0;
18211 r = guestfs_lvcreate (g, logvol, volgroup, 8);
18216 char fstype[] = "ext2";
18217 char device[] = "/dev/VG/LV";
18219 suppress_error = 0;
18220 r = guestfs_mkfs (g, fstype, device);
18225 char device[] = "/dev/VG/LV";
18226 char mountpoint[] = "/";
18228 suppress_error = 0;
18229 r = guestfs_mount (g, device, mountpoint);
18233 /* TestOutputListOfDevices for pvs (0) */
18237 suppress_error = 0;
18238 r = guestfs_pvs (g);
18242 fprintf (stderr, "test_pvs_0: short list returned from command\n");
18247 char expected[] = "/dev/sda1";
18249 if (strcmp (r[0], expected) != 0) {
18250 fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18254 if (r[1] != NULL) {
18255 fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
18259 for (i = 0; r[i] != NULL; ++i)
18266 static int test_pvs_1_skip (void)
18270 str = getenv ("TEST_ONLY");
18272 return strstr (str, "pvs") == NULL;
18273 str = getenv ("SKIP_TEST_PVS_1");
18274 if (str && strcmp (str, "1") == 0) return 1;
18275 str = getenv ("SKIP_TEST_PVS");
18276 if (str && strcmp (str, "1") == 0) return 1;
18280 static int test_pvs_1 (void)
18282 if (test_pvs_1_skip ()) {
18283 printf (" %s skipped (reason: environment variable set)\n", "test_pvs_1");
18287 /* InitNone|InitEmpty for test_pvs_1 */
18289 char device[] = "/dev/sda";
18291 suppress_error = 0;
18292 r = guestfs_blockdev_setrw (g, device);
18298 suppress_error = 0;
18299 r = guestfs_umount_all (g);
18305 suppress_error = 0;
18306 r = guestfs_lvm_remove_all (g);
18310 /* TestOutputListOfDevices for pvs (1) */
18312 char device[] = "/dev/sda";
18313 char lines_0[] = ",200";
18314 char lines_1[] = ",400";
18315 char lines_2[] = ",";
18323 suppress_error = 0;
18324 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18329 char device[] = "/dev/sda1";
18331 suppress_error = 0;
18332 r = guestfs_pvcreate (g, device);
18337 char device[] = "/dev/sda2";
18339 suppress_error = 0;
18340 r = guestfs_pvcreate (g, device);
18345 char device[] = "/dev/sda3";
18347 suppress_error = 0;
18348 r = guestfs_pvcreate (g, device);
18355 suppress_error = 0;
18356 r = guestfs_pvs (g);
18360 fprintf (stderr, "test_pvs_1: short list returned from command\n");
18365 char expected[] = "/dev/sda1";
18367 if (strcmp (r[0], expected) != 0) {
18368 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18373 fprintf (stderr, "test_pvs_1: short list returned from command\n");
18378 char expected[] = "/dev/sda2";
18380 if (strcmp (r[1], expected) != 0) {
18381 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18386 fprintf (stderr, "test_pvs_1: short list returned from command\n");
18391 char expected[] = "/dev/sda3";
18393 if (strcmp (r[2], expected) != 0) {
18394 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18398 if (r[3] != NULL) {
18399 fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
18403 for (i = 0; r[i] != NULL; ++i)
18410 static int test_list_partitions_0_skip (void)
18414 str = getenv ("TEST_ONLY");
18416 return strstr (str, "list_partitions") == NULL;
18417 str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
18418 if (str && strcmp (str, "1") == 0) return 1;
18419 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
18420 if (str && strcmp (str, "1") == 0) return 1;
18424 static int test_list_partitions_0 (void)
18426 if (test_list_partitions_0_skip ()) {
18427 printf (" %s skipped (reason: environment variable set)\n", "test_list_partitions_0");
18431 /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
18433 char device[] = "/dev/sda";
18435 suppress_error = 0;
18436 r = guestfs_blockdev_setrw (g, device);
18442 suppress_error = 0;
18443 r = guestfs_umount_all (g);
18449 suppress_error = 0;
18450 r = guestfs_lvm_remove_all (g);
18455 char device[] = "/dev/sda";
18456 char lines_0[] = ",";
18462 suppress_error = 0;
18463 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18468 char fstype[] = "ext2";
18469 char device[] = "/dev/sda1";
18471 suppress_error = 0;
18472 r = guestfs_mkfs (g, fstype, device);
18477 char device[] = "/dev/sda1";
18478 char mountpoint[] = "/";
18480 suppress_error = 0;
18481 r = guestfs_mount (g, device, mountpoint);
18485 /* TestOutputListOfDevices for list_partitions (0) */
18489 suppress_error = 0;
18490 r = guestfs_list_partitions (g);
18494 fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
18499 char expected[] = "/dev/sda1";
18501 if (strcmp (r[0], expected) != 0) {
18502 fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18506 if (r[1] != NULL) {
18507 fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
18511 for (i = 0; r[i] != NULL; ++i)
18518 static int test_list_partitions_1_skip (void)
18522 str = getenv ("TEST_ONLY");
18524 return strstr (str, "list_partitions") == NULL;
18525 str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
18526 if (str && strcmp (str, "1") == 0) return 1;
18527 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
18528 if (str && strcmp (str, "1") == 0) return 1;
18532 static int test_list_partitions_1 (void)
18534 if (test_list_partitions_1_skip ()) {
18535 printf (" %s skipped (reason: environment variable set)\n", "test_list_partitions_1");
18539 /* InitNone|InitEmpty for test_list_partitions_1 */
18541 char device[] = "/dev/sda";
18543 suppress_error = 0;
18544 r = guestfs_blockdev_setrw (g, device);
18550 suppress_error = 0;
18551 r = guestfs_umount_all (g);
18557 suppress_error = 0;
18558 r = guestfs_lvm_remove_all (g);
18562 /* TestOutputListOfDevices for list_partitions (1) */
18564 char device[] = "/dev/sda";
18565 char lines_0[] = ",200";
18566 char lines_1[] = ",400";
18567 char lines_2[] = ",";
18575 suppress_error = 0;
18576 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18583 suppress_error = 0;
18584 r = guestfs_list_partitions (g);
18588 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
18593 char expected[] = "/dev/sda1";
18595 if (strcmp (r[0], expected) != 0) {
18596 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18601 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
18606 char expected[] = "/dev/sda2";
18608 if (strcmp (r[1], expected) != 0) {
18609 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18614 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
18619 char expected[] = "/dev/sda3";
18621 if (strcmp (r[2], expected) != 0) {
18622 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18626 if (r[3] != NULL) {
18627 fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
18631 for (i = 0; r[i] != NULL; ++i)
18638 static int test_list_devices_0_skip (void)
18642 str = getenv ("TEST_ONLY");
18644 return strstr (str, "list_devices") == NULL;
18645 str = getenv ("SKIP_TEST_LIST_DEVICES_0");
18646 if (str && strcmp (str, "1") == 0) return 1;
18647 str = getenv ("SKIP_TEST_LIST_DEVICES");
18648 if (str && strcmp (str, "1") == 0) return 1;
18652 static int test_list_devices_0 (void)
18654 if (test_list_devices_0_skip ()) {
18655 printf (" %s skipped (reason: environment variable set)\n", "test_list_devices_0");
18659 /* InitNone|InitEmpty for test_list_devices_0 */
18661 char device[] = "/dev/sda";
18663 suppress_error = 0;
18664 r = guestfs_blockdev_setrw (g, device);
18670 suppress_error = 0;
18671 r = guestfs_umount_all (g);
18677 suppress_error = 0;
18678 r = guestfs_lvm_remove_all (g);
18682 /* TestOutputListOfDevices for list_devices (0) */
18686 suppress_error = 0;
18687 r = guestfs_list_devices (g);
18691 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18696 char expected[] = "/dev/sda";
18698 if (strcmp (r[0], expected) != 0) {
18699 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18704 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18709 char expected[] = "/dev/sdb";
18711 if (strcmp (r[1], expected) != 0) {
18712 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18717 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18722 char expected[] = "/dev/sdc";
18724 if (strcmp (r[2], expected) != 0) {
18725 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18730 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18735 char expected[] = "/dev/sdd";
18737 if (strcmp (r[3], expected) != 0) {
18738 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
18742 if (r[4] != NULL) {
18743 fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
18747 for (i = 0; r[i] != NULL; ++i)
18754 static int test_ls_0_skip (void)
18758 str = getenv ("TEST_ONLY");
18760 return strstr (str, "ls") == NULL;
18761 str = getenv ("SKIP_TEST_LS_0");
18762 if (str && strcmp (str, "1") == 0) return 1;
18763 str = getenv ("SKIP_TEST_LS");
18764 if (str && strcmp (str, "1") == 0) return 1;
18768 static int test_ls_0 (void)
18770 if (test_ls_0_skip ()) {
18771 printf (" %s skipped (reason: environment variable set)\n", "test_ls_0");
18775 /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
18777 char device[] = "/dev/sda";
18779 suppress_error = 0;
18780 r = guestfs_blockdev_setrw (g, device);
18786 suppress_error = 0;
18787 r = guestfs_umount_all (g);
18793 suppress_error = 0;
18794 r = guestfs_lvm_remove_all (g);
18799 char device[] = "/dev/sda";
18800 char lines_0[] = ",";
18806 suppress_error = 0;
18807 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18812 char fstype[] = "ext2";
18813 char device[] = "/dev/sda1";
18815 suppress_error = 0;
18816 r = guestfs_mkfs (g, fstype, device);
18821 char device[] = "/dev/sda1";
18822 char mountpoint[] = "/";
18824 suppress_error = 0;
18825 r = guestfs_mount (g, device, mountpoint);
18829 /* TestOutputList for ls (0) */
18831 char path[] = "/new";
18833 suppress_error = 0;
18834 r = guestfs_touch (g, path);
18839 char path[] = "/newer";
18841 suppress_error = 0;
18842 r = guestfs_touch (g, path);
18847 char path[] = "/newest";
18849 suppress_error = 0;
18850 r = guestfs_touch (g, path);
18855 char directory[] = "/";
18858 suppress_error = 0;
18859 r = guestfs_ls (g, directory);
18863 fprintf (stderr, "test_ls_0: short list returned from command\n");
18868 char expected[] = "lost+found";
18869 if (strcmp (r[0], expected) != 0) {
18870 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18875 fprintf (stderr, "test_ls_0: short list returned from command\n");
18880 char expected[] = "new";
18881 if (strcmp (r[1], expected) != 0) {
18882 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18887 fprintf (stderr, "test_ls_0: short list returned from command\n");
18892 char expected[] = "newer";
18893 if (strcmp (r[2], expected) != 0) {
18894 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18899 fprintf (stderr, "test_ls_0: short list returned from command\n");
18904 char expected[] = "newest";
18905 if (strcmp (r[3], expected) != 0) {
18906 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
18910 if (r[4] != NULL) {
18911 fprintf (stderr, "test_ls_0: extra elements returned from command\n");
18915 for (i = 0; r[i] != NULL; ++i)
18922 static int test_cat_0_skip (void)
18926 str = getenv ("TEST_ONLY");
18928 return strstr (str, "cat") == NULL;
18929 str = getenv ("SKIP_TEST_CAT_0");
18930 if (str && strcmp (str, "1") == 0) return 1;
18931 str = getenv ("SKIP_TEST_CAT");
18932 if (str && strcmp (str, "1") == 0) return 1;
18936 static int test_cat_0 (void)
18938 if (test_cat_0_skip ()) {
18939 printf (" %s skipped (reason: environment variable set)\n", "test_cat_0");
18943 /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
18945 char device[] = "/dev/sda";
18947 suppress_error = 0;
18948 r = guestfs_blockdev_setrw (g, device);
18954 suppress_error = 0;
18955 r = guestfs_umount_all (g);
18961 suppress_error = 0;
18962 r = guestfs_lvm_remove_all (g);
18967 char device[] = "/dev/sda";
18968 char lines_0[] = ",";
18974 suppress_error = 0;
18975 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18980 char fstype[] = "ext2";
18981 char device[] = "/dev/sda1";
18983 suppress_error = 0;
18984 r = guestfs_mkfs (g, fstype, device);
18989 char device[] = "/dev/sda1";
18990 char mountpoint[] = "/";
18992 suppress_error = 0;
18993 r = guestfs_mount (g, device, mountpoint);
18997 /* TestOutput for cat (0) */
18998 char expected[] = "new file contents";
19000 char path[] = "/new";
19001 char content[] = "new file contents";
19003 suppress_error = 0;
19004 r = guestfs_write_file (g, path, content, 0);
19009 char path[] = "/new";
19011 suppress_error = 0;
19012 r = guestfs_cat (g, path);
19015 if (strcmp (r, expected) != 0) {
19016 fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
19024 static int test_touch_0_skip (void)
19028 str = getenv ("TEST_ONLY");
19030 return strstr (str, "touch") == NULL;
19031 str = getenv ("SKIP_TEST_TOUCH_0");
19032 if (str && strcmp (str, "1") == 0) return 1;
19033 str = getenv ("SKIP_TEST_TOUCH");
19034 if (str && strcmp (str, "1") == 0) return 1;
19038 static int test_touch_0 (void)
19040 if (test_touch_0_skip ()) {
19041 printf (" %s skipped (reason: environment variable set)\n", "test_touch_0");
19045 /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
19047 char device[] = "/dev/sda";
19049 suppress_error = 0;
19050 r = guestfs_blockdev_setrw (g, device);
19056 suppress_error = 0;
19057 r = guestfs_umount_all (g);
19063 suppress_error = 0;
19064 r = guestfs_lvm_remove_all (g);
19069 char device[] = "/dev/sda";
19070 char lines_0[] = ",";
19076 suppress_error = 0;
19077 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
19082 char fstype[] = "ext2";
19083 char device[] = "/dev/sda1";
19085 suppress_error = 0;
19086 r = guestfs_mkfs (g, fstype, device);
19091 char device[] = "/dev/sda1";
19092 char mountpoint[] = "/";
19094 suppress_error = 0;
19095 r = guestfs_mount (g, device, mountpoint);
19099 /* TestOutputTrue for touch (0) */
19101 char path[] = "/new";
19103 suppress_error = 0;
19104 r = guestfs_touch (g, path);
19109 char path[] = "/new";
19111 suppress_error = 0;
19112 r = guestfs_exists (g, path);
19116 fprintf (stderr, "test_touch_0: expected true, got false\n");
19123 static int test_sync_0_skip (void)
19127 str = getenv ("TEST_ONLY");
19129 return strstr (str, "sync") == NULL;
19130 str = getenv ("SKIP_TEST_SYNC_0");
19131 if (str && strcmp (str, "1") == 0) return 1;
19132 str = getenv ("SKIP_TEST_SYNC");
19133 if (str && strcmp (str, "1") == 0) return 1;
19137 static int test_sync_0 (void)
19139 if (test_sync_0_skip ()) {
19140 printf (" %s skipped (reason: environment variable set)\n", "test_sync_0");
19144 /* InitNone|InitEmpty for test_sync_0 */
19146 char device[] = "/dev/sda";
19148 suppress_error = 0;
19149 r = guestfs_blockdev_setrw (g, device);
19155 suppress_error = 0;
19156 r = guestfs_umount_all (g);
19162 suppress_error = 0;
19163 r = guestfs_lvm_remove_all (g);
19167 /* TestRun for sync (0) */
19170 suppress_error = 0;
19171 r = guestfs_sync (g);
19178 static int test_mount_0_skip (void)
19182 str = getenv ("TEST_ONLY");
19184 return strstr (str, "mount") == NULL;
19185 str = getenv ("SKIP_TEST_MOUNT_0");
19186 if (str && strcmp (str, "1") == 0) return 1;
19187 str = getenv ("SKIP_TEST_MOUNT");
19188 if (str && strcmp (str, "1") == 0) return 1;
19192 static int test_mount_0 (void)
19194 if (test_mount_0_skip ()) {
19195 printf (" %s skipped (reason: environment variable set)\n", "test_mount_0");
19199 /* InitNone|InitEmpty for test_mount_0 */
19201 char device[] = "/dev/sda";
19203 suppress_error = 0;
19204 r = guestfs_blockdev_setrw (g, device);
19210 suppress_error = 0;
19211 r = guestfs_umount_all (g);
19217 suppress_error = 0;
19218 r = guestfs_lvm_remove_all (g);
19222 /* TestOutput for mount (0) */
19223 char expected[] = "new file contents";
19225 char device[] = "/dev/sda";
19226 char lines_0[] = ",";
19232 suppress_error = 0;
19233 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
19238 char fstype[] = "ext2";
19239 char device[] = "/dev/sda1";
19241 suppress_error = 0;
19242 r = guestfs_mkfs (g, fstype, device);
19247 char device[] = "/dev/sda1";
19248 char mountpoint[] = "/";
19250 suppress_error = 0;
19251 r = guestfs_mount (g, device, mountpoint);
19256 char path[] = "/new";
19257 char content[] = "new file contents";
19259 suppress_error = 0;
19260 r = guestfs_write_file (g, path, content, 0);
19265 char path[] = "/new";
19267 suppress_error = 0;
19268 r = guestfs_cat (g, path);
19271 if (strcmp (r, expected) != 0) {
19272 fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
19280 int main (int argc, char *argv[])
19284 const char *filename;
19286 int nr_tests, test_num = 0;
19288 setbuf (stdout, NULL);
19290 no_test_warnings ();
19292 g = guestfs_create ();
19294 printf ("guestfs_create FAILED\n");
19298 guestfs_set_error_handler (g, print_error, NULL);
19300 guestfs_set_path (g, "../appliance");
19302 filename = "test1.img";
19303 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
19308 if (lseek (fd, 524288000, SEEK_SET) == -1) {
19314 if (write (fd, &c, 1) == -1) {
19320 if (close (fd) == -1) {
19325 if (guestfs_add_drive (g, filename) == -1) {
19326 printf ("guestfs_add_drive %s FAILED\n", filename);
19330 filename = "test2.img";
19331 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
19336 if (lseek (fd, 52428800, SEEK_SET) == -1) {
19342 if (write (fd, &c, 1) == -1) {
19348 if (close (fd) == -1) {
19353 if (guestfs_add_drive (g, filename) == -1) {
19354 printf ("guestfs_add_drive %s FAILED\n", filename);
19358 filename = "test3.img";
19359 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
19364 if (lseek (fd, 10485760, SEEK_SET) == -1) {
19370 if (write (fd, &c, 1) == -1) {
19376 if (close (fd) == -1) {
19381 if (guestfs_add_drive (g, filename) == -1) {
19382 printf ("guestfs_add_drive %s FAILED\n", filename);
19386 if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
19387 printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
19391 if (guestfs_launch (g) == -1) {
19392 printf ("guestfs_launch FAILED\n");
19396 /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */
19399 if (guestfs_wait_ready (g) == -1) {
19400 printf ("guestfs_wait_ready FAILED\n");
19404 /* Cancel previous alarm. */
19410 printf ("%3d/%3d test_mknod_c_0\n", test_num, nr_tests);
19411 if (test_mknod_c_0 () == -1) {
19412 printf ("test_mknod_c_0 FAILED\n");
19416 printf ("%3d/%3d test_mknod_b_0\n", test_num, nr_tests);
19417 if (test_mknod_b_0 () == -1) {
19418 printf ("test_mknod_b_0 FAILED\n");
19422 printf ("%3d/%3d test_mkfifo_0\n", test_num, nr_tests);
19423 if (test_mkfifo_0 () == -1) {
19424 printf ("test_mkfifo_0 FAILED\n");
19428 printf ("%3d/%3d test_mknod_0\n", test_num, nr_tests);
19429 if (test_mknod_0 () == -1) {
19430 printf ("test_mknod_0 FAILED\n");
19434 printf ("%3d/%3d test_mknod_1\n", test_num, nr_tests);
19435 if (test_mknod_1 () == -1) {
19436 printf ("test_mknod_1 FAILED\n");
19440 printf ("%3d/%3d test_mkswap_U_0\n", test_num, nr_tests);
19441 if (test_mkswap_U_0 () == -1) {
19442 printf ("test_mkswap_U_0 FAILED\n");
19446 printf ("%3d/%3d test_mkswap_L_0\n", test_num, nr_tests);
19447 if (test_mkswap_L_0 () == -1) {
19448 printf ("test_mkswap_L_0 FAILED\n");
19452 printf ("%3d/%3d test_mkswap_0\n", test_num, nr_tests);
19453 if (test_mkswap_0 () == -1) {
19454 printf ("test_mkswap_0 FAILED\n");
19458 printf ("%3d/%3d test_initrd_list_0\n", test_num, nr_tests);
19459 if (test_initrd_list_0 () == -1) {
19460 printf ("test_initrd_list_0 FAILED\n");
19464 printf ("%3d/%3d test_du_0\n", test_num, nr_tests);
19465 if (test_du_0 () == -1) {
19466 printf ("test_du_0 FAILED\n");
19470 printf ("%3d/%3d test_tail_n_0\n", test_num, nr_tests);
19471 if (test_tail_n_0 () == -1) {
19472 printf ("test_tail_n_0 FAILED\n");
19476 printf ("%3d/%3d test_tail_n_1\n", test_num, nr_tests);
19477 if (test_tail_n_1 () == -1) {
19478 printf ("test_tail_n_1 FAILED\n");
19482 printf ("%3d/%3d test_tail_n_2\n", test_num, nr_tests);
19483 if (test_tail_n_2 () == -1) {
19484 printf ("test_tail_n_2 FAILED\n");
19488 printf ("%3d/%3d test_tail_0\n", test_num, nr_tests);
19489 if (test_tail_0 () == -1) {
19490 printf ("test_tail_0 FAILED\n");
19494 printf ("%3d/%3d test_head_n_0\n", test_num, nr_tests);
19495 if (test_head_n_0 () == -1) {
19496 printf ("test_head_n_0 FAILED\n");
19500 printf ("%3d/%3d test_head_n_1\n", test_num, nr_tests);
19501 if (test_head_n_1 () == -1) {
19502 printf ("test_head_n_1 FAILED\n");
19506 printf ("%3d/%3d test_head_n_2\n", test_num, nr_tests);
19507 if (test_head_n_2 () == -1) {
19508 printf ("test_head_n_2 FAILED\n");
19512 printf ("%3d/%3d test_head_0\n", test_num, nr_tests);
19513 if (test_head_0 () == -1) {
19514 printf ("test_head_0 FAILED\n");
19518 printf ("%3d/%3d test_wc_c_0\n", test_num, nr_tests);
19519 if (test_wc_c_0 () == -1) {
19520 printf ("test_wc_c_0 FAILED\n");
19524 printf ("%3d/%3d test_wc_w_0\n", test_num, nr_tests);
19525 if (test_wc_w_0 () == -1) {
19526 printf ("test_wc_w_0 FAILED\n");
19530 printf ("%3d/%3d test_wc_l_0\n", test_num, nr_tests);
19531 if (test_wc_l_0 () == -1) {
19532 printf ("test_wc_l_0 FAILED\n");
19536 printf ("%3d/%3d test_mkdtemp_0\n", test_num, nr_tests);
19537 if (test_mkdtemp_0 () == -1) {
19538 printf ("test_mkdtemp_0 FAILED\n");
19542 printf ("%3d/%3d test_scrub_file_0\n", test_num, nr_tests);
19543 if (test_scrub_file_0 () == -1) {
19544 printf ("test_scrub_file_0 FAILED\n");
19548 printf ("%3d/%3d test_scrub_device_0\n", test_num, nr_tests);
19549 if (test_scrub_device_0 () == -1) {
19550 printf ("test_scrub_device_0 FAILED\n");
19554 printf ("%3d/%3d test_glob_expand_0\n", test_num, nr_tests);
19555 if (test_glob_expand_0 () == -1) {
19556 printf ("test_glob_expand_0 FAILED\n");
19560 printf ("%3d/%3d test_glob_expand_1\n", test_num, nr_tests);
19561 if (test_glob_expand_1 () == -1) {
19562 printf ("test_glob_expand_1 FAILED\n");
19566 printf ("%3d/%3d test_glob_expand_2\n", test_num, nr_tests);
19567 if (test_glob_expand_2 () == -1) {
19568 printf ("test_glob_expand_2 FAILED\n");
19572 printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
19573 if (test_ntfs_3g_probe_0 () == -1) {
19574 printf ("test_ntfs_3g_probe_0 FAILED\n");
19578 printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
19579 if (test_ntfs_3g_probe_1 () == -1) {
19580 printf ("test_ntfs_3g_probe_1 FAILED\n");
19584 printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
19585 if (test_sleep_0 () == -1) {
19586 printf ("test_sleep_0 FAILED\n");
19590 printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
19591 if (test_find_0 () == -1) {
19592 printf ("test_find_0 FAILED\n");
19596 printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
19597 if (test_find_1 () == -1) {
19598 printf ("test_find_1 FAILED\n");
19602 printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
19603 if (test_find_2 () == -1) {
19604 printf ("test_find_2 FAILED\n");
19608 printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
19609 if (test_lvresize_0 () == -1) {
19610 printf ("test_lvresize_0 FAILED\n");
19614 printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
19615 if (test_zerofree_0 () == -1) {
19616 printf ("test_zerofree_0 FAILED\n");
19620 printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
19621 if (test_hexdump_0 () == -1) {
19622 printf ("test_hexdump_0 FAILED\n");
19626 printf ("%3d/%3d test_hexdump_1\n", test_num, nr_tests);
19627 if (test_hexdump_1 () == -1) {
19628 printf ("test_hexdump_1 FAILED\n");
19632 printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
19633 if (test_strings_e_0 () == -1) {
19634 printf ("test_strings_e_0 FAILED\n");
19638 printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
19639 if (test_strings_e_1 () == -1) {
19640 printf ("test_strings_e_1 FAILED\n");
19644 printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
19645 if (test_strings_0 () == -1) {
19646 printf ("test_strings_0 FAILED\n");
19650 printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
19651 if (test_strings_1 () == -1) {
19652 printf ("test_strings_1 FAILED\n");
19656 printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
19657 if (test_equal_0 () == -1) {
19658 printf ("test_equal_0 FAILED\n");
19662 printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
19663 if (test_equal_1 () == -1) {
19664 printf ("test_equal_1 FAILED\n");
19668 printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
19669 if (test_equal_2 () == -1) {
19670 printf ("test_equal_2 FAILED\n");
19674 printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
19675 if (test_ping_daemon_0 () == -1) {
19676 printf ("test_ping_daemon_0 FAILED\n");
19680 printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
19681 if (test_dmesg_0 () == -1) {
19682 printf ("test_dmesg_0 FAILED\n");
19686 printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
19687 if (test_drop_caches_0 () == -1) {
19688 printf ("test_drop_caches_0 FAILED\n");
19692 printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
19693 if (test_mv_0 () == -1) {
19694 printf ("test_mv_0 FAILED\n");
19698 printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
19699 if (test_mv_1 () == -1) {
19700 printf ("test_mv_1 FAILED\n");
19704 printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
19705 if (test_cp_a_0 () == -1) {
19706 printf ("test_cp_a_0 FAILED\n");
19710 printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
19711 if (test_cp_0 () == -1) {
19712 printf ("test_cp_0 FAILED\n");
19716 printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
19717 if (test_cp_1 () == -1) {
19718 printf ("test_cp_1 FAILED\n");
19722 printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
19723 if (test_cp_2 () == -1) {
19724 printf ("test_cp_2 FAILED\n");
19728 printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
19729 if (test_grub_install_0 () == -1) {
19730 printf ("test_grub_install_0 FAILED\n");
19734 printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
19735 if (test_zero_0 () == -1) {
19736 printf ("test_zero_0 FAILED\n");
19740 printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
19741 if (test_fsck_0 () == -1) {
19742 printf ("test_fsck_0 FAILED\n");
19746 printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
19747 if (test_fsck_1 () == -1) {
19748 printf ("test_fsck_1 FAILED\n");
19752 printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
19753 if (test_set_e2uuid_0 () == -1) {
19754 printf ("test_set_e2uuid_0 FAILED\n");
19758 printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
19759 if (test_set_e2uuid_1 () == -1) {
19760 printf ("test_set_e2uuid_1 FAILED\n");
19764 printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
19765 if (test_set_e2uuid_2 () == -1) {
19766 printf ("test_set_e2uuid_2 FAILED\n");
19770 printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
19771 if (test_set_e2uuid_3 () == -1) {
19772 printf ("test_set_e2uuid_3 FAILED\n");
19776 printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
19777 if (test_set_e2label_0 () == -1) {
19778 printf ("test_set_e2label_0 FAILED\n");
19782 printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
19783 if (test_pvremove_0 () == -1) {
19784 printf ("test_pvremove_0 FAILED\n");
19788 printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
19789 if (test_pvremove_1 () == -1) {
19790 printf ("test_pvremove_1 FAILED\n");
19794 printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
19795 if (test_pvremove_2 () == -1) {
19796 printf ("test_pvremove_2 FAILED\n");
19800 printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
19801 if (test_vgremove_0 () == -1) {
19802 printf ("test_vgremove_0 FAILED\n");
19806 printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
19807 if (test_vgremove_1 () == -1) {
19808 printf ("test_vgremove_1 FAILED\n");
19812 printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
19813 if (test_lvremove_0 () == -1) {
19814 printf ("test_lvremove_0 FAILED\n");
19818 printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
19819 if (test_lvremove_1 () == -1) {
19820 printf ("test_lvremove_1 FAILED\n");
19824 printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
19825 if (test_lvremove_2 () == -1) {
19826 printf ("test_lvremove_2 FAILED\n");
19830 printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
19831 if (test_mount_ro_0 () == -1) {
19832 printf ("test_mount_ro_0 FAILED\n");
19836 printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
19837 if (test_mount_ro_1 () == -1) {
19838 printf ("test_mount_ro_1 FAILED\n");
19842 printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
19843 if (test_tgz_in_0 () == -1) {
19844 printf ("test_tgz_in_0 FAILED\n");
19848 printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
19849 if (test_tar_in_0 () == -1) {
19850 printf ("test_tar_in_0 FAILED\n");
19854 printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
19855 if (test_checksum_0 () == -1) {
19856 printf ("test_checksum_0 FAILED\n");
19860 printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
19861 if (test_checksum_1 () == -1) {
19862 printf ("test_checksum_1 FAILED\n");
19866 printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
19867 if (test_checksum_2 () == -1) {
19868 printf ("test_checksum_2 FAILED\n");
19872 printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
19873 if (test_checksum_3 () == -1) {
19874 printf ("test_checksum_3 FAILED\n");
19878 printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
19879 if (test_checksum_4 () == -1) {
19880 printf ("test_checksum_4 FAILED\n");
19884 printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
19885 if (test_checksum_5 () == -1) {
19886 printf ("test_checksum_5 FAILED\n");
19890 printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
19891 if (test_checksum_6 () == -1) {
19892 printf ("test_checksum_6 FAILED\n");
19896 printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
19897 if (test_checksum_7 () == -1) {
19898 printf ("test_checksum_7 FAILED\n");
19902 printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
19903 if (test_checksum_8 () == -1) {
19904 printf ("test_checksum_8 FAILED\n");
19908 printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
19909 if (test_download_0 () == -1) {
19910 printf ("test_download_0 FAILED\n");
19914 printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
19915 if (test_upload_0 () == -1) {
19916 printf ("test_upload_0 FAILED\n");
19920 printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
19921 if (test_blockdev_rereadpt_0 () == -1) {
19922 printf ("test_blockdev_rereadpt_0 FAILED\n");
19926 printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
19927 if (test_blockdev_flushbufs_0 () == -1) {
19928 printf ("test_blockdev_flushbufs_0 FAILED\n");
19932 printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
19933 if (test_blockdev_getsize64_0 () == -1) {
19934 printf ("test_blockdev_getsize64_0 FAILED\n");
19938 printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
19939 if (test_blockdev_getsz_0 () == -1) {
19940 printf ("test_blockdev_getsz_0 FAILED\n");
19944 printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
19945 if (test_blockdev_getbsz_0 () == -1) {
19946 printf ("test_blockdev_getbsz_0 FAILED\n");
19950 printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
19951 if (test_blockdev_getss_0 () == -1) {
19952 printf ("test_blockdev_getss_0 FAILED\n");
19956 printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
19957 if (test_blockdev_getro_0 () == -1) {
19958 printf ("test_blockdev_getro_0 FAILED\n");
19962 printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
19963 if (test_blockdev_setrw_0 () == -1) {
19964 printf ("test_blockdev_setrw_0 FAILED\n");
19968 printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
19969 if (test_blockdev_setro_0 () == -1) {
19970 printf ("test_blockdev_setro_0 FAILED\n");
19974 printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
19975 if (test_statvfs_0 () == -1) {
19976 printf ("test_statvfs_0 FAILED\n");
19980 printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
19981 if (test_lstat_0 () == -1) {
19982 printf ("test_lstat_0 FAILED\n");
19986 printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
19987 if (test_stat_0 () == -1) {
19988 printf ("test_stat_0 FAILED\n");
19992 printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
19993 if (test_command_lines_0 () == -1) {
19994 printf ("test_command_lines_0 FAILED\n");
19998 printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
19999 if (test_command_lines_1 () == -1) {
20000 printf ("test_command_lines_1 FAILED\n");
20004 printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
20005 if (test_command_lines_2 () == -1) {
20006 printf ("test_command_lines_2 FAILED\n");
20010 printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
20011 if (test_command_lines_3 () == -1) {
20012 printf ("test_command_lines_3 FAILED\n");
20016 printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
20017 if (test_command_lines_4 () == -1) {
20018 printf ("test_command_lines_4 FAILED\n");
20022 printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
20023 if (test_command_lines_5 () == -1) {
20024 printf ("test_command_lines_5 FAILED\n");
20028 printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
20029 if (test_command_lines_6 () == -1) {
20030 printf ("test_command_lines_6 FAILED\n");
20034 printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
20035 if (test_command_lines_7 () == -1) {
20036 printf ("test_command_lines_7 FAILED\n");
20040 printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
20041 if (test_command_lines_8 () == -1) {
20042 printf ("test_command_lines_8 FAILED\n");
20046 printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
20047 if (test_command_lines_9 () == -1) {
20048 printf ("test_command_lines_9 FAILED\n");
20052 printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
20053 if (test_command_lines_10 () == -1) {
20054 printf ("test_command_lines_10 FAILED\n");
20058 printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
20059 if (test_command_0 () == -1) {
20060 printf ("test_command_0 FAILED\n");
20064 printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
20065 if (test_command_1 () == -1) {
20066 printf ("test_command_1 FAILED\n");
20070 printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
20071 if (test_command_2 () == -1) {
20072 printf ("test_command_2 FAILED\n");
20076 printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
20077 if (test_command_3 () == -1) {
20078 printf ("test_command_3 FAILED\n");
20082 printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
20083 if (test_command_4 () == -1) {
20084 printf ("test_command_4 FAILED\n");
20088 printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
20089 if (test_command_5 () == -1) {
20090 printf ("test_command_5 FAILED\n");
20094 printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
20095 if (test_command_6 () == -1) {
20096 printf ("test_command_6 FAILED\n");
20100 printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
20101 if (test_command_7 () == -1) {
20102 printf ("test_command_7 FAILED\n");
20106 printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
20107 if (test_command_8 () == -1) {
20108 printf ("test_command_8 FAILED\n");
20112 printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
20113 if (test_command_9 () == -1) {
20114 printf ("test_command_9 FAILED\n");
20118 printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
20119 if (test_command_10 () == -1) {
20120 printf ("test_command_10 FAILED\n");
20124 printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
20125 if (test_command_11 () == -1) {
20126 printf ("test_command_11 FAILED\n");
20130 printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
20131 if (test_file_0 () == -1) {
20132 printf ("test_file_0 FAILED\n");
20136 printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
20137 if (test_file_1 () == -1) {
20138 printf ("test_file_1 FAILED\n");
20142 printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
20143 if (test_file_2 () == -1) {
20144 printf ("test_file_2 FAILED\n");
20148 printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
20149 if (test_umount_all_0 () == -1) {
20150 printf ("test_umount_all_0 FAILED\n");
20154 printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
20155 if (test_umount_all_1 () == -1) {
20156 printf ("test_umount_all_1 FAILED\n");
20160 printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
20161 if (test_mounts_0 () == -1) {
20162 printf ("test_mounts_0 FAILED\n");
20166 printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
20167 if (test_umount_0 () == -1) {
20168 printf ("test_umount_0 FAILED\n");
20172 printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
20173 if (test_umount_1 () == -1) {
20174 printf ("test_umount_1 FAILED\n");
20178 printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
20179 if (test_write_file_0 () == -1) {
20180 printf ("test_write_file_0 FAILED\n");
20184 printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
20185 if (test_write_file_1 () == -1) {
20186 printf ("test_write_file_1 FAILED\n");
20190 printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
20191 if (test_write_file_2 () == -1) {
20192 printf ("test_write_file_2 FAILED\n");
20196 printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
20197 if (test_write_file_3 () == -1) {
20198 printf ("test_write_file_3 FAILED\n");
20202 printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
20203 if (test_write_file_4 () == -1) {
20204 printf ("test_write_file_4 FAILED\n");
20208 printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
20209 if (test_write_file_5 () == -1) {
20210 printf ("test_write_file_5 FAILED\n");
20214 printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
20215 if (test_mkfs_0 () == -1) {
20216 printf ("test_mkfs_0 FAILED\n");
20220 printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
20221 if (test_lvcreate_0 () == -1) {
20222 printf ("test_lvcreate_0 FAILED\n");
20226 printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
20227 if (test_vgcreate_0 () == -1) {
20228 printf ("test_vgcreate_0 FAILED\n");
20232 printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
20233 if (test_pvcreate_0 () == -1) {
20234 printf ("test_pvcreate_0 FAILED\n");
20238 printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
20239 if (test_is_dir_0 () == -1) {
20240 printf ("test_is_dir_0 FAILED\n");
20244 printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
20245 if (test_is_dir_1 () == -1) {
20246 printf ("test_is_dir_1 FAILED\n");
20250 printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
20251 if (test_is_file_0 () == -1) {
20252 printf ("test_is_file_0 FAILED\n");
20256 printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
20257 if (test_is_file_1 () == -1) {
20258 printf ("test_is_file_1 FAILED\n");
20262 printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
20263 if (test_exists_0 () == -1) {
20264 printf ("test_exists_0 FAILED\n");
20268 printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
20269 if (test_exists_1 () == -1) {
20270 printf ("test_exists_1 FAILED\n");
20274 printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
20275 if (test_mkdir_p_0 () == -1) {
20276 printf ("test_mkdir_p_0 FAILED\n");
20280 printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
20281 if (test_mkdir_p_1 () == -1) {
20282 printf ("test_mkdir_p_1 FAILED\n");
20286 printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
20287 if (test_mkdir_p_2 () == -1) {
20288 printf ("test_mkdir_p_2 FAILED\n");
20292 printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
20293 if (test_mkdir_p_3 () == -1) {
20294 printf ("test_mkdir_p_3 FAILED\n");
20298 printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
20299 if (test_mkdir_p_4 () == -1) {
20300 printf ("test_mkdir_p_4 FAILED\n");
20304 printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
20305 if (test_mkdir_0 () == -1) {
20306 printf ("test_mkdir_0 FAILED\n");
20310 printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
20311 if (test_mkdir_1 () == -1) {
20312 printf ("test_mkdir_1 FAILED\n");
20316 printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
20317 if (test_rm_rf_0 () == -1) {
20318 printf ("test_rm_rf_0 FAILED\n");
20322 printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
20323 if (test_rmdir_0 () == -1) {
20324 printf ("test_rmdir_0 FAILED\n");
20328 printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
20329 if (test_rmdir_1 () == -1) {
20330 printf ("test_rmdir_1 FAILED\n");
20334 printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
20335 if (test_rmdir_2 () == -1) {
20336 printf ("test_rmdir_2 FAILED\n");
20340 printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
20341 if (test_rm_0 () == -1) {
20342 printf ("test_rm_0 FAILED\n");
20346 printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
20347 if (test_rm_1 () == -1) {
20348 printf ("test_rm_1 FAILED\n");
20352 printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
20353 if (test_rm_2 () == -1) {
20354 printf ("test_rm_2 FAILED\n");
20358 printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
20359 if (test_read_lines_0 () == -1) {
20360 printf ("test_read_lines_0 FAILED\n");
20364 printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
20365 if (test_read_lines_1 () == -1) {
20366 printf ("test_read_lines_1 FAILED\n");
20370 printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
20371 if (test_lvs_0 () == -1) {
20372 printf ("test_lvs_0 FAILED\n");
20376 printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
20377 if (test_lvs_1 () == -1) {
20378 printf ("test_lvs_1 FAILED\n");
20382 printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
20383 if (test_vgs_0 () == -1) {
20384 printf ("test_vgs_0 FAILED\n");
20388 printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
20389 if (test_vgs_1 () == -1) {
20390 printf ("test_vgs_1 FAILED\n");
20394 printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
20395 if (test_pvs_0 () == -1) {
20396 printf ("test_pvs_0 FAILED\n");
20400 printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
20401 if (test_pvs_1 () == -1) {
20402 printf ("test_pvs_1 FAILED\n");
20406 printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
20407 if (test_list_partitions_0 () == -1) {
20408 printf ("test_list_partitions_0 FAILED\n");
20412 printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
20413 if (test_list_partitions_1 () == -1) {
20414 printf ("test_list_partitions_1 FAILED\n");
20418 printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
20419 if (test_list_devices_0 () == -1) {
20420 printf ("test_list_devices_0 FAILED\n");
20424 printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
20425 if (test_ls_0 () == -1) {
20426 printf ("test_ls_0 FAILED\n");
20430 printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
20431 if (test_cat_0 () == -1) {
20432 printf ("test_cat_0 FAILED\n");
20436 printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
20437 if (test_touch_0 () == -1) {
20438 printf ("test_touch_0 FAILED\n");
20442 printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
20443 if (test_sync_0 () == -1) {
20444 printf ("test_sync_0 FAILED\n");
20448 printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
20449 if (test_mount_0 () == -1) {
20450 printf ("test_mount_0 FAILED\n");
20455 unlink ("test1.img");
20456 unlink ("test2.img");
20457 unlink ("test3.img");
20460 printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);