1 /* libguestfs generated file
2 * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
3 * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
5 * Copyright (C) 2009 Red Hat Inc.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
26 #include <sys/types.h>
32 static int suppress_error = 0;
34 static void print_error (guestfs_h *g, void *data, const char *msg)
37 fprintf (stderr, "%s\n", msg);
40 static void print_strings (char * const * const argv)
44 for (argc = 0; argv[argc] != NULL; ++argc)
45 printf ("\t%s\n", argv[argc]);
49 static void print_table (char * const * const argv)
53 for (i = 0; argv[i] != NULL; i += 2)
54 printf ("%s: %s\n", argv[i], argv[i+1]);
58 static void no_test_warnings (void)
60 fprintf (stderr, "warning: \"guestfs_test0\" has no tests\n");
61 fprintf (stderr, "warning: \"guestfs_test0rint\" has no tests\n");
62 fprintf (stderr, "warning: \"guestfs_test0rinterr\" has no tests\n");
63 fprintf (stderr, "warning: \"guestfs_test0rint64\" has no tests\n");
64 fprintf (stderr, "warning: \"guestfs_test0rint64err\" has no tests\n");
65 fprintf (stderr, "warning: \"guestfs_test0rbool\" has no tests\n");
66 fprintf (stderr, "warning: \"guestfs_test0rboolerr\" has no tests\n");
67 fprintf (stderr, "warning: \"guestfs_test0rconststring\" has no tests\n");
68 fprintf (stderr, "warning: \"guestfs_test0rconststringerr\" has no tests\n");
69 fprintf (stderr, "warning: \"guestfs_test0rstring\" has no tests\n");
70 fprintf (stderr, "warning: \"guestfs_test0rstringerr\" has no tests\n");
71 fprintf (stderr, "warning: \"guestfs_test0rstringlist\" has no tests\n");
72 fprintf (stderr, "warning: \"guestfs_test0rstringlisterr\" has no tests\n");
73 fprintf (stderr, "warning: \"guestfs_test0rintbool\" has no tests\n");
74 fprintf (stderr, "warning: \"guestfs_test0rintboolerr\" has no tests\n");
75 fprintf (stderr, "warning: \"guestfs_test0rpvlist\" has no tests\n");
76 fprintf (stderr, "warning: \"guestfs_test0rpvlisterr\" has no tests\n");
77 fprintf (stderr, "warning: \"guestfs_test0rvglist\" has no tests\n");
78 fprintf (stderr, "warning: \"guestfs_test0rvglisterr\" has no tests\n");
79 fprintf (stderr, "warning: \"guestfs_test0rlvlist\" has no tests\n");
80 fprintf (stderr, "warning: \"guestfs_test0rlvlisterr\" has no tests\n");
81 fprintf (stderr, "warning: \"guestfs_test0rstat\" has no tests\n");
82 fprintf (stderr, "warning: \"guestfs_test0rstaterr\" has no tests\n");
83 fprintf (stderr, "warning: \"guestfs_test0rstatvfs\" has no tests\n");
84 fprintf (stderr, "warning: \"guestfs_test0rstatvfserr\" has no tests\n");
85 fprintf (stderr, "warning: \"guestfs_test0rhashtable\" has no tests\n");
86 fprintf (stderr, "warning: \"guestfs_test0rhashtableerr\" has no tests\n");
87 fprintf (stderr, "warning: \"guestfs_launch\" has no tests\n");
88 fprintf (stderr, "warning: \"guestfs_wait_ready\" has no tests\n");
89 fprintf (stderr, "warning: \"guestfs_kill_subprocess\" has no tests\n");
90 fprintf (stderr, "warning: \"guestfs_add_drive\" has no tests\n");
91 fprintf (stderr, "warning: \"guestfs_add_cdrom\" has no tests\n");
92 fprintf (stderr, "warning: \"guestfs_add_drive_ro\" has no tests\n");
93 fprintf (stderr, "warning: \"guestfs_config\" has no tests\n");
94 fprintf (stderr, "warning: \"guestfs_set_qemu\" has no tests\n");
95 fprintf (stderr, "warning: \"guestfs_get_qemu\" has no tests\n");
96 fprintf (stderr, "warning: \"guestfs_set_path\" has no tests\n");
97 fprintf (stderr, "warning: \"guestfs_get_path\" has no tests\n");
98 fprintf (stderr, "warning: \"guestfs_set_append\" has no tests\n");
99 fprintf (stderr, "warning: \"guestfs_get_append\" has no tests\n");
100 fprintf (stderr, "warning: \"guestfs_set_autosync\" has no tests\n");
101 fprintf (stderr, "warning: \"guestfs_get_autosync\" has no tests\n");
102 fprintf (stderr, "warning: \"guestfs_set_verbose\" has no tests\n");
103 fprintf (stderr, "warning: \"guestfs_get_verbose\" has no tests\n");
104 fprintf (stderr, "warning: \"guestfs_is_ready\" has no tests\n");
105 fprintf (stderr, "warning: \"guestfs_is_config\" has no tests\n");
106 fprintf (stderr, "warning: \"guestfs_is_launching\" has no tests\n");
107 fprintf (stderr, "warning: \"guestfs_is_busy\" has no tests\n");
108 fprintf (stderr, "warning: \"guestfs_get_state\" has no tests\n");
109 fprintf (stderr, "warning: \"guestfs_set_busy\" has no tests\n");
110 fprintf (stderr, "warning: \"guestfs_set_ready\" has no tests\n");
111 fprintf (stderr, "warning: \"guestfs_end_busy\" has no tests\n");
112 fprintf (stderr, "warning: \"guestfs_ll\" has no tests\n");
113 fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n");
114 fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n");
115 fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n");
116 fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n");
117 fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n");
118 fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n");
119 fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n");
120 fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n");
121 fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n");
122 fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n");
123 fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n");
124 fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n");
125 fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n");
126 fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n");
127 fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n");
128 fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n");
129 fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n");
130 fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n");
131 fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n");
132 fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n");
133 fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n");
134 fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n");
135 fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n");
136 fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n");
137 fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n");
138 fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n");
139 fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n");
140 fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n");
141 fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n");
142 fprintf (stderr, "warning: \"guestfs_pvresize\" has no tests\n");
143 fprintf (stderr, "warning: \"guestfs_sfdisk_N\" has no tests\n");
144 fprintf (stderr, "warning: \"guestfs_sfdisk_l\" has no tests\n");
145 fprintf (stderr, "warning: \"guestfs_sfdisk_kernel_geometry\" has no tests\n");
146 fprintf (stderr, "warning: \"guestfs_sfdisk_disk_geometry\" has no tests\n");
147 fprintf (stderr, "warning: \"guestfs_vg_activate_all\" has no tests\n");
148 fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n");
149 fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n");
150 fprintf (stderr, "warning: \"guestfs_e2fsck_f\" has no tests\n");
151 fprintf (stderr, "warning: \"guestfs_sh\" has no tests\n");
152 fprintf (stderr, "warning: \"guestfs_sh_lines\" has no tests\n");
153 fprintf (stderr, "warning: \"guestfs_scrub_freespace\" has no tests\n");
154 fprintf (stderr, "warning: \"guestfs_df\" has no tests\n");
155 fprintf (stderr, "warning: \"guestfs_df_h\" has no tests\n");
156 fprintf (stderr, "warning: \"guestfs_mount_loop\" has no tests\n");
159 static int test_mkswap_U_0_skip (void)
163 str = getenv ("TEST_ONLY");
165 return strstr (str, "mkswap_U") == NULL;
166 str = getenv ("SKIP_TEST_MKSWAP_U_0");
167 if (str && strcmp (str, "1") == 0) return 1;
168 str = getenv ("SKIP_TEST_MKSWAP_U");
169 if (str && strcmp (str, "1") == 0) return 1;
173 static int test_mkswap_U_0 (void)
175 if (test_mkswap_U_0_skip ()) {
176 printf ("%s skipped (reason: environment variable set)\n", "test_mkswap_U_0");
180 /* InitNone|InitEmpty for test_mkswap_U_0 */
182 char device[] = "/dev/sda";
185 r = guestfs_blockdev_setrw (g, device);
192 r = guestfs_umount_all (g);
199 r = guestfs_lvm_remove_all (g);
203 /* TestRun for mkswap_U (0) */
205 char device[] = "/dev/sda";
206 char lines_0[] = ",";
213 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
218 char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
219 char device[] = "/dev/sda1";
222 r = guestfs_mkswap_U (g, uuid, device);
229 static int test_mkswap_L_0_skip (void)
233 str = getenv ("TEST_ONLY");
235 return strstr (str, "mkswap_L") == NULL;
236 str = getenv ("SKIP_TEST_MKSWAP_L_0");
237 if (str && strcmp (str, "1") == 0) return 1;
238 str = getenv ("SKIP_TEST_MKSWAP_L");
239 if (str && strcmp (str, "1") == 0) return 1;
243 static int test_mkswap_L_0 (void)
245 if (test_mkswap_L_0_skip ()) {
246 printf ("%s skipped (reason: environment variable set)\n", "test_mkswap_L_0");
250 /* InitNone|InitEmpty for test_mkswap_L_0 */
252 char device[] = "/dev/sda";
255 r = guestfs_blockdev_setrw (g, device);
262 r = guestfs_umount_all (g);
269 r = guestfs_lvm_remove_all (g);
273 /* TestRun for mkswap_L (0) */
275 char device[] = "/dev/sda";
276 char lines_0[] = ",";
283 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
288 char label[] = "hello";
289 char device[] = "/dev/sda1";
292 r = guestfs_mkswap_L (g, label, device);
299 static int test_mkswap_0_skip (void)
303 str = getenv ("TEST_ONLY");
305 return strstr (str, "mkswap") == NULL;
306 str = getenv ("SKIP_TEST_MKSWAP_0");
307 if (str && strcmp (str, "1") == 0) return 1;
308 str = getenv ("SKIP_TEST_MKSWAP");
309 if (str && strcmp (str, "1") == 0) return 1;
313 static int test_mkswap_0 (void)
315 if (test_mkswap_0_skip ()) {
316 printf ("%s skipped (reason: environment variable set)\n", "test_mkswap_0");
320 /* InitNone|InitEmpty for test_mkswap_0 */
322 char device[] = "/dev/sda";
325 r = guestfs_blockdev_setrw (g, device);
332 r = guestfs_umount_all (g);
339 r = guestfs_lvm_remove_all (g);
343 /* TestRun for mkswap (0) */
345 char device[] = "/dev/sda";
346 char lines_0[] = ",";
353 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
358 char device[] = "/dev/sda1";
361 r = guestfs_mkswap (g, device);
368 static int test_initrd_list_0_skip (void)
372 str = getenv ("TEST_ONLY");
374 return strstr (str, "initrd_list") == NULL;
375 str = getenv ("SKIP_TEST_INITRD_LIST_0");
376 if (str && strcmp (str, "1") == 0) return 1;
377 str = getenv ("SKIP_TEST_INITRD_LIST");
378 if (str && strcmp (str, "1") == 0) return 1;
382 static int test_initrd_list_0 (void)
384 if (test_initrd_list_0_skip ()) {
385 printf ("%s skipped (reason: environment variable set)\n", "test_initrd_list_0");
389 /* InitBasicFS for test_initrd_list_0: create ext2 on /dev/sda1 */
391 char device[] = "/dev/sda";
394 r = guestfs_blockdev_setrw (g, device);
401 r = guestfs_umount_all (g);
408 r = guestfs_lvm_remove_all (g);
413 char device[] = "/dev/sda";
414 char lines_0[] = ",";
421 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
426 char fstype[] = "ext2";
427 char device[] = "/dev/sda1";
430 r = guestfs_mkfs (g, fstype, device);
435 char device[] = "/dev/sda1";
436 char mountpoint[] = "/";
439 r = guestfs_mount (g, device, mountpoint);
443 /* TestOutputList for initrd_list (0) */
445 char options[] = "ro";
446 char vfstype[] = "squashfs";
447 char device[] = "/dev/sdd";
448 char mountpoint[] = "/";
451 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
456 char path[] = "/initrd";
460 r = guestfs_initrd_list (g, path);
464 fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
469 char expected[] = "empty";
470 if (strcmp (r[0], expected) != 0) {
471 fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
476 fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
481 char expected[] = "known-1";
482 if (strcmp (r[1], expected) != 0) {
483 fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
488 fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
493 char expected[] = "known-2";
494 if (strcmp (r[2], expected) != 0) {
495 fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
500 fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
505 char expected[] = "known-3";
506 if (strcmp (r[3], expected) != 0) {
507 fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
512 fprintf (stderr, "test_initrd_list_0: extra elements returned from command\n");
516 for (i = 0; r[i] != NULL; ++i)
523 static int test_du_0_skip (void)
527 str = getenv ("TEST_ONLY");
529 return strstr (str, "du") == NULL;
530 str = getenv ("SKIP_TEST_DU_0");
531 if (str && strcmp (str, "1") == 0) return 1;
532 str = getenv ("SKIP_TEST_DU");
533 if (str && strcmp (str, "1") == 0) return 1;
537 static int test_du_0 (void)
539 if (test_du_0_skip ()) {
540 printf ("%s skipped (reason: environment variable set)\n", "test_du_0");
544 /* InitBasicFS for test_du_0: create ext2 on /dev/sda1 */
546 char device[] = "/dev/sda";
549 r = guestfs_blockdev_setrw (g, device);
556 r = guestfs_umount_all (g);
563 r = guestfs_lvm_remove_all (g);
568 char device[] = "/dev/sda";
569 char lines_0[] = ",";
576 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
581 char fstype[] = "ext2";
582 char device[] = "/dev/sda1";
585 r = guestfs_mkfs (g, fstype, device);
590 char device[] = "/dev/sda1";
591 char mountpoint[] = "/";
594 r = guestfs_mount (g, device, mountpoint);
598 /* TestOutputInt for du (0) */
603 r = guestfs_mkdir (g, path);
611 r = guestfs_du (g, path);
615 fprintf (stderr, "test_du_0: expected 1 but got %d\n", (int) r);
622 static int test_tail_n_0_skip (void)
626 str = getenv ("TEST_ONLY");
628 return strstr (str, "tail_n") == NULL;
629 str = getenv ("SKIP_TEST_TAIL_N_0");
630 if (str && strcmp (str, "1") == 0) return 1;
631 str = getenv ("SKIP_TEST_TAIL_N");
632 if (str && strcmp (str, "1") == 0) return 1;
636 static int test_tail_n_0 (void)
638 if (test_tail_n_0_skip ()) {
639 printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_0");
643 /* InitBasicFS for test_tail_n_0: create ext2 on /dev/sda1 */
645 char device[] = "/dev/sda";
648 r = guestfs_blockdev_setrw (g, device);
655 r = guestfs_umount_all (g);
662 r = guestfs_lvm_remove_all (g);
667 char device[] = "/dev/sda";
668 char lines_0[] = ",";
675 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
680 char fstype[] = "ext2";
681 char device[] = "/dev/sda1";
684 r = guestfs_mkfs (g, fstype, device);
689 char device[] = "/dev/sda1";
690 char mountpoint[] = "/";
693 r = guestfs_mount (g, device, mountpoint);
697 /* TestOutputList for tail_n (0) */
699 char options[] = "ro";
700 char vfstype[] = "squashfs";
701 char device[] = "/dev/sdd";
702 char mountpoint[] = "/";
705 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
710 char path[] = "/10klines";
714 r = guestfs_tail_n (g, 3, path);
718 fprintf (stderr, "test_tail_n_0: short list returned from command\n");
723 char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
724 if (strcmp (r[0], expected) != 0) {
725 fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
730 fprintf (stderr, "test_tail_n_0: short list returned from command\n");
735 char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
736 if (strcmp (r[1], expected) != 0) {
737 fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
742 fprintf (stderr, "test_tail_n_0: short list returned from command\n");
747 char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
748 if (strcmp (r[2], expected) != 0) {
749 fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
754 fprintf (stderr, "test_tail_n_0: extra elements returned from command\n");
758 for (i = 0; r[i] != NULL; ++i)
765 static int test_tail_n_1_skip (void)
769 str = getenv ("TEST_ONLY");
771 return strstr (str, "tail_n") == NULL;
772 str = getenv ("SKIP_TEST_TAIL_N_1");
773 if (str && strcmp (str, "1") == 0) return 1;
774 str = getenv ("SKIP_TEST_TAIL_N");
775 if (str && strcmp (str, "1") == 0) return 1;
779 static int test_tail_n_1 (void)
781 if (test_tail_n_1_skip ()) {
782 printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_1");
786 /* InitBasicFS for test_tail_n_1: create ext2 on /dev/sda1 */
788 char device[] = "/dev/sda";
791 r = guestfs_blockdev_setrw (g, device);
798 r = guestfs_umount_all (g);
805 r = guestfs_lvm_remove_all (g);
810 char device[] = "/dev/sda";
811 char lines_0[] = ",";
818 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
823 char fstype[] = "ext2";
824 char device[] = "/dev/sda1";
827 r = guestfs_mkfs (g, fstype, device);
832 char device[] = "/dev/sda1";
833 char mountpoint[] = "/";
836 r = guestfs_mount (g, device, mountpoint);
840 /* TestOutputList for tail_n (1) */
842 char options[] = "ro";
843 char vfstype[] = "squashfs";
844 char device[] = "/dev/sdd";
845 char mountpoint[] = "/";
848 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
853 char path[] = "/10klines";
857 r = guestfs_tail_n (g, -9998, path);
861 fprintf (stderr, "test_tail_n_1: short list returned from command\n");
866 char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
867 if (strcmp (r[0], expected) != 0) {
868 fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
873 fprintf (stderr, "test_tail_n_1: short list returned from command\n");
878 char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
879 if (strcmp (r[1], expected) != 0) {
880 fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
885 fprintf (stderr, "test_tail_n_1: short list returned from command\n");
890 char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
891 if (strcmp (r[2], expected) != 0) {
892 fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
897 fprintf (stderr, "test_tail_n_1: extra elements returned from command\n");
901 for (i = 0; r[i] != NULL; ++i)
908 static int test_tail_n_2_skip (void)
912 str = getenv ("TEST_ONLY");
914 return strstr (str, "tail_n") == NULL;
915 str = getenv ("SKIP_TEST_TAIL_N_2");
916 if (str && strcmp (str, "1") == 0) return 1;
917 str = getenv ("SKIP_TEST_TAIL_N");
918 if (str && strcmp (str, "1") == 0) return 1;
922 static int test_tail_n_2 (void)
924 if (test_tail_n_2_skip ()) {
925 printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_2");
929 /* InitBasicFS for test_tail_n_2: create ext2 on /dev/sda1 */
931 char device[] = "/dev/sda";
934 r = guestfs_blockdev_setrw (g, device);
941 r = guestfs_umount_all (g);
948 r = guestfs_lvm_remove_all (g);
953 char device[] = "/dev/sda";
954 char lines_0[] = ",";
961 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
966 char fstype[] = "ext2";
967 char device[] = "/dev/sda1";
970 r = guestfs_mkfs (g, fstype, device);
975 char device[] = "/dev/sda1";
976 char mountpoint[] = "/";
979 r = guestfs_mount (g, device, mountpoint);
983 /* TestOutputList for tail_n (2) */
985 char options[] = "ro";
986 char vfstype[] = "squashfs";
987 char device[] = "/dev/sdd";
988 char mountpoint[] = "/";
991 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
996 char path[] = "/10klines";
1000 r = guestfs_tail_n (g, 0, path);
1004 fprintf (stderr, "test_tail_n_2: extra elements returned from command\n");
1008 for (i = 0; r[i] != NULL; ++i)
1015 static int test_tail_0_skip (void)
1019 str = getenv ("TEST_ONLY");
1021 return strstr (str, "tail") == NULL;
1022 str = getenv ("SKIP_TEST_TAIL_0");
1023 if (str && strcmp (str, "1") == 0) return 1;
1024 str = getenv ("SKIP_TEST_TAIL");
1025 if (str && strcmp (str, "1") == 0) return 1;
1029 static int test_tail_0 (void)
1031 if (test_tail_0_skip ()) {
1032 printf ("%s skipped (reason: environment variable set)\n", "test_tail_0");
1036 /* InitBasicFS for test_tail_0: create ext2 on /dev/sda1 */
1038 char device[] = "/dev/sda";
1041 r = guestfs_blockdev_setrw (g, device);
1048 r = guestfs_umount_all (g);
1055 r = guestfs_lvm_remove_all (g);
1060 char device[] = "/dev/sda";
1061 char lines_0[] = ",";
1068 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1073 char fstype[] = "ext2";
1074 char device[] = "/dev/sda1";
1077 r = guestfs_mkfs (g, fstype, device);
1082 char device[] = "/dev/sda1";
1083 char mountpoint[] = "/";
1086 r = guestfs_mount (g, device, mountpoint);
1090 /* TestOutputList for tail (0) */
1092 char options[] = "ro";
1093 char vfstype[] = "squashfs";
1094 char device[] = "/dev/sdd";
1095 char mountpoint[] = "/";
1098 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1103 char path[] = "/10klines";
1107 r = guestfs_tail (g, path);
1111 fprintf (stderr, "test_tail_0: short list returned from command\n");
1116 char expected[] = "9990abcdefghijklmnopqrstuvwxyz";
1117 if (strcmp (r[0], expected) != 0) {
1118 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1123 fprintf (stderr, "test_tail_0: short list returned from command\n");
1128 char expected[] = "9991abcdefghijklmnopqrstuvwxyz";
1129 if (strcmp (r[1], expected) != 0) {
1130 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1135 fprintf (stderr, "test_tail_0: short list returned from command\n");
1140 char expected[] = "9992abcdefghijklmnopqrstuvwxyz";
1141 if (strcmp (r[2], expected) != 0) {
1142 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1147 fprintf (stderr, "test_tail_0: short list returned from command\n");
1152 char expected[] = "9993abcdefghijklmnopqrstuvwxyz";
1153 if (strcmp (r[3], expected) != 0) {
1154 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1159 fprintf (stderr, "test_tail_0: short list returned from command\n");
1164 char expected[] = "9994abcdefghijklmnopqrstuvwxyz";
1165 if (strcmp (r[4], expected) != 0) {
1166 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
1171 fprintf (stderr, "test_tail_0: short list returned from command\n");
1176 char expected[] = "9995abcdefghijklmnopqrstuvwxyz";
1177 if (strcmp (r[5], expected) != 0) {
1178 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
1183 fprintf (stderr, "test_tail_0: short list returned from command\n");
1188 char expected[] = "9996abcdefghijklmnopqrstuvwxyz";
1189 if (strcmp (r[6], expected) != 0) {
1190 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
1195 fprintf (stderr, "test_tail_0: short list returned from command\n");
1200 char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
1201 if (strcmp (r[7], expected) != 0) {
1202 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
1207 fprintf (stderr, "test_tail_0: short list returned from command\n");
1212 char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
1213 if (strcmp (r[8], expected) != 0) {
1214 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
1219 fprintf (stderr, "test_tail_0: short list returned from command\n");
1224 char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
1225 if (strcmp (r[9], expected) != 0) {
1226 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
1230 if (r[10] != NULL) {
1231 fprintf (stderr, "test_tail_0: extra elements returned from command\n");
1235 for (i = 0; r[i] != NULL; ++i)
1242 static int test_head_n_0_skip (void)
1246 str = getenv ("TEST_ONLY");
1248 return strstr (str, "head_n") == NULL;
1249 str = getenv ("SKIP_TEST_HEAD_N_0");
1250 if (str && strcmp (str, "1") == 0) return 1;
1251 str = getenv ("SKIP_TEST_HEAD_N");
1252 if (str && strcmp (str, "1") == 0) return 1;
1256 static int test_head_n_0 (void)
1258 if (test_head_n_0_skip ()) {
1259 printf ("%s skipped (reason: environment variable set)\n", "test_head_n_0");
1263 /* InitBasicFS for test_head_n_0: create ext2 on /dev/sda1 */
1265 char device[] = "/dev/sda";
1268 r = guestfs_blockdev_setrw (g, device);
1275 r = guestfs_umount_all (g);
1282 r = guestfs_lvm_remove_all (g);
1287 char device[] = "/dev/sda";
1288 char lines_0[] = ",";
1295 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1300 char fstype[] = "ext2";
1301 char device[] = "/dev/sda1";
1304 r = guestfs_mkfs (g, fstype, device);
1309 char device[] = "/dev/sda1";
1310 char mountpoint[] = "/";
1313 r = guestfs_mount (g, device, mountpoint);
1317 /* TestOutputList for head_n (0) */
1319 char options[] = "ro";
1320 char vfstype[] = "squashfs";
1321 char device[] = "/dev/sdd";
1322 char mountpoint[] = "/";
1325 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1330 char path[] = "/10klines";
1334 r = guestfs_head_n (g, 3, path);
1338 fprintf (stderr, "test_head_n_0: short list returned from command\n");
1343 char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1344 if (strcmp (r[0], expected) != 0) {
1345 fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1350 fprintf (stderr, "test_head_n_0: short list returned from command\n");
1355 char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1356 if (strcmp (r[1], expected) != 0) {
1357 fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1362 fprintf (stderr, "test_head_n_0: short list returned from command\n");
1367 char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1368 if (strcmp (r[2], expected) != 0) {
1369 fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1374 fprintf (stderr, "test_head_n_0: extra elements returned from command\n");
1378 for (i = 0; r[i] != NULL; ++i)
1385 static int test_head_n_1_skip (void)
1389 str = getenv ("TEST_ONLY");
1391 return strstr (str, "head_n") == NULL;
1392 str = getenv ("SKIP_TEST_HEAD_N_1");
1393 if (str && strcmp (str, "1") == 0) return 1;
1394 str = getenv ("SKIP_TEST_HEAD_N");
1395 if (str && strcmp (str, "1") == 0) return 1;
1399 static int test_head_n_1 (void)
1401 if (test_head_n_1_skip ()) {
1402 printf ("%s skipped (reason: environment variable set)\n", "test_head_n_1");
1406 /* InitBasicFS for test_head_n_1: create ext2 on /dev/sda1 */
1408 char device[] = "/dev/sda";
1411 r = guestfs_blockdev_setrw (g, device);
1418 r = guestfs_umount_all (g);
1425 r = guestfs_lvm_remove_all (g);
1430 char device[] = "/dev/sda";
1431 char lines_0[] = ",";
1438 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1443 char fstype[] = "ext2";
1444 char device[] = "/dev/sda1";
1447 r = guestfs_mkfs (g, fstype, device);
1452 char device[] = "/dev/sda1";
1453 char mountpoint[] = "/";
1456 r = guestfs_mount (g, device, mountpoint);
1460 /* TestOutputList for head_n (1) */
1462 char options[] = "ro";
1463 char vfstype[] = "squashfs";
1464 char device[] = "/dev/sdd";
1465 char mountpoint[] = "/";
1468 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1473 char path[] = "/10klines";
1477 r = guestfs_head_n (g, -9997, path);
1481 fprintf (stderr, "test_head_n_1: short list returned from command\n");
1486 char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1487 if (strcmp (r[0], expected) != 0) {
1488 fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1493 fprintf (stderr, "test_head_n_1: short list returned from command\n");
1498 char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1499 if (strcmp (r[1], expected) != 0) {
1500 fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1505 fprintf (stderr, "test_head_n_1: short list returned from command\n");
1510 char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1511 if (strcmp (r[2], expected) != 0) {
1512 fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1517 fprintf (stderr, "test_head_n_1: extra elements returned from command\n");
1521 for (i = 0; r[i] != NULL; ++i)
1528 static int test_head_n_2_skip (void)
1532 str = getenv ("TEST_ONLY");
1534 return strstr (str, "head_n") == NULL;
1535 str = getenv ("SKIP_TEST_HEAD_N_2");
1536 if (str && strcmp (str, "1") == 0) return 1;
1537 str = getenv ("SKIP_TEST_HEAD_N");
1538 if (str && strcmp (str, "1") == 0) return 1;
1542 static int test_head_n_2 (void)
1544 if (test_head_n_2_skip ()) {
1545 printf ("%s skipped (reason: environment variable set)\n", "test_head_n_2");
1549 /* InitBasicFS for test_head_n_2: create ext2 on /dev/sda1 */
1551 char device[] = "/dev/sda";
1554 r = guestfs_blockdev_setrw (g, device);
1561 r = guestfs_umount_all (g);
1568 r = guestfs_lvm_remove_all (g);
1573 char device[] = "/dev/sda";
1574 char lines_0[] = ",";
1581 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1586 char fstype[] = "ext2";
1587 char device[] = "/dev/sda1";
1590 r = guestfs_mkfs (g, fstype, device);
1595 char device[] = "/dev/sda1";
1596 char mountpoint[] = "/";
1599 r = guestfs_mount (g, device, mountpoint);
1603 /* TestOutputList for head_n (2) */
1605 char options[] = "ro";
1606 char vfstype[] = "squashfs";
1607 char device[] = "/dev/sdd";
1608 char mountpoint[] = "/";
1611 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1616 char path[] = "/10klines";
1620 r = guestfs_head_n (g, 0, path);
1624 fprintf (stderr, "test_head_n_2: extra elements returned from command\n");
1628 for (i = 0; r[i] != NULL; ++i)
1635 static int test_head_0_skip (void)
1639 str = getenv ("TEST_ONLY");
1641 return strstr (str, "head") == NULL;
1642 str = getenv ("SKIP_TEST_HEAD_0");
1643 if (str && strcmp (str, "1") == 0) return 1;
1644 str = getenv ("SKIP_TEST_HEAD");
1645 if (str && strcmp (str, "1") == 0) return 1;
1649 static int test_head_0 (void)
1651 if (test_head_0_skip ()) {
1652 printf ("%s skipped (reason: environment variable set)\n", "test_head_0");
1656 /* InitBasicFS for test_head_0: create ext2 on /dev/sda1 */
1658 char device[] = "/dev/sda";
1661 r = guestfs_blockdev_setrw (g, device);
1668 r = guestfs_umount_all (g);
1675 r = guestfs_lvm_remove_all (g);
1680 char device[] = "/dev/sda";
1681 char lines_0[] = ",";
1688 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1693 char fstype[] = "ext2";
1694 char device[] = "/dev/sda1";
1697 r = guestfs_mkfs (g, fstype, device);
1702 char device[] = "/dev/sda1";
1703 char mountpoint[] = "/";
1706 r = guestfs_mount (g, device, mountpoint);
1710 /* TestOutputList for head (0) */
1712 char options[] = "ro";
1713 char vfstype[] = "squashfs";
1714 char device[] = "/dev/sdd";
1715 char mountpoint[] = "/";
1718 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1723 char path[] = "/10klines";
1727 r = guestfs_head (g, path);
1731 fprintf (stderr, "test_head_0: short list returned from command\n");
1736 char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1737 if (strcmp (r[0], expected) != 0) {
1738 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1743 fprintf (stderr, "test_head_0: short list returned from command\n");
1748 char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1749 if (strcmp (r[1], expected) != 0) {
1750 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1755 fprintf (stderr, "test_head_0: short list returned from command\n");
1760 char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1761 if (strcmp (r[2], expected) != 0) {
1762 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1767 fprintf (stderr, "test_head_0: short list returned from command\n");
1772 char expected[] = "3abcdefghijklmnopqrstuvwxyz";
1773 if (strcmp (r[3], expected) != 0) {
1774 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1779 fprintf (stderr, "test_head_0: short list returned from command\n");
1784 char expected[] = "4abcdefghijklmnopqrstuvwxyz";
1785 if (strcmp (r[4], expected) != 0) {
1786 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
1791 fprintf (stderr, "test_head_0: short list returned from command\n");
1796 char expected[] = "5abcdefghijklmnopqrstuvwxyz";
1797 if (strcmp (r[5], expected) != 0) {
1798 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
1803 fprintf (stderr, "test_head_0: short list returned from command\n");
1808 char expected[] = "6abcdefghijklmnopqrstuvwxyz";
1809 if (strcmp (r[6], expected) != 0) {
1810 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
1815 fprintf (stderr, "test_head_0: short list returned from command\n");
1820 char expected[] = "7abcdefghijklmnopqrstuvwxyz";
1821 if (strcmp (r[7], expected) != 0) {
1822 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
1827 fprintf (stderr, "test_head_0: short list returned from command\n");
1832 char expected[] = "8abcdefghijklmnopqrstuvwxyz";
1833 if (strcmp (r[8], expected) != 0) {
1834 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
1839 fprintf (stderr, "test_head_0: short list returned from command\n");
1844 char expected[] = "9abcdefghijklmnopqrstuvwxyz";
1845 if (strcmp (r[9], expected) != 0) {
1846 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
1850 if (r[10] != NULL) {
1851 fprintf (stderr, "test_head_0: extra elements returned from command\n");
1855 for (i = 0; r[i] != NULL; ++i)
1862 static int test_wc_c_0_skip (void)
1866 str = getenv ("TEST_ONLY");
1868 return strstr (str, "wc_c") == NULL;
1869 str = getenv ("SKIP_TEST_WC_C_0");
1870 if (str && strcmp (str, "1") == 0) return 1;
1871 str = getenv ("SKIP_TEST_WC_C");
1872 if (str && strcmp (str, "1") == 0) return 1;
1876 static int test_wc_c_0 (void)
1878 if (test_wc_c_0_skip ()) {
1879 printf ("%s skipped (reason: environment variable set)\n", "test_wc_c_0");
1883 /* InitBasicFS for test_wc_c_0: create ext2 on /dev/sda1 */
1885 char device[] = "/dev/sda";
1888 r = guestfs_blockdev_setrw (g, device);
1895 r = guestfs_umount_all (g);
1902 r = guestfs_lvm_remove_all (g);
1907 char device[] = "/dev/sda";
1908 char lines_0[] = ",";
1915 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1920 char fstype[] = "ext2";
1921 char device[] = "/dev/sda1";
1924 r = guestfs_mkfs (g, fstype, device);
1929 char device[] = "/dev/sda1";
1930 char mountpoint[] = "/";
1933 r = guestfs_mount (g, device, mountpoint);
1937 /* TestOutputInt for wc_c (0) */
1939 char options[] = "ro";
1940 char vfstype[] = "squashfs";
1941 char device[] = "/dev/sdd";
1942 char mountpoint[] = "/";
1945 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1950 char path[] = "/100kallspaces";
1953 r = guestfs_wc_c (g, path);
1957 fprintf (stderr, "test_wc_c_0: expected 102400 but got %d\n", (int) r);
1964 static int test_wc_w_0_skip (void)
1968 str = getenv ("TEST_ONLY");
1970 return strstr (str, "wc_w") == NULL;
1971 str = getenv ("SKIP_TEST_WC_W_0");
1972 if (str && strcmp (str, "1") == 0) return 1;
1973 str = getenv ("SKIP_TEST_WC_W");
1974 if (str && strcmp (str, "1") == 0) return 1;
1978 static int test_wc_w_0 (void)
1980 if (test_wc_w_0_skip ()) {
1981 printf ("%s skipped (reason: environment variable set)\n", "test_wc_w_0");
1985 /* InitBasicFS for test_wc_w_0: create ext2 on /dev/sda1 */
1987 char device[] = "/dev/sda";
1990 r = guestfs_blockdev_setrw (g, device);
1997 r = guestfs_umount_all (g);
2004 r = guestfs_lvm_remove_all (g);
2009 char device[] = "/dev/sda";
2010 char lines_0[] = ",";
2017 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2022 char fstype[] = "ext2";
2023 char device[] = "/dev/sda1";
2026 r = guestfs_mkfs (g, fstype, device);
2031 char device[] = "/dev/sda1";
2032 char mountpoint[] = "/";
2035 r = guestfs_mount (g, device, mountpoint);
2039 /* TestOutputInt for wc_w (0) */
2041 char options[] = "ro";
2042 char vfstype[] = "squashfs";
2043 char device[] = "/dev/sdd";
2044 char mountpoint[] = "/";
2047 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2052 char path[] = "/10klines";
2055 r = guestfs_wc_w (g, path);
2059 fprintf (stderr, "test_wc_w_0: expected 10000 but got %d\n", (int) r);
2066 static int test_wc_l_0_skip (void)
2070 str = getenv ("TEST_ONLY");
2072 return strstr (str, "wc_l") == NULL;
2073 str = getenv ("SKIP_TEST_WC_L_0");
2074 if (str && strcmp (str, "1") == 0) return 1;
2075 str = getenv ("SKIP_TEST_WC_L");
2076 if (str && strcmp (str, "1") == 0) return 1;
2080 static int test_wc_l_0 (void)
2082 if (test_wc_l_0_skip ()) {
2083 printf ("%s skipped (reason: environment variable set)\n", "test_wc_l_0");
2087 /* InitBasicFS for test_wc_l_0: create ext2 on /dev/sda1 */
2089 char device[] = "/dev/sda";
2092 r = guestfs_blockdev_setrw (g, device);
2099 r = guestfs_umount_all (g);
2106 r = guestfs_lvm_remove_all (g);
2111 char device[] = "/dev/sda";
2112 char lines_0[] = ",";
2119 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2124 char fstype[] = "ext2";
2125 char device[] = "/dev/sda1";
2128 r = guestfs_mkfs (g, fstype, device);
2133 char device[] = "/dev/sda1";
2134 char mountpoint[] = "/";
2137 r = guestfs_mount (g, device, mountpoint);
2141 /* TestOutputInt for wc_l (0) */
2143 char options[] = "ro";
2144 char vfstype[] = "squashfs";
2145 char device[] = "/dev/sdd";
2146 char mountpoint[] = "/";
2149 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2154 char path[] = "/10klines";
2157 r = guestfs_wc_l (g, path);
2161 fprintf (stderr, "test_wc_l_0: expected 10000 but got %d\n", (int) r);
2168 static int test_mkdtemp_0_skip (void)
2172 str = getenv ("TEST_ONLY");
2174 return strstr (str, "mkdtemp") == NULL;
2175 str = getenv ("SKIP_TEST_MKDTEMP_0");
2176 if (str && strcmp (str, "1") == 0) return 1;
2177 str = getenv ("SKIP_TEST_MKDTEMP");
2178 if (str && strcmp (str, "1") == 0) return 1;
2182 static int test_mkdtemp_0 (void)
2184 if (test_mkdtemp_0_skip ()) {
2185 printf ("%s skipped (reason: environment variable set)\n", "test_mkdtemp_0");
2189 /* InitBasicFS for test_mkdtemp_0: create ext2 on /dev/sda1 */
2191 char device[] = "/dev/sda";
2194 r = guestfs_blockdev_setrw (g, device);
2201 r = guestfs_umount_all (g);
2208 r = guestfs_lvm_remove_all (g);
2213 char device[] = "/dev/sda";
2214 char lines_0[] = ",";
2221 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2226 char fstype[] = "ext2";
2227 char device[] = "/dev/sda1";
2230 r = guestfs_mkfs (g, fstype, device);
2235 char device[] = "/dev/sda1";
2236 char mountpoint[] = "/";
2239 r = guestfs_mount (g, device, mountpoint);
2243 /* TestRun for mkdtemp (0) */
2245 char path[] = "/tmp";
2248 r = guestfs_mkdir (g, path);
2253 char template[] = "/tmp/tmpXXXXXX";
2256 r = guestfs_mkdtemp (g, template);
2264 static int test_scrub_file_0_skip (void)
2268 str = getenv ("TEST_ONLY");
2270 return strstr (str, "scrub_file") == NULL;
2271 str = getenv ("SKIP_TEST_SCRUB_FILE_0");
2272 if (str && strcmp (str, "1") == 0) return 1;
2273 str = getenv ("SKIP_TEST_SCRUB_FILE");
2274 if (str && strcmp (str, "1") == 0) return 1;
2278 static int test_scrub_file_0 (void)
2280 if (test_scrub_file_0_skip ()) {
2281 printf ("%s skipped (reason: environment variable set)\n", "test_scrub_file_0");
2285 /* InitBasicFS for test_scrub_file_0: create ext2 on /dev/sda1 */
2287 char device[] = "/dev/sda";
2290 r = guestfs_blockdev_setrw (g, device);
2297 r = guestfs_umount_all (g);
2304 r = guestfs_lvm_remove_all (g);
2309 char device[] = "/dev/sda";
2310 char lines_0[] = ",";
2317 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2322 char fstype[] = "ext2";
2323 char device[] = "/dev/sda1";
2326 r = guestfs_mkfs (g, fstype, device);
2331 char device[] = "/dev/sda1";
2332 char mountpoint[] = "/";
2335 r = guestfs_mount (g, device, mountpoint);
2339 /* TestRun for scrub_file (0) */
2341 char path[] = "/file";
2342 char content[] = "content";
2345 r = guestfs_write_file (g, path, content, 0);
2350 char file[] = "/file";
2353 r = guestfs_scrub_file (g, file);
2360 static int test_scrub_device_0_skip (void)
2364 str = getenv ("TEST_ONLY");
2366 return strstr (str, "scrub_device") == NULL;
2367 str = getenv ("SKIP_TEST_SCRUB_DEVICE_0");
2368 if (str && strcmp (str, "1") == 0) return 1;
2369 str = getenv ("SKIP_TEST_SCRUB_DEVICE");
2370 if (str && strcmp (str, "1") == 0) return 1;
2374 static int test_scrub_device_0 (void)
2376 if (test_scrub_device_0_skip ()) {
2377 printf ("%s skipped (reason: environment variable set)\n", "test_scrub_device_0");
2381 /* InitNone|InitEmpty for test_scrub_device_0 */
2383 char device[] = "/dev/sda";
2386 r = guestfs_blockdev_setrw (g, device);
2393 r = guestfs_umount_all (g);
2400 r = guestfs_lvm_remove_all (g);
2404 /* TestRun for scrub_device (0) */
2406 char device[] = "/dev/sdc";
2409 r = guestfs_scrub_device (g, device);
2416 static int test_glob_expand_0_skip (void)
2420 str = getenv ("TEST_ONLY");
2422 return strstr (str, "glob_expand") == NULL;
2423 str = getenv ("SKIP_TEST_GLOB_EXPAND_0");
2424 if (str && strcmp (str, "1") == 0) return 1;
2425 str = getenv ("SKIP_TEST_GLOB_EXPAND");
2426 if (str && strcmp (str, "1") == 0) return 1;
2430 static int test_glob_expand_0 (void)
2432 if (test_glob_expand_0_skip ()) {
2433 printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_0");
2437 /* InitBasicFS for test_glob_expand_0: create ext2 on /dev/sda1 */
2439 char device[] = "/dev/sda";
2442 r = guestfs_blockdev_setrw (g, device);
2449 r = guestfs_umount_all (g);
2456 r = guestfs_lvm_remove_all (g);
2461 char device[] = "/dev/sda";
2462 char lines_0[] = ",";
2469 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2474 char fstype[] = "ext2";
2475 char device[] = "/dev/sda1";
2478 r = guestfs_mkfs (g, fstype, device);
2483 char device[] = "/dev/sda1";
2484 char mountpoint[] = "/";
2487 r = guestfs_mount (g, device, mountpoint);
2491 /* TestOutputList for glob_expand (0) */
2493 char path[] = "/a/b/c";
2496 r = guestfs_mkdir_p (g, path);
2501 char path[] = "/a/b/c/d";
2504 r = guestfs_touch (g, path);
2509 char path[] = "/a/b/c/e";
2512 r = guestfs_touch (g, path);
2517 char pattern[] = "/a/b/c/*";
2521 r = guestfs_glob_expand (g, pattern);
2525 fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
2530 char expected[] = "/a/b/c/d";
2531 if (strcmp (r[0], expected) != 0) {
2532 fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2537 fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
2542 char expected[] = "/a/b/c/e";
2543 if (strcmp (r[1], expected) != 0) {
2544 fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2549 fprintf (stderr, "test_glob_expand_0: extra elements returned from command\n");
2553 for (i = 0; r[i] != NULL; ++i)
2560 static int test_glob_expand_1_skip (void)
2564 str = getenv ("TEST_ONLY");
2566 return strstr (str, "glob_expand") == NULL;
2567 str = getenv ("SKIP_TEST_GLOB_EXPAND_1");
2568 if (str && strcmp (str, "1") == 0) return 1;
2569 str = getenv ("SKIP_TEST_GLOB_EXPAND");
2570 if (str && strcmp (str, "1") == 0) return 1;
2574 static int test_glob_expand_1 (void)
2576 if (test_glob_expand_1_skip ()) {
2577 printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_1");
2581 /* InitBasicFS for test_glob_expand_1: create ext2 on /dev/sda1 */
2583 char device[] = "/dev/sda";
2586 r = guestfs_blockdev_setrw (g, device);
2593 r = guestfs_umount_all (g);
2600 r = guestfs_lvm_remove_all (g);
2605 char device[] = "/dev/sda";
2606 char lines_0[] = ",";
2613 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2618 char fstype[] = "ext2";
2619 char device[] = "/dev/sda1";
2622 r = guestfs_mkfs (g, fstype, device);
2627 char device[] = "/dev/sda1";
2628 char mountpoint[] = "/";
2631 r = guestfs_mount (g, device, mountpoint);
2635 /* TestOutputList for glob_expand (1) */
2637 char path[] = "/a/b/c";
2640 r = guestfs_mkdir_p (g, path);
2645 char path[] = "/a/b/c/d";
2648 r = guestfs_touch (g, path);
2653 char path[] = "/a/b/c/e";
2656 r = guestfs_touch (g, path);
2661 char pattern[] = "/a/*/c/*";
2665 r = guestfs_glob_expand (g, pattern);
2669 fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
2674 char expected[] = "/a/b/c/d";
2675 if (strcmp (r[0], expected) != 0) {
2676 fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2681 fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
2686 char expected[] = "/a/b/c/e";
2687 if (strcmp (r[1], expected) != 0) {
2688 fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2693 fprintf (stderr, "test_glob_expand_1: extra elements returned from command\n");
2697 for (i = 0; r[i] != NULL; ++i)
2704 static int test_glob_expand_2_skip (void)
2708 str = getenv ("TEST_ONLY");
2710 return strstr (str, "glob_expand") == NULL;
2711 str = getenv ("SKIP_TEST_GLOB_EXPAND_2");
2712 if (str && strcmp (str, "1") == 0) return 1;
2713 str = getenv ("SKIP_TEST_GLOB_EXPAND");
2714 if (str && strcmp (str, "1") == 0) return 1;
2718 static int test_glob_expand_2 (void)
2720 if (test_glob_expand_2_skip ()) {
2721 printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_2");
2725 /* InitBasicFS for test_glob_expand_2: create ext2 on /dev/sda1 */
2727 char device[] = "/dev/sda";
2730 r = guestfs_blockdev_setrw (g, device);
2737 r = guestfs_umount_all (g);
2744 r = guestfs_lvm_remove_all (g);
2749 char device[] = "/dev/sda";
2750 char lines_0[] = ",";
2757 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2762 char fstype[] = "ext2";
2763 char device[] = "/dev/sda1";
2766 r = guestfs_mkfs (g, fstype, device);
2771 char device[] = "/dev/sda1";
2772 char mountpoint[] = "/";
2775 r = guestfs_mount (g, device, mountpoint);
2779 /* TestOutputList for glob_expand (2) */
2781 char path[] = "/a/b/c";
2784 r = guestfs_mkdir_p (g, path);
2789 char path[] = "/a/b/c/d";
2792 r = guestfs_touch (g, path);
2797 char path[] = "/a/b/c/e";
2800 r = guestfs_touch (g, path);
2805 char pattern[] = "/a/*/x/*";
2809 r = guestfs_glob_expand (g, pattern);
2813 fprintf (stderr, "test_glob_expand_2: extra elements returned from command\n");
2817 for (i = 0; r[i] != NULL; ++i)
2824 static int test_ntfs_3g_probe_0_skip (void)
2828 str = getenv ("TEST_ONLY");
2830 return strstr (str, "ntfs_3g_probe") == NULL;
2831 str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0");
2832 if (str && strcmp (str, "1") == 0) return 1;
2833 str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
2834 if (str && strcmp (str, "1") == 0) return 1;
2838 static int test_ntfs_3g_probe_0 (void)
2840 if (test_ntfs_3g_probe_0_skip ()) {
2841 printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_0");
2845 /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
2847 char device[] = "/dev/sda";
2850 r = guestfs_blockdev_setrw (g, device);
2857 r = guestfs_umount_all (g);
2864 r = guestfs_lvm_remove_all (g);
2868 /* TestOutputInt for ntfs_3g_probe (0) */
2870 char device[] = "/dev/sda";
2871 char lines_0[] = ",";
2878 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2883 char fstype[] = "ntfs";
2884 char device[] = "/dev/sda1";
2887 r = guestfs_mkfs (g, fstype, device);
2892 char device[] = "/dev/sda1";
2895 r = guestfs_ntfs_3g_probe (g, 1, device);
2899 fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n", (int) r);
2906 static int test_ntfs_3g_probe_1_skip (void)
2910 str = getenv ("TEST_ONLY");
2912 return strstr (str, "ntfs_3g_probe") == NULL;
2913 str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
2914 if (str && strcmp (str, "1") == 0) return 1;
2915 str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
2916 if (str && strcmp (str, "1") == 0) return 1;
2920 static int test_ntfs_3g_probe_1 (void)
2922 if (test_ntfs_3g_probe_1_skip ()) {
2923 printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_1");
2927 /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
2929 char device[] = "/dev/sda";
2932 r = guestfs_blockdev_setrw (g, device);
2939 r = guestfs_umount_all (g);
2946 r = guestfs_lvm_remove_all (g);
2950 /* TestOutputInt for ntfs_3g_probe (1) */
2952 char device[] = "/dev/sda";
2953 char lines_0[] = ",";
2960 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2965 char fstype[] = "ext2";
2966 char device[] = "/dev/sda1";
2969 r = guestfs_mkfs (g, fstype, device);
2974 char device[] = "/dev/sda1";
2977 r = guestfs_ntfs_3g_probe (g, 1, device);
2981 fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n", (int) r);
2988 static int test_sleep_0_skip (void)
2992 str = getenv ("TEST_ONLY");
2994 return strstr (str, "sleep") == NULL;
2995 str = getenv ("SKIP_TEST_SLEEP_0");
2996 if (str && strcmp (str, "1") == 0) return 1;
2997 str = getenv ("SKIP_TEST_SLEEP");
2998 if (str && strcmp (str, "1") == 0) return 1;
3002 static int test_sleep_0 (void)
3004 if (test_sleep_0_skip ()) {
3005 printf ("%s skipped (reason: environment variable set)\n", "test_sleep_0");
3009 /* InitNone|InitEmpty for test_sleep_0 */
3011 char device[] = "/dev/sda";
3014 r = guestfs_blockdev_setrw (g, device);
3021 r = guestfs_umount_all (g);
3028 r = guestfs_lvm_remove_all (g);
3032 /* TestRun for sleep (0) */
3036 r = guestfs_sleep (g, 1);
3043 static int test_find_0_skip (void)
3047 str = getenv ("TEST_ONLY");
3049 return strstr (str, "find") == NULL;
3050 str = getenv ("SKIP_TEST_FIND_0");
3051 if (str && strcmp (str, "1") == 0) return 1;
3052 str = getenv ("SKIP_TEST_FIND");
3053 if (str && strcmp (str, "1") == 0) return 1;
3057 static int test_find_0 (void)
3059 if (test_find_0_skip ()) {
3060 printf ("%s skipped (reason: environment variable set)\n", "test_find_0");
3064 /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
3066 char device[] = "/dev/sda";
3069 r = guestfs_blockdev_setrw (g, device);
3076 r = guestfs_umount_all (g);
3083 r = guestfs_lvm_remove_all (g);
3088 char device[] = "/dev/sda";
3089 char lines_0[] = ",";
3096 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3101 char fstype[] = "ext2";
3102 char device[] = "/dev/sda1";
3105 r = guestfs_mkfs (g, fstype, device);
3110 char device[] = "/dev/sda1";
3111 char mountpoint[] = "/";
3114 r = guestfs_mount (g, device, mountpoint);
3118 /* TestOutputList for find (0) */
3120 char directory[] = "/";
3124 r = guestfs_find (g, directory);
3128 fprintf (stderr, "test_find_0: short list returned from command\n");
3133 char expected[] = "lost+found";
3134 if (strcmp (r[0], expected) != 0) {
3135 fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3140 fprintf (stderr, "test_find_0: extra elements returned from command\n");
3144 for (i = 0; r[i] != NULL; ++i)
3151 static int test_find_1_skip (void)
3155 str = getenv ("TEST_ONLY");
3157 return strstr (str, "find") == NULL;
3158 str = getenv ("SKIP_TEST_FIND_1");
3159 if (str && strcmp (str, "1") == 0) return 1;
3160 str = getenv ("SKIP_TEST_FIND");
3161 if (str && strcmp (str, "1") == 0) return 1;
3165 static int test_find_1 (void)
3167 if (test_find_1_skip ()) {
3168 printf ("%s skipped (reason: environment variable set)\n", "test_find_1");
3172 /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
3174 char device[] = "/dev/sda";
3177 r = guestfs_blockdev_setrw (g, device);
3184 r = guestfs_umount_all (g);
3191 r = guestfs_lvm_remove_all (g);
3196 char device[] = "/dev/sda";
3197 char lines_0[] = ",";
3204 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3209 char fstype[] = "ext2";
3210 char device[] = "/dev/sda1";
3213 r = guestfs_mkfs (g, fstype, device);
3218 char device[] = "/dev/sda1";
3219 char mountpoint[] = "/";
3222 r = guestfs_mount (g, device, mountpoint);
3226 /* TestOutputList for find (1) */
3231 r = guestfs_touch (g, path);
3239 r = guestfs_mkdir (g, path);
3244 char path[] = "/b/c";
3247 r = guestfs_touch (g, path);
3252 char directory[] = "/";
3256 r = guestfs_find (g, directory);
3260 fprintf (stderr, "test_find_1: short list returned from command\n");
3265 char expected[] = "a";
3266 if (strcmp (r[0], expected) != 0) {
3267 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3272 fprintf (stderr, "test_find_1: short list returned from command\n");
3277 char expected[] = "b";
3278 if (strcmp (r[1], expected) != 0) {
3279 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3284 fprintf (stderr, "test_find_1: short list returned from command\n");
3289 char expected[] = "b/c";
3290 if (strcmp (r[2], expected) != 0) {
3291 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
3296 fprintf (stderr, "test_find_1: short list returned from command\n");
3301 char expected[] = "lost+found";
3302 if (strcmp (r[3], expected) != 0) {
3303 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
3308 fprintf (stderr, "test_find_1: extra elements returned from command\n");
3312 for (i = 0; r[i] != NULL; ++i)
3319 static int test_find_2_skip (void)
3323 str = getenv ("TEST_ONLY");
3325 return strstr (str, "find") == NULL;
3326 str = getenv ("SKIP_TEST_FIND_2");
3327 if (str && strcmp (str, "1") == 0) return 1;
3328 str = getenv ("SKIP_TEST_FIND");
3329 if (str && strcmp (str, "1") == 0) return 1;
3333 static int test_find_2 (void)
3335 if (test_find_2_skip ()) {
3336 printf ("%s skipped (reason: environment variable set)\n", "test_find_2");
3340 /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
3342 char device[] = "/dev/sda";
3345 r = guestfs_blockdev_setrw (g, device);
3352 r = guestfs_umount_all (g);
3359 r = guestfs_lvm_remove_all (g);
3364 char device[] = "/dev/sda";
3365 char lines_0[] = ",";
3372 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3377 char fstype[] = "ext2";
3378 char device[] = "/dev/sda1";
3381 r = guestfs_mkfs (g, fstype, device);
3386 char device[] = "/dev/sda1";
3387 char mountpoint[] = "/";
3390 r = guestfs_mount (g, device, mountpoint);
3394 /* TestOutputList for find (2) */
3396 char path[] = "/a/b/c";
3399 r = guestfs_mkdir_p (g, path);
3404 char path[] = "/a/b/c/d";
3407 r = guestfs_touch (g, path);
3412 char directory[] = "/a/b/";
3416 r = guestfs_find (g, directory);
3420 fprintf (stderr, "test_find_2: short list returned from command\n");
3425 char expected[] = "c";
3426 if (strcmp (r[0], expected) != 0) {
3427 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3432 fprintf (stderr, "test_find_2: short list returned from command\n");
3437 char expected[] = "c/d";
3438 if (strcmp (r[1], expected) != 0) {
3439 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3444 fprintf (stderr, "test_find_2: extra elements returned from command\n");
3448 for (i = 0; r[i] != NULL; ++i)
3455 static int test_lvresize_0_skip (void)
3459 str = getenv ("TEST_ONLY");
3461 return strstr (str, "lvresize") == NULL;
3462 str = getenv ("SKIP_TEST_LVRESIZE_0");
3463 if (str && strcmp (str, "1") == 0) return 1;
3464 str = getenv ("SKIP_TEST_LVRESIZE");
3465 if (str && strcmp (str, "1") == 0) return 1;
3469 static int test_lvresize_0 (void)
3471 if (test_lvresize_0_skip ()) {
3472 printf ("%s skipped (reason: environment variable set)\n", "test_lvresize_0");
3476 /* InitNone|InitEmpty for test_lvresize_0 */
3478 char device[] = "/dev/sda";
3481 r = guestfs_blockdev_setrw (g, device);
3488 r = guestfs_umount_all (g);
3495 r = guestfs_lvm_remove_all (g);
3499 /* TestOutput for lvresize (0) */
3500 char expected[] = "test content";
3502 char device[] = "/dev/sda";
3503 char lines_0[] = ",";
3510 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3515 char device[] = "/dev/sda1";
3518 r = guestfs_pvcreate (g, device);
3523 char volgroup[] = "VG";
3524 char physvols_0[] = "/dev/sda1";
3525 char *physvols[] = {
3531 r = guestfs_vgcreate (g, volgroup, physvols);
3536 char logvol[] = "LV";
3537 char volgroup[] = "VG";
3540 r = guestfs_lvcreate (g, logvol, volgroup, 10);
3545 char fstype[] = "ext2";
3546 char device[] = "/dev/VG/LV";
3549 r = guestfs_mkfs (g, fstype, device);
3554 char device[] = "/dev/VG/LV";
3555 char mountpoint[] = "/";
3558 r = guestfs_mount (g, device, mountpoint);
3563 char path[] = "/new";
3564 char content[] = "test content";
3567 r = guestfs_write_file (g, path, content, 0);
3572 char pathordevice[] = "/";
3575 r = guestfs_umount (g, pathordevice);
3580 char device[] = "/dev/VG/LV";
3583 r = guestfs_lvresize (g, device, 20);
3588 char device[] = "/dev/VG/LV";
3591 r = guestfs_e2fsck_f (g, device);
3596 char device[] = "/dev/VG/LV";
3599 r = guestfs_resize2fs (g, device);
3604 char device[] = "/dev/VG/LV";
3605 char mountpoint[] = "/";
3608 r = guestfs_mount (g, device, mountpoint);
3613 char path[] = "/new";
3616 r = guestfs_cat (g, path);
3619 if (strcmp (r, expected) != 0) {
3620 fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
3628 static int test_zerofree_0_skip (void)
3632 str = getenv ("TEST_ONLY");
3634 return strstr (str, "zerofree") == NULL;
3635 str = getenv ("SKIP_TEST_ZEROFREE_0");
3636 if (str && strcmp (str, "1") == 0) return 1;
3637 str = getenv ("SKIP_TEST_ZEROFREE");
3638 if (str && strcmp (str, "1") == 0) return 1;
3642 static int test_zerofree_0 (void)
3644 if (test_zerofree_0_skip ()) {
3645 printf ("%s skipped (reason: environment variable set)\n", "test_zerofree_0");
3649 /* InitNone|InitEmpty for test_zerofree_0 */
3651 char device[] = "/dev/sda";
3654 r = guestfs_blockdev_setrw (g, device);
3661 r = guestfs_umount_all (g);
3668 r = guestfs_lvm_remove_all (g);
3672 /* TestOutput for zerofree (0) */
3673 char expected[] = "test file";
3675 char device[] = "/dev/sda";
3676 char lines_0[] = ",";
3683 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3688 char fstype[] = "ext3";
3689 char device[] = "/dev/sda1";
3692 r = guestfs_mkfs (g, fstype, device);
3697 char device[] = "/dev/sda1";
3698 char mountpoint[] = "/";
3701 r = guestfs_mount (g, device, mountpoint);
3706 char path[] = "/new";
3707 char content[] = "test file";
3710 r = guestfs_write_file (g, path, content, 0);
3715 char pathordevice[] = "/dev/sda1";
3718 r = guestfs_umount (g, pathordevice);
3723 char device[] = "/dev/sda1";
3726 r = guestfs_zerofree (g, device);
3731 char device[] = "/dev/sda1";
3732 char mountpoint[] = "/";
3735 r = guestfs_mount (g, device, mountpoint);
3740 char path[] = "/new";
3743 r = guestfs_cat (g, path);
3746 if (strcmp (r, expected) != 0) {
3747 fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
3755 static int test_hexdump_0_skip (void)
3759 str = getenv ("TEST_ONLY");
3761 return strstr (str, "hexdump") == NULL;
3762 str = getenv ("SKIP_TEST_HEXDUMP_0");
3763 if (str && strcmp (str, "1") == 0) return 1;
3764 str = getenv ("SKIP_TEST_HEXDUMP");
3765 if (str && strcmp (str, "1") == 0) return 1;
3769 static int test_hexdump_0 (void)
3771 if (test_hexdump_0_skip ()) {
3772 printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_0");
3776 /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
3778 char device[] = "/dev/sda";
3781 r = guestfs_blockdev_setrw (g, device);
3788 r = guestfs_umount_all (g);
3795 r = guestfs_lvm_remove_all (g);
3800 char device[] = "/dev/sda";
3801 char lines_0[] = ",";
3808 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3813 char fstype[] = "ext2";
3814 char device[] = "/dev/sda1";
3817 r = guestfs_mkfs (g, fstype, device);
3822 char device[] = "/dev/sda1";
3823 char mountpoint[] = "/";
3826 r = guestfs_mount (g, device, mountpoint);
3830 /* TestOutput for hexdump (0) */
3831 char expected[] = "00000000 68 65 6c 6c 6f 0a 77 6f 72 6c 64 0a |hello.world.|\n0000000c\n";
3833 char path[] = "/new";
3834 char content[] = "hello\nworld\n";
3837 r = guestfs_write_file (g, path, content, 12);
3842 char path[] = "/new";
3845 r = guestfs_hexdump (g, path);
3848 if (strcmp (r, expected) != 0) {
3849 fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
3857 static int test_hexdump_1_skip (void)
3861 str = getenv ("TEST_ONLY");
3863 return strstr (str, "hexdump") == NULL;
3864 str = getenv ("SKIP_TEST_HEXDUMP_1");
3865 if (str && strcmp (str, "1") == 0) return 1;
3866 str = getenv ("SKIP_TEST_HEXDUMP");
3867 if (str && strcmp (str, "1") == 0) return 1;
3871 static int test_hexdump_1 (void)
3873 if (test_hexdump_1_skip ()) {
3874 printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_1");
3878 /* InitBasicFS for test_hexdump_1: create ext2 on /dev/sda1 */
3880 char device[] = "/dev/sda";
3883 r = guestfs_blockdev_setrw (g, device);
3890 r = guestfs_umount_all (g);
3897 r = guestfs_lvm_remove_all (g);
3902 char device[] = "/dev/sda";
3903 char lines_0[] = ",";
3910 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3915 char fstype[] = "ext2";
3916 char device[] = "/dev/sda1";
3919 r = guestfs_mkfs (g, fstype, device);
3924 char device[] = "/dev/sda1";
3925 char mountpoint[] = "/";
3928 r = guestfs_mount (g, device, mountpoint);
3932 /* TestRun for hexdump (1) */
3934 char options[] = "ro";
3935 char vfstype[] = "squashfs";
3936 char device[] = "/dev/sdd";
3937 char mountpoint[] = "/";
3940 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3945 char path[] = "/100krandom";
3948 r = guestfs_hexdump (g, path);
3956 static int test_strings_e_0_skip (void)
3960 str = getenv ("TEST_ONLY");
3962 return strstr (str, "strings_e") == NULL;
3963 str = getenv ("SKIP_TEST_STRINGS_E_0");
3964 if (str && strcmp (str, "1") == 0) return 1;
3965 str = getenv ("SKIP_TEST_STRINGS_E");
3966 if (str && strcmp (str, "1") == 0) return 1;
3970 static int test_strings_e_0 (void)
3972 if (test_strings_e_0_skip ()) {
3973 printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_0");
3977 /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
3979 char device[] = "/dev/sda";
3982 r = guestfs_blockdev_setrw (g, device);
3989 r = guestfs_umount_all (g);
3996 r = guestfs_lvm_remove_all (g);
4001 char device[] = "/dev/sda";
4002 char lines_0[] = ",";
4009 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4014 char fstype[] = "ext2";
4015 char device[] = "/dev/sda1";
4018 r = guestfs_mkfs (g, fstype, device);
4023 char device[] = "/dev/sda1";
4024 char mountpoint[] = "/";
4027 r = guestfs_mount (g, device, mountpoint);
4031 /* TestOutputList for strings_e (0) */
4033 char path[] = "/new";
4034 char content[] = "hello\nworld\n";
4037 r = guestfs_write_file (g, path, content, 0);
4042 char encoding[] = "b";
4043 char path[] = "/new";
4047 r = guestfs_strings_e (g, encoding, path);
4051 fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
4055 for (i = 0; r[i] != NULL; ++i)
4062 static int test_strings_e_1_skip (void)
4066 str = getenv ("TEST_ONLY");
4068 return strstr (str, "strings_e") == NULL;
4069 str = getenv ("SKIP_TEST_STRINGS_E_1");
4070 if (str && strcmp (str, "1") == 0) return 1;
4071 str = getenv ("SKIP_TEST_STRINGS_E");
4072 if (str && strcmp (str, "1") == 0) return 1;
4076 static int test_strings_e_1 (void)
4078 if (test_strings_e_1_skip ()) {
4079 printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_1");
4083 printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
4087 static int test_strings_0_skip (void)
4091 str = getenv ("TEST_ONLY");
4093 return strstr (str, "strings") == NULL;
4094 str = getenv ("SKIP_TEST_STRINGS_0");
4095 if (str && strcmp (str, "1") == 0) return 1;
4096 str = getenv ("SKIP_TEST_STRINGS");
4097 if (str && strcmp (str, "1") == 0) return 1;
4101 static int test_strings_0 (void)
4103 if (test_strings_0_skip ()) {
4104 printf ("%s skipped (reason: environment variable set)\n", "test_strings_0");
4108 /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
4110 char device[] = "/dev/sda";
4113 r = guestfs_blockdev_setrw (g, device);
4120 r = guestfs_umount_all (g);
4127 r = guestfs_lvm_remove_all (g);
4132 char device[] = "/dev/sda";
4133 char lines_0[] = ",";
4140 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4145 char fstype[] = "ext2";
4146 char device[] = "/dev/sda1";
4149 r = guestfs_mkfs (g, fstype, device);
4154 char device[] = "/dev/sda1";
4155 char mountpoint[] = "/";
4158 r = guestfs_mount (g, device, mountpoint);
4162 /* TestOutputList for strings (0) */
4164 char path[] = "/new";
4165 char content[] = "hello\nworld\n";
4168 r = guestfs_write_file (g, path, content, 0);
4173 char path[] = "/new";
4177 r = guestfs_strings (g, path);
4181 fprintf (stderr, "test_strings_0: short list returned from command\n");
4186 char expected[] = "hello";
4187 if (strcmp (r[0], expected) != 0) {
4188 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4193 fprintf (stderr, "test_strings_0: short list returned from command\n");
4198 char expected[] = "world";
4199 if (strcmp (r[1], expected) != 0) {
4200 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
4205 fprintf (stderr, "test_strings_0: extra elements returned from command\n");
4209 for (i = 0; r[i] != NULL; ++i)
4216 static int test_strings_1_skip (void)
4220 str = getenv ("TEST_ONLY");
4222 return strstr (str, "strings") == NULL;
4223 str = getenv ("SKIP_TEST_STRINGS_1");
4224 if (str && strcmp (str, "1") == 0) return 1;
4225 str = getenv ("SKIP_TEST_STRINGS");
4226 if (str && strcmp (str, "1") == 0) return 1;
4230 static int test_strings_1 (void)
4232 if (test_strings_1_skip ()) {
4233 printf ("%s skipped (reason: environment variable set)\n", "test_strings_1");
4237 /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
4239 char device[] = "/dev/sda";
4242 r = guestfs_blockdev_setrw (g, device);
4249 r = guestfs_umount_all (g);
4256 r = guestfs_lvm_remove_all (g);
4261 char device[] = "/dev/sda";
4262 char lines_0[] = ",";
4269 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4274 char fstype[] = "ext2";
4275 char device[] = "/dev/sda1";
4278 r = guestfs_mkfs (g, fstype, device);
4283 char device[] = "/dev/sda1";
4284 char mountpoint[] = "/";
4287 r = guestfs_mount (g, device, mountpoint);
4291 /* TestOutputList for strings (1) */
4293 char path[] = "/new";
4296 r = guestfs_touch (g, path);
4301 char path[] = "/new";
4305 r = guestfs_strings (g, path);
4309 fprintf (stderr, "test_strings_1: extra elements returned from command\n");
4313 for (i = 0; r[i] != NULL; ++i)
4320 static int test_equal_0_skip (void)
4324 str = getenv ("TEST_ONLY");
4326 return strstr (str, "equal") == NULL;
4327 str = getenv ("SKIP_TEST_EQUAL_0");
4328 if (str && strcmp (str, "1") == 0) return 1;
4329 str = getenv ("SKIP_TEST_EQUAL");
4330 if (str && strcmp (str, "1") == 0) return 1;
4334 static int test_equal_0 (void)
4336 if (test_equal_0_skip ()) {
4337 printf ("%s skipped (reason: environment variable set)\n", "test_equal_0");
4341 /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
4343 char device[] = "/dev/sda";
4346 r = guestfs_blockdev_setrw (g, device);
4353 r = guestfs_umount_all (g);
4360 r = guestfs_lvm_remove_all (g);
4365 char device[] = "/dev/sda";
4366 char lines_0[] = ",";
4373 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4378 char fstype[] = "ext2";
4379 char device[] = "/dev/sda1";
4382 r = guestfs_mkfs (g, fstype, device);
4387 char device[] = "/dev/sda1";
4388 char mountpoint[] = "/";
4391 r = guestfs_mount (g, device, mountpoint);
4395 /* TestOutputTrue for equal (0) */
4397 char path[] = "/file1";
4398 char content[] = "contents of a file";
4401 r = guestfs_write_file (g, path, content, 0);
4406 char src[] = "/file1";
4407 char dest[] = "/file2";
4410 r = guestfs_cp (g, src, dest);
4415 char file1[] = "/file1";
4416 char file2[] = "/file2";
4419 r = guestfs_equal (g, file1, file2);
4423 fprintf (stderr, "test_equal_0: expected true, got false\n");
4430 static int test_equal_1_skip (void)
4434 str = getenv ("TEST_ONLY");
4436 return strstr (str, "equal") == NULL;
4437 str = getenv ("SKIP_TEST_EQUAL_1");
4438 if (str && strcmp (str, "1") == 0) return 1;
4439 str = getenv ("SKIP_TEST_EQUAL");
4440 if (str && strcmp (str, "1") == 0) return 1;
4444 static int test_equal_1 (void)
4446 if (test_equal_1_skip ()) {
4447 printf ("%s skipped (reason: environment variable set)\n", "test_equal_1");
4451 /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
4453 char device[] = "/dev/sda";
4456 r = guestfs_blockdev_setrw (g, device);
4463 r = guestfs_umount_all (g);
4470 r = guestfs_lvm_remove_all (g);
4475 char device[] = "/dev/sda";
4476 char lines_0[] = ",";
4483 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4488 char fstype[] = "ext2";
4489 char device[] = "/dev/sda1";
4492 r = guestfs_mkfs (g, fstype, device);
4497 char device[] = "/dev/sda1";
4498 char mountpoint[] = "/";
4501 r = guestfs_mount (g, device, mountpoint);
4505 /* TestOutputFalse for equal (1) */
4507 char path[] = "/file1";
4508 char content[] = "contents of a file";
4511 r = guestfs_write_file (g, path, content, 0);
4516 char path[] = "/file2";
4517 char content[] = "contents of another file";
4520 r = guestfs_write_file (g, path, content, 0);
4525 char file1[] = "/file1";
4526 char file2[] = "/file2";
4529 r = guestfs_equal (g, file1, file2);
4533 fprintf (stderr, "test_equal_1: expected false, got true\n");
4540 static int test_equal_2_skip (void)
4544 str = getenv ("TEST_ONLY");
4546 return strstr (str, "equal") == NULL;
4547 str = getenv ("SKIP_TEST_EQUAL_2");
4548 if (str && strcmp (str, "1") == 0) return 1;
4549 str = getenv ("SKIP_TEST_EQUAL");
4550 if (str && strcmp (str, "1") == 0) return 1;
4554 static int test_equal_2 (void)
4556 if (test_equal_2_skip ()) {
4557 printf ("%s skipped (reason: environment variable set)\n", "test_equal_2");
4561 /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
4563 char device[] = "/dev/sda";
4566 r = guestfs_blockdev_setrw (g, device);
4573 r = guestfs_umount_all (g);
4580 r = guestfs_lvm_remove_all (g);
4585 char device[] = "/dev/sda";
4586 char lines_0[] = ",";
4593 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4598 char fstype[] = "ext2";
4599 char device[] = "/dev/sda1";
4602 r = guestfs_mkfs (g, fstype, device);
4607 char device[] = "/dev/sda1";
4608 char mountpoint[] = "/";
4611 r = guestfs_mount (g, device, mountpoint);
4615 /* TestLastFail for equal (2) */
4617 char file1[] = "/file1";
4618 char file2[] = "/file2";
4621 r = guestfs_equal (g, file1, file2);
4628 static int test_ping_daemon_0_skip (void)
4632 str = getenv ("TEST_ONLY");
4634 return strstr (str, "ping_daemon") == NULL;
4635 str = getenv ("SKIP_TEST_PING_DAEMON_0");
4636 if (str && strcmp (str, "1") == 0) return 1;
4637 str = getenv ("SKIP_TEST_PING_DAEMON");
4638 if (str && strcmp (str, "1") == 0) return 1;
4642 static int test_ping_daemon_0 (void)
4644 if (test_ping_daemon_0_skip ()) {
4645 printf ("%s skipped (reason: environment variable set)\n", "test_ping_daemon_0");
4649 /* InitNone|InitEmpty for test_ping_daemon_0 */
4651 char device[] = "/dev/sda";
4654 r = guestfs_blockdev_setrw (g, device);
4661 r = guestfs_umount_all (g);
4668 r = guestfs_lvm_remove_all (g);
4672 /* TestRun for ping_daemon (0) */
4676 r = guestfs_ping_daemon (g);
4683 static int test_dmesg_0_skip (void)
4687 str = getenv ("TEST_ONLY");
4689 return strstr (str, "dmesg") == NULL;
4690 str = getenv ("SKIP_TEST_DMESG_0");
4691 if (str && strcmp (str, "1") == 0) return 1;
4692 str = getenv ("SKIP_TEST_DMESG");
4693 if (str && strcmp (str, "1") == 0) return 1;
4697 static int test_dmesg_0 (void)
4699 if (test_dmesg_0_skip ()) {
4700 printf ("%s skipped (reason: environment variable set)\n", "test_dmesg_0");
4704 /* InitNone|InitEmpty for test_dmesg_0 */
4706 char device[] = "/dev/sda";
4709 r = guestfs_blockdev_setrw (g, device);
4716 r = guestfs_umount_all (g);
4723 r = guestfs_lvm_remove_all (g);
4727 /* TestRun for dmesg (0) */
4731 r = guestfs_dmesg (g);
4739 static int test_drop_caches_0_skip (void)
4743 str = getenv ("TEST_ONLY");
4745 return strstr (str, "drop_caches") == NULL;
4746 str = getenv ("SKIP_TEST_DROP_CACHES_0");
4747 if (str && strcmp (str, "1") == 0) return 1;
4748 str = getenv ("SKIP_TEST_DROP_CACHES");
4749 if (str && strcmp (str, "1") == 0) return 1;
4753 static int test_drop_caches_0 (void)
4755 if (test_drop_caches_0_skip ()) {
4756 printf ("%s skipped (reason: environment variable set)\n", "test_drop_caches_0");
4760 /* InitNone|InitEmpty for test_drop_caches_0 */
4762 char device[] = "/dev/sda";
4765 r = guestfs_blockdev_setrw (g, device);
4772 r = guestfs_umount_all (g);
4779 r = guestfs_lvm_remove_all (g);
4783 /* TestRun for drop_caches (0) */
4787 r = guestfs_drop_caches (g, 3);
4794 static int test_mv_0_skip (void)
4798 str = getenv ("TEST_ONLY");
4800 return strstr (str, "mv") == NULL;
4801 str = getenv ("SKIP_TEST_MV_0");
4802 if (str && strcmp (str, "1") == 0) return 1;
4803 str = getenv ("SKIP_TEST_MV");
4804 if (str && strcmp (str, "1") == 0) return 1;
4808 static int test_mv_0 (void)
4810 if (test_mv_0_skip ()) {
4811 printf ("%s skipped (reason: environment variable set)\n", "test_mv_0");
4815 /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
4817 char device[] = "/dev/sda";
4820 r = guestfs_blockdev_setrw (g, device);
4827 r = guestfs_umount_all (g);
4834 r = guestfs_lvm_remove_all (g);
4839 char device[] = "/dev/sda";
4840 char lines_0[] = ",";
4847 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4852 char fstype[] = "ext2";
4853 char device[] = "/dev/sda1";
4856 r = guestfs_mkfs (g, fstype, device);
4861 char device[] = "/dev/sda1";
4862 char mountpoint[] = "/";
4865 r = guestfs_mount (g, device, mountpoint);
4869 /* TestOutput for mv (0) */
4870 char expected[] = "file content";
4872 char path[] = "/old";
4873 char content[] = "file content";
4876 r = guestfs_write_file (g, path, content, 0);
4881 char src[] = "/old";
4882 char dest[] = "/new";
4885 r = guestfs_mv (g, src, dest);
4890 char path[] = "/new";
4893 r = guestfs_cat (g, path);
4896 if (strcmp (r, expected) != 0) {
4897 fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
4905 static int test_mv_1_skip (void)
4909 str = getenv ("TEST_ONLY");
4911 return strstr (str, "mv") == NULL;
4912 str = getenv ("SKIP_TEST_MV_1");
4913 if (str && strcmp (str, "1") == 0) return 1;
4914 str = getenv ("SKIP_TEST_MV");
4915 if (str && strcmp (str, "1") == 0) return 1;
4919 static int test_mv_1 (void)
4921 if (test_mv_1_skip ()) {
4922 printf ("%s skipped (reason: environment variable set)\n", "test_mv_1");
4926 /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
4928 char device[] = "/dev/sda";
4931 r = guestfs_blockdev_setrw (g, device);
4938 r = guestfs_umount_all (g);
4945 r = guestfs_lvm_remove_all (g);
4950 char device[] = "/dev/sda";
4951 char lines_0[] = ",";
4958 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4963 char fstype[] = "ext2";
4964 char device[] = "/dev/sda1";
4967 r = guestfs_mkfs (g, fstype, device);
4972 char device[] = "/dev/sda1";
4973 char mountpoint[] = "/";
4976 r = guestfs_mount (g, device, mountpoint);
4980 /* TestOutputFalse for mv (1) */
4982 char path[] = "/old";
4983 char content[] = "file content";
4986 r = guestfs_write_file (g, path, content, 0);
4991 char src[] = "/old";
4992 char dest[] = "/new";
4995 r = guestfs_mv (g, src, dest);
5000 char path[] = "/old";
5003 r = guestfs_is_file (g, path);
5007 fprintf (stderr, "test_mv_1: expected false, got true\n");
5014 static int test_cp_a_0_skip (void)
5018 str = getenv ("TEST_ONLY");
5020 return strstr (str, "cp_a") == NULL;
5021 str = getenv ("SKIP_TEST_CP_A_0");
5022 if (str && strcmp (str, "1") == 0) return 1;
5023 str = getenv ("SKIP_TEST_CP_A");
5024 if (str && strcmp (str, "1") == 0) return 1;
5028 static int test_cp_a_0 (void)
5030 if (test_cp_a_0_skip ()) {
5031 printf ("%s skipped (reason: environment variable set)\n", "test_cp_a_0");
5035 /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
5037 char device[] = "/dev/sda";
5040 r = guestfs_blockdev_setrw (g, device);
5047 r = guestfs_umount_all (g);
5054 r = guestfs_lvm_remove_all (g);
5059 char device[] = "/dev/sda";
5060 char lines_0[] = ",";
5067 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5072 char fstype[] = "ext2";
5073 char device[] = "/dev/sda1";
5076 r = guestfs_mkfs (g, fstype, device);
5081 char device[] = "/dev/sda1";
5082 char mountpoint[] = "/";
5085 r = guestfs_mount (g, device, mountpoint);
5089 /* TestOutput for cp_a (0) */
5090 char expected[] = "file content";
5092 char path[] = "/olddir";
5095 r = guestfs_mkdir (g, path);
5100 char path[] = "/newdir";
5103 r = guestfs_mkdir (g, path);
5108 char path[] = "/olddir/file";
5109 char content[] = "file content";
5112 r = guestfs_write_file (g, path, content, 0);
5117 char src[] = "/olddir";
5118 char dest[] = "/newdir";
5121 r = guestfs_cp_a (g, src, dest);
5126 char path[] = "/newdir/olddir/file";
5129 r = guestfs_cat (g, path);
5132 if (strcmp (r, expected) != 0) {
5133 fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
5141 static int test_cp_0_skip (void)
5145 str = getenv ("TEST_ONLY");
5147 return strstr (str, "cp") == NULL;
5148 str = getenv ("SKIP_TEST_CP_0");
5149 if (str && strcmp (str, "1") == 0) return 1;
5150 str = getenv ("SKIP_TEST_CP");
5151 if (str && strcmp (str, "1") == 0) return 1;
5155 static int test_cp_0 (void)
5157 if (test_cp_0_skip ()) {
5158 printf ("%s skipped (reason: environment variable set)\n", "test_cp_0");
5162 /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
5164 char device[] = "/dev/sda";
5167 r = guestfs_blockdev_setrw (g, device);
5174 r = guestfs_umount_all (g);
5181 r = guestfs_lvm_remove_all (g);
5186 char device[] = "/dev/sda";
5187 char lines_0[] = ",";
5194 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5199 char fstype[] = "ext2";
5200 char device[] = "/dev/sda1";
5203 r = guestfs_mkfs (g, fstype, device);
5208 char device[] = "/dev/sda1";
5209 char mountpoint[] = "/";
5212 r = guestfs_mount (g, device, mountpoint);
5216 /* TestOutput for cp (0) */
5217 char expected[] = "file content";
5219 char path[] = "/old";
5220 char content[] = "file content";
5223 r = guestfs_write_file (g, path, content, 0);
5228 char src[] = "/old";
5229 char dest[] = "/new";
5232 r = guestfs_cp (g, src, dest);
5237 char path[] = "/new";
5240 r = guestfs_cat (g, path);
5243 if (strcmp (r, expected) != 0) {
5244 fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
5252 static int test_cp_1_skip (void)
5256 str = getenv ("TEST_ONLY");
5258 return strstr (str, "cp") == NULL;
5259 str = getenv ("SKIP_TEST_CP_1");
5260 if (str && strcmp (str, "1") == 0) return 1;
5261 str = getenv ("SKIP_TEST_CP");
5262 if (str && strcmp (str, "1") == 0) return 1;
5266 static int test_cp_1 (void)
5268 if (test_cp_1_skip ()) {
5269 printf ("%s skipped (reason: environment variable set)\n", "test_cp_1");
5273 /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
5275 char device[] = "/dev/sda";
5278 r = guestfs_blockdev_setrw (g, device);
5285 r = guestfs_umount_all (g);
5292 r = guestfs_lvm_remove_all (g);
5297 char device[] = "/dev/sda";
5298 char lines_0[] = ",";
5305 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5310 char fstype[] = "ext2";
5311 char device[] = "/dev/sda1";
5314 r = guestfs_mkfs (g, fstype, device);
5319 char device[] = "/dev/sda1";
5320 char mountpoint[] = "/";
5323 r = guestfs_mount (g, device, mountpoint);
5327 /* TestOutputTrue for cp (1) */
5329 char path[] = "/old";
5330 char content[] = "file content";
5333 r = guestfs_write_file (g, path, content, 0);
5338 char src[] = "/old";
5339 char dest[] = "/new";
5342 r = guestfs_cp (g, src, dest);
5347 char path[] = "/old";
5350 r = guestfs_is_file (g, path);
5354 fprintf (stderr, "test_cp_1: expected true, got false\n");
5361 static int test_cp_2_skip (void)
5365 str = getenv ("TEST_ONLY");
5367 return strstr (str, "cp") == NULL;
5368 str = getenv ("SKIP_TEST_CP_2");
5369 if (str && strcmp (str, "1") == 0) return 1;
5370 str = getenv ("SKIP_TEST_CP");
5371 if (str && strcmp (str, "1") == 0) return 1;
5375 static int test_cp_2 (void)
5377 if (test_cp_2_skip ()) {
5378 printf ("%s skipped (reason: environment variable set)\n", "test_cp_2");
5382 /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
5384 char device[] = "/dev/sda";
5387 r = guestfs_blockdev_setrw (g, device);
5394 r = guestfs_umount_all (g);
5401 r = guestfs_lvm_remove_all (g);
5406 char device[] = "/dev/sda";
5407 char lines_0[] = ",";
5414 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5419 char fstype[] = "ext2";
5420 char device[] = "/dev/sda1";
5423 r = guestfs_mkfs (g, fstype, device);
5428 char device[] = "/dev/sda1";
5429 char mountpoint[] = "/";
5432 r = guestfs_mount (g, device, mountpoint);
5436 /* TestOutput for cp (2) */
5437 char expected[] = "file content";
5439 char path[] = "/old";
5440 char content[] = "file content";
5443 r = guestfs_write_file (g, path, content, 0);
5448 char path[] = "/dir";
5451 r = guestfs_mkdir (g, path);
5456 char src[] = "/old";
5457 char dest[] = "/dir/new";
5460 r = guestfs_cp (g, src, dest);
5465 char path[] = "/dir/new";
5468 r = guestfs_cat (g, path);
5471 if (strcmp (r, expected) != 0) {
5472 fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
5480 static int test_grub_install_0_skip (void)
5484 str = getenv ("TEST_ONLY");
5486 return strstr (str, "grub_install") == NULL;
5487 str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
5488 if (str && strcmp (str, "1") == 0) return 1;
5489 str = getenv ("SKIP_TEST_GRUB_INSTALL");
5490 if (str && strcmp (str, "1") == 0) return 1;
5494 static int test_grub_install_0 (void)
5496 if (test_grub_install_0_skip ()) {
5497 printf ("%s skipped (reason: environment variable set)\n", "test_grub_install_0");
5501 /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
5503 char device[] = "/dev/sda";
5506 r = guestfs_blockdev_setrw (g, device);
5513 r = guestfs_umount_all (g);
5520 r = guestfs_lvm_remove_all (g);
5525 char device[] = "/dev/sda";
5526 char lines_0[] = ",";
5533 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5538 char fstype[] = "ext2";
5539 char device[] = "/dev/sda1";
5542 r = guestfs_mkfs (g, fstype, device);
5547 char device[] = "/dev/sda1";
5548 char mountpoint[] = "/";
5551 r = guestfs_mount (g, device, mountpoint);
5555 /* TestOutputTrue for grub_install (0) */
5558 char device[] = "/dev/sda1";
5561 r = guestfs_grub_install (g, root, device);
5566 char path[] = "/boot";
5569 r = guestfs_is_dir (g, path);
5573 fprintf (stderr, "test_grub_install_0: expected true, got false\n");
5580 static int test_zero_0_skip (void)
5584 str = getenv ("TEST_ONLY");
5586 return strstr (str, "zero") == NULL;
5587 str = getenv ("SKIP_TEST_ZERO_0");
5588 if (str && strcmp (str, "1") == 0) return 1;
5589 str = getenv ("SKIP_TEST_ZERO");
5590 if (str && strcmp (str, "1") == 0) return 1;
5594 static int test_zero_0 (void)
5596 if (test_zero_0_skip ()) {
5597 printf ("%s skipped (reason: environment variable set)\n", "test_zero_0");
5601 /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
5603 char device[] = "/dev/sda";
5606 r = guestfs_blockdev_setrw (g, device);
5613 r = guestfs_umount_all (g);
5620 r = guestfs_lvm_remove_all (g);
5625 char device[] = "/dev/sda";
5626 char lines_0[] = ",";
5633 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5638 char fstype[] = "ext2";
5639 char device[] = "/dev/sda1";
5642 r = guestfs_mkfs (g, fstype, device);
5647 char device[] = "/dev/sda1";
5648 char mountpoint[] = "/";
5651 r = guestfs_mount (g, device, mountpoint);
5655 /* TestOutput for zero (0) */
5656 char expected[] = "data";
5658 char pathordevice[] = "/dev/sda1";
5661 r = guestfs_umount (g, pathordevice);
5666 char device[] = "/dev/sda1";
5669 r = guestfs_zero (g, device);
5674 char path[] = "/dev/sda1";
5677 r = guestfs_file (g, path);
5680 if (strcmp (r, expected) != 0) {
5681 fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
5689 static int test_fsck_0_skip (void)
5693 str = getenv ("TEST_ONLY");
5695 return strstr (str, "fsck") == NULL;
5696 str = getenv ("SKIP_TEST_FSCK_0");
5697 if (str && strcmp (str, "1") == 0) return 1;
5698 str = getenv ("SKIP_TEST_FSCK");
5699 if (str && strcmp (str, "1") == 0) return 1;
5703 static int test_fsck_0 (void)
5705 if (test_fsck_0_skip ()) {
5706 printf ("%s skipped (reason: environment variable set)\n", "test_fsck_0");
5710 /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
5712 char device[] = "/dev/sda";
5715 r = guestfs_blockdev_setrw (g, device);
5722 r = guestfs_umount_all (g);
5729 r = guestfs_lvm_remove_all (g);
5734 char device[] = "/dev/sda";
5735 char lines_0[] = ",";
5742 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5747 char fstype[] = "ext2";
5748 char device[] = "/dev/sda1";
5751 r = guestfs_mkfs (g, fstype, device);
5756 char device[] = "/dev/sda1";
5757 char mountpoint[] = "/";
5760 r = guestfs_mount (g, device, mountpoint);
5764 /* TestOutputInt for fsck (0) */
5766 char pathordevice[] = "/dev/sda1";
5769 r = guestfs_umount (g, pathordevice);
5774 char fstype[] = "ext2";
5775 char device[] = "/dev/sda1";
5778 r = guestfs_fsck (g, fstype, device);
5782 fprintf (stderr, "test_fsck_0: expected 0 but got %d\n", (int) r);
5789 static int test_fsck_1_skip (void)
5793 str = getenv ("TEST_ONLY");
5795 return strstr (str, "fsck") == NULL;
5796 str = getenv ("SKIP_TEST_FSCK_1");
5797 if (str && strcmp (str, "1") == 0) return 1;
5798 str = getenv ("SKIP_TEST_FSCK");
5799 if (str && strcmp (str, "1") == 0) return 1;
5803 static int test_fsck_1 (void)
5805 if (test_fsck_1_skip ()) {
5806 printf ("%s skipped (reason: environment variable set)\n", "test_fsck_1");
5810 /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
5812 char device[] = "/dev/sda";
5815 r = guestfs_blockdev_setrw (g, device);
5822 r = guestfs_umount_all (g);
5829 r = guestfs_lvm_remove_all (g);
5834 char device[] = "/dev/sda";
5835 char lines_0[] = ",";
5842 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5847 char fstype[] = "ext2";
5848 char device[] = "/dev/sda1";
5851 r = guestfs_mkfs (g, fstype, device);
5856 char device[] = "/dev/sda1";
5857 char mountpoint[] = "/";
5860 r = guestfs_mount (g, device, mountpoint);
5864 /* TestOutputInt for fsck (1) */
5866 char pathordevice[] = "/dev/sda1";
5869 r = guestfs_umount (g, pathordevice);
5874 char device[] = "/dev/sda1";
5877 r = guestfs_zero (g, device);
5882 char fstype[] = "ext2";
5883 char device[] = "/dev/sda1";
5886 r = guestfs_fsck (g, fstype, device);
5890 fprintf (stderr, "test_fsck_1: expected 8 but got %d\n", (int) r);
5897 static int test_set_e2uuid_0_skip (void)
5901 str = getenv ("TEST_ONLY");
5903 return strstr (str, "set_e2uuid") == NULL;
5904 str = getenv ("SKIP_TEST_SET_E2UUID_0");
5905 if (str && strcmp (str, "1") == 0) return 1;
5906 str = getenv ("SKIP_TEST_SET_E2UUID");
5907 if (str && strcmp (str, "1") == 0) return 1;
5911 static int test_set_e2uuid_0 (void)
5913 if (test_set_e2uuid_0_skip ()) {
5914 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_0");
5918 /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
5920 char device[] = "/dev/sda";
5923 r = guestfs_blockdev_setrw (g, device);
5930 r = guestfs_umount_all (g);
5937 r = guestfs_lvm_remove_all (g);
5942 char device[] = "/dev/sda";
5943 char lines_0[] = ",";
5950 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5955 char fstype[] = "ext2";
5956 char device[] = "/dev/sda1";
5959 r = guestfs_mkfs (g, fstype, device);
5964 char device[] = "/dev/sda1";
5965 char mountpoint[] = "/";
5968 r = guestfs_mount (g, device, mountpoint);
5972 /* TestOutput for set_e2uuid (0) */
5973 char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
5975 char device[] = "/dev/sda1";
5976 char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
5979 r = guestfs_set_e2uuid (g, device, uuid);
5984 char device[] = "/dev/sda1";
5987 r = guestfs_get_e2uuid (g, device);
5990 if (strcmp (r, expected) != 0) {
5991 fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
5999 static int test_set_e2uuid_1_skip (void)
6003 str = getenv ("TEST_ONLY");
6005 return strstr (str, "set_e2uuid") == NULL;
6006 str = getenv ("SKIP_TEST_SET_E2UUID_1");
6007 if (str && strcmp (str, "1") == 0) return 1;
6008 str = getenv ("SKIP_TEST_SET_E2UUID");
6009 if (str && strcmp (str, "1") == 0) return 1;
6013 static int test_set_e2uuid_1 (void)
6015 if (test_set_e2uuid_1_skip ()) {
6016 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_1");
6020 /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
6022 char device[] = "/dev/sda";
6025 r = guestfs_blockdev_setrw (g, device);
6032 r = guestfs_umount_all (g);
6039 r = guestfs_lvm_remove_all (g);
6044 char device[] = "/dev/sda";
6045 char lines_0[] = ",";
6052 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6057 char fstype[] = "ext2";
6058 char device[] = "/dev/sda1";
6061 r = guestfs_mkfs (g, fstype, device);
6066 char device[] = "/dev/sda1";
6067 char mountpoint[] = "/";
6070 r = guestfs_mount (g, device, mountpoint);
6074 /* TestOutput for set_e2uuid (1) */
6075 char expected[] = "";
6077 char device[] = "/dev/sda1";
6078 char uuid[] = "clear";
6081 r = guestfs_set_e2uuid (g, device, uuid);
6086 char device[] = "/dev/sda1";
6089 r = guestfs_get_e2uuid (g, device);
6092 if (strcmp (r, expected) != 0) {
6093 fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
6101 static int test_set_e2uuid_2_skip (void)
6105 str = getenv ("TEST_ONLY");
6107 return strstr (str, "set_e2uuid") == NULL;
6108 str = getenv ("SKIP_TEST_SET_E2UUID_2");
6109 if (str && strcmp (str, "1") == 0) return 1;
6110 str = getenv ("SKIP_TEST_SET_E2UUID");
6111 if (str && strcmp (str, "1") == 0) return 1;
6115 static int test_set_e2uuid_2 (void)
6117 if (test_set_e2uuid_2_skip ()) {
6118 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_2");
6122 /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
6124 char device[] = "/dev/sda";
6127 r = guestfs_blockdev_setrw (g, device);
6134 r = guestfs_umount_all (g);
6141 r = guestfs_lvm_remove_all (g);
6146 char device[] = "/dev/sda";
6147 char lines_0[] = ",";
6154 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6159 char fstype[] = "ext2";
6160 char device[] = "/dev/sda1";
6163 r = guestfs_mkfs (g, fstype, device);
6168 char device[] = "/dev/sda1";
6169 char mountpoint[] = "/";
6172 r = guestfs_mount (g, device, mountpoint);
6176 /* TestRun for set_e2uuid (2) */
6178 char device[] = "/dev/sda1";
6179 char uuid[] = "random";
6182 r = guestfs_set_e2uuid (g, device, uuid);
6189 static int test_set_e2uuid_3_skip (void)
6193 str = getenv ("TEST_ONLY");
6195 return strstr (str, "set_e2uuid") == NULL;
6196 str = getenv ("SKIP_TEST_SET_E2UUID_3");
6197 if (str && strcmp (str, "1") == 0) return 1;
6198 str = getenv ("SKIP_TEST_SET_E2UUID");
6199 if (str && strcmp (str, "1") == 0) return 1;
6203 static int test_set_e2uuid_3 (void)
6205 if (test_set_e2uuid_3_skip ()) {
6206 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_3");
6210 /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
6212 char device[] = "/dev/sda";
6215 r = guestfs_blockdev_setrw (g, device);
6222 r = guestfs_umount_all (g);
6229 r = guestfs_lvm_remove_all (g);
6234 char device[] = "/dev/sda";
6235 char lines_0[] = ",";
6242 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6247 char fstype[] = "ext2";
6248 char device[] = "/dev/sda1";
6251 r = guestfs_mkfs (g, fstype, device);
6256 char device[] = "/dev/sda1";
6257 char mountpoint[] = "/";
6260 r = guestfs_mount (g, device, mountpoint);
6264 /* TestRun for set_e2uuid (3) */
6266 char device[] = "/dev/sda1";
6267 char uuid[] = "time";
6270 r = guestfs_set_e2uuid (g, device, uuid);
6277 static int test_set_e2label_0_skip (void)
6281 str = getenv ("TEST_ONLY");
6283 return strstr (str, "set_e2label") == NULL;
6284 str = getenv ("SKIP_TEST_SET_E2LABEL_0");
6285 if (str && strcmp (str, "1") == 0) return 1;
6286 str = getenv ("SKIP_TEST_SET_E2LABEL");
6287 if (str && strcmp (str, "1") == 0) return 1;
6291 static int test_set_e2label_0 (void)
6293 if (test_set_e2label_0_skip ()) {
6294 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2label_0");
6298 /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
6300 char device[] = "/dev/sda";
6303 r = guestfs_blockdev_setrw (g, device);
6310 r = guestfs_umount_all (g);
6317 r = guestfs_lvm_remove_all (g);
6322 char device[] = "/dev/sda";
6323 char lines_0[] = ",";
6330 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6335 char fstype[] = "ext2";
6336 char device[] = "/dev/sda1";
6339 r = guestfs_mkfs (g, fstype, device);
6344 char device[] = "/dev/sda1";
6345 char mountpoint[] = "/";
6348 r = guestfs_mount (g, device, mountpoint);
6352 /* TestOutput for set_e2label (0) */
6353 char expected[] = "testlabel";
6355 char device[] = "/dev/sda1";
6356 char label[] = "testlabel";
6359 r = guestfs_set_e2label (g, device, label);
6364 char device[] = "/dev/sda1";
6367 r = guestfs_get_e2label (g, device);
6370 if (strcmp (r, expected) != 0) {
6371 fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
6379 static int test_pvremove_0_skip (void)
6383 str = getenv ("TEST_ONLY");
6385 return strstr (str, "pvremove") == NULL;
6386 str = getenv ("SKIP_TEST_PVREMOVE_0");
6387 if (str && strcmp (str, "1") == 0) return 1;
6388 str = getenv ("SKIP_TEST_PVREMOVE");
6389 if (str && strcmp (str, "1") == 0) return 1;
6393 static int test_pvremove_0 (void)
6395 if (test_pvremove_0_skip ()) {
6396 printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_0");
6400 /* InitNone|InitEmpty for test_pvremove_0 */
6402 char device[] = "/dev/sda";
6405 r = guestfs_blockdev_setrw (g, device);
6412 r = guestfs_umount_all (g);
6419 r = guestfs_lvm_remove_all (g);
6423 /* TestOutputListOfDevices for pvremove (0) */
6425 char device[] = "/dev/sda";
6426 char lines_0[] = ",";
6433 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6438 char device[] = "/dev/sda1";
6441 r = guestfs_pvcreate (g, device);
6446 char volgroup[] = "VG";
6447 char physvols_0[] = "/dev/sda1";
6448 char *physvols[] = {
6454 r = guestfs_vgcreate (g, volgroup, physvols);
6459 char logvol[] = "LV1";
6460 char volgroup[] = "VG";
6463 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6468 char logvol[] = "LV2";
6469 char volgroup[] = "VG";
6472 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6477 char vgname[] = "VG";
6480 r = guestfs_vgremove (g, vgname);
6485 char device[] = "/dev/sda1";
6488 r = guestfs_pvremove (g, device);
6496 r = guestfs_lvs (g);
6500 fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
6504 for (i = 0; r[i] != NULL; ++i)
6511 static int test_pvremove_1_skip (void)
6515 str = getenv ("TEST_ONLY");
6517 return strstr (str, "pvremove") == NULL;
6518 str = getenv ("SKIP_TEST_PVREMOVE_1");
6519 if (str && strcmp (str, "1") == 0) return 1;
6520 str = getenv ("SKIP_TEST_PVREMOVE");
6521 if (str && strcmp (str, "1") == 0) return 1;
6525 static int test_pvremove_1 (void)
6527 if (test_pvremove_1_skip ()) {
6528 printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_1");
6532 /* InitNone|InitEmpty for test_pvremove_1 */
6534 char device[] = "/dev/sda";
6537 r = guestfs_blockdev_setrw (g, device);
6544 r = guestfs_umount_all (g);
6551 r = guestfs_lvm_remove_all (g);
6555 /* TestOutputListOfDevices for pvremove (1) */
6557 char device[] = "/dev/sda";
6558 char lines_0[] = ",";
6565 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6570 char device[] = "/dev/sda1";
6573 r = guestfs_pvcreate (g, device);
6578 char volgroup[] = "VG";
6579 char physvols_0[] = "/dev/sda1";
6580 char *physvols[] = {
6586 r = guestfs_vgcreate (g, volgroup, physvols);
6591 char logvol[] = "LV1";
6592 char volgroup[] = "VG";
6595 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6600 char logvol[] = "LV2";
6601 char volgroup[] = "VG";
6604 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6609 char vgname[] = "VG";
6612 r = guestfs_vgremove (g, vgname);
6617 char device[] = "/dev/sda1";
6620 r = guestfs_pvremove (g, device);
6628 r = guestfs_vgs (g);
6632 fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
6636 for (i = 0; r[i] != NULL; ++i)
6643 static int test_pvremove_2_skip (void)
6647 str = getenv ("TEST_ONLY");
6649 return strstr (str, "pvremove") == NULL;
6650 str = getenv ("SKIP_TEST_PVREMOVE_2");
6651 if (str && strcmp (str, "1") == 0) return 1;
6652 str = getenv ("SKIP_TEST_PVREMOVE");
6653 if (str && strcmp (str, "1") == 0) return 1;
6657 static int test_pvremove_2 (void)
6659 if (test_pvremove_2_skip ()) {
6660 printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_2");
6664 /* InitNone|InitEmpty for test_pvremove_2 */
6666 char device[] = "/dev/sda";
6669 r = guestfs_blockdev_setrw (g, device);
6676 r = guestfs_umount_all (g);
6683 r = guestfs_lvm_remove_all (g);
6687 /* TestOutputListOfDevices for pvremove (2) */
6689 char device[] = "/dev/sda";
6690 char lines_0[] = ",";
6697 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6702 char device[] = "/dev/sda1";
6705 r = guestfs_pvcreate (g, device);
6710 char volgroup[] = "VG";
6711 char physvols_0[] = "/dev/sda1";
6712 char *physvols[] = {
6718 r = guestfs_vgcreate (g, volgroup, physvols);
6723 char logvol[] = "LV1";
6724 char volgroup[] = "VG";
6727 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6732 char logvol[] = "LV2";
6733 char volgroup[] = "VG";
6736 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6741 char vgname[] = "VG";
6744 r = guestfs_vgremove (g, vgname);
6749 char device[] = "/dev/sda1";
6752 r = guestfs_pvremove (g, device);
6760 r = guestfs_pvs (g);
6764 fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
6768 for (i = 0; r[i] != NULL; ++i)
6775 static int test_vgremove_0_skip (void)
6779 str = getenv ("TEST_ONLY");
6781 return strstr (str, "vgremove") == NULL;
6782 str = getenv ("SKIP_TEST_VGREMOVE_0");
6783 if (str && strcmp (str, "1") == 0) return 1;
6784 str = getenv ("SKIP_TEST_VGREMOVE");
6785 if (str && strcmp (str, "1") == 0) return 1;
6789 static int test_vgremove_0 (void)
6791 if (test_vgremove_0_skip ()) {
6792 printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_0");
6796 /* InitNone|InitEmpty for test_vgremove_0 */
6798 char device[] = "/dev/sda";
6801 r = guestfs_blockdev_setrw (g, device);
6808 r = guestfs_umount_all (g);
6815 r = guestfs_lvm_remove_all (g);
6819 /* TestOutputList for vgremove (0) */
6821 char device[] = "/dev/sda";
6822 char lines_0[] = ",";
6829 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6834 char device[] = "/dev/sda1";
6837 r = guestfs_pvcreate (g, device);
6842 char volgroup[] = "VG";
6843 char physvols_0[] = "/dev/sda1";
6844 char *physvols[] = {
6850 r = guestfs_vgcreate (g, volgroup, physvols);
6855 char logvol[] = "LV1";
6856 char volgroup[] = "VG";
6859 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6864 char logvol[] = "LV2";
6865 char volgroup[] = "VG";
6868 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6873 char vgname[] = "VG";
6876 r = guestfs_vgremove (g, vgname);
6884 r = guestfs_lvs (g);
6888 fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
6892 for (i = 0; r[i] != NULL; ++i)
6899 static int test_vgremove_1_skip (void)
6903 str = getenv ("TEST_ONLY");
6905 return strstr (str, "vgremove") == NULL;
6906 str = getenv ("SKIP_TEST_VGREMOVE_1");
6907 if (str && strcmp (str, "1") == 0) return 1;
6908 str = getenv ("SKIP_TEST_VGREMOVE");
6909 if (str && strcmp (str, "1") == 0) return 1;
6913 static int test_vgremove_1 (void)
6915 if (test_vgremove_1_skip ()) {
6916 printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_1");
6920 /* InitNone|InitEmpty for test_vgremove_1 */
6922 char device[] = "/dev/sda";
6925 r = guestfs_blockdev_setrw (g, device);
6932 r = guestfs_umount_all (g);
6939 r = guestfs_lvm_remove_all (g);
6943 /* TestOutputList for vgremove (1) */
6945 char device[] = "/dev/sda";
6946 char lines_0[] = ",";
6953 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6958 char device[] = "/dev/sda1";
6961 r = guestfs_pvcreate (g, device);
6966 char volgroup[] = "VG";
6967 char physvols_0[] = "/dev/sda1";
6968 char *physvols[] = {
6974 r = guestfs_vgcreate (g, volgroup, physvols);
6979 char logvol[] = "LV1";
6980 char volgroup[] = "VG";
6983 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6988 char logvol[] = "LV2";
6989 char volgroup[] = "VG";
6992 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6997 char vgname[] = "VG";
7000 r = guestfs_vgremove (g, vgname);
7008 r = guestfs_vgs (g);
7012 fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
7016 for (i = 0; r[i] != NULL; ++i)
7023 static int test_lvremove_0_skip (void)
7027 str = getenv ("TEST_ONLY");
7029 return strstr (str, "lvremove") == NULL;
7030 str = getenv ("SKIP_TEST_LVREMOVE_0");
7031 if (str && strcmp (str, "1") == 0) return 1;
7032 str = getenv ("SKIP_TEST_LVREMOVE");
7033 if (str && strcmp (str, "1") == 0) return 1;
7037 static int test_lvremove_0 (void)
7039 if (test_lvremove_0_skip ()) {
7040 printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_0");
7044 /* InitNone|InitEmpty for test_lvremove_0 */
7046 char device[] = "/dev/sda";
7049 r = guestfs_blockdev_setrw (g, device);
7056 r = guestfs_umount_all (g);
7063 r = guestfs_lvm_remove_all (g);
7067 /* TestOutputList for lvremove (0) */
7069 char device[] = "/dev/sda";
7070 char lines_0[] = ",";
7077 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7082 char device[] = "/dev/sda1";
7085 r = guestfs_pvcreate (g, device);
7090 char volgroup[] = "VG";
7091 char physvols_0[] = "/dev/sda1";
7092 char *physvols[] = {
7098 r = guestfs_vgcreate (g, volgroup, physvols);
7103 char logvol[] = "LV1";
7104 char volgroup[] = "VG";
7107 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7112 char logvol[] = "LV2";
7113 char volgroup[] = "VG";
7116 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7121 char device[] = "/dev/VG/LV1";
7124 r = guestfs_lvremove (g, device);
7132 r = guestfs_lvs (g);
7136 fprintf (stderr, "test_lvremove_0: short list returned from command\n");
7141 char expected[] = "/dev/VG/LV2";
7142 if (strcmp (r[0], expected) != 0) {
7143 fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7148 fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
7152 for (i = 0; r[i] != NULL; ++i)
7159 static int test_lvremove_1_skip (void)
7163 str = getenv ("TEST_ONLY");
7165 return strstr (str, "lvremove") == NULL;
7166 str = getenv ("SKIP_TEST_LVREMOVE_1");
7167 if (str && strcmp (str, "1") == 0) return 1;
7168 str = getenv ("SKIP_TEST_LVREMOVE");
7169 if (str && strcmp (str, "1") == 0) return 1;
7173 static int test_lvremove_1 (void)
7175 if (test_lvremove_1_skip ()) {
7176 printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_1");
7180 /* InitNone|InitEmpty for test_lvremove_1 */
7182 char device[] = "/dev/sda";
7185 r = guestfs_blockdev_setrw (g, device);
7192 r = guestfs_umount_all (g);
7199 r = guestfs_lvm_remove_all (g);
7203 /* TestOutputList for lvremove (1) */
7205 char device[] = "/dev/sda";
7206 char lines_0[] = ",";
7213 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7218 char device[] = "/dev/sda1";
7221 r = guestfs_pvcreate (g, device);
7226 char volgroup[] = "VG";
7227 char physvols_0[] = "/dev/sda1";
7228 char *physvols[] = {
7234 r = guestfs_vgcreate (g, volgroup, physvols);
7239 char logvol[] = "LV1";
7240 char volgroup[] = "VG";
7243 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7248 char logvol[] = "LV2";
7249 char volgroup[] = "VG";
7252 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7257 char device[] = "/dev/VG";
7260 r = guestfs_lvremove (g, device);
7268 r = guestfs_lvs (g);
7272 fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
7276 for (i = 0; r[i] != NULL; ++i)
7283 static int test_lvremove_2_skip (void)
7287 str = getenv ("TEST_ONLY");
7289 return strstr (str, "lvremove") == NULL;
7290 str = getenv ("SKIP_TEST_LVREMOVE_2");
7291 if (str && strcmp (str, "1") == 0) return 1;
7292 str = getenv ("SKIP_TEST_LVREMOVE");
7293 if (str && strcmp (str, "1") == 0) return 1;
7297 static int test_lvremove_2 (void)
7299 if (test_lvremove_2_skip ()) {
7300 printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_2");
7304 /* InitNone|InitEmpty for test_lvremove_2 */
7306 char device[] = "/dev/sda";
7309 r = guestfs_blockdev_setrw (g, device);
7316 r = guestfs_umount_all (g);
7323 r = guestfs_lvm_remove_all (g);
7327 /* TestOutputList for lvremove (2) */
7329 char device[] = "/dev/sda";
7330 char lines_0[] = ",";
7337 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7342 char device[] = "/dev/sda1";
7345 r = guestfs_pvcreate (g, device);
7350 char volgroup[] = "VG";
7351 char physvols_0[] = "/dev/sda1";
7352 char *physvols[] = {
7358 r = guestfs_vgcreate (g, volgroup, physvols);
7363 char logvol[] = "LV1";
7364 char volgroup[] = "VG";
7367 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7372 char logvol[] = "LV2";
7373 char volgroup[] = "VG";
7376 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7381 char device[] = "/dev/VG";
7384 r = guestfs_lvremove (g, device);
7392 r = guestfs_vgs (g);
7396 fprintf (stderr, "test_lvremove_2: short list returned from command\n");
7401 char expected[] = "VG";
7402 if (strcmp (r[0], expected) != 0) {
7403 fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7408 fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
7412 for (i = 0; r[i] != NULL; ++i)
7419 static int test_mount_ro_0_skip (void)
7423 str = getenv ("TEST_ONLY");
7425 return strstr (str, "mount_ro") == NULL;
7426 str = getenv ("SKIP_TEST_MOUNT_RO_0");
7427 if (str && strcmp (str, "1") == 0) return 1;
7428 str = getenv ("SKIP_TEST_MOUNT_RO");
7429 if (str && strcmp (str, "1") == 0) return 1;
7433 static int test_mount_ro_0 (void)
7435 if (test_mount_ro_0_skip ()) {
7436 printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_0");
7440 /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
7442 char device[] = "/dev/sda";
7445 r = guestfs_blockdev_setrw (g, device);
7452 r = guestfs_umount_all (g);
7459 r = guestfs_lvm_remove_all (g);
7464 char device[] = "/dev/sda";
7465 char lines_0[] = ",";
7472 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7477 char fstype[] = "ext2";
7478 char device[] = "/dev/sda1";
7481 r = guestfs_mkfs (g, fstype, device);
7486 char device[] = "/dev/sda1";
7487 char mountpoint[] = "/";
7490 r = guestfs_mount (g, device, mountpoint);
7494 /* TestLastFail for mount_ro (0) */
7496 char pathordevice[] = "/";
7499 r = guestfs_umount (g, pathordevice);
7504 char device[] = "/dev/sda1";
7505 char mountpoint[] = "/";
7508 r = guestfs_mount_ro (g, device, mountpoint);
7513 char path[] = "/new";
7516 r = guestfs_touch (g, path);
7523 static int test_mount_ro_1_skip (void)
7527 str = getenv ("TEST_ONLY");
7529 return strstr (str, "mount_ro") == NULL;
7530 str = getenv ("SKIP_TEST_MOUNT_RO_1");
7531 if (str && strcmp (str, "1") == 0) return 1;
7532 str = getenv ("SKIP_TEST_MOUNT_RO");
7533 if (str && strcmp (str, "1") == 0) return 1;
7537 static int test_mount_ro_1 (void)
7539 if (test_mount_ro_1_skip ()) {
7540 printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_1");
7544 /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
7546 char device[] = "/dev/sda";
7549 r = guestfs_blockdev_setrw (g, device);
7556 r = guestfs_umount_all (g);
7563 r = guestfs_lvm_remove_all (g);
7568 char device[] = "/dev/sda";
7569 char lines_0[] = ",";
7576 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7581 char fstype[] = "ext2";
7582 char device[] = "/dev/sda1";
7585 r = guestfs_mkfs (g, fstype, device);
7590 char device[] = "/dev/sda1";
7591 char mountpoint[] = "/";
7594 r = guestfs_mount (g, device, mountpoint);
7598 /* TestOutput for mount_ro (1) */
7599 char expected[] = "data";
7601 char path[] = "/new";
7602 char content[] = "data";
7605 r = guestfs_write_file (g, path, content, 0);
7610 char pathordevice[] = "/";
7613 r = guestfs_umount (g, pathordevice);
7618 char device[] = "/dev/sda1";
7619 char mountpoint[] = "/";
7622 r = guestfs_mount_ro (g, device, mountpoint);
7627 char path[] = "/new";
7630 r = guestfs_cat (g, path);
7633 if (strcmp (r, expected) != 0) {
7634 fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
7642 static int test_tgz_in_0_skip (void)
7646 str = getenv ("TEST_ONLY");
7648 return strstr (str, "tgz_in") == NULL;
7649 str = getenv ("SKIP_TEST_TGZ_IN_0");
7650 if (str && strcmp (str, "1") == 0) return 1;
7651 str = getenv ("SKIP_TEST_TGZ_IN");
7652 if (str && strcmp (str, "1") == 0) return 1;
7656 static int test_tgz_in_0 (void)
7658 if (test_tgz_in_0_skip ()) {
7659 printf ("%s skipped (reason: environment variable set)\n", "test_tgz_in_0");
7663 /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
7665 char device[] = "/dev/sda";
7668 r = guestfs_blockdev_setrw (g, device);
7675 r = guestfs_umount_all (g);
7682 r = guestfs_lvm_remove_all (g);
7687 char device[] = "/dev/sda";
7688 char lines_0[] = ",";
7695 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7700 char fstype[] = "ext2";
7701 char device[] = "/dev/sda1";
7704 r = guestfs_mkfs (g, fstype, device);
7709 char device[] = "/dev/sda1";
7710 char mountpoint[] = "/";
7713 r = guestfs_mount (g, device, mountpoint);
7717 /* TestOutput for tgz_in (0) */
7718 char expected[] = "hello\n";
7720 char directory[] = "/";
7723 r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
7728 char path[] = "/hello";
7731 r = guestfs_cat (g, path);
7734 if (strcmp (r, expected) != 0) {
7735 fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
7743 static int test_tar_in_0_skip (void)
7747 str = getenv ("TEST_ONLY");
7749 return strstr (str, "tar_in") == NULL;
7750 str = getenv ("SKIP_TEST_TAR_IN_0");
7751 if (str && strcmp (str, "1") == 0) return 1;
7752 str = getenv ("SKIP_TEST_TAR_IN");
7753 if (str && strcmp (str, "1") == 0) return 1;
7757 static int test_tar_in_0 (void)
7759 if (test_tar_in_0_skip ()) {
7760 printf ("%s skipped (reason: environment variable set)\n", "test_tar_in_0");
7764 /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
7766 char device[] = "/dev/sda";
7769 r = guestfs_blockdev_setrw (g, device);
7776 r = guestfs_umount_all (g);
7783 r = guestfs_lvm_remove_all (g);
7788 char device[] = "/dev/sda";
7789 char lines_0[] = ",";
7796 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7801 char fstype[] = "ext2";
7802 char device[] = "/dev/sda1";
7805 r = guestfs_mkfs (g, fstype, device);
7810 char device[] = "/dev/sda1";
7811 char mountpoint[] = "/";
7814 r = guestfs_mount (g, device, mountpoint);
7818 /* TestOutput for tar_in (0) */
7819 char expected[] = "hello\n";
7821 char directory[] = "/";
7824 r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
7829 char path[] = "/hello";
7832 r = guestfs_cat (g, path);
7835 if (strcmp (r, expected) != 0) {
7836 fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
7844 static int test_checksum_0_skip (void)
7848 str = getenv ("TEST_ONLY");
7850 return strstr (str, "checksum") == NULL;
7851 str = getenv ("SKIP_TEST_CHECKSUM_0");
7852 if (str && strcmp (str, "1") == 0) return 1;
7853 str = getenv ("SKIP_TEST_CHECKSUM");
7854 if (str && strcmp (str, "1") == 0) return 1;
7858 static int test_checksum_0 (void)
7860 if (test_checksum_0_skip ()) {
7861 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_0");
7865 /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
7867 char device[] = "/dev/sda";
7870 r = guestfs_blockdev_setrw (g, device);
7877 r = guestfs_umount_all (g);
7884 r = guestfs_lvm_remove_all (g);
7889 char device[] = "/dev/sda";
7890 char lines_0[] = ",";
7897 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7902 char fstype[] = "ext2";
7903 char device[] = "/dev/sda1";
7906 r = guestfs_mkfs (g, fstype, device);
7911 char device[] = "/dev/sda1";
7912 char mountpoint[] = "/";
7915 r = guestfs_mount (g, device, mountpoint);
7919 /* TestOutput for checksum (0) */
7920 char expected[] = "935282863";
7922 char path[] = "/new";
7923 char content[] = "test\n";
7926 r = guestfs_write_file (g, path, content, 0);
7931 char csumtype[] = "crc";
7932 char path[] = "/new";
7935 r = guestfs_checksum (g, csumtype, path);
7938 if (strcmp (r, expected) != 0) {
7939 fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
7947 static int test_checksum_1_skip (void)
7951 str = getenv ("TEST_ONLY");
7953 return strstr (str, "checksum") == NULL;
7954 str = getenv ("SKIP_TEST_CHECKSUM_1");
7955 if (str && strcmp (str, "1") == 0) return 1;
7956 str = getenv ("SKIP_TEST_CHECKSUM");
7957 if (str && strcmp (str, "1") == 0) return 1;
7961 static int test_checksum_1 (void)
7963 if (test_checksum_1_skip ()) {
7964 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_1");
7968 /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
7970 char device[] = "/dev/sda";
7973 r = guestfs_blockdev_setrw (g, device);
7980 r = guestfs_umount_all (g);
7987 r = guestfs_lvm_remove_all (g);
7992 char device[] = "/dev/sda";
7993 char lines_0[] = ",";
8000 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8005 char fstype[] = "ext2";
8006 char device[] = "/dev/sda1";
8009 r = guestfs_mkfs (g, fstype, device);
8014 char device[] = "/dev/sda1";
8015 char mountpoint[] = "/";
8018 r = guestfs_mount (g, device, mountpoint);
8022 /* TestLastFail for checksum (1) */
8024 char csumtype[] = "crc";
8025 char path[] = "/new";
8028 r = guestfs_checksum (g, csumtype, path);
8036 static int test_checksum_2_skip (void)
8040 str = getenv ("TEST_ONLY");
8042 return strstr (str, "checksum") == NULL;
8043 str = getenv ("SKIP_TEST_CHECKSUM_2");
8044 if (str && strcmp (str, "1") == 0) return 1;
8045 str = getenv ("SKIP_TEST_CHECKSUM");
8046 if (str && strcmp (str, "1") == 0) return 1;
8050 static int test_checksum_2 (void)
8052 if (test_checksum_2_skip ()) {
8053 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_2");
8057 /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
8059 char device[] = "/dev/sda";
8062 r = guestfs_blockdev_setrw (g, device);
8069 r = guestfs_umount_all (g);
8076 r = guestfs_lvm_remove_all (g);
8081 char device[] = "/dev/sda";
8082 char lines_0[] = ",";
8089 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8094 char fstype[] = "ext2";
8095 char device[] = "/dev/sda1";
8098 r = guestfs_mkfs (g, fstype, device);
8103 char device[] = "/dev/sda1";
8104 char mountpoint[] = "/";
8107 r = guestfs_mount (g, device, mountpoint);
8111 /* TestOutput for checksum (2) */
8112 char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
8114 char path[] = "/new";
8115 char content[] = "test\n";
8118 r = guestfs_write_file (g, path, content, 0);
8123 char csumtype[] = "md5";
8124 char path[] = "/new";
8127 r = guestfs_checksum (g, csumtype, path);
8130 if (strcmp (r, expected) != 0) {
8131 fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
8139 static int test_checksum_3_skip (void)
8143 str = getenv ("TEST_ONLY");
8145 return strstr (str, "checksum") == NULL;
8146 str = getenv ("SKIP_TEST_CHECKSUM_3");
8147 if (str && strcmp (str, "1") == 0) return 1;
8148 str = getenv ("SKIP_TEST_CHECKSUM");
8149 if (str && strcmp (str, "1") == 0) return 1;
8153 static int test_checksum_3 (void)
8155 if (test_checksum_3_skip ()) {
8156 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_3");
8160 /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
8162 char device[] = "/dev/sda";
8165 r = guestfs_blockdev_setrw (g, device);
8172 r = guestfs_umount_all (g);
8179 r = guestfs_lvm_remove_all (g);
8184 char device[] = "/dev/sda";
8185 char lines_0[] = ",";
8192 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8197 char fstype[] = "ext2";
8198 char device[] = "/dev/sda1";
8201 r = guestfs_mkfs (g, fstype, device);
8206 char device[] = "/dev/sda1";
8207 char mountpoint[] = "/";
8210 r = guestfs_mount (g, device, mountpoint);
8214 /* TestOutput for checksum (3) */
8215 char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
8217 char path[] = "/new";
8218 char content[] = "test\n";
8221 r = guestfs_write_file (g, path, content, 0);
8226 char csumtype[] = "sha1";
8227 char path[] = "/new";
8230 r = guestfs_checksum (g, csumtype, path);
8233 if (strcmp (r, expected) != 0) {
8234 fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
8242 static int test_checksum_4_skip (void)
8246 str = getenv ("TEST_ONLY");
8248 return strstr (str, "checksum") == NULL;
8249 str = getenv ("SKIP_TEST_CHECKSUM_4");
8250 if (str && strcmp (str, "1") == 0) return 1;
8251 str = getenv ("SKIP_TEST_CHECKSUM");
8252 if (str && strcmp (str, "1") == 0) return 1;
8256 static int test_checksum_4 (void)
8258 if (test_checksum_4_skip ()) {
8259 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_4");
8263 /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
8265 char device[] = "/dev/sda";
8268 r = guestfs_blockdev_setrw (g, device);
8275 r = guestfs_umount_all (g);
8282 r = guestfs_lvm_remove_all (g);
8287 char device[] = "/dev/sda";
8288 char lines_0[] = ",";
8295 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8300 char fstype[] = "ext2";
8301 char device[] = "/dev/sda1";
8304 r = guestfs_mkfs (g, fstype, device);
8309 char device[] = "/dev/sda1";
8310 char mountpoint[] = "/";
8313 r = guestfs_mount (g, device, mountpoint);
8317 /* TestOutput for checksum (4) */
8318 char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
8320 char path[] = "/new";
8321 char content[] = "test\n";
8324 r = guestfs_write_file (g, path, content, 0);
8329 char csumtype[] = "sha224";
8330 char path[] = "/new";
8333 r = guestfs_checksum (g, csumtype, path);
8336 if (strcmp (r, expected) != 0) {
8337 fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
8345 static int test_checksum_5_skip (void)
8349 str = getenv ("TEST_ONLY");
8351 return strstr (str, "checksum") == NULL;
8352 str = getenv ("SKIP_TEST_CHECKSUM_5");
8353 if (str && strcmp (str, "1") == 0) return 1;
8354 str = getenv ("SKIP_TEST_CHECKSUM");
8355 if (str && strcmp (str, "1") == 0) return 1;
8359 static int test_checksum_5 (void)
8361 if (test_checksum_5_skip ()) {
8362 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_5");
8366 /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
8368 char device[] = "/dev/sda";
8371 r = guestfs_blockdev_setrw (g, device);
8378 r = guestfs_umount_all (g);
8385 r = guestfs_lvm_remove_all (g);
8390 char device[] = "/dev/sda";
8391 char lines_0[] = ",";
8398 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8403 char fstype[] = "ext2";
8404 char device[] = "/dev/sda1";
8407 r = guestfs_mkfs (g, fstype, device);
8412 char device[] = "/dev/sda1";
8413 char mountpoint[] = "/";
8416 r = guestfs_mount (g, device, mountpoint);
8420 /* TestOutput for checksum (5) */
8421 char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
8423 char path[] = "/new";
8424 char content[] = "test\n";
8427 r = guestfs_write_file (g, path, content, 0);
8432 char csumtype[] = "sha256";
8433 char path[] = "/new";
8436 r = guestfs_checksum (g, csumtype, path);
8439 if (strcmp (r, expected) != 0) {
8440 fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
8448 static int test_checksum_6_skip (void)
8452 str = getenv ("TEST_ONLY");
8454 return strstr (str, "checksum") == NULL;
8455 str = getenv ("SKIP_TEST_CHECKSUM_6");
8456 if (str && strcmp (str, "1") == 0) return 1;
8457 str = getenv ("SKIP_TEST_CHECKSUM");
8458 if (str && strcmp (str, "1") == 0) return 1;
8462 static int test_checksum_6 (void)
8464 if (test_checksum_6_skip ()) {
8465 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_6");
8469 /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
8471 char device[] = "/dev/sda";
8474 r = guestfs_blockdev_setrw (g, device);
8481 r = guestfs_umount_all (g);
8488 r = guestfs_lvm_remove_all (g);
8493 char device[] = "/dev/sda";
8494 char lines_0[] = ",";
8501 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8506 char fstype[] = "ext2";
8507 char device[] = "/dev/sda1";
8510 r = guestfs_mkfs (g, fstype, device);
8515 char device[] = "/dev/sda1";
8516 char mountpoint[] = "/";
8519 r = guestfs_mount (g, device, mountpoint);
8523 /* TestOutput for checksum (6) */
8524 char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
8526 char path[] = "/new";
8527 char content[] = "test\n";
8530 r = guestfs_write_file (g, path, content, 0);
8535 char csumtype[] = "sha384";
8536 char path[] = "/new";
8539 r = guestfs_checksum (g, csumtype, path);
8542 if (strcmp (r, expected) != 0) {
8543 fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
8551 static int test_checksum_7_skip (void)
8555 str = getenv ("TEST_ONLY");
8557 return strstr (str, "checksum") == NULL;
8558 str = getenv ("SKIP_TEST_CHECKSUM_7");
8559 if (str && strcmp (str, "1") == 0) return 1;
8560 str = getenv ("SKIP_TEST_CHECKSUM");
8561 if (str && strcmp (str, "1") == 0) return 1;
8565 static int test_checksum_7 (void)
8567 if (test_checksum_7_skip ()) {
8568 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_7");
8572 /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
8574 char device[] = "/dev/sda";
8577 r = guestfs_blockdev_setrw (g, device);
8584 r = guestfs_umount_all (g);
8591 r = guestfs_lvm_remove_all (g);
8596 char device[] = "/dev/sda";
8597 char lines_0[] = ",";
8604 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8609 char fstype[] = "ext2";
8610 char device[] = "/dev/sda1";
8613 r = guestfs_mkfs (g, fstype, device);
8618 char device[] = "/dev/sda1";
8619 char mountpoint[] = "/";
8622 r = guestfs_mount (g, device, mountpoint);
8626 /* TestOutput for checksum (7) */
8627 char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
8629 char path[] = "/new";
8630 char content[] = "test\n";
8633 r = guestfs_write_file (g, path, content, 0);
8638 char csumtype[] = "sha512";
8639 char path[] = "/new";
8642 r = guestfs_checksum (g, csumtype, path);
8645 if (strcmp (r, expected) != 0) {
8646 fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
8654 static int test_checksum_8_skip (void)
8658 str = getenv ("TEST_ONLY");
8660 return strstr (str, "checksum") == NULL;
8661 str = getenv ("SKIP_TEST_CHECKSUM_8");
8662 if (str && strcmp (str, "1") == 0) return 1;
8663 str = getenv ("SKIP_TEST_CHECKSUM");
8664 if (str && strcmp (str, "1") == 0) return 1;
8668 static int test_checksum_8 (void)
8670 if (test_checksum_8_skip ()) {
8671 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_8");
8675 /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
8677 char device[] = "/dev/sda";
8680 r = guestfs_blockdev_setrw (g, device);
8687 r = guestfs_umount_all (g);
8694 r = guestfs_lvm_remove_all (g);
8699 char device[] = "/dev/sda";
8700 char lines_0[] = ",";
8707 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8712 char fstype[] = "ext2";
8713 char device[] = "/dev/sda1";
8716 r = guestfs_mkfs (g, fstype, device);
8721 char device[] = "/dev/sda1";
8722 char mountpoint[] = "/";
8725 r = guestfs_mount (g, device, mountpoint);
8729 /* TestOutput for checksum (8) */
8730 char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
8732 char options[] = "ro";
8733 char vfstype[] = "squashfs";
8734 char device[] = "/dev/sdd";
8735 char mountpoint[] = "/";
8738 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
8743 char csumtype[] = "md5";
8744 char path[] = "/known-3";
8747 r = guestfs_checksum (g, csumtype, path);
8750 if (strcmp (r, expected) != 0) {
8751 fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
8759 static int test_download_0_skip (void)
8763 str = getenv ("TEST_ONLY");
8765 return strstr (str, "download") == NULL;
8766 str = getenv ("SKIP_TEST_DOWNLOAD_0");
8767 if (str && strcmp (str, "1") == 0) return 1;
8768 str = getenv ("SKIP_TEST_DOWNLOAD");
8769 if (str && strcmp (str, "1") == 0) return 1;
8773 static int test_download_0 (void)
8775 if (test_download_0_skip ()) {
8776 printf ("%s skipped (reason: environment variable set)\n", "test_download_0");
8780 /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
8782 char device[] = "/dev/sda";
8785 r = guestfs_blockdev_setrw (g, device);
8792 r = guestfs_umount_all (g);
8799 r = guestfs_lvm_remove_all (g);
8804 char device[] = "/dev/sda";
8805 char lines_0[] = ",";
8812 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8817 char fstype[] = "ext2";
8818 char device[] = "/dev/sda1";
8821 r = guestfs_mkfs (g, fstype, device);
8826 char device[] = "/dev/sda1";
8827 char mountpoint[] = "/";
8830 r = guestfs_mount (g, device, mountpoint);
8834 /* TestOutput for download (0) */
8835 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
8837 char remotefilename[] = "/COPYING.LIB";
8840 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
8845 char remotefilename[] = "/COPYING.LIB";
8848 r = guestfs_download (g, remotefilename, "testdownload.tmp");
8853 char remotefilename[] = "/upload";
8856 r = guestfs_upload (g, "testdownload.tmp", remotefilename);
8861 char csumtype[] = "md5";
8862 char path[] = "/upload";
8865 r = guestfs_checksum (g, csumtype, path);
8868 if (strcmp (r, expected) != 0) {
8869 fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
8877 static int test_upload_0_skip (void)
8881 str = getenv ("TEST_ONLY");
8883 return strstr (str, "upload") == NULL;
8884 str = getenv ("SKIP_TEST_UPLOAD_0");
8885 if (str && strcmp (str, "1") == 0) return 1;
8886 str = getenv ("SKIP_TEST_UPLOAD");
8887 if (str && strcmp (str, "1") == 0) return 1;
8891 static int test_upload_0 (void)
8893 if (test_upload_0_skip ()) {
8894 printf ("%s skipped (reason: environment variable set)\n", "test_upload_0");
8898 /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
8900 char device[] = "/dev/sda";
8903 r = guestfs_blockdev_setrw (g, device);
8910 r = guestfs_umount_all (g);
8917 r = guestfs_lvm_remove_all (g);
8922 char device[] = "/dev/sda";
8923 char lines_0[] = ",";
8930 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8935 char fstype[] = "ext2";
8936 char device[] = "/dev/sda1";
8939 r = guestfs_mkfs (g, fstype, device);
8944 char device[] = "/dev/sda1";
8945 char mountpoint[] = "/";
8948 r = guestfs_mount (g, device, mountpoint);
8952 /* TestOutput for upload (0) */
8953 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
8955 char remotefilename[] = "/COPYING.LIB";
8958 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
8963 char csumtype[] = "md5";
8964 char path[] = "/COPYING.LIB";
8967 r = guestfs_checksum (g, csumtype, path);
8970 if (strcmp (r, expected) != 0) {
8971 fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
8979 static int test_blockdev_rereadpt_0_skip (void)
8983 str = getenv ("TEST_ONLY");
8985 return strstr (str, "blockdev_rereadpt") == NULL;
8986 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
8987 if (str && strcmp (str, "1") == 0) return 1;
8988 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
8989 if (str && strcmp (str, "1") == 0) return 1;
8993 static int test_blockdev_rereadpt_0 (void)
8995 if (test_blockdev_rereadpt_0_skip ()) {
8996 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_rereadpt_0");
9000 /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
9002 char device[] = "/dev/sda";
9005 r = guestfs_blockdev_setrw (g, device);
9012 r = guestfs_umount_all (g);
9019 r = guestfs_lvm_remove_all (g);
9023 /* TestRun for blockdev_rereadpt (0) */
9025 char device[] = "/dev/sda";
9028 r = guestfs_blockdev_rereadpt (g, device);
9035 static int test_blockdev_flushbufs_0_skip (void)
9039 str = getenv ("TEST_ONLY");
9041 return strstr (str, "blockdev_flushbufs") == NULL;
9042 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
9043 if (str && strcmp (str, "1") == 0) return 1;
9044 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
9045 if (str && strcmp (str, "1") == 0) return 1;
9049 static int test_blockdev_flushbufs_0 (void)
9051 if (test_blockdev_flushbufs_0_skip ()) {
9052 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_flushbufs_0");
9056 /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
9058 char device[] = "/dev/sda";
9061 r = guestfs_blockdev_setrw (g, device);
9068 r = guestfs_umount_all (g);
9075 r = guestfs_lvm_remove_all (g);
9079 /* TestRun for blockdev_flushbufs (0) */
9081 char device[] = "/dev/sda";
9084 r = guestfs_blockdev_flushbufs (g, device);
9091 static int test_blockdev_getsize64_0_skip (void)
9095 str = getenv ("TEST_ONLY");
9097 return strstr (str, "blockdev_getsize64") == NULL;
9098 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
9099 if (str && strcmp (str, "1") == 0) return 1;
9100 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
9101 if (str && strcmp (str, "1") == 0) return 1;
9105 static int test_blockdev_getsize64_0 (void)
9107 if (test_blockdev_getsize64_0_skip ()) {
9108 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsize64_0");
9112 /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
9114 char device[] = "/dev/sda";
9117 r = guestfs_blockdev_setrw (g, device);
9124 r = guestfs_umount_all (g);
9131 r = guestfs_lvm_remove_all (g);
9135 /* TestOutputInt for blockdev_getsize64 (0) */
9137 char device[] = "/dev/sda";
9140 r = guestfs_blockdev_getsize64 (g, device);
9143 if (r != 524288000) {
9144 fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n", (int) r);
9151 static int test_blockdev_getsz_0_skip (void)
9155 str = getenv ("TEST_ONLY");
9157 return strstr (str, "blockdev_getsz") == NULL;
9158 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
9159 if (str && strcmp (str, "1") == 0) return 1;
9160 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
9161 if (str && strcmp (str, "1") == 0) return 1;
9165 static int test_blockdev_getsz_0 (void)
9167 if (test_blockdev_getsz_0_skip ()) {
9168 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsz_0");
9172 /* InitNone|InitEmpty for test_blockdev_getsz_0 */
9174 char device[] = "/dev/sda";
9177 r = guestfs_blockdev_setrw (g, device);
9184 r = guestfs_umount_all (g);
9191 r = guestfs_lvm_remove_all (g);
9195 /* TestOutputInt for blockdev_getsz (0) */
9197 char device[] = "/dev/sda";
9200 r = guestfs_blockdev_getsz (g, device);
9204 fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n", (int) r);
9211 static int test_blockdev_getbsz_0_skip (void)
9215 str = getenv ("TEST_ONLY");
9217 return strstr (str, "blockdev_getbsz") == NULL;
9218 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
9219 if (str && strcmp (str, "1") == 0) return 1;
9220 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
9221 if (str && strcmp (str, "1") == 0) return 1;
9225 static int test_blockdev_getbsz_0 (void)
9227 if (test_blockdev_getbsz_0_skip ()) {
9228 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getbsz_0");
9232 /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
9234 char device[] = "/dev/sda";
9237 r = guestfs_blockdev_setrw (g, device);
9244 r = guestfs_umount_all (g);
9251 r = guestfs_lvm_remove_all (g);
9255 /* TestOutputInt for blockdev_getbsz (0) */
9257 char device[] = "/dev/sda";
9260 r = guestfs_blockdev_getbsz (g, device);
9264 fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n", (int) r);
9271 static int test_blockdev_getss_0_skip (void)
9275 str = getenv ("TEST_ONLY");
9277 return strstr (str, "blockdev_getss") == NULL;
9278 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
9279 if (str && strcmp (str, "1") == 0) return 1;
9280 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
9281 if (str && strcmp (str, "1") == 0) return 1;
9285 static int test_blockdev_getss_0 (void)
9287 if (test_blockdev_getss_0_skip ()) {
9288 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getss_0");
9292 /* InitNone|InitEmpty for test_blockdev_getss_0 */
9294 char device[] = "/dev/sda";
9297 r = guestfs_blockdev_setrw (g, device);
9304 r = guestfs_umount_all (g);
9311 r = guestfs_lvm_remove_all (g);
9315 /* TestOutputInt for blockdev_getss (0) */
9317 char device[] = "/dev/sda";
9320 r = guestfs_blockdev_getss (g, device);
9324 fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n", (int) r);
9331 static int test_blockdev_getro_0_skip (void)
9335 str = getenv ("TEST_ONLY");
9337 return strstr (str, "blockdev_getro") == NULL;
9338 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
9339 if (str && strcmp (str, "1") == 0) return 1;
9340 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
9341 if (str && strcmp (str, "1") == 0) return 1;
9345 static int test_blockdev_getro_0 (void)
9347 if (test_blockdev_getro_0_skip ()) {
9348 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getro_0");
9352 /* InitNone|InitEmpty for test_blockdev_getro_0 */
9354 char device[] = "/dev/sda";
9357 r = guestfs_blockdev_setrw (g, device);
9364 r = guestfs_umount_all (g);
9371 r = guestfs_lvm_remove_all (g);
9375 /* TestOutputTrue for blockdev_getro (0) */
9377 char device[] = "/dev/sda";
9380 r = guestfs_blockdev_setro (g, device);
9385 char device[] = "/dev/sda";
9388 r = guestfs_blockdev_getro (g, device);
9392 fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
9399 static int test_blockdev_setrw_0_skip (void)
9403 str = getenv ("TEST_ONLY");
9405 return strstr (str, "blockdev_setrw") == NULL;
9406 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
9407 if (str && strcmp (str, "1") == 0) return 1;
9408 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
9409 if (str && strcmp (str, "1") == 0) return 1;
9413 static int test_blockdev_setrw_0 (void)
9415 if (test_blockdev_setrw_0_skip ()) {
9416 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setrw_0");
9420 /* InitNone|InitEmpty for test_blockdev_setrw_0 */
9422 char device[] = "/dev/sda";
9425 r = guestfs_blockdev_setrw (g, device);
9432 r = guestfs_umount_all (g);
9439 r = guestfs_lvm_remove_all (g);
9443 /* TestOutputFalse for blockdev_setrw (0) */
9445 char device[] = "/dev/sda";
9448 r = guestfs_blockdev_setrw (g, device);
9453 char device[] = "/dev/sda";
9456 r = guestfs_blockdev_getro (g, device);
9460 fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
9467 static int test_blockdev_setro_0_skip (void)
9471 str = getenv ("TEST_ONLY");
9473 return strstr (str, "blockdev_setro") == NULL;
9474 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
9475 if (str && strcmp (str, "1") == 0) return 1;
9476 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
9477 if (str && strcmp (str, "1") == 0) return 1;
9481 static int test_blockdev_setro_0 (void)
9483 if (test_blockdev_setro_0_skip ()) {
9484 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setro_0");
9488 /* InitNone|InitEmpty for test_blockdev_setro_0 */
9490 char device[] = "/dev/sda";
9493 r = guestfs_blockdev_setrw (g, device);
9500 r = guestfs_umount_all (g);
9507 r = guestfs_lvm_remove_all (g);
9511 /* TestOutputTrue for blockdev_setro (0) */
9513 char device[] = "/dev/sda";
9516 r = guestfs_blockdev_setro (g, device);
9521 char device[] = "/dev/sda";
9524 r = guestfs_blockdev_getro (g, device);
9528 fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
9535 static int test_statvfs_0_skip (void)
9539 str = getenv ("TEST_ONLY");
9541 return strstr (str, "statvfs") == NULL;
9542 str = getenv ("SKIP_TEST_STATVFS_0");
9543 if (str && strcmp (str, "1") == 0) return 1;
9544 str = getenv ("SKIP_TEST_STATVFS");
9545 if (str && strcmp (str, "1") == 0) return 1;
9549 static int test_statvfs_0 (void)
9551 if (test_statvfs_0_skip ()) {
9552 printf ("%s skipped (reason: environment variable set)\n", "test_statvfs_0");
9556 /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
9558 char device[] = "/dev/sda";
9561 r = guestfs_blockdev_setrw (g, device);
9568 r = guestfs_umount_all (g);
9575 r = guestfs_lvm_remove_all (g);
9580 char device[] = "/dev/sda";
9581 char lines_0[] = ",";
9588 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9593 char fstype[] = "ext2";
9594 char device[] = "/dev/sda1";
9597 r = guestfs_mkfs (g, fstype, device);
9602 char device[] = "/dev/sda1";
9603 char mountpoint[] = "/";
9606 r = guestfs_mount (g, device, mountpoint);
9610 /* TestOutputStruct for statvfs (0) */
9613 struct guestfs_statvfs *r;
9615 r = guestfs_statvfs (g, path);
9618 if (r->bfree != 487702) {
9619 fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
9623 if (r->blocks != 490020) {
9624 fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
9628 if (r->bsize != 1024) {
9629 fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
9638 static int test_lstat_0_skip (void)
9642 str = getenv ("TEST_ONLY");
9644 return strstr (str, "lstat") == NULL;
9645 str = getenv ("SKIP_TEST_LSTAT_0");
9646 if (str && strcmp (str, "1") == 0) return 1;
9647 str = getenv ("SKIP_TEST_LSTAT");
9648 if (str && strcmp (str, "1") == 0) return 1;
9652 static int test_lstat_0 (void)
9654 if (test_lstat_0_skip ()) {
9655 printf ("%s skipped (reason: environment variable set)\n", "test_lstat_0");
9659 /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
9661 char device[] = "/dev/sda";
9664 r = guestfs_blockdev_setrw (g, device);
9671 r = guestfs_umount_all (g);
9678 r = guestfs_lvm_remove_all (g);
9683 char device[] = "/dev/sda";
9684 char lines_0[] = ",";
9691 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9696 char fstype[] = "ext2";
9697 char device[] = "/dev/sda1";
9700 r = guestfs_mkfs (g, fstype, device);
9705 char device[] = "/dev/sda1";
9706 char mountpoint[] = "/";
9709 r = guestfs_mount (g, device, mountpoint);
9713 /* TestOutputStruct for lstat (0) */
9715 char path[] = "/new";
9718 r = guestfs_touch (g, path);
9723 char path[] = "/new";
9724 struct guestfs_stat *r;
9726 r = guestfs_lstat (g, path);
9730 fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
9739 static int test_stat_0_skip (void)
9743 str = getenv ("TEST_ONLY");
9745 return strstr (str, "stat") == NULL;
9746 str = getenv ("SKIP_TEST_STAT_0");
9747 if (str && strcmp (str, "1") == 0) return 1;
9748 str = getenv ("SKIP_TEST_STAT");
9749 if (str && strcmp (str, "1") == 0) return 1;
9753 static int test_stat_0 (void)
9755 if (test_stat_0_skip ()) {
9756 printf ("%s skipped (reason: environment variable set)\n", "test_stat_0");
9760 /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
9762 char device[] = "/dev/sda";
9765 r = guestfs_blockdev_setrw (g, device);
9772 r = guestfs_umount_all (g);
9779 r = guestfs_lvm_remove_all (g);
9784 char device[] = "/dev/sda";
9785 char lines_0[] = ",";
9792 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9797 char fstype[] = "ext2";
9798 char device[] = "/dev/sda1";
9801 r = guestfs_mkfs (g, fstype, device);
9806 char device[] = "/dev/sda1";
9807 char mountpoint[] = "/";
9810 r = guestfs_mount (g, device, mountpoint);
9814 /* TestOutputStruct for stat (0) */
9816 char path[] = "/new";
9819 r = guestfs_touch (g, path);
9824 char path[] = "/new";
9825 struct guestfs_stat *r;
9827 r = guestfs_stat (g, path);
9831 fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
9840 static int test_command_lines_0_skip (void)
9844 str = getenv ("TEST_ONLY");
9846 return strstr (str, "command_lines") == NULL;
9847 str = getenv ("SKIP_TEST_COMMAND_LINES_0");
9848 if (str && strcmp (str, "1") == 0) return 1;
9849 str = getenv ("SKIP_TEST_COMMAND_LINES");
9850 if (str && strcmp (str, "1") == 0) return 1;
9854 static int test_command_lines_0 (void)
9856 if (test_command_lines_0_skip ()) {
9857 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_0");
9861 /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
9863 char device[] = "/dev/sda";
9866 r = guestfs_blockdev_setrw (g, device);
9873 r = guestfs_umount_all (g);
9880 r = guestfs_lvm_remove_all (g);
9885 char device[] = "/dev/sda";
9886 char lines_0[] = ",";
9893 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9898 char fstype[] = "ext2";
9899 char device[] = "/dev/sda1";
9902 r = guestfs_mkfs (g, fstype, device);
9907 char device[] = "/dev/sda1";
9908 char mountpoint[] = "/";
9911 r = guestfs_mount (g, device, mountpoint);
9915 /* TestOutputList for command_lines (0) */
9917 char remotefilename[] = "/test-command";
9920 r = guestfs_upload (g, "test-command", remotefilename);
9925 char path[] = "/test-command";
9928 r = guestfs_chmod (g, 493, path);
9933 char arguments_0[] = "/test-command";
9934 char arguments_1[] = "1";
9935 char *arguments[] = {
9943 r = guestfs_command_lines (g, arguments);
9947 fprintf (stderr, "test_command_lines_0: short list returned from command\n");
9952 char expected[] = "Result1";
9953 if (strcmp (r[0], expected) != 0) {
9954 fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9959 fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
9963 for (i = 0; r[i] != NULL; ++i)
9970 static int test_command_lines_1_skip (void)
9974 str = getenv ("TEST_ONLY");
9976 return strstr (str, "command_lines") == NULL;
9977 str = getenv ("SKIP_TEST_COMMAND_LINES_1");
9978 if (str && strcmp (str, "1") == 0) return 1;
9979 str = getenv ("SKIP_TEST_COMMAND_LINES");
9980 if (str && strcmp (str, "1") == 0) return 1;
9984 static int test_command_lines_1 (void)
9986 if (test_command_lines_1_skip ()) {
9987 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_1");
9991 /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
9993 char device[] = "/dev/sda";
9996 r = guestfs_blockdev_setrw (g, device);
10002 suppress_error = 0;
10003 r = guestfs_umount_all (g);
10009 suppress_error = 0;
10010 r = guestfs_lvm_remove_all (g);
10015 char device[] = "/dev/sda";
10016 char lines_0[] = ",";
10022 suppress_error = 0;
10023 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10028 char fstype[] = "ext2";
10029 char device[] = "/dev/sda1";
10031 suppress_error = 0;
10032 r = guestfs_mkfs (g, fstype, device);
10037 char device[] = "/dev/sda1";
10038 char mountpoint[] = "/";
10040 suppress_error = 0;
10041 r = guestfs_mount (g, device, mountpoint);
10045 /* TestOutputList for command_lines (1) */
10047 char remotefilename[] = "/test-command";
10049 suppress_error = 0;
10050 r = guestfs_upload (g, "test-command", remotefilename);
10055 char path[] = "/test-command";
10057 suppress_error = 0;
10058 r = guestfs_chmod (g, 493, path);
10063 char arguments_0[] = "/test-command";
10064 char arguments_1[] = "2";
10065 char *arguments[] = {
10072 suppress_error = 0;
10073 r = guestfs_command_lines (g, arguments);
10077 fprintf (stderr, "test_command_lines_1: short list returned from command\n");
10082 char expected[] = "Result2";
10083 if (strcmp (r[0], expected) != 0) {
10084 fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10088 if (r[1] != NULL) {
10089 fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
10093 for (i = 0; r[i] != NULL; ++i)
10100 static int test_command_lines_2_skip (void)
10104 str = getenv ("TEST_ONLY");
10106 return strstr (str, "command_lines") == NULL;
10107 str = getenv ("SKIP_TEST_COMMAND_LINES_2");
10108 if (str && strcmp (str, "1") == 0) return 1;
10109 str = getenv ("SKIP_TEST_COMMAND_LINES");
10110 if (str && strcmp (str, "1") == 0) return 1;
10114 static int test_command_lines_2 (void)
10116 if (test_command_lines_2_skip ()) {
10117 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_2");
10121 /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
10123 char device[] = "/dev/sda";
10125 suppress_error = 0;
10126 r = guestfs_blockdev_setrw (g, device);
10132 suppress_error = 0;
10133 r = guestfs_umount_all (g);
10139 suppress_error = 0;
10140 r = guestfs_lvm_remove_all (g);
10145 char device[] = "/dev/sda";
10146 char lines_0[] = ",";
10152 suppress_error = 0;
10153 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10158 char fstype[] = "ext2";
10159 char device[] = "/dev/sda1";
10161 suppress_error = 0;
10162 r = guestfs_mkfs (g, fstype, device);
10167 char device[] = "/dev/sda1";
10168 char mountpoint[] = "/";
10170 suppress_error = 0;
10171 r = guestfs_mount (g, device, mountpoint);
10175 /* TestOutputList for command_lines (2) */
10177 char remotefilename[] = "/test-command";
10179 suppress_error = 0;
10180 r = guestfs_upload (g, "test-command", remotefilename);
10185 char path[] = "/test-command";
10187 suppress_error = 0;
10188 r = guestfs_chmod (g, 493, path);
10193 char arguments_0[] = "/test-command";
10194 char arguments_1[] = "3";
10195 char *arguments[] = {
10202 suppress_error = 0;
10203 r = guestfs_command_lines (g, arguments);
10207 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
10212 char expected[] = "";
10213 if (strcmp (r[0], expected) != 0) {
10214 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10219 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
10224 char expected[] = "Result3";
10225 if (strcmp (r[1], expected) != 0) {
10226 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10230 if (r[2] != NULL) {
10231 fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
10235 for (i = 0; r[i] != NULL; ++i)
10242 static int test_command_lines_3_skip (void)
10246 str = getenv ("TEST_ONLY");
10248 return strstr (str, "command_lines") == NULL;
10249 str = getenv ("SKIP_TEST_COMMAND_LINES_3");
10250 if (str && strcmp (str, "1") == 0) return 1;
10251 str = getenv ("SKIP_TEST_COMMAND_LINES");
10252 if (str && strcmp (str, "1") == 0) return 1;
10256 static int test_command_lines_3 (void)
10258 if (test_command_lines_3_skip ()) {
10259 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_3");
10263 /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
10265 char device[] = "/dev/sda";
10267 suppress_error = 0;
10268 r = guestfs_blockdev_setrw (g, device);
10274 suppress_error = 0;
10275 r = guestfs_umount_all (g);
10281 suppress_error = 0;
10282 r = guestfs_lvm_remove_all (g);
10287 char device[] = "/dev/sda";
10288 char lines_0[] = ",";
10294 suppress_error = 0;
10295 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10300 char fstype[] = "ext2";
10301 char device[] = "/dev/sda1";
10303 suppress_error = 0;
10304 r = guestfs_mkfs (g, fstype, device);
10309 char device[] = "/dev/sda1";
10310 char mountpoint[] = "/";
10312 suppress_error = 0;
10313 r = guestfs_mount (g, device, mountpoint);
10317 /* TestOutputList for command_lines (3) */
10319 char remotefilename[] = "/test-command";
10321 suppress_error = 0;
10322 r = guestfs_upload (g, "test-command", remotefilename);
10327 char path[] = "/test-command";
10329 suppress_error = 0;
10330 r = guestfs_chmod (g, 493, path);
10335 char arguments_0[] = "/test-command";
10336 char arguments_1[] = "4";
10337 char *arguments[] = {
10344 suppress_error = 0;
10345 r = guestfs_command_lines (g, arguments);
10349 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
10354 char expected[] = "";
10355 if (strcmp (r[0], expected) != 0) {
10356 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10361 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
10366 char expected[] = "Result4";
10367 if (strcmp (r[1], expected) != 0) {
10368 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10372 if (r[2] != NULL) {
10373 fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
10377 for (i = 0; r[i] != NULL; ++i)
10384 static int test_command_lines_4_skip (void)
10388 str = getenv ("TEST_ONLY");
10390 return strstr (str, "command_lines") == NULL;
10391 str = getenv ("SKIP_TEST_COMMAND_LINES_4");
10392 if (str && strcmp (str, "1") == 0) return 1;
10393 str = getenv ("SKIP_TEST_COMMAND_LINES");
10394 if (str && strcmp (str, "1") == 0) return 1;
10398 static int test_command_lines_4 (void)
10400 if (test_command_lines_4_skip ()) {
10401 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_4");
10405 /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
10407 char device[] = "/dev/sda";
10409 suppress_error = 0;
10410 r = guestfs_blockdev_setrw (g, device);
10416 suppress_error = 0;
10417 r = guestfs_umount_all (g);
10423 suppress_error = 0;
10424 r = guestfs_lvm_remove_all (g);
10429 char device[] = "/dev/sda";
10430 char lines_0[] = ",";
10436 suppress_error = 0;
10437 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10442 char fstype[] = "ext2";
10443 char device[] = "/dev/sda1";
10445 suppress_error = 0;
10446 r = guestfs_mkfs (g, fstype, device);
10451 char device[] = "/dev/sda1";
10452 char mountpoint[] = "/";
10454 suppress_error = 0;
10455 r = guestfs_mount (g, device, mountpoint);
10459 /* TestOutputList for command_lines (4) */
10461 char remotefilename[] = "/test-command";
10463 suppress_error = 0;
10464 r = guestfs_upload (g, "test-command", remotefilename);
10469 char path[] = "/test-command";
10471 suppress_error = 0;
10472 r = guestfs_chmod (g, 493, path);
10477 char arguments_0[] = "/test-command";
10478 char arguments_1[] = "5";
10479 char *arguments[] = {
10486 suppress_error = 0;
10487 r = guestfs_command_lines (g, arguments);
10491 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10496 char expected[] = "";
10497 if (strcmp (r[0], expected) != 0) {
10498 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10503 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10508 char expected[] = "Result5";
10509 if (strcmp (r[1], expected) != 0) {
10510 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10515 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10520 char expected[] = "";
10521 if (strcmp (r[2], expected) != 0) {
10522 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10526 if (r[3] != NULL) {
10527 fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
10531 for (i = 0; r[i] != NULL; ++i)
10538 static int test_command_lines_5_skip (void)
10542 str = getenv ("TEST_ONLY");
10544 return strstr (str, "command_lines") == NULL;
10545 str = getenv ("SKIP_TEST_COMMAND_LINES_5");
10546 if (str && strcmp (str, "1") == 0) return 1;
10547 str = getenv ("SKIP_TEST_COMMAND_LINES");
10548 if (str && strcmp (str, "1") == 0) return 1;
10552 static int test_command_lines_5 (void)
10554 if (test_command_lines_5_skip ()) {
10555 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_5");
10559 /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
10561 char device[] = "/dev/sda";
10563 suppress_error = 0;
10564 r = guestfs_blockdev_setrw (g, device);
10570 suppress_error = 0;
10571 r = guestfs_umount_all (g);
10577 suppress_error = 0;
10578 r = guestfs_lvm_remove_all (g);
10583 char device[] = "/dev/sda";
10584 char lines_0[] = ",";
10590 suppress_error = 0;
10591 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10596 char fstype[] = "ext2";
10597 char device[] = "/dev/sda1";
10599 suppress_error = 0;
10600 r = guestfs_mkfs (g, fstype, device);
10605 char device[] = "/dev/sda1";
10606 char mountpoint[] = "/";
10608 suppress_error = 0;
10609 r = guestfs_mount (g, device, mountpoint);
10613 /* TestOutputList for command_lines (5) */
10615 char remotefilename[] = "/test-command";
10617 suppress_error = 0;
10618 r = guestfs_upload (g, "test-command", remotefilename);
10623 char path[] = "/test-command";
10625 suppress_error = 0;
10626 r = guestfs_chmod (g, 493, path);
10631 char arguments_0[] = "/test-command";
10632 char arguments_1[] = "6";
10633 char *arguments[] = {
10640 suppress_error = 0;
10641 r = guestfs_command_lines (g, arguments);
10645 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10650 char expected[] = "";
10651 if (strcmp (r[0], expected) != 0) {
10652 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10657 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10662 char expected[] = "";
10663 if (strcmp (r[1], expected) != 0) {
10664 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10669 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10674 char expected[] = "Result6";
10675 if (strcmp (r[2], expected) != 0) {
10676 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10681 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10686 char expected[] = "";
10687 if (strcmp (r[3], expected) != 0) {
10688 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
10692 if (r[4] != NULL) {
10693 fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
10697 for (i = 0; r[i] != NULL; ++i)
10704 static int test_command_lines_6_skip (void)
10708 str = getenv ("TEST_ONLY");
10710 return strstr (str, "command_lines") == NULL;
10711 str = getenv ("SKIP_TEST_COMMAND_LINES_6");
10712 if (str && strcmp (str, "1") == 0) return 1;
10713 str = getenv ("SKIP_TEST_COMMAND_LINES");
10714 if (str && strcmp (str, "1") == 0) return 1;
10718 static int test_command_lines_6 (void)
10720 if (test_command_lines_6_skip ()) {
10721 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_6");
10725 /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
10727 char device[] = "/dev/sda";
10729 suppress_error = 0;
10730 r = guestfs_blockdev_setrw (g, device);
10736 suppress_error = 0;
10737 r = guestfs_umount_all (g);
10743 suppress_error = 0;
10744 r = guestfs_lvm_remove_all (g);
10749 char device[] = "/dev/sda";
10750 char lines_0[] = ",";
10756 suppress_error = 0;
10757 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10762 char fstype[] = "ext2";
10763 char device[] = "/dev/sda1";
10765 suppress_error = 0;
10766 r = guestfs_mkfs (g, fstype, device);
10771 char device[] = "/dev/sda1";
10772 char mountpoint[] = "/";
10774 suppress_error = 0;
10775 r = guestfs_mount (g, device, mountpoint);
10779 /* TestOutputList for command_lines (6) */
10781 char remotefilename[] = "/test-command";
10783 suppress_error = 0;
10784 r = guestfs_upload (g, "test-command", remotefilename);
10789 char path[] = "/test-command";
10791 suppress_error = 0;
10792 r = guestfs_chmod (g, 493, path);
10797 char arguments_0[] = "/test-command";
10798 char arguments_1[] = "7";
10799 char *arguments[] = {
10806 suppress_error = 0;
10807 r = guestfs_command_lines (g, arguments);
10810 if (r[0] != NULL) {
10811 fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
10815 for (i = 0; r[i] != NULL; ++i)
10822 static int test_command_lines_7_skip (void)
10826 str = getenv ("TEST_ONLY");
10828 return strstr (str, "command_lines") == NULL;
10829 str = getenv ("SKIP_TEST_COMMAND_LINES_7");
10830 if (str && strcmp (str, "1") == 0) return 1;
10831 str = getenv ("SKIP_TEST_COMMAND_LINES");
10832 if (str && strcmp (str, "1") == 0) return 1;
10836 static int test_command_lines_7 (void)
10838 if (test_command_lines_7_skip ()) {
10839 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_7");
10843 /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
10845 char device[] = "/dev/sda";
10847 suppress_error = 0;
10848 r = guestfs_blockdev_setrw (g, device);
10854 suppress_error = 0;
10855 r = guestfs_umount_all (g);
10861 suppress_error = 0;
10862 r = guestfs_lvm_remove_all (g);
10867 char device[] = "/dev/sda";
10868 char lines_0[] = ",";
10874 suppress_error = 0;
10875 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10880 char fstype[] = "ext2";
10881 char device[] = "/dev/sda1";
10883 suppress_error = 0;
10884 r = guestfs_mkfs (g, fstype, device);
10889 char device[] = "/dev/sda1";
10890 char mountpoint[] = "/";
10892 suppress_error = 0;
10893 r = guestfs_mount (g, device, mountpoint);
10897 /* TestOutputList for command_lines (7) */
10899 char remotefilename[] = "/test-command";
10901 suppress_error = 0;
10902 r = guestfs_upload (g, "test-command", remotefilename);
10907 char path[] = "/test-command";
10909 suppress_error = 0;
10910 r = guestfs_chmod (g, 493, path);
10915 char arguments_0[] = "/test-command";
10916 char arguments_1[] = "8";
10917 char *arguments[] = {
10924 suppress_error = 0;
10925 r = guestfs_command_lines (g, arguments);
10929 fprintf (stderr, "test_command_lines_7: short list returned from command\n");
10934 char expected[] = "";
10935 if (strcmp (r[0], expected) != 0) {
10936 fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10940 if (r[1] != NULL) {
10941 fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
10945 for (i = 0; r[i] != NULL; ++i)
10952 static int test_command_lines_8_skip (void)
10956 str = getenv ("TEST_ONLY");
10958 return strstr (str, "command_lines") == NULL;
10959 str = getenv ("SKIP_TEST_COMMAND_LINES_8");
10960 if (str && strcmp (str, "1") == 0) return 1;
10961 str = getenv ("SKIP_TEST_COMMAND_LINES");
10962 if (str && strcmp (str, "1") == 0) return 1;
10966 static int test_command_lines_8 (void)
10968 if (test_command_lines_8_skip ()) {
10969 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_8");
10973 /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
10975 char device[] = "/dev/sda";
10977 suppress_error = 0;
10978 r = guestfs_blockdev_setrw (g, device);
10984 suppress_error = 0;
10985 r = guestfs_umount_all (g);
10991 suppress_error = 0;
10992 r = guestfs_lvm_remove_all (g);
10997 char device[] = "/dev/sda";
10998 char lines_0[] = ",";
11004 suppress_error = 0;
11005 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11010 char fstype[] = "ext2";
11011 char device[] = "/dev/sda1";
11013 suppress_error = 0;
11014 r = guestfs_mkfs (g, fstype, device);
11019 char device[] = "/dev/sda1";
11020 char mountpoint[] = "/";
11022 suppress_error = 0;
11023 r = guestfs_mount (g, device, mountpoint);
11027 /* TestOutputList for command_lines (8) */
11029 char remotefilename[] = "/test-command";
11031 suppress_error = 0;
11032 r = guestfs_upload (g, "test-command", remotefilename);
11037 char path[] = "/test-command";
11039 suppress_error = 0;
11040 r = guestfs_chmod (g, 493, path);
11045 char arguments_0[] = "/test-command";
11046 char arguments_1[] = "9";
11047 char *arguments[] = {
11054 suppress_error = 0;
11055 r = guestfs_command_lines (g, arguments);
11059 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
11064 char expected[] = "";
11065 if (strcmp (r[0], expected) != 0) {
11066 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11071 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
11076 char expected[] = "";
11077 if (strcmp (r[1], expected) != 0) {
11078 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11082 if (r[2] != NULL) {
11083 fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
11087 for (i = 0; r[i] != NULL; ++i)
11094 static int test_command_lines_9_skip (void)
11098 str = getenv ("TEST_ONLY");
11100 return strstr (str, "command_lines") == NULL;
11101 str = getenv ("SKIP_TEST_COMMAND_LINES_9");
11102 if (str && strcmp (str, "1") == 0) return 1;
11103 str = getenv ("SKIP_TEST_COMMAND_LINES");
11104 if (str && strcmp (str, "1") == 0) return 1;
11108 static int test_command_lines_9 (void)
11110 if (test_command_lines_9_skip ()) {
11111 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_9");
11115 /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
11117 char device[] = "/dev/sda";
11119 suppress_error = 0;
11120 r = guestfs_blockdev_setrw (g, device);
11126 suppress_error = 0;
11127 r = guestfs_umount_all (g);
11133 suppress_error = 0;
11134 r = guestfs_lvm_remove_all (g);
11139 char device[] = "/dev/sda";
11140 char lines_0[] = ",";
11146 suppress_error = 0;
11147 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11152 char fstype[] = "ext2";
11153 char device[] = "/dev/sda1";
11155 suppress_error = 0;
11156 r = guestfs_mkfs (g, fstype, device);
11161 char device[] = "/dev/sda1";
11162 char mountpoint[] = "/";
11164 suppress_error = 0;
11165 r = guestfs_mount (g, device, mountpoint);
11169 /* TestOutputList for command_lines (9) */
11171 char remotefilename[] = "/test-command";
11173 suppress_error = 0;
11174 r = guestfs_upload (g, "test-command", remotefilename);
11179 char path[] = "/test-command";
11181 suppress_error = 0;
11182 r = guestfs_chmod (g, 493, path);
11187 char arguments_0[] = "/test-command";
11188 char arguments_1[] = "10";
11189 char *arguments[] = {
11196 suppress_error = 0;
11197 r = guestfs_command_lines (g, arguments);
11201 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
11206 char expected[] = "Result10-1";
11207 if (strcmp (r[0], expected) != 0) {
11208 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11213 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
11218 char expected[] = "Result10-2";
11219 if (strcmp (r[1], expected) != 0) {
11220 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11224 if (r[2] != NULL) {
11225 fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
11229 for (i = 0; r[i] != NULL; ++i)
11236 static int test_command_lines_10_skip (void)
11240 str = getenv ("TEST_ONLY");
11242 return strstr (str, "command_lines") == NULL;
11243 str = getenv ("SKIP_TEST_COMMAND_LINES_10");
11244 if (str && strcmp (str, "1") == 0) return 1;
11245 str = getenv ("SKIP_TEST_COMMAND_LINES");
11246 if (str && strcmp (str, "1") == 0) return 1;
11250 static int test_command_lines_10 (void)
11252 if (test_command_lines_10_skip ()) {
11253 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_10");
11257 /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
11259 char device[] = "/dev/sda";
11261 suppress_error = 0;
11262 r = guestfs_blockdev_setrw (g, device);
11268 suppress_error = 0;
11269 r = guestfs_umount_all (g);
11275 suppress_error = 0;
11276 r = guestfs_lvm_remove_all (g);
11281 char device[] = "/dev/sda";
11282 char lines_0[] = ",";
11288 suppress_error = 0;
11289 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11294 char fstype[] = "ext2";
11295 char device[] = "/dev/sda1";
11297 suppress_error = 0;
11298 r = guestfs_mkfs (g, fstype, device);
11303 char device[] = "/dev/sda1";
11304 char mountpoint[] = "/";
11306 suppress_error = 0;
11307 r = guestfs_mount (g, device, mountpoint);
11311 /* TestOutputList for command_lines (10) */
11313 char remotefilename[] = "/test-command";
11315 suppress_error = 0;
11316 r = guestfs_upload (g, "test-command", remotefilename);
11321 char path[] = "/test-command";
11323 suppress_error = 0;
11324 r = guestfs_chmod (g, 493, path);
11329 char arguments_0[] = "/test-command";
11330 char arguments_1[] = "11";
11331 char *arguments[] = {
11338 suppress_error = 0;
11339 r = guestfs_command_lines (g, arguments);
11343 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
11348 char expected[] = "Result11-1";
11349 if (strcmp (r[0], expected) != 0) {
11350 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11355 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
11360 char expected[] = "Result11-2";
11361 if (strcmp (r[1], expected) != 0) {
11362 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11366 if (r[2] != NULL) {
11367 fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
11371 for (i = 0; r[i] != NULL; ++i)
11378 static int test_command_0_skip (void)
11382 str = getenv ("TEST_ONLY");
11384 return strstr (str, "command") == NULL;
11385 str = getenv ("SKIP_TEST_COMMAND_0");
11386 if (str && strcmp (str, "1") == 0) return 1;
11387 str = getenv ("SKIP_TEST_COMMAND");
11388 if (str && strcmp (str, "1") == 0) return 1;
11392 static int test_command_0 (void)
11394 if (test_command_0_skip ()) {
11395 printf ("%s skipped (reason: environment variable set)\n", "test_command_0");
11399 /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
11401 char device[] = "/dev/sda";
11403 suppress_error = 0;
11404 r = guestfs_blockdev_setrw (g, device);
11410 suppress_error = 0;
11411 r = guestfs_umount_all (g);
11417 suppress_error = 0;
11418 r = guestfs_lvm_remove_all (g);
11423 char device[] = "/dev/sda";
11424 char lines_0[] = ",";
11430 suppress_error = 0;
11431 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11436 char fstype[] = "ext2";
11437 char device[] = "/dev/sda1";
11439 suppress_error = 0;
11440 r = guestfs_mkfs (g, fstype, device);
11445 char device[] = "/dev/sda1";
11446 char mountpoint[] = "/";
11448 suppress_error = 0;
11449 r = guestfs_mount (g, device, mountpoint);
11453 /* TestOutput for command (0) */
11454 char expected[] = "Result1";
11456 char remotefilename[] = "/test-command";
11458 suppress_error = 0;
11459 r = guestfs_upload (g, "test-command", remotefilename);
11464 char path[] = "/test-command";
11466 suppress_error = 0;
11467 r = guestfs_chmod (g, 493, path);
11472 char arguments_0[] = "/test-command";
11473 char arguments_1[] = "1";
11474 char *arguments[] = {
11480 suppress_error = 0;
11481 r = guestfs_command (g, arguments);
11484 if (strcmp (r, expected) != 0) {
11485 fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
11493 static int test_command_1_skip (void)
11497 str = getenv ("TEST_ONLY");
11499 return strstr (str, "command") == NULL;
11500 str = getenv ("SKIP_TEST_COMMAND_1");
11501 if (str && strcmp (str, "1") == 0) return 1;
11502 str = getenv ("SKIP_TEST_COMMAND");
11503 if (str && strcmp (str, "1") == 0) return 1;
11507 static int test_command_1 (void)
11509 if (test_command_1_skip ()) {
11510 printf ("%s skipped (reason: environment variable set)\n", "test_command_1");
11514 /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
11516 char device[] = "/dev/sda";
11518 suppress_error = 0;
11519 r = guestfs_blockdev_setrw (g, device);
11525 suppress_error = 0;
11526 r = guestfs_umount_all (g);
11532 suppress_error = 0;
11533 r = guestfs_lvm_remove_all (g);
11538 char device[] = "/dev/sda";
11539 char lines_0[] = ",";
11545 suppress_error = 0;
11546 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11551 char fstype[] = "ext2";
11552 char device[] = "/dev/sda1";
11554 suppress_error = 0;
11555 r = guestfs_mkfs (g, fstype, device);
11560 char device[] = "/dev/sda1";
11561 char mountpoint[] = "/";
11563 suppress_error = 0;
11564 r = guestfs_mount (g, device, mountpoint);
11568 /* TestOutput for command (1) */
11569 char expected[] = "Result2\n";
11571 char remotefilename[] = "/test-command";
11573 suppress_error = 0;
11574 r = guestfs_upload (g, "test-command", remotefilename);
11579 char path[] = "/test-command";
11581 suppress_error = 0;
11582 r = guestfs_chmod (g, 493, path);
11587 char arguments_0[] = "/test-command";
11588 char arguments_1[] = "2";
11589 char *arguments[] = {
11595 suppress_error = 0;
11596 r = guestfs_command (g, arguments);
11599 if (strcmp (r, expected) != 0) {
11600 fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
11608 static int test_command_2_skip (void)
11612 str = getenv ("TEST_ONLY");
11614 return strstr (str, "command") == NULL;
11615 str = getenv ("SKIP_TEST_COMMAND_2");
11616 if (str && strcmp (str, "1") == 0) return 1;
11617 str = getenv ("SKIP_TEST_COMMAND");
11618 if (str && strcmp (str, "1") == 0) return 1;
11622 static int test_command_2 (void)
11624 if (test_command_2_skip ()) {
11625 printf ("%s skipped (reason: environment variable set)\n", "test_command_2");
11629 /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
11631 char device[] = "/dev/sda";
11633 suppress_error = 0;
11634 r = guestfs_blockdev_setrw (g, device);
11640 suppress_error = 0;
11641 r = guestfs_umount_all (g);
11647 suppress_error = 0;
11648 r = guestfs_lvm_remove_all (g);
11653 char device[] = "/dev/sda";
11654 char lines_0[] = ",";
11660 suppress_error = 0;
11661 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11666 char fstype[] = "ext2";
11667 char device[] = "/dev/sda1";
11669 suppress_error = 0;
11670 r = guestfs_mkfs (g, fstype, device);
11675 char device[] = "/dev/sda1";
11676 char mountpoint[] = "/";
11678 suppress_error = 0;
11679 r = guestfs_mount (g, device, mountpoint);
11683 /* TestOutput for command (2) */
11684 char expected[] = "\nResult3";
11686 char remotefilename[] = "/test-command";
11688 suppress_error = 0;
11689 r = guestfs_upload (g, "test-command", remotefilename);
11694 char path[] = "/test-command";
11696 suppress_error = 0;
11697 r = guestfs_chmod (g, 493, path);
11702 char arguments_0[] = "/test-command";
11703 char arguments_1[] = "3";
11704 char *arguments[] = {
11710 suppress_error = 0;
11711 r = guestfs_command (g, arguments);
11714 if (strcmp (r, expected) != 0) {
11715 fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
11723 static int test_command_3_skip (void)
11727 str = getenv ("TEST_ONLY");
11729 return strstr (str, "command") == NULL;
11730 str = getenv ("SKIP_TEST_COMMAND_3");
11731 if (str && strcmp (str, "1") == 0) return 1;
11732 str = getenv ("SKIP_TEST_COMMAND");
11733 if (str && strcmp (str, "1") == 0) return 1;
11737 static int test_command_3 (void)
11739 if (test_command_3_skip ()) {
11740 printf ("%s skipped (reason: environment variable set)\n", "test_command_3");
11744 /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
11746 char device[] = "/dev/sda";
11748 suppress_error = 0;
11749 r = guestfs_blockdev_setrw (g, device);
11755 suppress_error = 0;
11756 r = guestfs_umount_all (g);
11762 suppress_error = 0;
11763 r = guestfs_lvm_remove_all (g);
11768 char device[] = "/dev/sda";
11769 char lines_0[] = ",";
11775 suppress_error = 0;
11776 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11781 char fstype[] = "ext2";
11782 char device[] = "/dev/sda1";
11784 suppress_error = 0;
11785 r = guestfs_mkfs (g, fstype, device);
11790 char device[] = "/dev/sda1";
11791 char mountpoint[] = "/";
11793 suppress_error = 0;
11794 r = guestfs_mount (g, device, mountpoint);
11798 /* TestOutput for command (3) */
11799 char expected[] = "\nResult4\n";
11801 char remotefilename[] = "/test-command";
11803 suppress_error = 0;
11804 r = guestfs_upload (g, "test-command", remotefilename);
11809 char path[] = "/test-command";
11811 suppress_error = 0;
11812 r = guestfs_chmod (g, 493, path);
11817 char arguments_0[] = "/test-command";
11818 char arguments_1[] = "4";
11819 char *arguments[] = {
11825 suppress_error = 0;
11826 r = guestfs_command (g, arguments);
11829 if (strcmp (r, expected) != 0) {
11830 fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
11838 static int test_command_4_skip (void)
11842 str = getenv ("TEST_ONLY");
11844 return strstr (str, "command") == NULL;
11845 str = getenv ("SKIP_TEST_COMMAND_4");
11846 if (str && strcmp (str, "1") == 0) return 1;
11847 str = getenv ("SKIP_TEST_COMMAND");
11848 if (str && strcmp (str, "1") == 0) return 1;
11852 static int test_command_4 (void)
11854 if (test_command_4_skip ()) {
11855 printf ("%s skipped (reason: environment variable set)\n", "test_command_4");
11859 /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
11861 char device[] = "/dev/sda";
11863 suppress_error = 0;
11864 r = guestfs_blockdev_setrw (g, device);
11870 suppress_error = 0;
11871 r = guestfs_umount_all (g);
11877 suppress_error = 0;
11878 r = guestfs_lvm_remove_all (g);
11883 char device[] = "/dev/sda";
11884 char lines_0[] = ",";
11890 suppress_error = 0;
11891 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11896 char fstype[] = "ext2";
11897 char device[] = "/dev/sda1";
11899 suppress_error = 0;
11900 r = guestfs_mkfs (g, fstype, device);
11905 char device[] = "/dev/sda1";
11906 char mountpoint[] = "/";
11908 suppress_error = 0;
11909 r = guestfs_mount (g, device, mountpoint);
11913 /* TestOutput for command (4) */
11914 char expected[] = "\nResult5\n\n";
11916 char remotefilename[] = "/test-command";
11918 suppress_error = 0;
11919 r = guestfs_upload (g, "test-command", remotefilename);
11924 char path[] = "/test-command";
11926 suppress_error = 0;
11927 r = guestfs_chmod (g, 493, path);
11932 char arguments_0[] = "/test-command";
11933 char arguments_1[] = "5";
11934 char *arguments[] = {
11940 suppress_error = 0;
11941 r = guestfs_command (g, arguments);
11944 if (strcmp (r, expected) != 0) {
11945 fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
11953 static int test_command_5_skip (void)
11957 str = getenv ("TEST_ONLY");
11959 return strstr (str, "command") == NULL;
11960 str = getenv ("SKIP_TEST_COMMAND_5");
11961 if (str && strcmp (str, "1") == 0) return 1;
11962 str = getenv ("SKIP_TEST_COMMAND");
11963 if (str && strcmp (str, "1") == 0) return 1;
11967 static int test_command_5 (void)
11969 if (test_command_5_skip ()) {
11970 printf ("%s skipped (reason: environment variable set)\n", "test_command_5");
11974 /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
11976 char device[] = "/dev/sda";
11978 suppress_error = 0;
11979 r = guestfs_blockdev_setrw (g, device);
11985 suppress_error = 0;
11986 r = guestfs_umount_all (g);
11992 suppress_error = 0;
11993 r = guestfs_lvm_remove_all (g);
11998 char device[] = "/dev/sda";
11999 char lines_0[] = ",";
12005 suppress_error = 0;
12006 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12011 char fstype[] = "ext2";
12012 char device[] = "/dev/sda1";
12014 suppress_error = 0;
12015 r = guestfs_mkfs (g, fstype, device);
12020 char device[] = "/dev/sda1";
12021 char mountpoint[] = "/";
12023 suppress_error = 0;
12024 r = guestfs_mount (g, device, mountpoint);
12028 /* TestOutput for command (5) */
12029 char expected[] = "\n\nResult6\n\n";
12031 char remotefilename[] = "/test-command";
12033 suppress_error = 0;
12034 r = guestfs_upload (g, "test-command", remotefilename);
12039 char path[] = "/test-command";
12041 suppress_error = 0;
12042 r = guestfs_chmod (g, 493, path);
12047 char arguments_0[] = "/test-command";
12048 char arguments_1[] = "6";
12049 char *arguments[] = {
12055 suppress_error = 0;
12056 r = guestfs_command (g, arguments);
12059 if (strcmp (r, expected) != 0) {
12060 fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
12068 static int test_command_6_skip (void)
12072 str = getenv ("TEST_ONLY");
12074 return strstr (str, "command") == NULL;
12075 str = getenv ("SKIP_TEST_COMMAND_6");
12076 if (str && strcmp (str, "1") == 0) return 1;
12077 str = getenv ("SKIP_TEST_COMMAND");
12078 if (str && strcmp (str, "1") == 0) return 1;
12082 static int test_command_6 (void)
12084 if (test_command_6_skip ()) {
12085 printf ("%s skipped (reason: environment variable set)\n", "test_command_6");
12089 /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
12091 char device[] = "/dev/sda";
12093 suppress_error = 0;
12094 r = guestfs_blockdev_setrw (g, device);
12100 suppress_error = 0;
12101 r = guestfs_umount_all (g);
12107 suppress_error = 0;
12108 r = guestfs_lvm_remove_all (g);
12113 char device[] = "/dev/sda";
12114 char lines_0[] = ",";
12120 suppress_error = 0;
12121 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12126 char fstype[] = "ext2";
12127 char device[] = "/dev/sda1";
12129 suppress_error = 0;
12130 r = guestfs_mkfs (g, fstype, device);
12135 char device[] = "/dev/sda1";
12136 char mountpoint[] = "/";
12138 suppress_error = 0;
12139 r = guestfs_mount (g, device, mountpoint);
12143 /* TestOutput for command (6) */
12144 char expected[] = "";
12146 char remotefilename[] = "/test-command";
12148 suppress_error = 0;
12149 r = guestfs_upload (g, "test-command", remotefilename);
12154 char path[] = "/test-command";
12156 suppress_error = 0;
12157 r = guestfs_chmod (g, 493, path);
12162 char arguments_0[] = "/test-command";
12163 char arguments_1[] = "7";
12164 char *arguments[] = {
12170 suppress_error = 0;
12171 r = guestfs_command (g, arguments);
12174 if (strcmp (r, expected) != 0) {
12175 fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
12183 static int test_command_7_skip (void)
12187 str = getenv ("TEST_ONLY");
12189 return strstr (str, "command") == NULL;
12190 str = getenv ("SKIP_TEST_COMMAND_7");
12191 if (str && strcmp (str, "1") == 0) return 1;
12192 str = getenv ("SKIP_TEST_COMMAND");
12193 if (str && strcmp (str, "1") == 0) return 1;
12197 static int test_command_7 (void)
12199 if (test_command_7_skip ()) {
12200 printf ("%s skipped (reason: environment variable set)\n", "test_command_7");
12204 /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
12206 char device[] = "/dev/sda";
12208 suppress_error = 0;
12209 r = guestfs_blockdev_setrw (g, device);
12215 suppress_error = 0;
12216 r = guestfs_umount_all (g);
12222 suppress_error = 0;
12223 r = guestfs_lvm_remove_all (g);
12228 char device[] = "/dev/sda";
12229 char lines_0[] = ",";
12235 suppress_error = 0;
12236 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12241 char fstype[] = "ext2";
12242 char device[] = "/dev/sda1";
12244 suppress_error = 0;
12245 r = guestfs_mkfs (g, fstype, device);
12250 char device[] = "/dev/sda1";
12251 char mountpoint[] = "/";
12253 suppress_error = 0;
12254 r = guestfs_mount (g, device, mountpoint);
12258 /* TestOutput for command (7) */
12259 char expected[] = "\n";
12261 char remotefilename[] = "/test-command";
12263 suppress_error = 0;
12264 r = guestfs_upload (g, "test-command", remotefilename);
12269 char path[] = "/test-command";
12271 suppress_error = 0;
12272 r = guestfs_chmod (g, 493, path);
12277 char arguments_0[] = "/test-command";
12278 char arguments_1[] = "8";
12279 char *arguments[] = {
12285 suppress_error = 0;
12286 r = guestfs_command (g, arguments);
12289 if (strcmp (r, expected) != 0) {
12290 fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
12298 static int test_command_8_skip (void)
12302 str = getenv ("TEST_ONLY");
12304 return strstr (str, "command") == NULL;
12305 str = getenv ("SKIP_TEST_COMMAND_8");
12306 if (str && strcmp (str, "1") == 0) return 1;
12307 str = getenv ("SKIP_TEST_COMMAND");
12308 if (str && strcmp (str, "1") == 0) return 1;
12312 static int test_command_8 (void)
12314 if (test_command_8_skip ()) {
12315 printf ("%s skipped (reason: environment variable set)\n", "test_command_8");
12319 /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
12321 char device[] = "/dev/sda";
12323 suppress_error = 0;
12324 r = guestfs_blockdev_setrw (g, device);
12330 suppress_error = 0;
12331 r = guestfs_umount_all (g);
12337 suppress_error = 0;
12338 r = guestfs_lvm_remove_all (g);
12343 char device[] = "/dev/sda";
12344 char lines_0[] = ",";
12350 suppress_error = 0;
12351 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12356 char fstype[] = "ext2";
12357 char device[] = "/dev/sda1";
12359 suppress_error = 0;
12360 r = guestfs_mkfs (g, fstype, device);
12365 char device[] = "/dev/sda1";
12366 char mountpoint[] = "/";
12368 suppress_error = 0;
12369 r = guestfs_mount (g, device, mountpoint);
12373 /* TestOutput for command (8) */
12374 char expected[] = "\n\n";
12376 char remotefilename[] = "/test-command";
12378 suppress_error = 0;
12379 r = guestfs_upload (g, "test-command", remotefilename);
12384 char path[] = "/test-command";
12386 suppress_error = 0;
12387 r = guestfs_chmod (g, 493, path);
12392 char arguments_0[] = "/test-command";
12393 char arguments_1[] = "9";
12394 char *arguments[] = {
12400 suppress_error = 0;
12401 r = guestfs_command (g, arguments);
12404 if (strcmp (r, expected) != 0) {
12405 fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
12413 static int test_command_9_skip (void)
12417 str = getenv ("TEST_ONLY");
12419 return strstr (str, "command") == NULL;
12420 str = getenv ("SKIP_TEST_COMMAND_9");
12421 if (str && strcmp (str, "1") == 0) return 1;
12422 str = getenv ("SKIP_TEST_COMMAND");
12423 if (str && strcmp (str, "1") == 0) return 1;
12427 static int test_command_9 (void)
12429 if (test_command_9_skip ()) {
12430 printf ("%s skipped (reason: environment variable set)\n", "test_command_9");
12434 /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
12436 char device[] = "/dev/sda";
12438 suppress_error = 0;
12439 r = guestfs_blockdev_setrw (g, device);
12445 suppress_error = 0;
12446 r = guestfs_umount_all (g);
12452 suppress_error = 0;
12453 r = guestfs_lvm_remove_all (g);
12458 char device[] = "/dev/sda";
12459 char lines_0[] = ",";
12465 suppress_error = 0;
12466 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12471 char fstype[] = "ext2";
12472 char device[] = "/dev/sda1";
12474 suppress_error = 0;
12475 r = guestfs_mkfs (g, fstype, device);
12480 char device[] = "/dev/sda1";
12481 char mountpoint[] = "/";
12483 suppress_error = 0;
12484 r = guestfs_mount (g, device, mountpoint);
12488 /* TestOutput for command (9) */
12489 char expected[] = "Result10-1\nResult10-2\n";
12491 char remotefilename[] = "/test-command";
12493 suppress_error = 0;
12494 r = guestfs_upload (g, "test-command", remotefilename);
12499 char path[] = "/test-command";
12501 suppress_error = 0;
12502 r = guestfs_chmod (g, 493, path);
12507 char arguments_0[] = "/test-command";
12508 char arguments_1[] = "10";
12509 char *arguments[] = {
12515 suppress_error = 0;
12516 r = guestfs_command (g, arguments);
12519 if (strcmp (r, expected) != 0) {
12520 fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
12528 static int test_command_10_skip (void)
12532 str = getenv ("TEST_ONLY");
12534 return strstr (str, "command") == NULL;
12535 str = getenv ("SKIP_TEST_COMMAND_10");
12536 if (str && strcmp (str, "1") == 0) return 1;
12537 str = getenv ("SKIP_TEST_COMMAND");
12538 if (str && strcmp (str, "1") == 0) return 1;
12542 static int test_command_10 (void)
12544 if (test_command_10_skip ()) {
12545 printf ("%s skipped (reason: environment variable set)\n", "test_command_10");
12549 /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
12551 char device[] = "/dev/sda";
12553 suppress_error = 0;
12554 r = guestfs_blockdev_setrw (g, device);
12560 suppress_error = 0;
12561 r = guestfs_umount_all (g);
12567 suppress_error = 0;
12568 r = guestfs_lvm_remove_all (g);
12573 char device[] = "/dev/sda";
12574 char lines_0[] = ",";
12580 suppress_error = 0;
12581 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12586 char fstype[] = "ext2";
12587 char device[] = "/dev/sda1";
12589 suppress_error = 0;
12590 r = guestfs_mkfs (g, fstype, device);
12595 char device[] = "/dev/sda1";
12596 char mountpoint[] = "/";
12598 suppress_error = 0;
12599 r = guestfs_mount (g, device, mountpoint);
12603 /* TestOutput for command (10) */
12604 char expected[] = "Result11-1\nResult11-2";
12606 char remotefilename[] = "/test-command";
12608 suppress_error = 0;
12609 r = guestfs_upload (g, "test-command", remotefilename);
12614 char path[] = "/test-command";
12616 suppress_error = 0;
12617 r = guestfs_chmod (g, 493, path);
12622 char arguments_0[] = "/test-command";
12623 char arguments_1[] = "11";
12624 char *arguments[] = {
12630 suppress_error = 0;
12631 r = guestfs_command (g, arguments);
12634 if (strcmp (r, expected) != 0) {
12635 fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
12643 static int test_command_11_skip (void)
12647 str = getenv ("TEST_ONLY");
12649 return strstr (str, "command") == NULL;
12650 str = getenv ("SKIP_TEST_COMMAND_11");
12651 if (str && strcmp (str, "1") == 0) return 1;
12652 str = getenv ("SKIP_TEST_COMMAND");
12653 if (str && strcmp (str, "1") == 0) return 1;
12657 static int test_command_11 (void)
12659 if (test_command_11_skip ()) {
12660 printf ("%s skipped (reason: environment variable set)\n", "test_command_11");
12664 /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
12666 char device[] = "/dev/sda";
12668 suppress_error = 0;
12669 r = guestfs_blockdev_setrw (g, device);
12675 suppress_error = 0;
12676 r = guestfs_umount_all (g);
12682 suppress_error = 0;
12683 r = guestfs_lvm_remove_all (g);
12688 char device[] = "/dev/sda";
12689 char lines_0[] = ",";
12695 suppress_error = 0;
12696 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12701 char fstype[] = "ext2";
12702 char device[] = "/dev/sda1";
12704 suppress_error = 0;
12705 r = guestfs_mkfs (g, fstype, device);
12710 char device[] = "/dev/sda1";
12711 char mountpoint[] = "/";
12713 suppress_error = 0;
12714 r = guestfs_mount (g, device, mountpoint);
12718 /* TestLastFail for command (11) */
12720 char remotefilename[] = "/test-command";
12722 suppress_error = 0;
12723 r = guestfs_upload (g, "test-command", remotefilename);
12728 char path[] = "/test-command";
12730 suppress_error = 0;
12731 r = guestfs_chmod (g, 493, path);
12736 char arguments_0[] = "/test-command";
12737 char *arguments[] = {
12742 suppress_error = 1;
12743 r = guestfs_command (g, arguments);
12751 static int test_file_0_skip (void)
12755 str = getenv ("TEST_ONLY");
12757 return strstr (str, "file") == NULL;
12758 str = getenv ("SKIP_TEST_FILE_0");
12759 if (str && strcmp (str, "1") == 0) return 1;
12760 str = getenv ("SKIP_TEST_FILE");
12761 if (str && strcmp (str, "1") == 0) return 1;
12765 static int test_file_0 (void)
12767 if (test_file_0_skip ()) {
12768 printf ("%s skipped (reason: environment variable set)\n", "test_file_0");
12772 /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
12774 char device[] = "/dev/sda";
12776 suppress_error = 0;
12777 r = guestfs_blockdev_setrw (g, device);
12783 suppress_error = 0;
12784 r = guestfs_umount_all (g);
12790 suppress_error = 0;
12791 r = guestfs_lvm_remove_all (g);
12796 char device[] = "/dev/sda";
12797 char lines_0[] = ",";
12803 suppress_error = 0;
12804 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12809 char fstype[] = "ext2";
12810 char device[] = "/dev/sda1";
12812 suppress_error = 0;
12813 r = guestfs_mkfs (g, fstype, device);
12818 char device[] = "/dev/sda1";
12819 char mountpoint[] = "/";
12821 suppress_error = 0;
12822 r = guestfs_mount (g, device, mountpoint);
12826 /* TestOutput for file (0) */
12827 char expected[] = "empty";
12829 char path[] = "/new";
12831 suppress_error = 0;
12832 r = guestfs_touch (g, path);
12837 char path[] = "/new";
12839 suppress_error = 0;
12840 r = guestfs_file (g, path);
12843 if (strcmp (r, expected) != 0) {
12844 fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
12852 static int test_file_1_skip (void)
12856 str = getenv ("TEST_ONLY");
12858 return strstr (str, "file") == NULL;
12859 str = getenv ("SKIP_TEST_FILE_1");
12860 if (str && strcmp (str, "1") == 0) return 1;
12861 str = getenv ("SKIP_TEST_FILE");
12862 if (str && strcmp (str, "1") == 0) return 1;
12866 static int test_file_1 (void)
12868 if (test_file_1_skip ()) {
12869 printf ("%s skipped (reason: environment variable set)\n", "test_file_1");
12873 /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
12875 char device[] = "/dev/sda";
12877 suppress_error = 0;
12878 r = guestfs_blockdev_setrw (g, device);
12884 suppress_error = 0;
12885 r = guestfs_umount_all (g);
12891 suppress_error = 0;
12892 r = guestfs_lvm_remove_all (g);
12897 char device[] = "/dev/sda";
12898 char lines_0[] = ",";
12904 suppress_error = 0;
12905 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12910 char fstype[] = "ext2";
12911 char device[] = "/dev/sda1";
12913 suppress_error = 0;
12914 r = guestfs_mkfs (g, fstype, device);
12919 char device[] = "/dev/sda1";
12920 char mountpoint[] = "/";
12922 suppress_error = 0;
12923 r = guestfs_mount (g, device, mountpoint);
12927 /* TestOutput for file (1) */
12928 char expected[] = "ASCII text";
12930 char path[] = "/new";
12931 char content[] = "some content\n";
12933 suppress_error = 0;
12934 r = guestfs_write_file (g, path, content, 0);
12939 char path[] = "/new";
12941 suppress_error = 0;
12942 r = guestfs_file (g, path);
12945 if (strcmp (r, expected) != 0) {
12946 fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
12954 static int test_file_2_skip (void)
12958 str = getenv ("TEST_ONLY");
12960 return strstr (str, "file") == NULL;
12961 str = getenv ("SKIP_TEST_FILE_2");
12962 if (str && strcmp (str, "1") == 0) return 1;
12963 str = getenv ("SKIP_TEST_FILE");
12964 if (str && strcmp (str, "1") == 0) return 1;
12968 static int test_file_2 (void)
12970 if (test_file_2_skip ()) {
12971 printf ("%s skipped (reason: environment variable set)\n", "test_file_2");
12975 /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
12977 char device[] = "/dev/sda";
12979 suppress_error = 0;
12980 r = guestfs_blockdev_setrw (g, device);
12986 suppress_error = 0;
12987 r = guestfs_umount_all (g);
12993 suppress_error = 0;
12994 r = guestfs_lvm_remove_all (g);
12999 char device[] = "/dev/sda";
13000 char lines_0[] = ",";
13006 suppress_error = 0;
13007 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13012 char fstype[] = "ext2";
13013 char device[] = "/dev/sda1";
13015 suppress_error = 0;
13016 r = guestfs_mkfs (g, fstype, device);
13021 char device[] = "/dev/sda1";
13022 char mountpoint[] = "/";
13024 suppress_error = 0;
13025 r = guestfs_mount (g, device, mountpoint);
13029 /* TestLastFail for file (2) */
13031 char path[] = "/nofile";
13033 suppress_error = 1;
13034 r = guestfs_file (g, path);
13042 static int test_umount_all_0_skip (void)
13046 str = getenv ("TEST_ONLY");
13048 return strstr (str, "umount_all") == NULL;
13049 str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
13050 if (str && strcmp (str, "1") == 0) return 1;
13051 str = getenv ("SKIP_TEST_UMOUNT_ALL");
13052 if (str && strcmp (str, "1") == 0) return 1;
13056 static int test_umount_all_0 (void)
13058 if (test_umount_all_0_skip ()) {
13059 printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_0");
13063 /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
13065 char device[] = "/dev/sda";
13067 suppress_error = 0;
13068 r = guestfs_blockdev_setrw (g, device);
13074 suppress_error = 0;
13075 r = guestfs_umount_all (g);
13081 suppress_error = 0;
13082 r = guestfs_lvm_remove_all (g);
13087 char device[] = "/dev/sda";
13088 char lines_0[] = ",";
13094 suppress_error = 0;
13095 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13100 char fstype[] = "ext2";
13101 char device[] = "/dev/sda1";
13103 suppress_error = 0;
13104 r = guestfs_mkfs (g, fstype, device);
13109 char device[] = "/dev/sda1";
13110 char mountpoint[] = "/";
13112 suppress_error = 0;
13113 r = guestfs_mount (g, device, mountpoint);
13117 /* TestOutputList for umount_all (0) */
13120 suppress_error = 0;
13121 r = guestfs_umount_all (g);
13128 suppress_error = 0;
13129 r = guestfs_mounts (g);
13132 if (r[0] != NULL) {
13133 fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
13137 for (i = 0; r[i] != NULL; ++i)
13144 static int test_umount_all_1_skip (void)
13148 str = getenv ("TEST_ONLY");
13150 return strstr (str, "umount_all") == NULL;
13151 str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
13152 if (str && strcmp (str, "1") == 0) return 1;
13153 str = getenv ("SKIP_TEST_UMOUNT_ALL");
13154 if (str && strcmp (str, "1") == 0) return 1;
13158 static int test_umount_all_1 (void)
13160 if (test_umount_all_1_skip ()) {
13161 printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_1");
13165 /* InitNone|InitEmpty for test_umount_all_1 */
13167 char device[] = "/dev/sda";
13169 suppress_error = 0;
13170 r = guestfs_blockdev_setrw (g, device);
13176 suppress_error = 0;
13177 r = guestfs_umount_all (g);
13183 suppress_error = 0;
13184 r = guestfs_lvm_remove_all (g);
13188 /* TestOutputList for umount_all (1) */
13190 char device[] = "/dev/sda";
13191 char lines_0[] = ",10";
13192 char lines_1[] = ",20";
13193 char lines_2[] = ",";
13201 suppress_error = 0;
13202 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13207 char fstype[] = "ext2";
13208 char device[] = "/dev/sda1";
13210 suppress_error = 0;
13211 r = guestfs_mkfs (g, fstype, device);
13216 char fstype[] = "ext2";
13217 char device[] = "/dev/sda2";
13219 suppress_error = 0;
13220 r = guestfs_mkfs (g, fstype, device);
13225 char fstype[] = "ext2";
13226 char device[] = "/dev/sda3";
13228 suppress_error = 0;
13229 r = guestfs_mkfs (g, fstype, device);
13234 char device[] = "/dev/sda1";
13235 char mountpoint[] = "/";
13237 suppress_error = 0;
13238 r = guestfs_mount (g, device, mountpoint);
13243 char path[] = "/mp1";
13245 suppress_error = 0;
13246 r = guestfs_mkdir (g, path);
13251 char device[] = "/dev/sda2";
13252 char mountpoint[] = "/mp1";
13254 suppress_error = 0;
13255 r = guestfs_mount (g, device, mountpoint);
13260 char path[] = "/mp1/mp2";
13262 suppress_error = 0;
13263 r = guestfs_mkdir (g, path);
13268 char device[] = "/dev/sda3";
13269 char mountpoint[] = "/mp1/mp2";
13271 suppress_error = 0;
13272 r = guestfs_mount (g, device, mountpoint);
13277 char path[] = "/mp1/mp2/mp3";
13279 suppress_error = 0;
13280 r = guestfs_mkdir (g, path);
13286 suppress_error = 0;
13287 r = guestfs_umount_all (g);
13294 suppress_error = 0;
13295 r = guestfs_mounts (g);
13298 if (r[0] != NULL) {
13299 fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
13303 for (i = 0; r[i] != NULL; ++i)
13310 static int test_mounts_0_skip (void)
13314 str = getenv ("TEST_ONLY");
13316 return strstr (str, "mounts") == NULL;
13317 str = getenv ("SKIP_TEST_MOUNTS_0");
13318 if (str && strcmp (str, "1") == 0) return 1;
13319 str = getenv ("SKIP_TEST_MOUNTS");
13320 if (str && strcmp (str, "1") == 0) return 1;
13324 static int test_mounts_0 (void)
13326 if (test_mounts_0_skip ()) {
13327 printf ("%s skipped (reason: environment variable set)\n", "test_mounts_0");
13331 /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
13333 char device[] = "/dev/sda";
13335 suppress_error = 0;
13336 r = guestfs_blockdev_setrw (g, device);
13342 suppress_error = 0;
13343 r = guestfs_umount_all (g);
13349 suppress_error = 0;
13350 r = guestfs_lvm_remove_all (g);
13355 char device[] = "/dev/sda";
13356 char lines_0[] = ",";
13362 suppress_error = 0;
13363 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13368 char fstype[] = "ext2";
13369 char device[] = "/dev/sda1";
13371 suppress_error = 0;
13372 r = guestfs_mkfs (g, fstype, device);
13377 char device[] = "/dev/sda1";
13378 char mountpoint[] = "/";
13380 suppress_error = 0;
13381 r = guestfs_mount (g, device, mountpoint);
13385 /* TestOutputListOfDevices for mounts (0) */
13389 suppress_error = 0;
13390 r = guestfs_mounts (g);
13394 fprintf (stderr, "test_mounts_0: short list returned from command\n");
13399 char expected[] = "/dev/sda1";
13401 if (strcmp (r[0], expected) != 0) {
13402 fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13406 if (r[1] != NULL) {
13407 fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
13411 for (i = 0; r[i] != NULL; ++i)
13418 static int test_umount_0_skip (void)
13422 str = getenv ("TEST_ONLY");
13424 return strstr (str, "umount") == NULL;
13425 str = getenv ("SKIP_TEST_UMOUNT_0");
13426 if (str && strcmp (str, "1") == 0) return 1;
13427 str = getenv ("SKIP_TEST_UMOUNT");
13428 if (str && strcmp (str, "1") == 0) return 1;
13432 static int test_umount_0 (void)
13434 if (test_umount_0_skip ()) {
13435 printf ("%s skipped (reason: environment variable set)\n", "test_umount_0");
13439 /* InitNone|InitEmpty for test_umount_0 */
13441 char device[] = "/dev/sda";
13443 suppress_error = 0;
13444 r = guestfs_blockdev_setrw (g, device);
13450 suppress_error = 0;
13451 r = guestfs_umount_all (g);
13457 suppress_error = 0;
13458 r = guestfs_lvm_remove_all (g);
13462 /* TestOutputListOfDevices for umount (0) */
13464 char device[] = "/dev/sda";
13465 char lines_0[] = ",";
13471 suppress_error = 0;
13472 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13477 char fstype[] = "ext2";
13478 char device[] = "/dev/sda1";
13480 suppress_error = 0;
13481 r = guestfs_mkfs (g, fstype, device);
13486 char device[] = "/dev/sda1";
13487 char mountpoint[] = "/";
13489 suppress_error = 0;
13490 r = guestfs_mount (g, device, mountpoint);
13497 suppress_error = 0;
13498 r = guestfs_mounts (g);
13502 fprintf (stderr, "test_umount_0: short list returned from command\n");
13507 char expected[] = "/dev/sda1";
13509 if (strcmp (r[0], expected) != 0) {
13510 fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13514 if (r[1] != NULL) {
13515 fprintf (stderr, "test_umount_0: extra elements returned from command\n");
13519 for (i = 0; r[i] != NULL; ++i)
13526 static int test_umount_1_skip (void)
13530 str = getenv ("TEST_ONLY");
13532 return strstr (str, "umount") == NULL;
13533 str = getenv ("SKIP_TEST_UMOUNT_1");
13534 if (str && strcmp (str, "1") == 0) return 1;
13535 str = getenv ("SKIP_TEST_UMOUNT");
13536 if (str && strcmp (str, "1") == 0) return 1;
13540 static int test_umount_1 (void)
13542 if (test_umount_1_skip ()) {
13543 printf ("%s skipped (reason: environment variable set)\n", "test_umount_1");
13547 /* InitNone|InitEmpty for test_umount_1 */
13549 char device[] = "/dev/sda";
13551 suppress_error = 0;
13552 r = guestfs_blockdev_setrw (g, device);
13558 suppress_error = 0;
13559 r = guestfs_umount_all (g);
13565 suppress_error = 0;
13566 r = guestfs_lvm_remove_all (g);
13570 /* TestOutputList for umount (1) */
13572 char device[] = "/dev/sda";
13573 char lines_0[] = ",";
13579 suppress_error = 0;
13580 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13585 char fstype[] = "ext2";
13586 char device[] = "/dev/sda1";
13588 suppress_error = 0;
13589 r = guestfs_mkfs (g, fstype, device);
13594 char device[] = "/dev/sda1";
13595 char mountpoint[] = "/";
13597 suppress_error = 0;
13598 r = guestfs_mount (g, device, mountpoint);
13603 char pathordevice[] = "/";
13605 suppress_error = 0;
13606 r = guestfs_umount (g, pathordevice);
13613 suppress_error = 0;
13614 r = guestfs_mounts (g);
13617 if (r[0] != NULL) {
13618 fprintf (stderr, "test_umount_1: extra elements returned from command\n");
13622 for (i = 0; r[i] != NULL; ++i)
13629 static int test_write_file_0_skip (void)
13633 str = getenv ("TEST_ONLY");
13635 return strstr (str, "write_file") == NULL;
13636 str = getenv ("SKIP_TEST_WRITE_FILE_0");
13637 if (str && strcmp (str, "1") == 0) return 1;
13638 str = getenv ("SKIP_TEST_WRITE_FILE");
13639 if (str && strcmp (str, "1") == 0) return 1;
13643 static int test_write_file_0 (void)
13645 if (test_write_file_0_skip ()) {
13646 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_0");
13650 /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
13652 char device[] = "/dev/sda";
13654 suppress_error = 0;
13655 r = guestfs_blockdev_setrw (g, device);
13661 suppress_error = 0;
13662 r = guestfs_umount_all (g);
13668 suppress_error = 0;
13669 r = guestfs_lvm_remove_all (g);
13674 char device[] = "/dev/sda";
13675 char lines_0[] = ",";
13681 suppress_error = 0;
13682 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13687 char fstype[] = "ext2";
13688 char device[] = "/dev/sda1";
13690 suppress_error = 0;
13691 r = guestfs_mkfs (g, fstype, device);
13696 char device[] = "/dev/sda1";
13697 char mountpoint[] = "/";
13699 suppress_error = 0;
13700 r = guestfs_mount (g, device, mountpoint);
13704 /* TestOutput for write_file (0) */
13705 char expected[] = "new file contents";
13707 char path[] = "/new";
13708 char content[] = "new file contents";
13710 suppress_error = 0;
13711 r = guestfs_write_file (g, path, content, 0);
13716 char path[] = "/new";
13718 suppress_error = 0;
13719 r = guestfs_cat (g, path);
13722 if (strcmp (r, expected) != 0) {
13723 fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
13731 static int test_write_file_1_skip (void)
13735 str = getenv ("TEST_ONLY");
13737 return strstr (str, "write_file") == NULL;
13738 str = getenv ("SKIP_TEST_WRITE_FILE_1");
13739 if (str && strcmp (str, "1") == 0) return 1;
13740 str = getenv ("SKIP_TEST_WRITE_FILE");
13741 if (str && strcmp (str, "1") == 0) return 1;
13745 static int test_write_file_1 (void)
13747 if (test_write_file_1_skip ()) {
13748 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_1");
13752 /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
13754 char device[] = "/dev/sda";
13756 suppress_error = 0;
13757 r = guestfs_blockdev_setrw (g, device);
13763 suppress_error = 0;
13764 r = guestfs_umount_all (g);
13770 suppress_error = 0;
13771 r = guestfs_lvm_remove_all (g);
13776 char device[] = "/dev/sda";
13777 char lines_0[] = ",";
13783 suppress_error = 0;
13784 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13789 char fstype[] = "ext2";
13790 char device[] = "/dev/sda1";
13792 suppress_error = 0;
13793 r = guestfs_mkfs (g, fstype, device);
13798 char device[] = "/dev/sda1";
13799 char mountpoint[] = "/";
13801 suppress_error = 0;
13802 r = guestfs_mount (g, device, mountpoint);
13806 /* TestOutput for write_file (1) */
13807 char expected[] = "\nnew file contents\n";
13809 char path[] = "/new";
13810 char content[] = "\nnew file contents\n";
13812 suppress_error = 0;
13813 r = guestfs_write_file (g, path, content, 0);
13818 char path[] = "/new";
13820 suppress_error = 0;
13821 r = guestfs_cat (g, path);
13824 if (strcmp (r, expected) != 0) {
13825 fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
13833 static int test_write_file_2_skip (void)
13837 str = getenv ("TEST_ONLY");
13839 return strstr (str, "write_file") == NULL;
13840 str = getenv ("SKIP_TEST_WRITE_FILE_2");
13841 if (str && strcmp (str, "1") == 0) return 1;
13842 str = getenv ("SKIP_TEST_WRITE_FILE");
13843 if (str && strcmp (str, "1") == 0) return 1;
13847 static int test_write_file_2 (void)
13849 if (test_write_file_2_skip ()) {
13850 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_2");
13854 /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
13856 char device[] = "/dev/sda";
13858 suppress_error = 0;
13859 r = guestfs_blockdev_setrw (g, device);
13865 suppress_error = 0;
13866 r = guestfs_umount_all (g);
13872 suppress_error = 0;
13873 r = guestfs_lvm_remove_all (g);
13878 char device[] = "/dev/sda";
13879 char lines_0[] = ",";
13885 suppress_error = 0;
13886 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13891 char fstype[] = "ext2";
13892 char device[] = "/dev/sda1";
13894 suppress_error = 0;
13895 r = guestfs_mkfs (g, fstype, device);
13900 char device[] = "/dev/sda1";
13901 char mountpoint[] = "/";
13903 suppress_error = 0;
13904 r = guestfs_mount (g, device, mountpoint);
13908 /* TestOutput for write_file (2) */
13909 char expected[] = "\n\n";
13911 char path[] = "/new";
13912 char content[] = "\n\n";
13914 suppress_error = 0;
13915 r = guestfs_write_file (g, path, content, 0);
13920 char path[] = "/new";
13922 suppress_error = 0;
13923 r = guestfs_cat (g, path);
13926 if (strcmp (r, expected) != 0) {
13927 fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
13935 static int test_write_file_3_skip (void)
13939 str = getenv ("TEST_ONLY");
13941 return strstr (str, "write_file") == NULL;
13942 str = getenv ("SKIP_TEST_WRITE_FILE_3");
13943 if (str && strcmp (str, "1") == 0) return 1;
13944 str = getenv ("SKIP_TEST_WRITE_FILE");
13945 if (str && strcmp (str, "1") == 0) return 1;
13949 static int test_write_file_3 (void)
13951 if (test_write_file_3_skip ()) {
13952 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_3");
13956 /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
13958 char device[] = "/dev/sda";
13960 suppress_error = 0;
13961 r = guestfs_blockdev_setrw (g, device);
13967 suppress_error = 0;
13968 r = guestfs_umount_all (g);
13974 suppress_error = 0;
13975 r = guestfs_lvm_remove_all (g);
13980 char device[] = "/dev/sda";
13981 char lines_0[] = ",";
13987 suppress_error = 0;
13988 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13993 char fstype[] = "ext2";
13994 char device[] = "/dev/sda1";
13996 suppress_error = 0;
13997 r = guestfs_mkfs (g, fstype, device);
14002 char device[] = "/dev/sda1";
14003 char mountpoint[] = "/";
14005 suppress_error = 0;
14006 r = guestfs_mount (g, device, mountpoint);
14010 /* TestOutput for write_file (3) */
14011 char expected[] = "";
14013 char path[] = "/new";
14014 char content[] = "";
14016 suppress_error = 0;
14017 r = guestfs_write_file (g, path, content, 0);
14022 char path[] = "/new";
14024 suppress_error = 0;
14025 r = guestfs_cat (g, path);
14028 if (strcmp (r, expected) != 0) {
14029 fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
14037 static int test_write_file_4_skip (void)
14041 str = getenv ("TEST_ONLY");
14043 return strstr (str, "write_file") == NULL;
14044 str = getenv ("SKIP_TEST_WRITE_FILE_4");
14045 if (str && strcmp (str, "1") == 0) return 1;
14046 str = getenv ("SKIP_TEST_WRITE_FILE");
14047 if (str && strcmp (str, "1") == 0) return 1;
14051 static int test_write_file_4 (void)
14053 if (test_write_file_4_skip ()) {
14054 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_4");
14058 /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
14060 char device[] = "/dev/sda";
14062 suppress_error = 0;
14063 r = guestfs_blockdev_setrw (g, device);
14069 suppress_error = 0;
14070 r = guestfs_umount_all (g);
14076 suppress_error = 0;
14077 r = guestfs_lvm_remove_all (g);
14082 char device[] = "/dev/sda";
14083 char lines_0[] = ",";
14089 suppress_error = 0;
14090 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14095 char fstype[] = "ext2";
14096 char device[] = "/dev/sda1";
14098 suppress_error = 0;
14099 r = guestfs_mkfs (g, fstype, device);
14104 char device[] = "/dev/sda1";
14105 char mountpoint[] = "/";
14107 suppress_error = 0;
14108 r = guestfs_mount (g, device, mountpoint);
14112 /* TestOutput for write_file (4) */
14113 char expected[] = "\n\n\n";
14115 char path[] = "/new";
14116 char content[] = "\n\n\n";
14118 suppress_error = 0;
14119 r = guestfs_write_file (g, path, content, 0);
14124 char path[] = "/new";
14126 suppress_error = 0;
14127 r = guestfs_cat (g, path);
14130 if (strcmp (r, expected) != 0) {
14131 fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
14139 static int test_write_file_5_skip (void)
14143 str = getenv ("TEST_ONLY");
14145 return strstr (str, "write_file") == NULL;
14146 str = getenv ("SKIP_TEST_WRITE_FILE_5");
14147 if (str && strcmp (str, "1") == 0) return 1;
14148 str = getenv ("SKIP_TEST_WRITE_FILE");
14149 if (str && strcmp (str, "1") == 0) return 1;
14153 static int test_write_file_5 (void)
14155 if (test_write_file_5_skip ()) {
14156 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_5");
14160 /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
14162 char device[] = "/dev/sda";
14164 suppress_error = 0;
14165 r = guestfs_blockdev_setrw (g, device);
14171 suppress_error = 0;
14172 r = guestfs_umount_all (g);
14178 suppress_error = 0;
14179 r = guestfs_lvm_remove_all (g);
14184 char device[] = "/dev/sda";
14185 char lines_0[] = ",";
14191 suppress_error = 0;
14192 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14197 char fstype[] = "ext2";
14198 char device[] = "/dev/sda1";
14200 suppress_error = 0;
14201 r = guestfs_mkfs (g, fstype, device);
14206 char device[] = "/dev/sda1";
14207 char mountpoint[] = "/";
14209 suppress_error = 0;
14210 r = guestfs_mount (g, device, mountpoint);
14214 /* TestOutput for write_file (5) */
14215 char expected[] = "\n";
14217 char path[] = "/new";
14218 char content[] = "\n";
14220 suppress_error = 0;
14221 r = guestfs_write_file (g, path, content, 0);
14226 char path[] = "/new";
14228 suppress_error = 0;
14229 r = guestfs_cat (g, path);
14232 if (strcmp (r, expected) != 0) {
14233 fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
14241 static int test_mkfs_0_skip (void)
14245 str = getenv ("TEST_ONLY");
14247 return strstr (str, "mkfs") == NULL;
14248 str = getenv ("SKIP_TEST_MKFS_0");
14249 if (str && strcmp (str, "1") == 0) return 1;
14250 str = getenv ("SKIP_TEST_MKFS");
14251 if (str && strcmp (str, "1") == 0) return 1;
14255 static int test_mkfs_0 (void)
14257 if (test_mkfs_0_skip ()) {
14258 printf ("%s skipped (reason: environment variable set)\n", "test_mkfs_0");
14262 /* InitNone|InitEmpty for test_mkfs_0 */
14264 char device[] = "/dev/sda";
14266 suppress_error = 0;
14267 r = guestfs_blockdev_setrw (g, device);
14273 suppress_error = 0;
14274 r = guestfs_umount_all (g);
14280 suppress_error = 0;
14281 r = guestfs_lvm_remove_all (g);
14285 /* TestOutput for mkfs (0) */
14286 char expected[] = "new file contents";
14288 char device[] = "/dev/sda";
14289 char lines_0[] = ",";
14295 suppress_error = 0;
14296 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14301 char fstype[] = "ext2";
14302 char device[] = "/dev/sda1";
14304 suppress_error = 0;
14305 r = guestfs_mkfs (g, fstype, device);
14310 char device[] = "/dev/sda1";
14311 char mountpoint[] = "/";
14313 suppress_error = 0;
14314 r = guestfs_mount (g, device, mountpoint);
14319 char path[] = "/new";
14320 char content[] = "new file contents";
14322 suppress_error = 0;
14323 r = guestfs_write_file (g, path, content, 0);
14328 char path[] = "/new";
14330 suppress_error = 0;
14331 r = guestfs_cat (g, path);
14334 if (strcmp (r, expected) != 0) {
14335 fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
14343 static int test_lvcreate_0_skip (void)
14347 str = getenv ("TEST_ONLY");
14349 return strstr (str, "lvcreate") == NULL;
14350 str = getenv ("SKIP_TEST_LVCREATE_0");
14351 if (str && strcmp (str, "1") == 0) return 1;
14352 str = getenv ("SKIP_TEST_LVCREATE");
14353 if (str && strcmp (str, "1") == 0) return 1;
14357 static int test_lvcreate_0 (void)
14359 if (test_lvcreate_0_skip ()) {
14360 printf ("%s skipped (reason: environment variable set)\n", "test_lvcreate_0");
14364 /* InitNone|InitEmpty for test_lvcreate_0 */
14366 char device[] = "/dev/sda";
14368 suppress_error = 0;
14369 r = guestfs_blockdev_setrw (g, device);
14375 suppress_error = 0;
14376 r = guestfs_umount_all (g);
14382 suppress_error = 0;
14383 r = guestfs_lvm_remove_all (g);
14387 /* TestOutputList for lvcreate (0) */
14389 char device[] = "/dev/sda";
14390 char lines_0[] = ",10";
14391 char lines_1[] = ",20";
14392 char lines_2[] = ",";
14400 suppress_error = 0;
14401 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14406 char device[] = "/dev/sda1";
14408 suppress_error = 0;
14409 r = guestfs_pvcreate (g, device);
14414 char device[] = "/dev/sda2";
14416 suppress_error = 0;
14417 r = guestfs_pvcreate (g, device);
14422 char device[] = "/dev/sda3";
14424 suppress_error = 0;
14425 r = guestfs_pvcreate (g, device);
14430 char volgroup[] = "VG1";
14431 char physvols_0[] = "/dev/sda1";
14432 char physvols_1[] = "/dev/sda2";
14433 char *physvols[] = {
14439 suppress_error = 0;
14440 r = guestfs_vgcreate (g, volgroup, physvols);
14445 char volgroup[] = "VG2";
14446 char physvols_0[] = "/dev/sda3";
14447 char *physvols[] = {
14452 suppress_error = 0;
14453 r = guestfs_vgcreate (g, volgroup, physvols);
14458 char logvol[] = "LV1";
14459 char volgroup[] = "VG1";
14461 suppress_error = 0;
14462 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14467 char logvol[] = "LV2";
14468 char volgroup[] = "VG1";
14470 suppress_error = 0;
14471 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14476 char logvol[] = "LV3";
14477 char volgroup[] = "VG2";
14479 suppress_error = 0;
14480 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14485 char logvol[] = "LV4";
14486 char volgroup[] = "VG2";
14488 suppress_error = 0;
14489 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14494 char logvol[] = "LV5";
14495 char volgroup[] = "VG2";
14497 suppress_error = 0;
14498 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14505 suppress_error = 0;
14506 r = guestfs_lvs (g);
14510 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14515 char expected[] = "/dev/VG1/LV1";
14516 if (strcmp (r[0], expected) != 0) {
14517 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14522 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14527 char expected[] = "/dev/VG1/LV2";
14528 if (strcmp (r[1], expected) != 0) {
14529 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14534 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14539 char expected[] = "/dev/VG2/LV3";
14540 if (strcmp (r[2], expected) != 0) {
14541 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14546 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14551 char expected[] = "/dev/VG2/LV4";
14552 if (strcmp (r[3], expected) != 0) {
14553 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
14558 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14563 char expected[] = "/dev/VG2/LV5";
14564 if (strcmp (r[4], expected) != 0) {
14565 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
14569 if (r[5] != NULL) {
14570 fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
14574 for (i = 0; r[i] != NULL; ++i)
14581 static int test_vgcreate_0_skip (void)
14585 str = getenv ("TEST_ONLY");
14587 return strstr (str, "vgcreate") == NULL;
14588 str = getenv ("SKIP_TEST_VGCREATE_0");
14589 if (str && strcmp (str, "1") == 0) return 1;
14590 str = getenv ("SKIP_TEST_VGCREATE");
14591 if (str && strcmp (str, "1") == 0) return 1;
14595 static int test_vgcreate_0 (void)
14597 if (test_vgcreate_0_skip ()) {
14598 printf ("%s skipped (reason: environment variable set)\n", "test_vgcreate_0");
14602 /* InitNone|InitEmpty for test_vgcreate_0 */
14604 char device[] = "/dev/sda";
14606 suppress_error = 0;
14607 r = guestfs_blockdev_setrw (g, device);
14613 suppress_error = 0;
14614 r = guestfs_umount_all (g);
14620 suppress_error = 0;
14621 r = guestfs_lvm_remove_all (g);
14625 /* TestOutputList for vgcreate (0) */
14627 char device[] = "/dev/sda";
14628 char lines_0[] = ",10";
14629 char lines_1[] = ",20";
14630 char lines_2[] = ",";
14638 suppress_error = 0;
14639 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14644 char device[] = "/dev/sda1";
14646 suppress_error = 0;
14647 r = guestfs_pvcreate (g, device);
14652 char device[] = "/dev/sda2";
14654 suppress_error = 0;
14655 r = guestfs_pvcreate (g, device);
14660 char device[] = "/dev/sda3";
14662 suppress_error = 0;
14663 r = guestfs_pvcreate (g, device);
14668 char volgroup[] = "VG1";
14669 char physvols_0[] = "/dev/sda1";
14670 char physvols_1[] = "/dev/sda2";
14671 char *physvols[] = {
14677 suppress_error = 0;
14678 r = guestfs_vgcreate (g, volgroup, physvols);
14683 char volgroup[] = "VG2";
14684 char physvols_0[] = "/dev/sda3";
14685 char *physvols[] = {
14690 suppress_error = 0;
14691 r = guestfs_vgcreate (g, volgroup, physvols);
14698 suppress_error = 0;
14699 r = guestfs_vgs (g);
14703 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
14708 char expected[] = "VG1";
14709 if (strcmp (r[0], expected) != 0) {
14710 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14715 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
14720 char expected[] = "VG2";
14721 if (strcmp (r[1], expected) != 0) {
14722 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14726 if (r[2] != NULL) {
14727 fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
14731 for (i = 0; r[i] != NULL; ++i)
14738 static int test_pvcreate_0_skip (void)
14742 str = getenv ("TEST_ONLY");
14744 return strstr (str, "pvcreate") == NULL;
14745 str = getenv ("SKIP_TEST_PVCREATE_0");
14746 if (str && strcmp (str, "1") == 0) return 1;
14747 str = getenv ("SKIP_TEST_PVCREATE");
14748 if (str && strcmp (str, "1") == 0) return 1;
14752 static int test_pvcreate_0 (void)
14754 if (test_pvcreate_0_skip ()) {
14755 printf ("%s skipped (reason: environment variable set)\n", "test_pvcreate_0");
14759 /* InitNone|InitEmpty for test_pvcreate_0 */
14761 char device[] = "/dev/sda";
14763 suppress_error = 0;
14764 r = guestfs_blockdev_setrw (g, device);
14770 suppress_error = 0;
14771 r = guestfs_umount_all (g);
14777 suppress_error = 0;
14778 r = guestfs_lvm_remove_all (g);
14782 /* TestOutputListOfDevices for pvcreate (0) */
14784 char device[] = "/dev/sda";
14785 char lines_0[] = ",10";
14786 char lines_1[] = ",20";
14787 char lines_2[] = ",";
14795 suppress_error = 0;
14796 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14801 char device[] = "/dev/sda1";
14803 suppress_error = 0;
14804 r = guestfs_pvcreate (g, device);
14809 char device[] = "/dev/sda2";
14811 suppress_error = 0;
14812 r = guestfs_pvcreate (g, device);
14817 char device[] = "/dev/sda3";
14819 suppress_error = 0;
14820 r = guestfs_pvcreate (g, device);
14827 suppress_error = 0;
14828 r = guestfs_pvs (g);
14832 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14837 char expected[] = "/dev/sda1";
14839 if (strcmp (r[0], expected) != 0) {
14840 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14845 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14850 char expected[] = "/dev/sda2";
14852 if (strcmp (r[1], expected) != 0) {
14853 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14858 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14863 char expected[] = "/dev/sda3";
14865 if (strcmp (r[2], expected) != 0) {
14866 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14870 if (r[3] != NULL) {
14871 fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
14875 for (i = 0; r[i] != NULL; ++i)
14882 static int test_is_dir_0_skip (void)
14886 str = getenv ("TEST_ONLY");
14888 return strstr (str, "is_dir") == NULL;
14889 str = getenv ("SKIP_TEST_IS_DIR_0");
14890 if (str && strcmp (str, "1") == 0) return 1;
14891 str = getenv ("SKIP_TEST_IS_DIR");
14892 if (str && strcmp (str, "1") == 0) return 1;
14896 static int test_is_dir_0 (void)
14898 if (test_is_dir_0_skip ()) {
14899 printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_0");
14903 /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
14905 char device[] = "/dev/sda";
14907 suppress_error = 0;
14908 r = guestfs_blockdev_setrw (g, device);
14914 suppress_error = 0;
14915 r = guestfs_umount_all (g);
14921 suppress_error = 0;
14922 r = guestfs_lvm_remove_all (g);
14927 char device[] = "/dev/sda";
14928 char lines_0[] = ",";
14934 suppress_error = 0;
14935 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14940 char fstype[] = "ext2";
14941 char device[] = "/dev/sda1";
14943 suppress_error = 0;
14944 r = guestfs_mkfs (g, fstype, device);
14949 char device[] = "/dev/sda1";
14950 char mountpoint[] = "/";
14952 suppress_error = 0;
14953 r = guestfs_mount (g, device, mountpoint);
14957 /* TestOutputFalse for is_dir (0) */
14959 char path[] = "/new";
14961 suppress_error = 0;
14962 r = guestfs_touch (g, path);
14967 char path[] = "/new";
14969 suppress_error = 0;
14970 r = guestfs_is_dir (g, path);
14974 fprintf (stderr, "test_is_dir_0: expected false, got true\n");
14981 static int test_is_dir_1_skip (void)
14985 str = getenv ("TEST_ONLY");
14987 return strstr (str, "is_dir") == NULL;
14988 str = getenv ("SKIP_TEST_IS_DIR_1");
14989 if (str && strcmp (str, "1") == 0) return 1;
14990 str = getenv ("SKIP_TEST_IS_DIR");
14991 if (str && strcmp (str, "1") == 0) return 1;
14995 static int test_is_dir_1 (void)
14997 if (test_is_dir_1_skip ()) {
14998 printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_1");
15002 /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
15004 char device[] = "/dev/sda";
15006 suppress_error = 0;
15007 r = guestfs_blockdev_setrw (g, device);
15013 suppress_error = 0;
15014 r = guestfs_umount_all (g);
15020 suppress_error = 0;
15021 r = guestfs_lvm_remove_all (g);
15026 char device[] = "/dev/sda";
15027 char lines_0[] = ",";
15033 suppress_error = 0;
15034 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15039 char fstype[] = "ext2";
15040 char device[] = "/dev/sda1";
15042 suppress_error = 0;
15043 r = guestfs_mkfs (g, fstype, device);
15048 char device[] = "/dev/sda1";
15049 char mountpoint[] = "/";
15051 suppress_error = 0;
15052 r = guestfs_mount (g, device, mountpoint);
15056 /* TestOutputTrue for is_dir (1) */
15058 char path[] = "/new";
15060 suppress_error = 0;
15061 r = guestfs_mkdir (g, path);
15066 char path[] = "/new";
15068 suppress_error = 0;
15069 r = guestfs_is_dir (g, path);
15073 fprintf (stderr, "test_is_dir_1: expected true, got false\n");
15080 static int test_is_file_0_skip (void)
15084 str = getenv ("TEST_ONLY");
15086 return strstr (str, "is_file") == NULL;
15087 str = getenv ("SKIP_TEST_IS_FILE_0");
15088 if (str && strcmp (str, "1") == 0) return 1;
15089 str = getenv ("SKIP_TEST_IS_FILE");
15090 if (str && strcmp (str, "1") == 0) return 1;
15094 static int test_is_file_0 (void)
15096 if (test_is_file_0_skip ()) {
15097 printf ("%s skipped (reason: environment variable set)\n", "test_is_file_0");
15101 /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
15103 char device[] = "/dev/sda";
15105 suppress_error = 0;
15106 r = guestfs_blockdev_setrw (g, device);
15112 suppress_error = 0;
15113 r = guestfs_umount_all (g);
15119 suppress_error = 0;
15120 r = guestfs_lvm_remove_all (g);
15125 char device[] = "/dev/sda";
15126 char lines_0[] = ",";
15132 suppress_error = 0;
15133 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15138 char fstype[] = "ext2";
15139 char device[] = "/dev/sda1";
15141 suppress_error = 0;
15142 r = guestfs_mkfs (g, fstype, device);
15147 char device[] = "/dev/sda1";
15148 char mountpoint[] = "/";
15150 suppress_error = 0;
15151 r = guestfs_mount (g, device, mountpoint);
15155 /* TestOutputTrue for is_file (0) */
15157 char path[] = "/new";
15159 suppress_error = 0;
15160 r = guestfs_touch (g, path);
15165 char path[] = "/new";
15167 suppress_error = 0;
15168 r = guestfs_is_file (g, path);
15172 fprintf (stderr, "test_is_file_0: expected true, got false\n");
15179 static int test_is_file_1_skip (void)
15183 str = getenv ("TEST_ONLY");
15185 return strstr (str, "is_file") == NULL;
15186 str = getenv ("SKIP_TEST_IS_FILE_1");
15187 if (str && strcmp (str, "1") == 0) return 1;
15188 str = getenv ("SKIP_TEST_IS_FILE");
15189 if (str && strcmp (str, "1") == 0) return 1;
15193 static int test_is_file_1 (void)
15195 if (test_is_file_1_skip ()) {
15196 printf ("%s skipped (reason: environment variable set)\n", "test_is_file_1");
15200 /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
15202 char device[] = "/dev/sda";
15204 suppress_error = 0;
15205 r = guestfs_blockdev_setrw (g, device);
15211 suppress_error = 0;
15212 r = guestfs_umount_all (g);
15218 suppress_error = 0;
15219 r = guestfs_lvm_remove_all (g);
15224 char device[] = "/dev/sda";
15225 char lines_0[] = ",";
15231 suppress_error = 0;
15232 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15237 char fstype[] = "ext2";
15238 char device[] = "/dev/sda1";
15240 suppress_error = 0;
15241 r = guestfs_mkfs (g, fstype, device);
15246 char device[] = "/dev/sda1";
15247 char mountpoint[] = "/";
15249 suppress_error = 0;
15250 r = guestfs_mount (g, device, mountpoint);
15254 /* TestOutputFalse for is_file (1) */
15256 char path[] = "/new";
15258 suppress_error = 0;
15259 r = guestfs_mkdir (g, path);
15264 char path[] = "/new";
15266 suppress_error = 0;
15267 r = guestfs_is_file (g, path);
15271 fprintf (stderr, "test_is_file_1: expected false, got true\n");
15278 static int test_exists_0_skip (void)
15282 str = getenv ("TEST_ONLY");
15284 return strstr (str, "exists") == NULL;
15285 str = getenv ("SKIP_TEST_EXISTS_0");
15286 if (str && strcmp (str, "1") == 0) return 1;
15287 str = getenv ("SKIP_TEST_EXISTS");
15288 if (str && strcmp (str, "1") == 0) return 1;
15292 static int test_exists_0 (void)
15294 if (test_exists_0_skip ()) {
15295 printf ("%s skipped (reason: environment variable set)\n", "test_exists_0");
15299 /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
15301 char device[] = "/dev/sda";
15303 suppress_error = 0;
15304 r = guestfs_blockdev_setrw (g, device);
15310 suppress_error = 0;
15311 r = guestfs_umount_all (g);
15317 suppress_error = 0;
15318 r = guestfs_lvm_remove_all (g);
15323 char device[] = "/dev/sda";
15324 char lines_0[] = ",";
15330 suppress_error = 0;
15331 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15336 char fstype[] = "ext2";
15337 char device[] = "/dev/sda1";
15339 suppress_error = 0;
15340 r = guestfs_mkfs (g, fstype, device);
15345 char device[] = "/dev/sda1";
15346 char mountpoint[] = "/";
15348 suppress_error = 0;
15349 r = guestfs_mount (g, device, mountpoint);
15353 /* TestOutputTrue for exists (0) */
15355 char path[] = "/new";
15357 suppress_error = 0;
15358 r = guestfs_touch (g, path);
15363 char path[] = "/new";
15365 suppress_error = 0;
15366 r = guestfs_exists (g, path);
15370 fprintf (stderr, "test_exists_0: expected true, got false\n");
15377 static int test_exists_1_skip (void)
15381 str = getenv ("TEST_ONLY");
15383 return strstr (str, "exists") == NULL;
15384 str = getenv ("SKIP_TEST_EXISTS_1");
15385 if (str && strcmp (str, "1") == 0) return 1;
15386 str = getenv ("SKIP_TEST_EXISTS");
15387 if (str && strcmp (str, "1") == 0) return 1;
15391 static int test_exists_1 (void)
15393 if (test_exists_1_skip ()) {
15394 printf ("%s skipped (reason: environment variable set)\n", "test_exists_1");
15398 /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
15400 char device[] = "/dev/sda";
15402 suppress_error = 0;
15403 r = guestfs_blockdev_setrw (g, device);
15409 suppress_error = 0;
15410 r = guestfs_umount_all (g);
15416 suppress_error = 0;
15417 r = guestfs_lvm_remove_all (g);
15422 char device[] = "/dev/sda";
15423 char lines_0[] = ",";
15429 suppress_error = 0;
15430 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15435 char fstype[] = "ext2";
15436 char device[] = "/dev/sda1";
15438 suppress_error = 0;
15439 r = guestfs_mkfs (g, fstype, device);
15444 char device[] = "/dev/sda1";
15445 char mountpoint[] = "/";
15447 suppress_error = 0;
15448 r = guestfs_mount (g, device, mountpoint);
15452 /* TestOutputTrue for exists (1) */
15454 char path[] = "/new";
15456 suppress_error = 0;
15457 r = guestfs_mkdir (g, path);
15462 char path[] = "/new";
15464 suppress_error = 0;
15465 r = guestfs_exists (g, path);
15469 fprintf (stderr, "test_exists_1: expected true, got false\n");
15476 static int test_mkdir_p_0_skip (void)
15480 str = getenv ("TEST_ONLY");
15482 return strstr (str, "mkdir_p") == NULL;
15483 str = getenv ("SKIP_TEST_MKDIR_P_0");
15484 if (str && strcmp (str, "1") == 0) return 1;
15485 str = getenv ("SKIP_TEST_MKDIR_P");
15486 if (str && strcmp (str, "1") == 0) return 1;
15490 static int test_mkdir_p_0 (void)
15492 if (test_mkdir_p_0_skip ()) {
15493 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_0");
15497 /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
15499 char device[] = "/dev/sda";
15501 suppress_error = 0;
15502 r = guestfs_blockdev_setrw (g, device);
15508 suppress_error = 0;
15509 r = guestfs_umount_all (g);
15515 suppress_error = 0;
15516 r = guestfs_lvm_remove_all (g);
15521 char device[] = "/dev/sda";
15522 char lines_0[] = ",";
15528 suppress_error = 0;
15529 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15534 char fstype[] = "ext2";
15535 char device[] = "/dev/sda1";
15537 suppress_error = 0;
15538 r = guestfs_mkfs (g, fstype, device);
15543 char device[] = "/dev/sda1";
15544 char mountpoint[] = "/";
15546 suppress_error = 0;
15547 r = guestfs_mount (g, device, mountpoint);
15551 /* TestOutputTrue for mkdir_p (0) */
15553 char path[] = "/new/foo/bar";
15555 suppress_error = 0;
15556 r = guestfs_mkdir_p (g, path);
15561 char path[] = "/new/foo/bar";
15563 suppress_error = 0;
15564 r = guestfs_is_dir (g, path);
15568 fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
15575 static int test_mkdir_p_1_skip (void)
15579 str = getenv ("TEST_ONLY");
15581 return strstr (str, "mkdir_p") == NULL;
15582 str = getenv ("SKIP_TEST_MKDIR_P_1");
15583 if (str && strcmp (str, "1") == 0) return 1;
15584 str = getenv ("SKIP_TEST_MKDIR_P");
15585 if (str && strcmp (str, "1") == 0) return 1;
15589 static int test_mkdir_p_1 (void)
15591 if (test_mkdir_p_1_skip ()) {
15592 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_1");
15596 /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
15598 char device[] = "/dev/sda";
15600 suppress_error = 0;
15601 r = guestfs_blockdev_setrw (g, device);
15607 suppress_error = 0;
15608 r = guestfs_umount_all (g);
15614 suppress_error = 0;
15615 r = guestfs_lvm_remove_all (g);
15620 char device[] = "/dev/sda";
15621 char lines_0[] = ",";
15627 suppress_error = 0;
15628 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15633 char fstype[] = "ext2";
15634 char device[] = "/dev/sda1";
15636 suppress_error = 0;
15637 r = guestfs_mkfs (g, fstype, device);
15642 char device[] = "/dev/sda1";
15643 char mountpoint[] = "/";
15645 suppress_error = 0;
15646 r = guestfs_mount (g, device, mountpoint);
15650 /* TestOutputTrue for mkdir_p (1) */
15652 char path[] = "/new/foo/bar";
15654 suppress_error = 0;
15655 r = guestfs_mkdir_p (g, path);
15660 char path[] = "/new/foo";
15662 suppress_error = 0;
15663 r = guestfs_is_dir (g, path);
15667 fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
15674 static int test_mkdir_p_2_skip (void)
15678 str = getenv ("TEST_ONLY");
15680 return strstr (str, "mkdir_p") == NULL;
15681 str = getenv ("SKIP_TEST_MKDIR_P_2");
15682 if (str && strcmp (str, "1") == 0) return 1;
15683 str = getenv ("SKIP_TEST_MKDIR_P");
15684 if (str && strcmp (str, "1") == 0) return 1;
15688 static int test_mkdir_p_2 (void)
15690 if (test_mkdir_p_2_skip ()) {
15691 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_2");
15695 /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
15697 char device[] = "/dev/sda";
15699 suppress_error = 0;
15700 r = guestfs_blockdev_setrw (g, device);
15706 suppress_error = 0;
15707 r = guestfs_umount_all (g);
15713 suppress_error = 0;
15714 r = guestfs_lvm_remove_all (g);
15719 char device[] = "/dev/sda";
15720 char lines_0[] = ",";
15726 suppress_error = 0;
15727 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15732 char fstype[] = "ext2";
15733 char device[] = "/dev/sda1";
15735 suppress_error = 0;
15736 r = guestfs_mkfs (g, fstype, device);
15741 char device[] = "/dev/sda1";
15742 char mountpoint[] = "/";
15744 suppress_error = 0;
15745 r = guestfs_mount (g, device, mountpoint);
15749 /* TestOutputTrue for mkdir_p (2) */
15751 char path[] = "/new/foo/bar";
15753 suppress_error = 0;
15754 r = guestfs_mkdir_p (g, path);
15759 char path[] = "/new";
15761 suppress_error = 0;
15762 r = guestfs_is_dir (g, path);
15766 fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
15773 static int test_mkdir_p_3_skip (void)
15777 str = getenv ("TEST_ONLY");
15779 return strstr (str, "mkdir_p") == NULL;
15780 str = getenv ("SKIP_TEST_MKDIR_P_3");
15781 if (str && strcmp (str, "1") == 0) return 1;
15782 str = getenv ("SKIP_TEST_MKDIR_P");
15783 if (str && strcmp (str, "1") == 0) return 1;
15787 static int test_mkdir_p_3 (void)
15789 if (test_mkdir_p_3_skip ()) {
15790 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_3");
15794 /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
15796 char device[] = "/dev/sda";
15798 suppress_error = 0;
15799 r = guestfs_blockdev_setrw (g, device);
15805 suppress_error = 0;
15806 r = guestfs_umount_all (g);
15812 suppress_error = 0;
15813 r = guestfs_lvm_remove_all (g);
15818 char device[] = "/dev/sda";
15819 char lines_0[] = ",";
15825 suppress_error = 0;
15826 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15831 char fstype[] = "ext2";
15832 char device[] = "/dev/sda1";
15834 suppress_error = 0;
15835 r = guestfs_mkfs (g, fstype, device);
15840 char device[] = "/dev/sda1";
15841 char mountpoint[] = "/";
15843 suppress_error = 0;
15844 r = guestfs_mount (g, device, mountpoint);
15848 /* TestRun for mkdir_p (3) */
15850 char path[] = "/new";
15852 suppress_error = 0;
15853 r = guestfs_mkdir (g, path);
15858 char path[] = "/new";
15860 suppress_error = 0;
15861 r = guestfs_mkdir_p (g, path);
15868 static int test_mkdir_p_4_skip (void)
15872 str = getenv ("TEST_ONLY");
15874 return strstr (str, "mkdir_p") == NULL;
15875 str = getenv ("SKIP_TEST_MKDIR_P_4");
15876 if (str && strcmp (str, "1") == 0) return 1;
15877 str = getenv ("SKIP_TEST_MKDIR_P");
15878 if (str && strcmp (str, "1") == 0) return 1;
15882 static int test_mkdir_p_4 (void)
15884 if (test_mkdir_p_4_skip ()) {
15885 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_4");
15889 /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
15891 char device[] = "/dev/sda";
15893 suppress_error = 0;
15894 r = guestfs_blockdev_setrw (g, device);
15900 suppress_error = 0;
15901 r = guestfs_umount_all (g);
15907 suppress_error = 0;
15908 r = guestfs_lvm_remove_all (g);
15913 char device[] = "/dev/sda";
15914 char lines_0[] = ",";
15920 suppress_error = 0;
15921 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15926 char fstype[] = "ext2";
15927 char device[] = "/dev/sda1";
15929 suppress_error = 0;
15930 r = guestfs_mkfs (g, fstype, device);
15935 char device[] = "/dev/sda1";
15936 char mountpoint[] = "/";
15938 suppress_error = 0;
15939 r = guestfs_mount (g, device, mountpoint);
15943 /* TestLastFail for mkdir_p (4) */
15945 char path[] = "/new";
15947 suppress_error = 0;
15948 r = guestfs_touch (g, path);
15953 char path[] = "/new";
15955 suppress_error = 1;
15956 r = guestfs_mkdir_p (g, path);
15963 static int test_mkdir_0_skip (void)
15967 str = getenv ("TEST_ONLY");
15969 return strstr (str, "mkdir") == NULL;
15970 str = getenv ("SKIP_TEST_MKDIR_0");
15971 if (str && strcmp (str, "1") == 0) return 1;
15972 str = getenv ("SKIP_TEST_MKDIR");
15973 if (str && strcmp (str, "1") == 0) return 1;
15977 static int test_mkdir_0 (void)
15979 if (test_mkdir_0_skip ()) {
15980 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_0");
15984 /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
15986 char device[] = "/dev/sda";
15988 suppress_error = 0;
15989 r = guestfs_blockdev_setrw (g, device);
15995 suppress_error = 0;
15996 r = guestfs_umount_all (g);
16002 suppress_error = 0;
16003 r = guestfs_lvm_remove_all (g);
16008 char device[] = "/dev/sda";
16009 char lines_0[] = ",";
16015 suppress_error = 0;
16016 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16021 char fstype[] = "ext2";
16022 char device[] = "/dev/sda1";
16024 suppress_error = 0;
16025 r = guestfs_mkfs (g, fstype, device);
16030 char device[] = "/dev/sda1";
16031 char mountpoint[] = "/";
16033 suppress_error = 0;
16034 r = guestfs_mount (g, device, mountpoint);
16038 /* TestOutputTrue for mkdir (0) */
16040 char path[] = "/new";
16042 suppress_error = 0;
16043 r = guestfs_mkdir (g, path);
16048 char path[] = "/new";
16050 suppress_error = 0;
16051 r = guestfs_is_dir (g, path);
16055 fprintf (stderr, "test_mkdir_0: expected true, got false\n");
16062 static int test_mkdir_1_skip (void)
16066 str = getenv ("TEST_ONLY");
16068 return strstr (str, "mkdir") == NULL;
16069 str = getenv ("SKIP_TEST_MKDIR_1");
16070 if (str && strcmp (str, "1") == 0) return 1;
16071 str = getenv ("SKIP_TEST_MKDIR");
16072 if (str && strcmp (str, "1") == 0) return 1;
16076 static int test_mkdir_1 (void)
16078 if (test_mkdir_1_skip ()) {
16079 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_1");
16083 /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
16085 char device[] = "/dev/sda";
16087 suppress_error = 0;
16088 r = guestfs_blockdev_setrw (g, device);
16094 suppress_error = 0;
16095 r = guestfs_umount_all (g);
16101 suppress_error = 0;
16102 r = guestfs_lvm_remove_all (g);
16107 char device[] = "/dev/sda";
16108 char lines_0[] = ",";
16114 suppress_error = 0;
16115 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16120 char fstype[] = "ext2";
16121 char device[] = "/dev/sda1";
16123 suppress_error = 0;
16124 r = guestfs_mkfs (g, fstype, device);
16129 char device[] = "/dev/sda1";
16130 char mountpoint[] = "/";
16132 suppress_error = 0;
16133 r = guestfs_mount (g, device, mountpoint);
16137 /* TestLastFail for mkdir (1) */
16139 char path[] = "/new/foo/bar";
16141 suppress_error = 1;
16142 r = guestfs_mkdir (g, path);
16149 static int test_rm_rf_0_skip (void)
16153 str = getenv ("TEST_ONLY");
16155 return strstr (str, "rm_rf") == NULL;
16156 str = getenv ("SKIP_TEST_RM_RF_0");
16157 if (str && strcmp (str, "1") == 0) return 1;
16158 str = getenv ("SKIP_TEST_RM_RF");
16159 if (str && strcmp (str, "1") == 0) return 1;
16163 static int test_rm_rf_0 (void)
16165 if (test_rm_rf_0_skip ()) {
16166 printf ("%s skipped (reason: environment variable set)\n", "test_rm_rf_0");
16170 /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
16172 char device[] = "/dev/sda";
16174 suppress_error = 0;
16175 r = guestfs_blockdev_setrw (g, device);
16181 suppress_error = 0;
16182 r = guestfs_umount_all (g);
16188 suppress_error = 0;
16189 r = guestfs_lvm_remove_all (g);
16194 char device[] = "/dev/sda";
16195 char lines_0[] = ",";
16201 suppress_error = 0;
16202 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16207 char fstype[] = "ext2";
16208 char device[] = "/dev/sda1";
16210 suppress_error = 0;
16211 r = guestfs_mkfs (g, fstype, device);
16216 char device[] = "/dev/sda1";
16217 char mountpoint[] = "/";
16219 suppress_error = 0;
16220 r = guestfs_mount (g, device, mountpoint);
16224 /* TestOutputFalse for rm_rf (0) */
16226 char path[] = "/new";
16228 suppress_error = 0;
16229 r = guestfs_mkdir (g, path);
16234 char path[] = "/new/foo";
16236 suppress_error = 0;
16237 r = guestfs_mkdir (g, path);
16242 char path[] = "/new/foo/bar";
16244 suppress_error = 0;
16245 r = guestfs_touch (g, path);
16250 char path[] = "/new";
16252 suppress_error = 0;
16253 r = guestfs_rm_rf (g, path);
16258 char path[] = "/new";
16260 suppress_error = 0;
16261 r = guestfs_exists (g, path);
16265 fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
16272 static int test_rmdir_0_skip (void)
16276 str = getenv ("TEST_ONLY");
16278 return strstr (str, "rmdir") == NULL;
16279 str = getenv ("SKIP_TEST_RMDIR_0");
16280 if (str && strcmp (str, "1") == 0) return 1;
16281 str = getenv ("SKIP_TEST_RMDIR");
16282 if (str && strcmp (str, "1") == 0) return 1;
16286 static int test_rmdir_0 (void)
16288 if (test_rmdir_0_skip ()) {
16289 printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_0");
16293 /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
16295 char device[] = "/dev/sda";
16297 suppress_error = 0;
16298 r = guestfs_blockdev_setrw (g, device);
16304 suppress_error = 0;
16305 r = guestfs_umount_all (g);
16311 suppress_error = 0;
16312 r = guestfs_lvm_remove_all (g);
16317 char device[] = "/dev/sda";
16318 char lines_0[] = ",";
16324 suppress_error = 0;
16325 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16330 char fstype[] = "ext2";
16331 char device[] = "/dev/sda1";
16333 suppress_error = 0;
16334 r = guestfs_mkfs (g, fstype, device);
16339 char device[] = "/dev/sda1";
16340 char mountpoint[] = "/";
16342 suppress_error = 0;
16343 r = guestfs_mount (g, device, mountpoint);
16347 /* TestRun for rmdir (0) */
16349 char path[] = "/new";
16351 suppress_error = 0;
16352 r = guestfs_mkdir (g, path);
16357 char path[] = "/new";
16359 suppress_error = 0;
16360 r = guestfs_rmdir (g, path);
16367 static int test_rmdir_1_skip (void)
16371 str = getenv ("TEST_ONLY");
16373 return strstr (str, "rmdir") == NULL;
16374 str = getenv ("SKIP_TEST_RMDIR_1");
16375 if (str && strcmp (str, "1") == 0) return 1;
16376 str = getenv ("SKIP_TEST_RMDIR");
16377 if (str && strcmp (str, "1") == 0) return 1;
16381 static int test_rmdir_1 (void)
16383 if (test_rmdir_1_skip ()) {
16384 printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_1");
16388 /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
16390 char device[] = "/dev/sda";
16392 suppress_error = 0;
16393 r = guestfs_blockdev_setrw (g, device);
16399 suppress_error = 0;
16400 r = guestfs_umount_all (g);
16406 suppress_error = 0;
16407 r = guestfs_lvm_remove_all (g);
16412 char device[] = "/dev/sda";
16413 char lines_0[] = ",";
16419 suppress_error = 0;
16420 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16425 char fstype[] = "ext2";
16426 char device[] = "/dev/sda1";
16428 suppress_error = 0;
16429 r = guestfs_mkfs (g, fstype, device);
16434 char device[] = "/dev/sda1";
16435 char mountpoint[] = "/";
16437 suppress_error = 0;
16438 r = guestfs_mount (g, device, mountpoint);
16442 /* TestLastFail for rmdir (1) */
16444 char path[] = "/new";
16446 suppress_error = 1;
16447 r = guestfs_rmdir (g, path);
16454 static int test_rmdir_2_skip (void)
16458 str = getenv ("TEST_ONLY");
16460 return strstr (str, "rmdir") == NULL;
16461 str = getenv ("SKIP_TEST_RMDIR_2");
16462 if (str && strcmp (str, "1") == 0) return 1;
16463 str = getenv ("SKIP_TEST_RMDIR");
16464 if (str && strcmp (str, "1") == 0) return 1;
16468 static int test_rmdir_2 (void)
16470 if (test_rmdir_2_skip ()) {
16471 printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_2");
16475 /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
16477 char device[] = "/dev/sda";
16479 suppress_error = 0;
16480 r = guestfs_blockdev_setrw (g, device);
16486 suppress_error = 0;
16487 r = guestfs_umount_all (g);
16493 suppress_error = 0;
16494 r = guestfs_lvm_remove_all (g);
16499 char device[] = "/dev/sda";
16500 char lines_0[] = ",";
16506 suppress_error = 0;
16507 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16512 char fstype[] = "ext2";
16513 char device[] = "/dev/sda1";
16515 suppress_error = 0;
16516 r = guestfs_mkfs (g, fstype, device);
16521 char device[] = "/dev/sda1";
16522 char mountpoint[] = "/";
16524 suppress_error = 0;
16525 r = guestfs_mount (g, device, mountpoint);
16529 /* TestLastFail for rmdir (2) */
16531 char path[] = "/new";
16533 suppress_error = 0;
16534 r = guestfs_touch (g, path);
16539 char path[] = "/new";
16541 suppress_error = 1;
16542 r = guestfs_rmdir (g, path);
16549 static int test_rm_0_skip (void)
16553 str = getenv ("TEST_ONLY");
16555 return strstr (str, "rm") == NULL;
16556 str = getenv ("SKIP_TEST_RM_0");
16557 if (str && strcmp (str, "1") == 0) return 1;
16558 str = getenv ("SKIP_TEST_RM");
16559 if (str && strcmp (str, "1") == 0) return 1;
16563 static int test_rm_0 (void)
16565 if (test_rm_0_skip ()) {
16566 printf ("%s skipped (reason: environment variable set)\n", "test_rm_0");
16570 /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
16572 char device[] = "/dev/sda";
16574 suppress_error = 0;
16575 r = guestfs_blockdev_setrw (g, device);
16581 suppress_error = 0;
16582 r = guestfs_umount_all (g);
16588 suppress_error = 0;
16589 r = guestfs_lvm_remove_all (g);
16594 char device[] = "/dev/sda";
16595 char lines_0[] = ",";
16601 suppress_error = 0;
16602 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16607 char fstype[] = "ext2";
16608 char device[] = "/dev/sda1";
16610 suppress_error = 0;
16611 r = guestfs_mkfs (g, fstype, device);
16616 char device[] = "/dev/sda1";
16617 char mountpoint[] = "/";
16619 suppress_error = 0;
16620 r = guestfs_mount (g, device, mountpoint);
16624 /* TestRun for rm (0) */
16626 char path[] = "/new";
16628 suppress_error = 0;
16629 r = guestfs_touch (g, path);
16634 char path[] = "/new";
16636 suppress_error = 0;
16637 r = guestfs_rm (g, path);
16644 static int test_rm_1_skip (void)
16648 str = getenv ("TEST_ONLY");
16650 return strstr (str, "rm") == NULL;
16651 str = getenv ("SKIP_TEST_RM_1");
16652 if (str && strcmp (str, "1") == 0) return 1;
16653 str = getenv ("SKIP_TEST_RM");
16654 if (str && strcmp (str, "1") == 0) return 1;
16658 static int test_rm_1 (void)
16660 if (test_rm_1_skip ()) {
16661 printf ("%s skipped (reason: environment variable set)\n", "test_rm_1");
16665 /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
16667 char device[] = "/dev/sda";
16669 suppress_error = 0;
16670 r = guestfs_blockdev_setrw (g, device);
16676 suppress_error = 0;
16677 r = guestfs_umount_all (g);
16683 suppress_error = 0;
16684 r = guestfs_lvm_remove_all (g);
16689 char device[] = "/dev/sda";
16690 char lines_0[] = ",";
16696 suppress_error = 0;
16697 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16702 char fstype[] = "ext2";
16703 char device[] = "/dev/sda1";
16705 suppress_error = 0;
16706 r = guestfs_mkfs (g, fstype, device);
16711 char device[] = "/dev/sda1";
16712 char mountpoint[] = "/";
16714 suppress_error = 0;
16715 r = guestfs_mount (g, device, mountpoint);
16719 /* TestLastFail for rm (1) */
16721 char path[] = "/new";
16723 suppress_error = 1;
16724 r = guestfs_rm (g, path);
16731 static int test_rm_2_skip (void)
16735 str = getenv ("TEST_ONLY");
16737 return strstr (str, "rm") == NULL;
16738 str = getenv ("SKIP_TEST_RM_2");
16739 if (str && strcmp (str, "1") == 0) return 1;
16740 str = getenv ("SKIP_TEST_RM");
16741 if (str && strcmp (str, "1") == 0) return 1;
16745 static int test_rm_2 (void)
16747 if (test_rm_2_skip ()) {
16748 printf ("%s skipped (reason: environment variable set)\n", "test_rm_2");
16752 /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
16754 char device[] = "/dev/sda";
16756 suppress_error = 0;
16757 r = guestfs_blockdev_setrw (g, device);
16763 suppress_error = 0;
16764 r = guestfs_umount_all (g);
16770 suppress_error = 0;
16771 r = guestfs_lvm_remove_all (g);
16776 char device[] = "/dev/sda";
16777 char lines_0[] = ",";
16783 suppress_error = 0;
16784 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16789 char fstype[] = "ext2";
16790 char device[] = "/dev/sda1";
16792 suppress_error = 0;
16793 r = guestfs_mkfs (g, fstype, device);
16798 char device[] = "/dev/sda1";
16799 char mountpoint[] = "/";
16801 suppress_error = 0;
16802 r = guestfs_mount (g, device, mountpoint);
16806 /* TestLastFail for rm (2) */
16808 char path[] = "/new";
16810 suppress_error = 0;
16811 r = guestfs_mkdir (g, path);
16816 char path[] = "/new";
16818 suppress_error = 1;
16819 r = guestfs_rm (g, path);
16826 static int test_read_lines_0_skip (void)
16830 str = getenv ("TEST_ONLY");
16832 return strstr (str, "read_lines") == NULL;
16833 str = getenv ("SKIP_TEST_READ_LINES_0");
16834 if (str && strcmp (str, "1") == 0) return 1;
16835 str = getenv ("SKIP_TEST_READ_LINES");
16836 if (str && strcmp (str, "1") == 0) return 1;
16840 static int test_read_lines_0 (void)
16842 if (test_read_lines_0_skip ()) {
16843 printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_0");
16847 /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
16849 char device[] = "/dev/sda";
16851 suppress_error = 0;
16852 r = guestfs_blockdev_setrw (g, device);
16858 suppress_error = 0;
16859 r = guestfs_umount_all (g);
16865 suppress_error = 0;
16866 r = guestfs_lvm_remove_all (g);
16871 char device[] = "/dev/sda";
16872 char lines_0[] = ",";
16878 suppress_error = 0;
16879 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16884 char fstype[] = "ext2";
16885 char device[] = "/dev/sda1";
16887 suppress_error = 0;
16888 r = guestfs_mkfs (g, fstype, device);
16893 char device[] = "/dev/sda1";
16894 char mountpoint[] = "/";
16896 suppress_error = 0;
16897 r = guestfs_mount (g, device, mountpoint);
16901 /* TestOutputList for read_lines (0) */
16903 char path[] = "/new";
16904 char content[] = "line1\r\nline2\nline3";
16906 suppress_error = 0;
16907 r = guestfs_write_file (g, path, content, 0);
16912 char path[] = "/new";
16915 suppress_error = 0;
16916 r = guestfs_read_lines (g, path);
16920 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16925 char expected[] = "line1";
16926 if (strcmp (r[0], expected) != 0) {
16927 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16932 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16937 char expected[] = "line2";
16938 if (strcmp (r[1], expected) != 0) {
16939 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
16944 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16949 char expected[] = "line3";
16950 if (strcmp (r[2], expected) != 0) {
16951 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
16955 if (r[3] != NULL) {
16956 fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
16960 for (i = 0; r[i] != NULL; ++i)
16967 static int test_read_lines_1_skip (void)
16971 str = getenv ("TEST_ONLY");
16973 return strstr (str, "read_lines") == NULL;
16974 str = getenv ("SKIP_TEST_READ_LINES_1");
16975 if (str && strcmp (str, "1") == 0) return 1;
16976 str = getenv ("SKIP_TEST_READ_LINES");
16977 if (str && strcmp (str, "1") == 0) return 1;
16981 static int test_read_lines_1 (void)
16983 if (test_read_lines_1_skip ()) {
16984 printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_1");
16988 /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
16990 char device[] = "/dev/sda";
16992 suppress_error = 0;
16993 r = guestfs_blockdev_setrw (g, device);
16999 suppress_error = 0;
17000 r = guestfs_umount_all (g);
17006 suppress_error = 0;
17007 r = guestfs_lvm_remove_all (g);
17012 char device[] = "/dev/sda";
17013 char lines_0[] = ",";
17019 suppress_error = 0;
17020 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17025 char fstype[] = "ext2";
17026 char device[] = "/dev/sda1";
17028 suppress_error = 0;
17029 r = guestfs_mkfs (g, fstype, device);
17034 char device[] = "/dev/sda1";
17035 char mountpoint[] = "/";
17037 suppress_error = 0;
17038 r = guestfs_mount (g, device, mountpoint);
17042 /* TestOutputList for read_lines (1) */
17044 char path[] = "/new";
17045 char content[] = "";
17047 suppress_error = 0;
17048 r = guestfs_write_file (g, path, content, 0);
17053 char path[] = "/new";
17056 suppress_error = 0;
17057 r = guestfs_read_lines (g, path);
17060 if (r[0] != NULL) {
17061 fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
17065 for (i = 0; r[i] != NULL; ++i)
17072 static int test_lvs_0_skip (void)
17076 str = getenv ("TEST_ONLY");
17078 return strstr (str, "lvs") == NULL;
17079 str = getenv ("SKIP_TEST_LVS_0");
17080 if (str && strcmp (str, "1") == 0) return 1;
17081 str = getenv ("SKIP_TEST_LVS");
17082 if (str && strcmp (str, "1") == 0) return 1;
17086 static int test_lvs_0 (void)
17088 if (test_lvs_0_skip ()) {
17089 printf ("%s skipped (reason: environment variable set)\n", "test_lvs_0");
17093 /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
17095 char device[] = "/dev/sda";
17097 suppress_error = 0;
17098 r = guestfs_blockdev_setrw (g, device);
17104 suppress_error = 0;
17105 r = guestfs_umount_all (g);
17111 suppress_error = 0;
17112 r = guestfs_lvm_remove_all (g);
17117 char device[] = "/dev/sda";
17118 char lines_0[] = ",";
17124 suppress_error = 0;
17125 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17130 char device[] = "/dev/sda1";
17132 suppress_error = 0;
17133 r = guestfs_pvcreate (g, device);
17138 char volgroup[] = "VG";
17139 char physvols_0[] = "/dev/sda1";
17140 char *physvols[] = {
17145 suppress_error = 0;
17146 r = guestfs_vgcreate (g, volgroup, physvols);
17151 char logvol[] = "LV";
17152 char volgroup[] = "VG";
17154 suppress_error = 0;
17155 r = guestfs_lvcreate (g, logvol, volgroup, 8);
17160 char fstype[] = "ext2";
17161 char device[] = "/dev/VG/LV";
17163 suppress_error = 0;
17164 r = guestfs_mkfs (g, fstype, device);
17169 char device[] = "/dev/VG/LV";
17170 char mountpoint[] = "/";
17172 suppress_error = 0;
17173 r = guestfs_mount (g, device, mountpoint);
17177 /* TestOutputList for lvs (0) */
17181 suppress_error = 0;
17182 r = guestfs_lvs (g);
17186 fprintf (stderr, "test_lvs_0: short list returned from command\n");
17191 char expected[] = "/dev/VG/LV";
17192 if (strcmp (r[0], expected) != 0) {
17193 fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17197 if (r[1] != NULL) {
17198 fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
17202 for (i = 0; r[i] != NULL; ++i)
17209 static int test_lvs_1_skip (void)
17213 str = getenv ("TEST_ONLY");
17215 return strstr (str, "lvs") == NULL;
17216 str = getenv ("SKIP_TEST_LVS_1");
17217 if (str && strcmp (str, "1") == 0) return 1;
17218 str = getenv ("SKIP_TEST_LVS");
17219 if (str && strcmp (str, "1") == 0) return 1;
17223 static int test_lvs_1 (void)
17225 if (test_lvs_1_skip ()) {
17226 printf ("%s skipped (reason: environment variable set)\n", "test_lvs_1");
17230 /* InitNone|InitEmpty for test_lvs_1 */
17232 char device[] = "/dev/sda";
17234 suppress_error = 0;
17235 r = guestfs_blockdev_setrw (g, device);
17241 suppress_error = 0;
17242 r = guestfs_umount_all (g);
17248 suppress_error = 0;
17249 r = guestfs_lvm_remove_all (g);
17253 /* TestOutputList for lvs (1) */
17255 char device[] = "/dev/sda";
17256 char lines_0[] = ",10";
17257 char lines_1[] = ",20";
17258 char lines_2[] = ",";
17266 suppress_error = 0;
17267 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17272 char device[] = "/dev/sda1";
17274 suppress_error = 0;
17275 r = guestfs_pvcreate (g, device);
17280 char device[] = "/dev/sda2";
17282 suppress_error = 0;
17283 r = guestfs_pvcreate (g, device);
17288 char device[] = "/dev/sda3";
17290 suppress_error = 0;
17291 r = guestfs_pvcreate (g, device);
17296 char volgroup[] = "VG1";
17297 char physvols_0[] = "/dev/sda1";
17298 char physvols_1[] = "/dev/sda2";
17299 char *physvols[] = {
17305 suppress_error = 0;
17306 r = guestfs_vgcreate (g, volgroup, physvols);
17311 char volgroup[] = "VG2";
17312 char physvols_0[] = "/dev/sda3";
17313 char *physvols[] = {
17318 suppress_error = 0;
17319 r = guestfs_vgcreate (g, volgroup, physvols);
17324 char logvol[] = "LV1";
17325 char volgroup[] = "VG1";
17327 suppress_error = 0;
17328 r = guestfs_lvcreate (g, logvol, volgroup, 50);
17333 char logvol[] = "LV2";
17334 char volgroup[] = "VG1";
17336 suppress_error = 0;
17337 r = guestfs_lvcreate (g, logvol, volgroup, 50);
17342 char logvol[] = "LV3";
17343 char volgroup[] = "VG2";
17345 suppress_error = 0;
17346 r = guestfs_lvcreate (g, logvol, volgroup, 50);
17353 suppress_error = 0;
17354 r = guestfs_lvs (g);
17358 fprintf (stderr, "test_lvs_1: short list returned from command\n");
17363 char expected[] = "/dev/VG1/LV1";
17364 if (strcmp (r[0], expected) != 0) {
17365 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17370 fprintf (stderr, "test_lvs_1: short list returned from command\n");
17375 char expected[] = "/dev/VG1/LV2";
17376 if (strcmp (r[1], expected) != 0) {
17377 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17382 fprintf (stderr, "test_lvs_1: short list returned from command\n");
17387 char expected[] = "/dev/VG2/LV3";
17388 if (strcmp (r[2], expected) != 0) {
17389 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17393 if (r[3] != NULL) {
17394 fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
17398 for (i = 0; r[i] != NULL; ++i)
17405 static int test_vgs_0_skip (void)
17409 str = getenv ("TEST_ONLY");
17411 return strstr (str, "vgs") == NULL;
17412 str = getenv ("SKIP_TEST_VGS_0");
17413 if (str && strcmp (str, "1") == 0) return 1;
17414 str = getenv ("SKIP_TEST_VGS");
17415 if (str && strcmp (str, "1") == 0) return 1;
17419 static int test_vgs_0 (void)
17421 if (test_vgs_0_skip ()) {
17422 printf ("%s skipped (reason: environment variable set)\n", "test_vgs_0");
17426 /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
17428 char device[] = "/dev/sda";
17430 suppress_error = 0;
17431 r = guestfs_blockdev_setrw (g, device);
17437 suppress_error = 0;
17438 r = guestfs_umount_all (g);
17444 suppress_error = 0;
17445 r = guestfs_lvm_remove_all (g);
17450 char device[] = "/dev/sda";
17451 char lines_0[] = ",";
17457 suppress_error = 0;
17458 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17463 char device[] = "/dev/sda1";
17465 suppress_error = 0;
17466 r = guestfs_pvcreate (g, device);
17471 char volgroup[] = "VG";
17472 char physvols_0[] = "/dev/sda1";
17473 char *physvols[] = {
17478 suppress_error = 0;
17479 r = guestfs_vgcreate (g, volgroup, physvols);
17484 char logvol[] = "LV";
17485 char volgroup[] = "VG";
17487 suppress_error = 0;
17488 r = guestfs_lvcreate (g, logvol, volgroup, 8);
17493 char fstype[] = "ext2";
17494 char device[] = "/dev/VG/LV";
17496 suppress_error = 0;
17497 r = guestfs_mkfs (g, fstype, device);
17502 char device[] = "/dev/VG/LV";
17503 char mountpoint[] = "/";
17505 suppress_error = 0;
17506 r = guestfs_mount (g, device, mountpoint);
17510 /* TestOutputList for vgs (0) */
17514 suppress_error = 0;
17515 r = guestfs_vgs (g);
17519 fprintf (stderr, "test_vgs_0: short list returned from command\n");
17524 char expected[] = "VG";
17525 if (strcmp (r[0], expected) != 0) {
17526 fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17530 if (r[1] != NULL) {
17531 fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
17535 for (i = 0; r[i] != NULL; ++i)
17542 static int test_vgs_1_skip (void)
17546 str = getenv ("TEST_ONLY");
17548 return strstr (str, "vgs") == NULL;
17549 str = getenv ("SKIP_TEST_VGS_1");
17550 if (str && strcmp (str, "1") == 0) return 1;
17551 str = getenv ("SKIP_TEST_VGS");
17552 if (str && strcmp (str, "1") == 0) return 1;
17556 static int test_vgs_1 (void)
17558 if (test_vgs_1_skip ()) {
17559 printf ("%s skipped (reason: environment variable set)\n", "test_vgs_1");
17563 /* InitNone|InitEmpty for test_vgs_1 */
17565 char device[] = "/dev/sda";
17567 suppress_error = 0;
17568 r = guestfs_blockdev_setrw (g, device);
17574 suppress_error = 0;
17575 r = guestfs_umount_all (g);
17581 suppress_error = 0;
17582 r = guestfs_lvm_remove_all (g);
17586 /* TestOutputList for vgs (1) */
17588 char device[] = "/dev/sda";
17589 char lines_0[] = ",10";
17590 char lines_1[] = ",20";
17591 char lines_2[] = ",";
17599 suppress_error = 0;
17600 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17605 char device[] = "/dev/sda1";
17607 suppress_error = 0;
17608 r = guestfs_pvcreate (g, device);
17613 char device[] = "/dev/sda2";
17615 suppress_error = 0;
17616 r = guestfs_pvcreate (g, device);
17621 char device[] = "/dev/sda3";
17623 suppress_error = 0;
17624 r = guestfs_pvcreate (g, device);
17629 char volgroup[] = "VG1";
17630 char physvols_0[] = "/dev/sda1";
17631 char physvols_1[] = "/dev/sda2";
17632 char *physvols[] = {
17638 suppress_error = 0;
17639 r = guestfs_vgcreate (g, volgroup, physvols);
17644 char volgroup[] = "VG2";
17645 char physvols_0[] = "/dev/sda3";
17646 char *physvols[] = {
17651 suppress_error = 0;
17652 r = guestfs_vgcreate (g, volgroup, physvols);
17659 suppress_error = 0;
17660 r = guestfs_vgs (g);
17664 fprintf (stderr, "test_vgs_1: short list returned from command\n");
17669 char expected[] = "VG1";
17670 if (strcmp (r[0], expected) != 0) {
17671 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17676 fprintf (stderr, "test_vgs_1: short list returned from command\n");
17681 char expected[] = "VG2";
17682 if (strcmp (r[1], expected) != 0) {
17683 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17687 if (r[2] != NULL) {
17688 fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
17692 for (i = 0; r[i] != NULL; ++i)
17699 static int test_pvs_0_skip (void)
17703 str = getenv ("TEST_ONLY");
17705 return strstr (str, "pvs") == NULL;
17706 str = getenv ("SKIP_TEST_PVS_0");
17707 if (str && strcmp (str, "1") == 0) return 1;
17708 str = getenv ("SKIP_TEST_PVS");
17709 if (str && strcmp (str, "1") == 0) return 1;
17713 static int test_pvs_0 (void)
17715 if (test_pvs_0_skip ()) {
17716 printf ("%s skipped (reason: environment variable set)\n", "test_pvs_0");
17720 /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
17722 char device[] = "/dev/sda";
17724 suppress_error = 0;
17725 r = guestfs_blockdev_setrw (g, device);
17731 suppress_error = 0;
17732 r = guestfs_umount_all (g);
17738 suppress_error = 0;
17739 r = guestfs_lvm_remove_all (g);
17744 char device[] = "/dev/sda";
17745 char lines_0[] = ",";
17751 suppress_error = 0;
17752 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17757 char device[] = "/dev/sda1";
17759 suppress_error = 0;
17760 r = guestfs_pvcreate (g, device);
17765 char volgroup[] = "VG";
17766 char physvols_0[] = "/dev/sda1";
17767 char *physvols[] = {
17772 suppress_error = 0;
17773 r = guestfs_vgcreate (g, volgroup, physvols);
17778 char logvol[] = "LV";
17779 char volgroup[] = "VG";
17781 suppress_error = 0;
17782 r = guestfs_lvcreate (g, logvol, volgroup, 8);
17787 char fstype[] = "ext2";
17788 char device[] = "/dev/VG/LV";
17790 suppress_error = 0;
17791 r = guestfs_mkfs (g, fstype, device);
17796 char device[] = "/dev/VG/LV";
17797 char mountpoint[] = "/";
17799 suppress_error = 0;
17800 r = guestfs_mount (g, device, mountpoint);
17804 /* TestOutputListOfDevices for pvs (0) */
17808 suppress_error = 0;
17809 r = guestfs_pvs (g);
17813 fprintf (stderr, "test_pvs_0: short list returned from command\n");
17818 char expected[] = "/dev/sda1";
17820 if (strcmp (r[0], expected) != 0) {
17821 fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17825 if (r[1] != NULL) {
17826 fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
17830 for (i = 0; r[i] != NULL; ++i)
17837 static int test_pvs_1_skip (void)
17841 str = getenv ("TEST_ONLY");
17843 return strstr (str, "pvs") == NULL;
17844 str = getenv ("SKIP_TEST_PVS_1");
17845 if (str && strcmp (str, "1") == 0) return 1;
17846 str = getenv ("SKIP_TEST_PVS");
17847 if (str && strcmp (str, "1") == 0) return 1;
17851 static int test_pvs_1 (void)
17853 if (test_pvs_1_skip ()) {
17854 printf ("%s skipped (reason: environment variable set)\n", "test_pvs_1");
17858 /* InitNone|InitEmpty for test_pvs_1 */
17860 char device[] = "/dev/sda";
17862 suppress_error = 0;
17863 r = guestfs_blockdev_setrw (g, device);
17869 suppress_error = 0;
17870 r = guestfs_umount_all (g);
17876 suppress_error = 0;
17877 r = guestfs_lvm_remove_all (g);
17881 /* TestOutputListOfDevices for pvs (1) */
17883 char device[] = "/dev/sda";
17884 char lines_0[] = ",10";
17885 char lines_1[] = ",20";
17886 char lines_2[] = ",";
17894 suppress_error = 0;
17895 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17900 char device[] = "/dev/sda1";
17902 suppress_error = 0;
17903 r = guestfs_pvcreate (g, device);
17908 char device[] = "/dev/sda2";
17910 suppress_error = 0;
17911 r = guestfs_pvcreate (g, device);
17916 char device[] = "/dev/sda3";
17918 suppress_error = 0;
17919 r = guestfs_pvcreate (g, device);
17926 suppress_error = 0;
17927 r = guestfs_pvs (g);
17931 fprintf (stderr, "test_pvs_1: short list returned from command\n");
17936 char expected[] = "/dev/sda1";
17938 if (strcmp (r[0], expected) != 0) {
17939 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17944 fprintf (stderr, "test_pvs_1: short list returned from command\n");
17949 char expected[] = "/dev/sda2";
17951 if (strcmp (r[1], expected) != 0) {
17952 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17957 fprintf (stderr, "test_pvs_1: short list returned from command\n");
17962 char expected[] = "/dev/sda3";
17964 if (strcmp (r[2], expected) != 0) {
17965 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17969 if (r[3] != NULL) {
17970 fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
17974 for (i = 0; r[i] != NULL; ++i)
17981 static int test_list_partitions_0_skip (void)
17985 str = getenv ("TEST_ONLY");
17987 return strstr (str, "list_partitions") == NULL;
17988 str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
17989 if (str && strcmp (str, "1") == 0) return 1;
17990 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
17991 if (str && strcmp (str, "1") == 0) return 1;
17995 static int test_list_partitions_0 (void)
17997 if (test_list_partitions_0_skip ()) {
17998 printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_0");
18002 /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
18004 char device[] = "/dev/sda";
18006 suppress_error = 0;
18007 r = guestfs_blockdev_setrw (g, device);
18013 suppress_error = 0;
18014 r = guestfs_umount_all (g);
18020 suppress_error = 0;
18021 r = guestfs_lvm_remove_all (g);
18026 char device[] = "/dev/sda";
18027 char lines_0[] = ",";
18033 suppress_error = 0;
18034 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18039 char fstype[] = "ext2";
18040 char device[] = "/dev/sda1";
18042 suppress_error = 0;
18043 r = guestfs_mkfs (g, fstype, device);
18048 char device[] = "/dev/sda1";
18049 char mountpoint[] = "/";
18051 suppress_error = 0;
18052 r = guestfs_mount (g, device, mountpoint);
18056 /* TestOutputListOfDevices for list_partitions (0) */
18060 suppress_error = 0;
18061 r = guestfs_list_partitions (g);
18065 fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
18070 char expected[] = "/dev/sda1";
18072 if (strcmp (r[0], expected) != 0) {
18073 fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18077 if (r[1] != NULL) {
18078 fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
18082 for (i = 0; r[i] != NULL; ++i)
18089 static int test_list_partitions_1_skip (void)
18093 str = getenv ("TEST_ONLY");
18095 return strstr (str, "list_partitions") == NULL;
18096 str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
18097 if (str && strcmp (str, "1") == 0) return 1;
18098 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
18099 if (str && strcmp (str, "1") == 0) return 1;
18103 static int test_list_partitions_1 (void)
18105 if (test_list_partitions_1_skip ()) {
18106 printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_1");
18110 /* InitNone|InitEmpty for test_list_partitions_1 */
18112 char device[] = "/dev/sda";
18114 suppress_error = 0;
18115 r = guestfs_blockdev_setrw (g, device);
18121 suppress_error = 0;
18122 r = guestfs_umount_all (g);
18128 suppress_error = 0;
18129 r = guestfs_lvm_remove_all (g);
18133 /* TestOutputListOfDevices for list_partitions (1) */
18135 char device[] = "/dev/sda";
18136 char lines_0[] = ",10";
18137 char lines_1[] = ",20";
18138 char lines_2[] = ",";
18146 suppress_error = 0;
18147 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18154 suppress_error = 0;
18155 r = guestfs_list_partitions (g);
18159 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
18164 char expected[] = "/dev/sda1";
18166 if (strcmp (r[0], expected) != 0) {
18167 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18172 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
18177 char expected[] = "/dev/sda2";
18179 if (strcmp (r[1], expected) != 0) {
18180 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18185 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
18190 char expected[] = "/dev/sda3";
18192 if (strcmp (r[2], expected) != 0) {
18193 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18197 if (r[3] != NULL) {
18198 fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
18202 for (i = 0; r[i] != NULL; ++i)
18209 static int test_list_devices_0_skip (void)
18213 str = getenv ("TEST_ONLY");
18215 return strstr (str, "list_devices") == NULL;
18216 str = getenv ("SKIP_TEST_LIST_DEVICES_0");
18217 if (str && strcmp (str, "1") == 0) return 1;
18218 str = getenv ("SKIP_TEST_LIST_DEVICES");
18219 if (str && strcmp (str, "1") == 0) return 1;
18223 static int test_list_devices_0 (void)
18225 if (test_list_devices_0_skip ()) {
18226 printf ("%s skipped (reason: environment variable set)\n", "test_list_devices_0");
18230 /* InitNone|InitEmpty for test_list_devices_0 */
18232 char device[] = "/dev/sda";
18234 suppress_error = 0;
18235 r = guestfs_blockdev_setrw (g, device);
18241 suppress_error = 0;
18242 r = guestfs_umount_all (g);
18248 suppress_error = 0;
18249 r = guestfs_lvm_remove_all (g);
18253 /* TestOutputListOfDevices for list_devices (0) */
18257 suppress_error = 0;
18258 r = guestfs_list_devices (g);
18262 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18267 char expected[] = "/dev/sda";
18269 if (strcmp (r[0], expected) != 0) {
18270 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18275 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18280 char expected[] = "/dev/sdb";
18282 if (strcmp (r[1], expected) != 0) {
18283 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18288 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18293 char expected[] = "/dev/sdc";
18295 if (strcmp (r[2], expected) != 0) {
18296 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18301 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18306 char expected[] = "/dev/sdd";
18308 if (strcmp (r[3], expected) != 0) {
18309 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
18313 if (r[4] != NULL) {
18314 fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
18318 for (i = 0; r[i] != NULL; ++i)
18325 static int test_ls_0_skip (void)
18329 str = getenv ("TEST_ONLY");
18331 return strstr (str, "ls") == NULL;
18332 str = getenv ("SKIP_TEST_LS_0");
18333 if (str && strcmp (str, "1") == 0) return 1;
18334 str = getenv ("SKIP_TEST_LS");
18335 if (str && strcmp (str, "1") == 0) return 1;
18339 static int test_ls_0 (void)
18341 if (test_ls_0_skip ()) {
18342 printf ("%s skipped (reason: environment variable set)\n", "test_ls_0");
18346 /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
18348 char device[] = "/dev/sda";
18350 suppress_error = 0;
18351 r = guestfs_blockdev_setrw (g, device);
18357 suppress_error = 0;
18358 r = guestfs_umount_all (g);
18364 suppress_error = 0;
18365 r = guestfs_lvm_remove_all (g);
18370 char device[] = "/dev/sda";
18371 char lines_0[] = ",";
18377 suppress_error = 0;
18378 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18383 char fstype[] = "ext2";
18384 char device[] = "/dev/sda1";
18386 suppress_error = 0;
18387 r = guestfs_mkfs (g, fstype, device);
18392 char device[] = "/dev/sda1";
18393 char mountpoint[] = "/";
18395 suppress_error = 0;
18396 r = guestfs_mount (g, device, mountpoint);
18400 /* TestOutputList for ls (0) */
18402 char path[] = "/new";
18404 suppress_error = 0;
18405 r = guestfs_touch (g, path);
18410 char path[] = "/newer";
18412 suppress_error = 0;
18413 r = guestfs_touch (g, path);
18418 char path[] = "/newest";
18420 suppress_error = 0;
18421 r = guestfs_touch (g, path);
18426 char directory[] = "/";
18429 suppress_error = 0;
18430 r = guestfs_ls (g, directory);
18434 fprintf (stderr, "test_ls_0: short list returned from command\n");
18439 char expected[] = "lost+found";
18440 if (strcmp (r[0], expected) != 0) {
18441 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18446 fprintf (stderr, "test_ls_0: short list returned from command\n");
18451 char expected[] = "new";
18452 if (strcmp (r[1], expected) != 0) {
18453 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18458 fprintf (stderr, "test_ls_0: short list returned from command\n");
18463 char expected[] = "newer";
18464 if (strcmp (r[2], expected) != 0) {
18465 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18470 fprintf (stderr, "test_ls_0: short list returned from command\n");
18475 char expected[] = "newest";
18476 if (strcmp (r[3], expected) != 0) {
18477 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
18481 if (r[4] != NULL) {
18482 fprintf (stderr, "test_ls_0: extra elements returned from command\n");
18486 for (i = 0; r[i] != NULL; ++i)
18493 static int test_cat_0_skip (void)
18497 str = getenv ("TEST_ONLY");
18499 return strstr (str, "cat") == NULL;
18500 str = getenv ("SKIP_TEST_CAT_0");
18501 if (str && strcmp (str, "1") == 0) return 1;
18502 str = getenv ("SKIP_TEST_CAT");
18503 if (str && strcmp (str, "1") == 0) return 1;
18507 static int test_cat_0 (void)
18509 if (test_cat_0_skip ()) {
18510 printf ("%s skipped (reason: environment variable set)\n", "test_cat_0");
18514 /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
18516 char device[] = "/dev/sda";
18518 suppress_error = 0;
18519 r = guestfs_blockdev_setrw (g, device);
18525 suppress_error = 0;
18526 r = guestfs_umount_all (g);
18532 suppress_error = 0;
18533 r = guestfs_lvm_remove_all (g);
18538 char device[] = "/dev/sda";
18539 char lines_0[] = ",";
18545 suppress_error = 0;
18546 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18551 char fstype[] = "ext2";
18552 char device[] = "/dev/sda1";
18554 suppress_error = 0;
18555 r = guestfs_mkfs (g, fstype, device);
18560 char device[] = "/dev/sda1";
18561 char mountpoint[] = "/";
18563 suppress_error = 0;
18564 r = guestfs_mount (g, device, mountpoint);
18568 /* TestOutput for cat (0) */
18569 char expected[] = "new file contents";
18571 char path[] = "/new";
18572 char content[] = "new file contents";
18574 suppress_error = 0;
18575 r = guestfs_write_file (g, path, content, 0);
18580 char path[] = "/new";
18582 suppress_error = 0;
18583 r = guestfs_cat (g, path);
18586 if (strcmp (r, expected) != 0) {
18587 fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
18595 static int test_touch_0_skip (void)
18599 str = getenv ("TEST_ONLY");
18601 return strstr (str, "touch") == NULL;
18602 str = getenv ("SKIP_TEST_TOUCH_0");
18603 if (str && strcmp (str, "1") == 0) return 1;
18604 str = getenv ("SKIP_TEST_TOUCH");
18605 if (str && strcmp (str, "1") == 0) return 1;
18609 static int test_touch_0 (void)
18611 if (test_touch_0_skip ()) {
18612 printf ("%s skipped (reason: environment variable set)\n", "test_touch_0");
18616 /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
18618 char device[] = "/dev/sda";
18620 suppress_error = 0;
18621 r = guestfs_blockdev_setrw (g, device);
18627 suppress_error = 0;
18628 r = guestfs_umount_all (g);
18634 suppress_error = 0;
18635 r = guestfs_lvm_remove_all (g);
18640 char device[] = "/dev/sda";
18641 char lines_0[] = ",";
18647 suppress_error = 0;
18648 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18653 char fstype[] = "ext2";
18654 char device[] = "/dev/sda1";
18656 suppress_error = 0;
18657 r = guestfs_mkfs (g, fstype, device);
18662 char device[] = "/dev/sda1";
18663 char mountpoint[] = "/";
18665 suppress_error = 0;
18666 r = guestfs_mount (g, device, mountpoint);
18670 /* TestOutputTrue for touch (0) */
18672 char path[] = "/new";
18674 suppress_error = 0;
18675 r = guestfs_touch (g, path);
18680 char path[] = "/new";
18682 suppress_error = 0;
18683 r = guestfs_exists (g, path);
18687 fprintf (stderr, "test_touch_0: expected true, got false\n");
18694 static int test_sync_0_skip (void)
18698 str = getenv ("TEST_ONLY");
18700 return strstr (str, "sync") == NULL;
18701 str = getenv ("SKIP_TEST_SYNC_0");
18702 if (str && strcmp (str, "1") == 0) return 1;
18703 str = getenv ("SKIP_TEST_SYNC");
18704 if (str && strcmp (str, "1") == 0) return 1;
18708 static int test_sync_0 (void)
18710 if (test_sync_0_skip ()) {
18711 printf ("%s skipped (reason: environment variable set)\n", "test_sync_0");
18715 /* InitNone|InitEmpty for test_sync_0 */
18717 char device[] = "/dev/sda";
18719 suppress_error = 0;
18720 r = guestfs_blockdev_setrw (g, device);
18726 suppress_error = 0;
18727 r = guestfs_umount_all (g);
18733 suppress_error = 0;
18734 r = guestfs_lvm_remove_all (g);
18738 /* TestRun for sync (0) */
18741 suppress_error = 0;
18742 r = guestfs_sync (g);
18749 static int test_mount_0_skip (void)
18753 str = getenv ("TEST_ONLY");
18755 return strstr (str, "mount") == NULL;
18756 str = getenv ("SKIP_TEST_MOUNT_0");
18757 if (str && strcmp (str, "1") == 0) return 1;
18758 str = getenv ("SKIP_TEST_MOUNT");
18759 if (str && strcmp (str, "1") == 0) return 1;
18763 static int test_mount_0 (void)
18765 if (test_mount_0_skip ()) {
18766 printf ("%s skipped (reason: environment variable set)\n", "test_mount_0");
18770 /* InitNone|InitEmpty for test_mount_0 */
18772 char device[] = "/dev/sda";
18774 suppress_error = 0;
18775 r = guestfs_blockdev_setrw (g, device);
18781 suppress_error = 0;
18782 r = guestfs_umount_all (g);
18788 suppress_error = 0;
18789 r = guestfs_lvm_remove_all (g);
18793 /* TestOutput for mount (0) */
18794 char expected[] = "new file contents";
18796 char device[] = "/dev/sda";
18797 char lines_0[] = ",";
18803 suppress_error = 0;
18804 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18809 char fstype[] = "ext2";
18810 char device[] = "/dev/sda1";
18812 suppress_error = 0;
18813 r = guestfs_mkfs (g, fstype, device);
18818 char device[] = "/dev/sda1";
18819 char mountpoint[] = "/";
18821 suppress_error = 0;
18822 r = guestfs_mount (g, device, mountpoint);
18827 char path[] = "/new";
18828 char content[] = "new file contents";
18830 suppress_error = 0;
18831 r = guestfs_write_file (g, path, content, 0);
18836 char path[] = "/new";
18838 suppress_error = 0;
18839 r = guestfs_cat (g, path);
18842 if (strcmp (r, expected) != 0) {
18843 fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
18851 int main (int argc, char *argv[])
18855 const char *filename;
18857 int nr_tests, test_num = 0;
18859 no_test_warnings ();
18861 g = guestfs_create ();
18863 printf ("guestfs_create FAILED\n");
18867 guestfs_set_error_handler (g, print_error, NULL);
18869 guestfs_set_path (g, "../appliance");
18871 filename = "test1.img";
18872 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18877 if (lseek (fd, 524288000, SEEK_SET) == -1) {
18883 if (write (fd, &c, 1) == -1) {
18889 if (close (fd) == -1) {
18894 if (guestfs_add_drive (g, filename) == -1) {
18895 printf ("guestfs_add_drive %s FAILED\n", filename);
18899 filename = "test2.img";
18900 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18905 if (lseek (fd, 52428800, SEEK_SET) == -1) {
18911 if (write (fd, &c, 1) == -1) {
18917 if (close (fd) == -1) {
18922 if (guestfs_add_drive (g, filename) == -1) {
18923 printf ("guestfs_add_drive %s FAILED\n", filename);
18927 filename = "test3.img";
18928 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18933 if (lseek (fd, 10485760, SEEK_SET) == -1) {
18939 if (write (fd, &c, 1) == -1) {
18945 if (close (fd) == -1) {
18950 if (guestfs_add_drive (g, filename) == -1) {
18951 printf ("guestfs_add_drive %s FAILED\n", filename);
18955 if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
18956 printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
18960 if (guestfs_launch (g) == -1) {
18961 printf ("guestfs_launch FAILED\n");
18965 /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */
18968 if (guestfs_wait_ready (g) == -1) {
18969 printf ("guestfs_wait_ready FAILED\n");
18973 /* Cancel previous alarm. */
18979 printf ("%3d/%3d test_mkswap_U_0\n", test_num, nr_tests);
18980 if (test_mkswap_U_0 () == -1) {
18981 printf ("test_mkswap_U_0 FAILED\n");
18985 printf ("%3d/%3d test_mkswap_L_0\n", test_num, nr_tests);
18986 if (test_mkswap_L_0 () == -1) {
18987 printf ("test_mkswap_L_0 FAILED\n");
18991 printf ("%3d/%3d test_mkswap_0\n", test_num, nr_tests);
18992 if (test_mkswap_0 () == -1) {
18993 printf ("test_mkswap_0 FAILED\n");
18997 printf ("%3d/%3d test_initrd_list_0\n", test_num, nr_tests);
18998 if (test_initrd_list_0 () == -1) {
18999 printf ("test_initrd_list_0 FAILED\n");
19003 printf ("%3d/%3d test_du_0\n", test_num, nr_tests);
19004 if (test_du_0 () == -1) {
19005 printf ("test_du_0 FAILED\n");
19009 printf ("%3d/%3d test_tail_n_0\n", test_num, nr_tests);
19010 if (test_tail_n_0 () == -1) {
19011 printf ("test_tail_n_0 FAILED\n");
19015 printf ("%3d/%3d test_tail_n_1\n", test_num, nr_tests);
19016 if (test_tail_n_1 () == -1) {
19017 printf ("test_tail_n_1 FAILED\n");
19021 printf ("%3d/%3d test_tail_n_2\n", test_num, nr_tests);
19022 if (test_tail_n_2 () == -1) {
19023 printf ("test_tail_n_2 FAILED\n");
19027 printf ("%3d/%3d test_tail_0\n", test_num, nr_tests);
19028 if (test_tail_0 () == -1) {
19029 printf ("test_tail_0 FAILED\n");
19033 printf ("%3d/%3d test_head_n_0\n", test_num, nr_tests);
19034 if (test_head_n_0 () == -1) {
19035 printf ("test_head_n_0 FAILED\n");
19039 printf ("%3d/%3d test_head_n_1\n", test_num, nr_tests);
19040 if (test_head_n_1 () == -1) {
19041 printf ("test_head_n_1 FAILED\n");
19045 printf ("%3d/%3d test_head_n_2\n", test_num, nr_tests);
19046 if (test_head_n_2 () == -1) {
19047 printf ("test_head_n_2 FAILED\n");
19051 printf ("%3d/%3d test_head_0\n", test_num, nr_tests);
19052 if (test_head_0 () == -1) {
19053 printf ("test_head_0 FAILED\n");
19057 printf ("%3d/%3d test_wc_c_0\n", test_num, nr_tests);
19058 if (test_wc_c_0 () == -1) {
19059 printf ("test_wc_c_0 FAILED\n");
19063 printf ("%3d/%3d test_wc_w_0\n", test_num, nr_tests);
19064 if (test_wc_w_0 () == -1) {
19065 printf ("test_wc_w_0 FAILED\n");
19069 printf ("%3d/%3d test_wc_l_0\n", test_num, nr_tests);
19070 if (test_wc_l_0 () == -1) {
19071 printf ("test_wc_l_0 FAILED\n");
19075 printf ("%3d/%3d test_mkdtemp_0\n", test_num, nr_tests);
19076 if (test_mkdtemp_0 () == -1) {
19077 printf ("test_mkdtemp_0 FAILED\n");
19081 printf ("%3d/%3d test_scrub_file_0\n", test_num, nr_tests);
19082 if (test_scrub_file_0 () == -1) {
19083 printf ("test_scrub_file_0 FAILED\n");
19087 printf ("%3d/%3d test_scrub_device_0\n", test_num, nr_tests);
19088 if (test_scrub_device_0 () == -1) {
19089 printf ("test_scrub_device_0 FAILED\n");
19093 printf ("%3d/%3d test_glob_expand_0\n", test_num, nr_tests);
19094 if (test_glob_expand_0 () == -1) {
19095 printf ("test_glob_expand_0 FAILED\n");
19099 printf ("%3d/%3d test_glob_expand_1\n", test_num, nr_tests);
19100 if (test_glob_expand_1 () == -1) {
19101 printf ("test_glob_expand_1 FAILED\n");
19105 printf ("%3d/%3d test_glob_expand_2\n", test_num, nr_tests);
19106 if (test_glob_expand_2 () == -1) {
19107 printf ("test_glob_expand_2 FAILED\n");
19111 printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
19112 if (test_ntfs_3g_probe_0 () == -1) {
19113 printf ("test_ntfs_3g_probe_0 FAILED\n");
19117 printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
19118 if (test_ntfs_3g_probe_1 () == -1) {
19119 printf ("test_ntfs_3g_probe_1 FAILED\n");
19123 printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
19124 if (test_sleep_0 () == -1) {
19125 printf ("test_sleep_0 FAILED\n");
19129 printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
19130 if (test_find_0 () == -1) {
19131 printf ("test_find_0 FAILED\n");
19135 printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
19136 if (test_find_1 () == -1) {
19137 printf ("test_find_1 FAILED\n");
19141 printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
19142 if (test_find_2 () == -1) {
19143 printf ("test_find_2 FAILED\n");
19147 printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
19148 if (test_lvresize_0 () == -1) {
19149 printf ("test_lvresize_0 FAILED\n");
19153 printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
19154 if (test_zerofree_0 () == -1) {
19155 printf ("test_zerofree_0 FAILED\n");
19159 printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
19160 if (test_hexdump_0 () == -1) {
19161 printf ("test_hexdump_0 FAILED\n");
19165 printf ("%3d/%3d test_hexdump_1\n", test_num, nr_tests);
19166 if (test_hexdump_1 () == -1) {
19167 printf ("test_hexdump_1 FAILED\n");
19171 printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
19172 if (test_strings_e_0 () == -1) {
19173 printf ("test_strings_e_0 FAILED\n");
19177 printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
19178 if (test_strings_e_1 () == -1) {
19179 printf ("test_strings_e_1 FAILED\n");
19183 printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
19184 if (test_strings_0 () == -1) {
19185 printf ("test_strings_0 FAILED\n");
19189 printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
19190 if (test_strings_1 () == -1) {
19191 printf ("test_strings_1 FAILED\n");
19195 printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
19196 if (test_equal_0 () == -1) {
19197 printf ("test_equal_0 FAILED\n");
19201 printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
19202 if (test_equal_1 () == -1) {
19203 printf ("test_equal_1 FAILED\n");
19207 printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
19208 if (test_equal_2 () == -1) {
19209 printf ("test_equal_2 FAILED\n");
19213 printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
19214 if (test_ping_daemon_0 () == -1) {
19215 printf ("test_ping_daemon_0 FAILED\n");
19219 printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
19220 if (test_dmesg_0 () == -1) {
19221 printf ("test_dmesg_0 FAILED\n");
19225 printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
19226 if (test_drop_caches_0 () == -1) {
19227 printf ("test_drop_caches_0 FAILED\n");
19231 printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
19232 if (test_mv_0 () == -1) {
19233 printf ("test_mv_0 FAILED\n");
19237 printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
19238 if (test_mv_1 () == -1) {
19239 printf ("test_mv_1 FAILED\n");
19243 printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
19244 if (test_cp_a_0 () == -1) {
19245 printf ("test_cp_a_0 FAILED\n");
19249 printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
19250 if (test_cp_0 () == -1) {
19251 printf ("test_cp_0 FAILED\n");
19255 printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
19256 if (test_cp_1 () == -1) {
19257 printf ("test_cp_1 FAILED\n");
19261 printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
19262 if (test_cp_2 () == -1) {
19263 printf ("test_cp_2 FAILED\n");
19267 printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
19268 if (test_grub_install_0 () == -1) {
19269 printf ("test_grub_install_0 FAILED\n");
19273 printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
19274 if (test_zero_0 () == -1) {
19275 printf ("test_zero_0 FAILED\n");
19279 printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
19280 if (test_fsck_0 () == -1) {
19281 printf ("test_fsck_0 FAILED\n");
19285 printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
19286 if (test_fsck_1 () == -1) {
19287 printf ("test_fsck_1 FAILED\n");
19291 printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
19292 if (test_set_e2uuid_0 () == -1) {
19293 printf ("test_set_e2uuid_0 FAILED\n");
19297 printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
19298 if (test_set_e2uuid_1 () == -1) {
19299 printf ("test_set_e2uuid_1 FAILED\n");
19303 printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
19304 if (test_set_e2uuid_2 () == -1) {
19305 printf ("test_set_e2uuid_2 FAILED\n");
19309 printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
19310 if (test_set_e2uuid_3 () == -1) {
19311 printf ("test_set_e2uuid_3 FAILED\n");
19315 printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
19316 if (test_set_e2label_0 () == -1) {
19317 printf ("test_set_e2label_0 FAILED\n");
19321 printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
19322 if (test_pvremove_0 () == -1) {
19323 printf ("test_pvremove_0 FAILED\n");
19327 printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
19328 if (test_pvremove_1 () == -1) {
19329 printf ("test_pvremove_1 FAILED\n");
19333 printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
19334 if (test_pvremove_2 () == -1) {
19335 printf ("test_pvremove_2 FAILED\n");
19339 printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
19340 if (test_vgremove_0 () == -1) {
19341 printf ("test_vgremove_0 FAILED\n");
19345 printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
19346 if (test_vgremove_1 () == -1) {
19347 printf ("test_vgremove_1 FAILED\n");
19351 printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
19352 if (test_lvremove_0 () == -1) {
19353 printf ("test_lvremove_0 FAILED\n");
19357 printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
19358 if (test_lvremove_1 () == -1) {
19359 printf ("test_lvremove_1 FAILED\n");
19363 printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
19364 if (test_lvremove_2 () == -1) {
19365 printf ("test_lvremove_2 FAILED\n");
19369 printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
19370 if (test_mount_ro_0 () == -1) {
19371 printf ("test_mount_ro_0 FAILED\n");
19375 printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
19376 if (test_mount_ro_1 () == -1) {
19377 printf ("test_mount_ro_1 FAILED\n");
19381 printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
19382 if (test_tgz_in_0 () == -1) {
19383 printf ("test_tgz_in_0 FAILED\n");
19387 printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
19388 if (test_tar_in_0 () == -1) {
19389 printf ("test_tar_in_0 FAILED\n");
19393 printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
19394 if (test_checksum_0 () == -1) {
19395 printf ("test_checksum_0 FAILED\n");
19399 printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
19400 if (test_checksum_1 () == -1) {
19401 printf ("test_checksum_1 FAILED\n");
19405 printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
19406 if (test_checksum_2 () == -1) {
19407 printf ("test_checksum_2 FAILED\n");
19411 printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
19412 if (test_checksum_3 () == -1) {
19413 printf ("test_checksum_3 FAILED\n");
19417 printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
19418 if (test_checksum_4 () == -1) {
19419 printf ("test_checksum_4 FAILED\n");
19423 printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
19424 if (test_checksum_5 () == -1) {
19425 printf ("test_checksum_5 FAILED\n");
19429 printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
19430 if (test_checksum_6 () == -1) {
19431 printf ("test_checksum_6 FAILED\n");
19435 printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
19436 if (test_checksum_7 () == -1) {
19437 printf ("test_checksum_7 FAILED\n");
19441 printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
19442 if (test_checksum_8 () == -1) {
19443 printf ("test_checksum_8 FAILED\n");
19447 printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
19448 if (test_download_0 () == -1) {
19449 printf ("test_download_0 FAILED\n");
19453 printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
19454 if (test_upload_0 () == -1) {
19455 printf ("test_upload_0 FAILED\n");
19459 printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
19460 if (test_blockdev_rereadpt_0 () == -1) {
19461 printf ("test_blockdev_rereadpt_0 FAILED\n");
19465 printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
19466 if (test_blockdev_flushbufs_0 () == -1) {
19467 printf ("test_blockdev_flushbufs_0 FAILED\n");
19471 printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
19472 if (test_blockdev_getsize64_0 () == -1) {
19473 printf ("test_blockdev_getsize64_0 FAILED\n");
19477 printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
19478 if (test_blockdev_getsz_0 () == -1) {
19479 printf ("test_blockdev_getsz_0 FAILED\n");
19483 printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
19484 if (test_blockdev_getbsz_0 () == -1) {
19485 printf ("test_blockdev_getbsz_0 FAILED\n");
19489 printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
19490 if (test_blockdev_getss_0 () == -1) {
19491 printf ("test_blockdev_getss_0 FAILED\n");
19495 printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
19496 if (test_blockdev_getro_0 () == -1) {
19497 printf ("test_blockdev_getro_0 FAILED\n");
19501 printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
19502 if (test_blockdev_setrw_0 () == -1) {
19503 printf ("test_blockdev_setrw_0 FAILED\n");
19507 printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
19508 if (test_blockdev_setro_0 () == -1) {
19509 printf ("test_blockdev_setro_0 FAILED\n");
19513 printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
19514 if (test_statvfs_0 () == -1) {
19515 printf ("test_statvfs_0 FAILED\n");
19519 printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
19520 if (test_lstat_0 () == -1) {
19521 printf ("test_lstat_0 FAILED\n");
19525 printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
19526 if (test_stat_0 () == -1) {
19527 printf ("test_stat_0 FAILED\n");
19531 printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
19532 if (test_command_lines_0 () == -1) {
19533 printf ("test_command_lines_0 FAILED\n");
19537 printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
19538 if (test_command_lines_1 () == -1) {
19539 printf ("test_command_lines_1 FAILED\n");
19543 printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
19544 if (test_command_lines_2 () == -1) {
19545 printf ("test_command_lines_2 FAILED\n");
19549 printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
19550 if (test_command_lines_3 () == -1) {
19551 printf ("test_command_lines_3 FAILED\n");
19555 printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
19556 if (test_command_lines_4 () == -1) {
19557 printf ("test_command_lines_4 FAILED\n");
19561 printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
19562 if (test_command_lines_5 () == -1) {
19563 printf ("test_command_lines_5 FAILED\n");
19567 printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
19568 if (test_command_lines_6 () == -1) {
19569 printf ("test_command_lines_6 FAILED\n");
19573 printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
19574 if (test_command_lines_7 () == -1) {
19575 printf ("test_command_lines_7 FAILED\n");
19579 printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
19580 if (test_command_lines_8 () == -1) {
19581 printf ("test_command_lines_8 FAILED\n");
19585 printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
19586 if (test_command_lines_9 () == -1) {
19587 printf ("test_command_lines_9 FAILED\n");
19591 printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
19592 if (test_command_lines_10 () == -1) {
19593 printf ("test_command_lines_10 FAILED\n");
19597 printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
19598 if (test_command_0 () == -1) {
19599 printf ("test_command_0 FAILED\n");
19603 printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
19604 if (test_command_1 () == -1) {
19605 printf ("test_command_1 FAILED\n");
19609 printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
19610 if (test_command_2 () == -1) {
19611 printf ("test_command_2 FAILED\n");
19615 printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
19616 if (test_command_3 () == -1) {
19617 printf ("test_command_3 FAILED\n");
19621 printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
19622 if (test_command_4 () == -1) {
19623 printf ("test_command_4 FAILED\n");
19627 printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
19628 if (test_command_5 () == -1) {
19629 printf ("test_command_5 FAILED\n");
19633 printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
19634 if (test_command_6 () == -1) {
19635 printf ("test_command_6 FAILED\n");
19639 printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
19640 if (test_command_7 () == -1) {
19641 printf ("test_command_7 FAILED\n");
19645 printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
19646 if (test_command_8 () == -1) {
19647 printf ("test_command_8 FAILED\n");
19651 printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
19652 if (test_command_9 () == -1) {
19653 printf ("test_command_9 FAILED\n");
19657 printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
19658 if (test_command_10 () == -1) {
19659 printf ("test_command_10 FAILED\n");
19663 printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
19664 if (test_command_11 () == -1) {
19665 printf ("test_command_11 FAILED\n");
19669 printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
19670 if (test_file_0 () == -1) {
19671 printf ("test_file_0 FAILED\n");
19675 printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
19676 if (test_file_1 () == -1) {
19677 printf ("test_file_1 FAILED\n");
19681 printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
19682 if (test_file_2 () == -1) {
19683 printf ("test_file_2 FAILED\n");
19687 printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
19688 if (test_umount_all_0 () == -1) {
19689 printf ("test_umount_all_0 FAILED\n");
19693 printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
19694 if (test_umount_all_1 () == -1) {
19695 printf ("test_umount_all_1 FAILED\n");
19699 printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
19700 if (test_mounts_0 () == -1) {
19701 printf ("test_mounts_0 FAILED\n");
19705 printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
19706 if (test_umount_0 () == -1) {
19707 printf ("test_umount_0 FAILED\n");
19711 printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
19712 if (test_umount_1 () == -1) {
19713 printf ("test_umount_1 FAILED\n");
19717 printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
19718 if (test_write_file_0 () == -1) {
19719 printf ("test_write_file_0 FAILED\n");
19723 printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
19724 if (test_write_file_1 () == -1) {
19725 printf ("test_write_file_1 FAILED\n");
19729 printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
19730 if (test_write_file_2 () == -1) {
19731 printf ("test_write_file_2 FAILED\n");
19735 printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
19736 if (test_write_file_3 () == -1) {
19737 printf ("test_write_file_3 FAILED\n");
19741 printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
19742 if (test_write_file_4 () == -1) {
19743 printf ("test_write_file_4 FAILED\n");
19747 printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
19748 if (test_write_file_5 () == -1) {
19749 printf ("test_write_file_5 FAILED\n");
19753 printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
19754 if (test_mkfs_0 () == -1) {
19755 printf ("test_mkfs_0 FAILED\n");
19759 printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
19760 if (test_lvcreate_0 () == -1) {
19761 printf ("test_lvcreate_0 FAILED\n");
19765 printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
19766 if (test_vgcreate_0 () == -1) {
19767 printf ("test_vgcreate_0 FAILED\n");
19771 printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
19772 if (test_pvcreate_0 () == -1) {
19773 printf ("test_pvcreate_0 FAILED\n");
19777 printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
19778 if (test_is_dir_0 () == -1) {
19779 printf ("test_is_dir_0 FAILED\n");
19783 printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
19784 if (test_is_dir_1 () == -1) {
19785 printf ("test_is_dir_1 FAILED\n");
19789 printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
19790 if (test_is_file_0 () == -1) {
19791 printf ("test_is_file_0 FAILED\n");
19795 printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
19796 if (test_is_file_1 () == -1) {
19797 printf ("test_is_file_1 FAILED\n");
19801 printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
19802 if (test_exists_0 () == -1) {
19803 printf ("test_exists_0 FAILED\n");
19807 printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
19808 if (test_exists_1 () == -1) {
19809 printf ("test_exists_1 FAILED\n");
19813 printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
19814 if (test_mkdir_p_0 () == -1) {
19815 printf ("test_mkdir_p_0 FAILED\n");
19819 printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
19820 if (test_mkdir_p_1 () == -1) {
19821 printf ("test_mkdir_p_1 FAILED\n");
19825 printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
19826 if (test_mkdir_p_2 () == -1) {
19827 printf ("test_mkdir_p_2 FAILED\n");
19831 printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
19832 if (test_mkdir_p_3 () == -1) {
19833 printf ("test_mkdir_p_3 FAILED\n");
19837 printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
19838 if (test_mkdir_p_4 () == -1) {
19839 printf ("test_mkdir_p_4 FAILED\n");
19843 printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
19844 if (test_mkdir_0 () == -1) {
19845 printf ("test_mkdir_0 FAILED\n");
19849 printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
19850 if (test_mkdir_1 () == -1) {
19851 printf ("test_mkdir_1 FAILED\n");
19855 printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
19856 if (test_rm_rf_0 () == -1) {
19857 printf ("test_rm_rf_0 FAILED\n");
19861 printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
19862 if (test_rmdir_0 () == -1) {
19863 printf ("test_rmdir_0 FAILED\n");
19867 printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
19868 if (test_rmdir_1 () == -1) {
19869 printf ("test_rmdir_1 FAILED\n");
19873 printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
19874 if (test_rmdir_2 () == -1) {
19875 printf ("test_rmdir_2 FAILED\n");
19879 printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
19880 if (test_rm_0 () == -1) {
19881 printf ("test_rm_0 FAILED\n");
19885 printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
19886 if (test_rm_1 () == -1) {
19887 printf ("test_rm_1 FAILED\n");
19891 printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
19892 if (test_rm_2 () == -1) {
19893 printf ("test_rm_2 FAILED\n");
19897 printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
19898 if (test_read_lines_0 () == -1) {
19899 printf ("test_read_lines_0 FAILED\n");
19903 printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
19904 if (test_read_lines_1 () == -1) {
19905 printf ("test_read_lines_1 FAILED\n");
19909 printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
19910 if (test_lvs_0 () == -1) {
19911 printf ("test_lvs_0 FAILED\n");
19915 printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
19916 if (test_lvs_1 () == -1) {
19917 printf ("test_lvs_1 FAILED\n");
19921 printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
19922 if (test_vgs_0 () == -1) {
19923 printf ("test_vgs_0 FAILED\n");
19927 printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
19928 if (test_vgs_1 () == -1) {
19929 printf ("test_vgs_1 FAILED\n");
19933 printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
19934 if (test_pvs_0 () == -1) {
19935 printf ("test_pvs_0 FAILED\n");
19939 printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
19940 if (test_pvs_1 () == -1) {
19941 printf ("test_pvs_1 FAILED\n");
19945 printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
19946 if (test_list_partitions_0 () == -1) {
19947 printf ("test_list_partitions_0 FAILED\n");
19951 printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
19952 if (test_list_partitions_1 () == -1) {
19953 printf ("test_list_partitions_1 FAILED\n");
19957 printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
19958 if (test_list_devices_0 () == -1) {
19959 printf ("test_list_devices_0 FAILED\n");
19963 printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
19964 if (test_ls_0 () == -1) {
19965 printf ("test_ls_0 FAILED\n");
19969 printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
19970 if (test_cat_0 () == -1) {
19971 printf ("test_cat_0 FAILED\n");
19975 printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
19976 if (test_touch_0 () == -1) {
19977 printf ("test_touch_0 FAILED\n");
19981 printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
19982 if (test_sync_0 () == -1) {
19983 printf ("test_sync_0 FAILED\n");
19987 printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
19988 if (test_mount_0 () == -1) {
19989 printf ("test_mount_0 FAILED\n");
19994 unlink ("test1.img");
19995 unlink ("test2.img");
19996 unlink ("test3.img");
19999 printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);