X-Git-Url: http://git.annexia.org/?p=libguestfs.git;a=blobdiff_plain;f=capitests%2Ftests.c;h=f1a450b03a838a4dfab85a2e34c577e86ace68ea;hp=5b6356f471651dcae11a7fe1de2d7d424e1518e2;hb=da8ddb2745c3d53c36e3ad7f09836a4c27a4d3e6;hpb=e02066bcb33a2aed5f23dd18c3168dc66efddb18 diff --git a/capitests/tests.c b/capitests/tests.c index 5b6356f..f1a450b 100644 --- a/capitests/tests.c +++ b/capitests/tests.c @@ -31,11 +31,6 @@ static guestfs_h *g; static int suppress_error = 0; -/* This will be 's' or 'h' depending on whether the guest kernel - * names IDE devices /dev/sd* or /dev/hd*. - */ -static char devchar = 's'; - static void print_error (guestfs_h *g, void *data, const char *msg) { if (!suppress_error) @@ -94,6 +89,7 @@ static void no_test_warnings (void) fprintf (stderr, "warning: \"guestfs_kill_subprocess\" has no tests\n"); fprintf (stderr, "warning: \"guestfs_add_drive\" has no tests\n"); fprintf (stderr, "warning: \"guestfs_add_cdrom\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_add_drive_ro\" has no tests\n"); fprintf (stderr, "warning: \"guestfs_config\" has no tests\n"); fprintf (stderr, "warning: \"guestfs_set_qemu\" has no tests\n"); fprintf (stderr, "warning: \"guestfs_get_qemu\" has no tests\n"); @@ -152,12 +148,2905 @@ static void no_test_warnings (void) fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n"); fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n"); fprintf (stderr, "warning: \"guestfs_e2fsck_f\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_sh\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_sh_lines\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_scrub_freespace\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_df\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_df_h\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_mount_loop\" has no tests\n"); +} + +static int test_mkswap_U_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mkswap_U") == NULL; + str = getenv ("SKIP_TEST_MKSWAP_U_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_MKSWAP_U"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_mkswap_U_0 (void) +{ + if (test_mkswap_U_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_mkswap_U_0"); + return 0; + } + + /* InitNone|InitEmpty for test_mkswap_U_0 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + /* TestRun for mkswap_U (0) */ + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkswap_U (g, uuid, device); + if (r == -1) + return -1; + } + return 0; +} + +static int test_mkswap_L_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mkswap_L") == NULL; + str = getenv ("SKIP_TEST_MKSWAP_L_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_MKSWAP_L"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_mkswap_L_0 (void) +{ + if (test_mkswap_L_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_mkswap_L_0"); + return 0; + } + + /* InitNone|InitEmpty for test_mkswap_L_0 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + /* TestRun for mkswap_L (0) */ + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char label[] = "hello"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkswap_L (g, label, device); + if (r == -1) + return -1; + } + return 0; +} + +static int test_mkswap_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mkswap") == NULL; + str = getenv ("SKIP_TEST_MKSWAP_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_MKSWAP"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_mkswap_0 (void) +{ + if (test_mkswap_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_mkswap_0"); + return 0; + } + + /* InitNone|InitEmpty for test_mkswap_0 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + /* TestRun for mkswap (0) */ + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkswap (g, device); + if (r == -1) + return -1; + } + return 0; +} + +static int test_initrd_list_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "initrd_list") == NULL; + str = getenv ("SKIP_TEST_INITRD_LIST_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_INITRD_LIST"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_initrd_list_0 (void) +{ + if (test_initrd_list_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_initrd_list_0"); + return 0; + } + + /* InitBasicFS for test_initrd_list_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for initrd_list (0) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/initrd"; + char **r; + int i; + suppress_error = 0; + r = guestfs_initrd_list (g, path); + if (r == NULL) + return -1; + if (!r[0]) { + fprintf (stderr, "test_initrd_list_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "empty"; + if (strcmp (r[0], expected) != 0) { + fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[0]); + return -1; + } + } + if (!r[1]) { + fprintf (stderr, "test_initrd_list_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "known-1"; + if (strcmp (r[1], expected) != 0) { + fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[1]); + return -1; + } + } + if (!r[2]) { + fprintf (stderr, "test_initrd_list_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "known-2"; + if (strcmp (r[2], expected) != 0) { + fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[2]); + return -1; + } + } + if (!r[3]) { + fprintf (stderr, "test_initrd_list_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "known-3"; + if (strcmp (r[3], expected) != 0) { + fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[3]); + return -1; + } + } + if (r[4] != NULL) { + fprintf (stderr, "test_initrd_list_0: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_du_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "du") == NULL; + str = getenv ("SKIP_TEST_DU_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_DU"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_du_0 (void) +{ + if (test_du_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_du_0"); + return 0; + } + + /* InitBasicFS for test_du_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputInt for du (0) */ + { + char path[] = "/p"; + int r; + suppress_error = 0; + r = guestfs_mkdir (g, path); + if (r == -1) + return -1; + } + { + char path[] = "/p"; + int64_t r; + suppress_error = 0; + r = guestfs_du (g, path); + if (r == -1) + return -1; + if (r != 1) { + fprintf (stderr, "test_du_0: expected 1 but got %d\n", (int) r); + return -1; + } + } + return 0; +} + +static int test_tail_n_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "tail_n") == NULL; + str = getenv ("SKIP_TEST_TAIL_N_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_TAIL_N"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_tail_n_0 (void) +{ + if (test_tail_n_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_0"); + return 0; + } + + /* InitBasicFS for test_tail_n_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for tail_n (0) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/10klines"; + char **r; + int i; + suppress_error = 0; + r = guestfs_tail_n (g, 3, path); + if (r == NULL) + return -1; + if (!r[0]) { + fprintf (stderr, "test_tail_n_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9997abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[0], expected) != 0) { + fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]); + return -1; + } + } + if (!r[1]) { + fprintf (stderr, "test_tail_n_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9998abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[1], expected) != 0) { + fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]); + return -1; + } + } + if (!r[2]) { + fprintf (stderr, "test_tail_n_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9999abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[2], expected) != 0) { + fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]); + return -1; + } + } + if (r[3] != NULL) { + fprintf (stderr, "test_tail_n_0: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_tail_n_1_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "tail_n") == NULL; + str = getenv ("SKIP_TEST_TAIL_N_1"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_TAIL_N"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_tail_n_1 (void) +{ + if (test_tail_n_1_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_1"); + return 0; + } + + /* InitBasicFS for test_tail_n_1: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for tail_n (1) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/10klines"; + char **r; + int i; + suppress_error = 0; + r = guestfs_tail_n (g, -9998, path); + if (r == NULL) + return -1; + if (!r[0]) { + fprintf (stderr, "test_tail_n_1: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9997abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[0], expected) != 0) { + fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]); + return -1; + } + } + if (!r[1]) { + fprintf (stderr, "test_tail_n_1: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9998abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[1], expected) != 0) { + fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]); + return -1; + } + } + if (!r[2]) { + fprintf (stderr, "test_tail_n_1: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9999abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[2], expected) != 0) { + fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]); + return -1; + } + } + if (r[3] != NULL) { + fprintf (stderr, "test_tail_n_1: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_tail_n_2_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "tail_n") == NULL; + str = getenv ("SKIP_TEST_TAIL_N_2"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_TAIL_N"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_tail_n_2 (void) +{ + if (test_tail_n_2_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_2"); + return 0; + } + + /* InitBasicFS for test_tail_n_2: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for tail_n (2) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/10klines"; + char **r; + int i; + suppress_error = 0; + r = guestfs_tail_n (g, 0, path); + if (r == NULL) + return -1; + if (r[0] != NULL) { + fprintf (stderr, "test_tail_n_2: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_tail_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "tail") == NULL; + str = getenv ("SKIP_TEST_TAIL_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_TAIL"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_tail_0 (void) +{ + if (test_tail_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_tail_0"); + return 0; + } + + /* InitBasicFS for test_tail_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for tail (0) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/10klines"; + char **r; + int i; + suppress_error = 0; + r = guestfs_tail (g, path); + if (r == NULL) + return -1; + if (!r[0]) { + fprintf (stderr, "test_tail_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9990abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[0], expected) != 0) { + fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[0]); + return -1; + } + } + if (!r[1]) { + fprintf (stderr, "test_tail_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9991abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[1], expected) != 0) { + fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[1]); + return -1; + } + } + if (!r[2]) { + fprintf (stderr, "test_tail_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9992abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[2], expected) != 0) { + fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[2]); + return -1; + } + } + if (!r[3]) { + fprintf (stderr, "test_tail_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9993abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[3], expected) != 0) { + fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[3]); + return -1; + } + } + if (!r[4]) { + fprintf (stderr, "test_tail_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9994abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[4], expected) != 0) { + fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[4]); + return -1; + } + } + if (!r[5]) { + fprintf (stderr, "test_tail_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9995abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[5], expected) != 0) { + fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[5]); + return -1; + } + } + if (!r[6]) { + fprintf (stderr, "test_tail_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9996abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[6], expected) != 0) { + fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[6]); + return -1; + } + } + if (!r[7]) { + fprintf (stderr, "test_tail_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9997abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[7], expected) != 0) { + fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[7]); + return -1; + } + } + if (!r[8]) { + fprintf (stderr, "test_tail_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9998abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[8], expected) != 0) { + fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[8]); + return -1; + } + } + if (!r[9]) { + fprintf (stderr, "test_tail_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9999abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[9], expected) != 0) { + fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[9]); + return -1; + } + } + if (r[10] != NULL) { + fprintf (stderr, "test_tail_0: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_head_n_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "head_n") == NULL; + str = getenv ("SKIP_TEST_HEAD_N_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_HEAD_N"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_head_n_0 (void) +{ + if (test_head_n_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_head_n_0"); + return 0; + } + + /* InitBasicFS for test_head_n_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for head_n (0) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/10klines"; + char **r; + int i; + suppress_error = 0; + r = guestfs_head_n (g, 3, path); + if (r == NULL) + return -1; + if (!r[0]) { + fprintf (stderr, "test_head_n_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "0abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[0], expected) != 0) { + fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]); + return -1; + } + } + if (!r[1]) { + fprintf (stderr, "test_head_n_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "1abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[1], expected) != 0) { + fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]); + return -1; + } + } + if (!r[2]) { + fprintf (stderr, "test_head_n_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "2abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[2], expected) != 0) { + fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]); + return -1; + } + } + if (r[3] != NULL) { + fprintf (stderr, "test_head_n_0: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_head_n_1_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "head_n") == NULL; + str = getenv ("SKIP_TEST_HEAD_N_1"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_HEAD_N"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_head_n_1 (void) +{ + if (test_head_n_1_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_head_n_1"); + return 0; + } + + /* InitBasicFS for test_head_n_1: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for head_n (1) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/10klines"; + char **r; + int i; + suppress_error = 0; + r = guestfs_head_n (g, -9997, path); + if (r == NULL) + return -1; + if (!r[0]) { + fprintf (stderr, "test_head_n_1: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "0abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[0], expected) != 0) { + fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]); + return -1; + } + } + if (!r[1]) { + fprintf (stderr, "test_head_n_1: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "1abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[1], expected) != 0) { + fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]); + return -1; + } + } + if (!r[2]) { + fprintf (stderr, "test_head_n_1: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "2abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[2], expected) != 0) { + fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]); + return -1; + } + } + if (r[3] != NULL) { + fprintf (stderr, "test_head_n_1: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_head_n_2_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "head_n") == NULL; + str = getenv ("SKIP_TEST_HEAD_N_2"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_HEAD_N"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_head_n_2 (void) +{ + if (test_head_n_2_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_head_n_2"); + return 0; + } + + /* InitBasicFS for test_head_n_2: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for head_n (2) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/10klines"; + char **r; + int i; + suppress_error = 0; + r = guestfs_head_n (g, 0, path); + if (r == NULL) + return -1; + if (r[0] != NULL) { + fprintf (stderr, "test_head_n_2: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_head_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "head") == NULL; + str = getenv ("SKIP_TEST_HEAD_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_HEAD"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_head_0 (void) +{ + if (test_head_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_head_0"); + return 0; + } + + /* InitBasicFS for test_head_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for head (0) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/10klines"; + char **r; + int i; + suppress_error = 0; + r = guestfs_head (g, path); + if (r == NULL) + return -1; + if (!r[0]) { + fprintf (stderr, "test_head_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "0abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[0], expected) != 0) { + fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[0]); + return -1; + } + } + if (!r[1]) { + fprintf (stderr, "test_head_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "1abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[1], expected) != 0) { + fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[1]); + return -1; + } + } + if (!r[2]) { + fprintf (stderr, "test_head_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "2abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[2], expected) != 0) { + fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[2]); + return -1; + } + } + if (!r[3]) { + fprintf (stderr, "test_head_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "3abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[3], expected) != 0) { + fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[3]); + return -1; + } + } + if (!r[4]) { + fprintf (stderr, "test_head_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "4abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[4], expected) != 0) { + fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[4]); + return -1; + } + } + if (!r[5]) { + fprintf (stderr, "test_head_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "5abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[5], expected) != 0) { + fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[5]); + return -1; + } + } + if (!r[6]) { + fprintf (stderr, "test_head_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "6abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[6], expected) != 0) { + fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[6]); + return -1; + } + } + if (!r[7]) { + fprintf (stderr, "test_head_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "7abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[7], expected) != 0) { + fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[7]); + return -1; + } + } + if (!r[8]) { + fprintf (stderr, "test_head_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "8abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[8], expected) != 0) { + fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[8]); + return -1; + } + } + if (!r[9]) { + fprintf (stderr, "test_head_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[9], expected) != 0) { + fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[9]); + return -1; + } + } + if (r[10] != NULL) { + fprintf (stderr, "test_head_0: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_wc_c_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "wc_c") == NULL; + str = getenv ("SKIP_TEST_WC_C_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_WC_C"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_wc_c_0 (void) +{ + if (test_wc_c_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_wc_c_0"); + return 0; + } + + /* InitBasicFS for test_wc_c_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputInt for wc_c (0) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/100kallspaces"; + int r; + suppress_error = 0; + r = guestfs_wc_c (g, path); + if (r == -1) + return -1; + if (r != 102400) { + fprintf (stderr, "test_wc_c_0: expected 102400 but got %d\n", (int) r); + return -1; + } + } + return 0; +} + +static int test_wc_w_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "wc_w") == NULL; + str = getenv ("SKIP_TEST_WC_W_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_WC_W"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_wc_w_0 (void) +{ + if (test_wc_w_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_wc_w_0"); + return 0; + } + + /* InitBasicFS for test_wc_w_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputInt for wc_w (0) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/10klines"; + int r; + suppress_error = 0; + r = guestfs_wc_w (g, path); + if (r == -1) + return -1; + if (r != 10000) { + fprintf (stderr, "test_wc_w_0: expected 10000 but got %d\n", (int) r); + return -1; + } + } + return 0; +} + +static int test_wc_l_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "wc_l") == NULL; + str = getenv ("SKIP_TEST_WC_L_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_WC_L"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_wc_l_0 (void) +{ + if (test_wc_l_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_wc_l_0"); + return 0; + } + + /* InitBasicFS for test_wc_l_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputInt for wc_l (0) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/10klines"; + int r; + suppress_error = 0; + r = guestfs_wc_l (g, path); + if (r == -1) + return -1; + if (r != 10000) { + fprintf (stderr, "test_wc_l_0: expected 10000 but got %d\n", (int) r); + return -1; + } + } + return 0; +} + +static int test_mkdtemp_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mkdtemp") == NULL; + str = getenv ("SKIP_TEST_MKDTEMP_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_MKDTEMP"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_mkdtemp_0 (void) +{ + if (test_mkdtemp_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_mkdtemp_0"); + return 0; + } + + /* InitBasicFS for test_mkdtemp_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestRun for mkdtemp (0) */ + { + char path[] = "/tmp"; + int r; + suppress_error = 0; + r = guestfs_mkdir (g, path); + if (r == -1) + return -1; + } + { + char template[] = "/tmp/tmpXXXXXX"; + char *r; + suppress_error = 0; + r = guestfs_mkdtemp (g, template); + if (r == NULL) + return -1; + free (r); + } + return 0; +} + +static int test_scrub_file_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "scrub_file") == NULL; + str = getenv ("SKIP_TEST_SCRUB_FILE_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_SCRUB_FILE"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_scrub_file_0 (void) +{ + if (test_scrub_file_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_scrub_file_0"); + return 0; + } + + /* InitBasicFS for test_scrub_file_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestRun for scrub_file (0) */ + { + char path[] = "/file"; + char content[] = "content"; + int r; + suppress_error = 0; + r = guestfs_write_file (g, path, content, 0); + if (r == -1) + return -1; + } + { + char file[] = "/file"; + int r; + suppress_error = 0; + r = guestfs_scrub_file (g, file); + if (r == -1) + return -1; + } + return 0; +} + +static int test_scrub_device_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "scrub_device") == NULL; + str = getenv ("SKIP_TEST_SCRUB_DEVICE_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_SCRUB_DEVICE"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_scrub_device_0 (void) +{ + if (test_scrub_device_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_scrub_device_0"); + return 0; + } + + /* InitNone|InitEmpty for test_scrub_device_0 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + /* TestRun for scrub_device (0) */ + { + char device[] = "/dev/sdc"; + int r; + suppress_error = 0; + r = guestfs_scrub_device (g, device); + if (r == -1) + return -1; + } + return 0; +} + +static int test_glob_expand_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "glob_expand") == NULL; + str = getenv ("SKIP_TEST_GLOB_EXPAND_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_GLOB_EXPAND"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_glob_expand_0 (void) +{ + if (test_glob_expand_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_0"); + return 0; + } + + /* InitBasicFS for test_glob_expand_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for glob_expand (0) */ + { + char path[] = "/a/b/c"; + int r; + suppress_error = 0; + r = guestfs_mkdir_p (g, path); + if (r == -1) + return -1; + } + { + char path[] = "/a/b/c/d"; + int r; + suppress_error = 0; + r = guestfs_touch (g, path); + if (r == -1) + return -1; + } + { + char path[] = "/a/b/c/e"; + int r; + suppress_error = 0; + r = guestfs_touch (g, path); + if (r == -1) + return -1; + } + { + char pattern[] = "/a/b/c/*"; + char **r; + int i; + suppress_error = 0; + r = guestfs_glob_expand (g, pattern); + if (r == NULL) + return -1; + if (!r[0]) { + fprintf (stderr, "test_glob_expand_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "/a/b/c/d"; + if (strcmp (r[0], expected) != 0) { + fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[0]); + return -1; + } + } + if (!r[1]) { + fprintf (stderr, "test_glob_expand_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "/a/b/c/e"; + if (strcmp (r[1], expected) != 0) { + fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[1]); + return -1; + } + } + if (r[2] != NULL) { + fprintf (stderr, "test_glob_expand_0: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_glob_expand_1_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "glob_expand") == NULL; + str = getenv ("SKIP_TEST_GLOB_EXPAND_1"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_GLOB_EXPAND"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_glob_expand_1 (void) +{ + if (test_glob_expand_1_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_1"); + return 0; + } + + /* InitBasicFS for test_glob_expand_1: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for glob_expand (1) */ + { + char path[] = "/a/b/c"; + int r; + suppress_error = 0; + r = guestfs_mkdir_p (g, path); + if (r == -1) + return -1; + } + { + char path[] = "/a/b/c/d"; + int r; + suppress_error = 0; + r = guestfs_touch (g, path); + if (r == -1) + return -1; + } + { + char path[] = "/a/b/c/e"; + int r; + suppress_error = 0; + r = guestfs_touch (g, path); + if (r == -1) + return -1; + } + { + char pattern[] = "/a/*/c/*"; + char **r; + int i; + suppress_error = 0; + r = guestfs_glob_expand (g, pattern); + if (r == NULL) + return -1; + if (!r[0]) { + fprintf (stderr, "test_glob_expand_1: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "/a/b/c/d"; + if (strcmp (r[0], expected) != 0) { + fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[0]); + return -1; + } + } + if (!r[1]) { + fprintf (stderr, "test_glob_expand_1: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "/a/b/c/e"; + if (strcmp (r[1], expected) != 0) { + fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[1]); + return -1; + } + } + if (r[2] != NULL) { + fprintf (stderr, "test_glob_expand_1: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_glob_expand_2_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "glob_expand") == NULL; + str = getenv ("SKIP_TEST_GLOB_EXPAND_2"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_GLOB_EXPAND"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_glob_expand_2 (void) +{ + if (test_glob_expand_2_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_2"); + return 0; + } + + /* InitBasicFS for test_glob_expand_2: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for glob_expand (2) */ + { + char path[] = "/a/b/c"; + int r; + suppress_error = 0; + r = guestfs_mkdir_p (g, path); + if (r == -1) + return -1; + } + { + char path[] = "/a/b/c/d"; + int r; + suppress_error = 0; + r = guestfs_touch (g, path); + if (r == -1) + return -1; + } + { + char path[] = "/a/b/c/e"; + int r; + suppress_error = 0; + r = guestfs_touch (g, path); + if (r == -1) + return -1; + } + { + char pattern[] = "/a/*/x/*"; + char **r; + int i; + suppress_error = 0; + r = guestfs_glob_expand (g, pattern); + if (r == NULL) + return -1; + if (r[0] != NULL) { + fprintf (stderr, "test_glob_expand_2: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_ntfs_3g_probe_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "ntfs_3g_probe") == NULL; + str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_NTFS_3G_PROBE"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_ntfs_3g_probe_0 (void) +{ + if (test_ntfs_3g_probe_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_0"); + return 0; + } + + /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + /* TestOutputInt for ntfs_3g_probe (0) */ + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ntfs"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_ntfs_3g_probe (g, 1, device); + if (r == -1) + return -1; + if (r != 0) { + fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n", (int) r); + return -1; + } + } + return 0; +} + +static int test_ntfs_3g_probe_1_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "ntfs_3g_probe") == NULL; + str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_NTFS_3G_PROBE"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_ntfs_3g_probe_1 (void) +{ + if (test_ntfs_3g_probe_1_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_1"); + return 0; + } + + /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + /* TestOutputInt for ntfs_3g_probe (1) */ + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_ntfs_3g_probe (g, 1, device); + if (r == -1) + return -1; + if (r != 12) { + fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n", (int) r); + return -1; + } + } + return 0; +} + +static int test_sleep_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "sleep") == NULL; + str = getenv ("SKIP_TEST_SLEEP_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_SLEEP"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_sleep_0 (void) +{ + if (test_sleep_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_sleep_0"); + return 0; + } + + /* InitNone|InitEmpty for test_sleep_0 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + /* TestRun for sleep (0) */ + { + int r; + suppress_error = 0; + r = guestfs_sleep (g, 1); + if (r == -1) + return -1; + } + return 0; } static int test_find_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "find") == NULL; str = getenv ("SKIP_TEST_FIND_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_FIND"); @@ -168,14 +3057,13 @@ static int test_find_0_skip (void) static int test_find_0 (void) { if (test_find_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_find_0"); return 0; } /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -198,7 +3086,6 @@ static int test_find_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -213,7 +3100,6 @@ static int test_find_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -222,7 +3108,6 @@ static int test_find_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -267,6 +3152,9 @@ static int test_find_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "find") == NULL; str = getenv ("SKIP_TEST_FIND_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_FIND"); @@ -277,14 +3165,13 @@ static int test_find_1_skip (void) static int test_find_1 (void) { if (test_find_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_find_1"); return 0; } /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -307,7 +3194,6 @@ static int test_find_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -322,7 +3208,6 @@ static int test_find_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -331,7 +3216,6 @@ static int test_find_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -436,6 +3320,9 @@ static int test_find_2_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "find") == NULL; str = getenv ("SKIP_TEST_FIND_2"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_FIND"); @@ -446,14 +3333,13 @@ static int test_find_2_skip (void) static int test_find_2 (void) { if (test_find_2_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_2"); + printf ("%s skipped (reason: environment variable set)\n", "test_find_2"); return 0; } /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -476,7 +3362,6 @@ static int test_find_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -491,7 +3376,6 @@ static int test_find_2 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -500,7 +3384,6 @@ static int test_find_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -573,6 +3456,9 @@ static int test_lvresize_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "lvresize") == NULL; str = getenv ("SKIP_TEST_LVRESIZE_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_LVRESIZE"); @@ -583,14 +3469,13 @@ static int test_lvresize_0_skip (void) static int test_lvresize_0 (void) { if (test_lvresize_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvresize_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_lvresize_0"); return 0; } /* InitNone|InitEmpty for test_lvresize_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -615,7 +3500,6 @@ static int test_lvresize_0 (void) char expected[] = "test content"; { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -629,7 +3513,6 @@ static int test_lvresize_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -639,7 +3522,6 @@ static int test_lvresize_0 (void) { char volgroup[] = "VG"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -747,6 +3629,9 @@ static int test_zerofree_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "zerofree") == NULL; str = getenv ("SKIP_TEST_ZEROFREE_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_ZEROFREE"); @@ -757,14 +3642,13 @@ static int test_zerofree_0_skip (void) static int test_zerofree_0 (void) { if (test_zerofree_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zerofree_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_zerofree_0"); return 0; } /* InitNone|InitEmpty for test_zerofree_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -789,7 +3673,6 @@ static int test_zerofree_0 (void) char expected[] = "test file"; { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -804,7 +3687,6 @@ static int test_zerofree_0 (void) { char fstype[] = "ext3"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -813,7 +3695,6 @@ static int test_zerofree_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -832,7 +3713,6 @@ static int test_zerofree_0 (void) } { char pathordevice[] = "/dev/sda1"; - pathordevice[5] = devchar; int r; suppress_error = 0; r = guestfs_umount (g, pathordevice); @@ -841,7 +3721,6 @@ static int test_zerofree_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_zerofree (g, device); @@ -850,7 +3729,6 @@ static int test_zerofree_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -878,6 +3756,9 @@ static int test_hexdump_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "hexdump") == NULL; str = getenv ("SKIP_TEST_HEXDUMP_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_HEXDUMP"); @@ -888,14 +3769,13 @@ static int test_hexdump_0_skip (void) static int test_hexdump_0 (void) { if (test_hexdump_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_hexdump_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_0"); return 0; } /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -918,7 +3798,6 @@ static int test_hexdump_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -933,7 +3812,6 @@ static int test_hexdump_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -942,7 +3820,6 @@ static int test_hexdump_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -977,10 +3854,112 @@ static int test_hexdump_0 (void) return 0; } +static int test_hexdump_1_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "hexdump") == NULL; + str = getenv ("SKIP_TEST_HEXDUMP_1"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_HEXDUMP"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_hexdump_1 (void) +{ + if (test_hexdump_1_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_1"); + return 0; + } + + /* InitBasicFS for test_hexdump_1: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestRun for hexdump (1) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/100krandom"; + char *r; + suppress_error = 0; + r = guestfs_hexdump (g, path); + if (r == NULL) + return -1; + free (r); + } + return 0; +} + static int test_strings_e_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "strings_e") == NULL; str = getenv ("SKIP_TEST_STRINGS_E_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_STRINGS_E"); @@ -991,14 +3970,13 @@ static int test_strings_e_0_skip (void) static int test_strings_e_0 (void) { if (test_strings_e_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_0"); return 0; } /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -1021,7 +3999,6 @@ static int test_strings_e_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -1036,7 +4013,6 @@ static int test_strings_e_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -1045,7 +4021,6 @@ static int test_strings_e_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -1088,6 +4063,9 @@ static int test_strings_e_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "strings_e") == NULL; str = getenv ("SKIP_TEST_STRINGS_E_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_STRINGS_E"); @@ -1098,7 +4076,7 @@ static int test_strings_e_1_skip (void) static int test_strings_e_1 (void) { if (test_strings_e_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_1"); return 0; } @@ -1110,6 +4088,9 @@ static int test_strings_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "strings") == NULL; str = getenv ("SKIP_TEST_STRINGS_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_STRINGS"); @@ -1120,14 +4101,13 @@ static int test_strings_0_skip (void) static int test_strings_0 (void) { if (test_strings_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_strings_0"); return 0; } /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -1150,7 +4130,6 @@ static int test_strings_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -1165,7 +4144,6 @@ static int test_strings_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -1174,7 +4152,6 @@ static int test_strings_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -1240,6 +4217,9 @@ static int test_strings_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "strings") == NULL; str = getenv ("SKIP_TEST_STRINGS_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_STRINGS"); @@ -1250,14 +4230,13 @@ static int test_strings_1_skip (void) static int test_strings_1 (void) { if (test_strings_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_strings_1"); return 0; } /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -1280,7 +4259,6 @@ static int test_strings_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -1295,7 +4273,6 @@ static int test_strings_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -1304,7 +4281,6 @@ static int test_strings_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -1345,6 +4321,9 @@ static int test_equal_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "equal") == NULL; str = getenv ("SKIP_TEST_EQUAL_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_EQUAL"); @@ -1355,14 +4334,13 @@ static int test_equal_0_skip (void) static int test_equal_0 (void) { if (test_equal_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_equal_0"); return 0; } /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -1385,7 +4363,6 @@ static int test_equal_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -1400,7 +4377,6 @@ static int test_equal_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -1409,7 +4385,6 @@ static int test_equal_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -1456,6 +4431,9 @@ static int test_equal_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "equal") == NULL; str = getenv ("SKIP_TEST_EQUAL_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_EQUAL"); @@ -1466,14 +4444,13 @@ static int test_equal_1_skip (void) static int test_equal_1 (void) { if (test_equal_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_equal_1"); return 0; } /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -1496,7 +4473,6 @@ static int test_equal_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -1511,7 +4487,6 @@ static int test_equal_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -1520,7 +4495,6 @@ static int test_equal_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -1567,6 +4541,9 @@ static int test_equal_2_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "equal") == NULL; str = getenv ("SKIP_TEST_EQUAL_2"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_EQUAL"); @@ -1577,14 +4554,13 @@ static int test_equal_2_skip (void) static int test_equal_2 (void) { if (test_equal_2_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_2"); + printf ("%s skipped (reason: environment variable set)\n", "test_equal_2"); return 0; } /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -1607,7 +4583,6 @@ static int test_equal_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -1622,7 +4597,6 @@ static int test_equal_2 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -1631,7 +4605,6 @@ static int test_equal_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -1656,6 +4629,9 @@ static int test_ping_daemon_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "ping_daemon") == NULL; str = getenv ("SKIP_TEST_PING_DAEMON_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_PING_DAEMON"); @@ -1666,14 +4642,13 @@ static int test_ping_daemon_0_skip (void) static int test_ping_daemon_0 (void) { if (test_ping_daemon_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ping_daemon_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_ping_daemon_0"); return 0; } /* InitNone|InitEmpty for test_ping_daemon_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -1709,6 +4684,9 @@ static int test_dmesg_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "dmesg") == NULL; str = getenv ("SKIP_TEST_DMESG_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_DMESG"); @@ -1719,14 +4697,13 @@ static int test_dmesg_0_skip (void) static int test_dmesg_0 (void) { if (test_dmesg_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_dmesg_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_dmesg_0"); return 0; } /* InitNone|InitEmpty for test_dmesg_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -1763,6 +4740,9 @@ static int test_drop_caches_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "drop_caches") == NULL; str = getenv ("SKIP_TEST_DROP_CACHES_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_DROP_CACHES"); @@ -1773,14 +4753,13 @@ static int test_drop_caches_0_skip (void) static int test_drop_caches_0 (void) { if (test_drop_caches_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_drop_caches_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_drop_caches_0"); return 0; } /* InitNone|InitEmpty for test_drop_caches_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -1816,6 +4795,9 @@ static int test_mv_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mv") == NULL; str = getenv ("SKIP_TEST_MV_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_MV"); @@ -1826,14 +4808,13 @@ static int test_mv_0_skip (void) static int test_mv_0 (void) { if (test_mv_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_mv_0"); return 0; } /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -1856,7 +4837,6 @@ static int test_mv_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -1871,7 +4851,6 @@ static int test_mv_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -1880,7 +4859,6 @@ static int test_mv_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -1928,6 +4906,9 @@ static int test_mv_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mv") == NULL; str = getenv ("SKIP_TEST_MV_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_MV"); @@ -1938,14 +4919,13 @@ static int test_mv_1_skip (void) static int test_mv_1 (void) { if (test_mv_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_mv_1"); return 0; } /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -1968,7 +4948,6 @@ static int test_mv_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -1983,7 +4962,6 @@ static int test_mv_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -1992,7 +4970,6 @@ static int test_mv_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -2038,6 +5015,9 @@ static int test_cp_a_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "cp_a") == NULL; str = getenv ("SKIP_TEST_CP_A_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_CP_A"); @@ -2048,14 +5028,13 @@ static int test_cp_a_0_skip (void) static int test_cp_a_0 (void) { if (test_cp_a_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_a_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_cp_a_0"); return 0; } /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -2078,7 +5057,6 @@ static int test_cp_a_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -2093,7 +5071,6 @@ static int test_cp_a_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -2102,7 +5079,6 @@ static int test_cp_a_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -2166,6 +5142,9 @@ static int test_cp_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "cp") == NULL; str = getenv ("SKIP_TEST_CP_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_CP"); @@ -2176,14 +5155,13 @@ static int test_cp_0_skip (void) static int test_cp_0 (void) { if (test_cp_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_cp_0"); return 0; } /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -2206,7 +5184,6 @@ static int test_cp_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -2221,7 +5198,6 @@ static int test_cp_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -2230,7 +5206,6 @@ static int test_cp_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -2278,6 +5253,9 @@ static int test_cp_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "cp") == NULL; str = getenv ("SKIP_TEST_CP_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_CP"); @@ -2288,14 +5266,13 @@ static int test_cp_1_skip (void) static int test_cp_1 (void) { if (test_cp_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_cp_1"); return 0; } /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -2318,7 +5295,6 @@ static int test_cp_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -2333,7 +5309,6 @@ static int test_cp_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -2342,7 +5317,6 @@ static int test_cp_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -2388,6 +5362,9 @@ static int test_cp_2_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "cp") == NULL; str = getenv ("SKIP_TEST_CP_2"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_CP"); @@ -2398,14 +5375,13 @@ static int test_cp_2_skip (void) static int test_cp_2 (void) { if (test_cp_2_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_2"); + printf ("%s skipped (reason: environment variable set)\n", "test_cp_2"); return 0; } /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -2428,7 +5404,6 @@ static int test_cp_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -2443,7 +5418,6 @@ static int test_cp_2 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -2452,7 +5426,6 @@ static int test_cp_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -2508,6 +5481,9 @@ static int test_grub_install_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "grub_install") == NULL; str = getenv ("SKIP_TEST_GRUB_INSTALL_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_GRUB_INSTALL"); @@ -2518,14 +5494,13 @@ static int test_grub_install_0_skip (void) static int test_grub_install_0 (void) { if (test_grub_install_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_grub_install_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_grub_install_0"); return 0; } /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -2548,7 +5523,6 @@ static int test_grub_install_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -2563,7 +5537,6 @@ static int test_grub_install_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -2572,7 +5545,6 @@ static int test_grub_install_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -2584,7 +5556,6 @@ static int test_grub_install_0 (void) { char root[] = "/"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_grub_install (g, root, device); @@ -2610,6 +5581,9 @@ static int test_zero_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "zero") == NULL; str = getenv ("SKIP_TEST_ZERO_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_ZERO"); @@ -2620,14 +5594,13 @@ static int test_zero_0_skip (void) static int test_zero_0 (void) { if (test_zero_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zero_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_zero_0"); return 0; } /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -2650,7 +5623,6 @@ static int test_zero_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -2665,7 +5637,6 @@ static int test_zero_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -2674,7 +5645,6 @@ static int test_zero_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -2686,7 +5656,6 @@ static int test_zero_0 (void) char expected[] = "data"; { char pathordevice[] = "/dev/sda1"; - pathordevice[5] = devchar; int r; suppress_error = 0; r = guestfs_umount (g, pathordevice); @@ -2695,7 +5664,6 @@ static int test_zero_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_zero (g, device); @@ -2704,7 +5672,6 @@ static int test_zero_0 (void) } { char path[] = "/dev/sda1"; - path[5] = devchar; char *r; suppress_error = 0; r = guestfs_file (g, path); @@ -2723,6 +5690,9 @@ static int test_fsck_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "fsck") == NULL; str = getenv ("SKIP_TEST_FSCK_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_FSCK"); @@ -2733,14 +5703,13 @@ static int test_fsck_0_skip (void) static int test_fsck_0 (void) { if (test_fsck_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_fsck_0"); return 0; } /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -2763,7 +5732,6 @@ static int test_fsck_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -2778,7 +5746,6 @@ static int test_fsck_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -2787,7 +5754,6 @@ static int test_fsck_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -2798,7 +5764,6 @@ static int test_fsck_0 (void) /* TestOutputInt for fsck (0) */ { char pathordevice[] = "/dev/sda1"; - pathordevice[5] = devchar; int r; suppress_error = 0; r = guestfs_umount (g, pathordevice); @@ -2808,7 +5773,6 @@ static int test_fsck_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_fsck (g, fstype, device); @@ -2826,6 +5790,9 @@ static int test_fsck_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "fsck") == NULL; str = getenv ("SKIP_TEST_FSCK_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_FSCK"); @@ -2836,14 +5803,13 @@ static int test_fsck_1_skip (void) static int test_fsck_1 (void) { if (test_fsck_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_fsck_1"); return 0; } /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -2866,7 +5832,6 @@ static int test_fsck_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -2881,7 +5846,6 @@ static int test_fsck_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -2890,7 +5854,6 @@ static int test_fsck_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -2901,7 +5864,6 @@ static int test_fsck_1 (void) /* TestOutputInt for fsck (1) */ { char pathordevice[] = "/dev/sda1"; - pathordevice[5] = devchar; int r; suppress_error = 0; r = guestfs_umount (g, pathordevice); @@ -2910,7 +5872,6 @@ static int test_fsck_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_zero (g, device); @@ -2920,7 +5881,6 @@ static int test_fsck_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_fsck (g, fstype, device); @@ -2938,6 +5898,9 @@ static int test_set_e2uuid_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "set_e2uuid") == NULL; str = getenv ("SKIP_TEST_SET_E2UUID_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_SET_E2UUID"); @@ -2948,14 +5911,13 @@ static int test_set_e2uuid_0_skip (void) static int test_set_e2uuid_0 (void) { if (test_set_e2uuid_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_0"); return 0; } /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -2978,7 +5940,6 @@ static int test_set_e2uuid_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -2993,7 +5954,6 @@ static int test_set_e2uuid_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -3002,7 +5962,6 @@ static int test_set_e2uuid_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -3014,7 +5973,6 @@ static int test_set_e2uuid_0 (void) char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d"; { char device[] = "/dev/sda1"; - device[5] = devchar; char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d"; int r; suppress_error = 0; @@ -3024,7 +5982,6 @@ static int test_set_e2uuid_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char *r; suppress_error = 0; r = guestfs_get_e2uuid (g, device); @@ -3043,6 +6000,9 @@ static int test_set_e2uuid_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "set_e2uuid") == NULL; str = getenv ("SKIP_TEST_SET_E2UUID_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_SET_E2UUID"); @@ -3053,14 +6013,13 @@ static int test_set_e2uuid_1_skip (void) static int test_set_e2uuid_1 (void) { if (test_set_e2uuid_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_1"); return 0; } /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -3083,7 +6042,6 @@ static int test_set_e2uuid_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -3098,7 +6056,6 @@ static int test_set_e2uuid_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -3107,7 +6064,6 @@ static int test_set_e2uuid_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -3119,7 +6075,6 @@ static int test_set_e2uuid_1 (void) char expected[] = ""; { char device[] = "/dev/sda1"; - device[5] = devchar; char uuid[] = "clear"; int r; suppress_error = 0; @@ -3129,7 +6084,6 @@ static int test_set_e2uuid_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char *r; suppress_error = 0; r = guestfs_get_e2uuid (g, device); @@ -3148,6 +6102,9 @@ static int test_set_e2uuid_2_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "set_e2uuid") == NULL; str = getenv ("SKIP_TEST_SET_E2UUID_2"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_SET_E2UUID"); @@ -3158,14 +6115,13 @@ static int test_set_e2uuid_2_skip (void) static int test_set_e2uuid_2 (void) { if (test_set_e2uuid_2_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_2"); + printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_2"); return 0; } /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -3188,7 +6144,6 @@ static int test_set_e2uuid_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -3203,7 +6158,6 @@ static int test_set_e2uuid_2 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -3212,7 +6166,6 @@ static int test_set_e2uuid_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -3223,7 +6176,6 @@ static int test_set_e2uuid_2 (void) /* TestRun for set_e2uuid (2) */ { char device[] = "/dev/sda1"; - device[5] = devchar; char uuid[] = "random"; int r; suppress_error = 0; @@ -3238,6 +6190,9 @@ static int test_set_e2uuid_3_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "set_e2uuid") == NULL; str = getenv ("SKIP_TEST_SET_E2UUID_3"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_SET_E2UUID"); @@ -3248,14 +6203,13 @@ static int test_set_e2uuid_3_skip (void) static int test_set_e2uuid_3 (void) { if (test_set_e2uuid_3_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_3"); + printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_3"); return 0; } /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -3278,7 +6232,6 @@ static int test_set_e2uuid_3 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -3293,7 +6246,6 @@ static int test_set_e2uuid_3 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -3302,7 +6254,6 @@ static int test_set_e2uuid_3 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -3313,7 +6264,6 @@ static int test_set_e2uuid_3 (void) /* TestRun for set_e2uuid (3) */ { char device[] = "/dev/sda1"; - device[5] = devchar; char uuid[] = "time"; int r; suppress_error = 0; @@ -3328,6 +6278,9 @@ static int test_set_e2label_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "set_e2label") == NULL; str = getenv ("SKIP_TEST_SET_E2LABEL_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_SET_E2LABEL"); @@ -3338,14 +6291,13 @@ static int test_set_e2label_0_skip (void) static int test_set_e2label_0 (void) { if (test_set_e2label_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2label_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_set_e2label_0"); return 0; } /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -3368,7 +6320,6 @@ static int test_set_e2label_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -3383,7 +6334,6 @@ static int test_set_e2label_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -3392,7 +6342,6 @@ static int test_set_e2label_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -3404,7 +6353,6 @@ static int test_set_e2label_0 (void) char expected[] = "testlabel"; { char device[] = "/dev/sda1"; - device[5] = devchar; char label[] = "testlabel"; int r; suppress_error = 0; @@ -3414,7 +6362,6 @@ static int test_set_e2label_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char *r; suppress_error = 0; r = guestfs_get_e2label (g, device); @@ -3433,6 +6380,9 @@ static int test_pvremove_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "pvremove") == NULL; str = getenv ("SKIP_TEST_PVREMOVE_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_PVREMOVE"); @@ -3443,14 +6393,13 @@ static int test_pvremove_0_skip (void) static int test_pvremove_0 (void) { if (test_pvremove_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_0"); return 0; } /* InitNone|InitEmpty for test_pvremove_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -3471,10 +6420,9 @@ static int test_pvremove_0 (void) if (r == -1) return -1; } - /* TestOutputList for pvremove (0) */ + /* TestOutputListOfDevices for pvremove (0) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -3488,7 +6436,6 @@ static int test_pvremove_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -3498,7 +6445,6 @@ static int test_pvremove_0 (void) { char volgroup[] = "VG"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -3537,7 +6483,6 @@ static int test_pvremove_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvremove (g, device); @@ -3567,6 +6512,9 @@ static int test_pvremove_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "pvremove") == NULL; str = getenv ("SKIP_TEST_PVREMOVE_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_PVREMOVE"); @@ -3577,14 +6525,13 @@ static int test_pvremove_1_skip (void) static int test_pvremove_1 (void) { if (test_pvremove_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_1"); return 0; } /* InitNone|InitEmpty for test_pvremove_1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -3605,10 +6552,9 @@ static int test_pvremove_1 (void) if (r == -1) return -1; } - /* TestOutputList for pvremove (1) */ + /* TestOutputListOfDevices for pvremove (1) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -3622,7 +6568,6 @@ static int test_pvremove_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -3632,7 +6577,6 @@ static int test_pvremove_1 (void) { char volgroup[] = "VG"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -3671,7 +6615,6 @@ static int test_pvremove_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvremove (g, device); @@ -3701,6 +6644,9 @@ static int test_pvremove_2_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "pvremove") == NULL; str = getenv ("SKIP_TEST_PVREMOVE_2"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_PVREMOVE"); @@ -3711,14 +6657,13 @@ static int test_pvremove_2_skip (void) static int test_pvremove_2 (void) { if (test_pvremove_2_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_2"); + printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_2"); return 0; } /* InitNone|InitEmpty for test_pvremove_2 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -3739,10 +6684,9 @@ static int test_pvremove_2 (void) if (r == -1) return -1; } - /* TestOutputList for pvremove (2) */ + /* TestOutputListOfDevices for pvremove (2) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -3756,7 +6700,6 @@ static int test_pvremove_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -3766,7 +6709,6 @@ static int test_pvremove_2 (void) { char volgroup[] = "VG"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -3805,7 +6747,6 @@ static int test_pvremove_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvremove (g, device); @@ -3835,6 +6776,9 @@ static int test_vgremove_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "vgremove") == NULL; str = getenv ("SKIP_TEST_VGREMOVE_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_VGREMOVE"); @@ -3845,14 +6789,13 @@ static int test_vgremove_0_skip (void) static int test_vgremove_0 (void) { if (test_vgremove_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_0"); return 0; } /* InitNone|InitEmpty for test_vgremove_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -3876,7 +6819,6 @@ static int test_vgremove_0 (void) /* TestOutputList for vgremove (0) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -3890,7 +6832,6 @@ static int test_vgremove_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -3900,7 +6841,6 @@ static int test_vgremove_0 (void) { char volgroup[] = "VG"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -3960,6 +6900,9 @@ static int test_vgremove_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "vgremove") == NULL; str = getenv ("SKIP_TEST_VGREMOVE_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_VGREMOVE"); @@ -3970,14 +6913,13 @@ static int test_vgremove_1_skip (void) static int test_vgremove_1 (void) { if (test_vgremove_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_1"); return 0; } /* InitNone|InitEmpty for test_vgremove_1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -4001,7 +6943,6 @@ static int test_vgremove_1 (void) /* TestOutputList for vgremove (1) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -4015,7 +6956,6 @@ static int test_vgremove_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -4025,7 +6965,6 @@ static int test_vgremove_1 (void) { char volgroup[] = "VG"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -4085,6 +7024,9 @@ static int test_lvremove_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "lvremove") == NULL; str = getenv ("SKIP_TEST_LVREMOVE_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_LVREMOVE"); @@ -4095,14 +7037,13 @@ static int test_lvremove_0_skip (void) static int test_lvremove_0 (void) { if (test_lvremove_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_0"); return 0; } /* InitNone|InitEmpty for test_lvremove_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -4126,7 +7067,6 @@ static int test_lvremove_0 (void) /* TestOutputList for lvremove (0) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -4140,7 +7080,6 @@ static int test_lvremove_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -4150,7 +7089,6 @@ static int test_lvremove_0 (void) { char volgroup[] = "VG"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -4222,6 +7160,9 @@ static int test_lvremove_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "lvremove") == NULL; str = getenv ("SKIP_TEST_LVREMOVE_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_LVREMOVE"); @@ -4232,14 +7173,13 @@ static int test_lvremove_1_skip (void) static int test_lvremove_1 (void) { if (test_lvremove_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_1"); return 0; } /* InitNone|InitEmpty for test_lvremove_1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -4263,7 +7203,6 @@ static int test_lvremove_1 (void) /* TestOutputList for lvremove (1) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -4277,7 +7216,6 @@ static int test_lvremove_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -4287,7 +7225,6 @@ static int test_lvremove_1 (void) { char volgroup[] = "VG"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -4347,6 +7284,9 @@ static int test_lvremove_2_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "lvremove") == NULL; str = getenv ("SKIP_TEST_LVREMOVE_2"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_LVREMOVE"); @@ -4357,14 +7297,13 @@ static int test_lvremove_2_skip (void) static int test_lvremove_2 (void) { if (test_lvremove_2_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_2"); + printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_2"); return 0; } /* InitNone|InitEmpty for test_lvremove_2 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -4388,7 +7327,6 @@ static int test_lvremove_2 (void) /* TestOutputList for lvremove (2) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -4402,7 +7340,6 @@ static int test_lvremove_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -4412,7 +7349,6 @@ static int test_lvremove_2 (void) { char volgroup[] = "VG"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -4484,6 +7420,9 @@ static int test_mount_ro_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mount_ro") == NULL; str = getenv ("SKIP_TEST_MOUNT_RO_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_MOUNT_RO"); @@ -4494,14 +7433,13 @@ static int test_mount_ro_0_skip (void) static int test_mount_ro_0 (void) { if (test_mount_ro_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_0"); return 0; } /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -4524,7 +7462,6 @@ static int test_mount_ro_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -4539,7 +7476,6 @@ static int test_mount_ro_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -4548,7 +7484,6 @@ static int test_mount_ro_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -4567,7 +7502,6 @@ static int test_mount_ro_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -4590,6 +7524,9 @@ static int test_mount_ro_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mount_ro") == NULL; str = getenv ("SKIP_TEST_MOUNT_RO_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_MOUNT_RO"); @@ -4600,14 +7537,13 @@ static int test_mount_ro_1_skip (void) static int test_mount_ro_1 (void) { if (test_mount_ro_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_1"); return 0; } /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -4630,7 +7566,6 @@ static int test_mount_ro_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -4645,7 +7580,6 @@ static int test_mount_ro_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -4654,7 +7588,6 @@ static int test_mount_ro_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -4683,7 +7616,6 @@ static int test_mount_ro_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -4711,6 +7643,9 @@ static int test_tgz_in_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "tgz_in") == NULL; str = getenv ("SKIP_TEST_TGZ_IN_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_TGZ_IN"); @@ -4721,14 +7656,13 @@ static int test_tgz_in_0_skip (void) static int test_tgz_in_0 (void) { if (test_tgz_in_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tgz_in_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_tgz_in_0"); return 0; } /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -4751,7 +7685,6 @@ static int test_tgz_in_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -4766,7 +7699,6 @@ static int test_tgz_in_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -4775,7 +7707,6 @@ static int test_tgz_in_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -4813,6 +7744,9 @@ static int test_tar_in_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "tar_in") == NULL; str = getenv ("SKIP_TEST_TAR_IN_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_TAR_IN"); @@ -4823,14 +7757,13 @@ static int test_tar_in_0_skip (void) static int test_tar_in_0 (void) { if (test_tar_in_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tar_in_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_tar_in_0"); return 0; } /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -4853,7 +7786,6 @@ static int test_tar_in_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -4868,7 +7800,6 @@ static int test_tar_in_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -4877,7 +7808,6 @@ static int test_tar_in_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -4915,6 +7845,9 @@ static int test_checksum_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "checksum") == NULL; str = getenv ("SKIP_TEST_CHECKSUM_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_CHECKSUM"); @@ -4925,14 +7858,13 @@ static int test_checksum_0_skip (void) static int test_checksum_0 (void) { if (test_checksum_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_checksum_0"); return 0; } /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -4955,7 +7887,6 @@ static int test_checksum_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -4970,7 +7901,6 @@ static int test_checksum_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -4979,7 +7909,6 @@ static int test_checksum_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -5019,6 +7948,9 @@ static int test_checksum_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "checksum") == NULL; str = getenv ("SKIP_TEST_CHECKSUM_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_CHECKSUM"); @@ -5029,14 +7961,13 @@ static int test_checksum_1_skip (void) static int test_checksum_1 (void) { if (test_checksum_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_checksum_1"); return 0; } /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -5059,7 +7990,6 @@ static int test_checksum_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -5074,7 +8004,6 @@ static int test_checksum_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -5083,7 +8012,6 @@ static int test_checksum_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -5109,6 +8037,9 @@ static int test_checksum_2_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "checksum") == NULL; str = getenv ("SKIP_TEST_CHECKSUM_2"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_CHECKSUM"); @@ -5119,14 +8050,13 @@ static int test_checksum_2_skip (void) static int test_checksum_2 (void) { if (test_checksum_2_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_2"); + printf ("%s skipped (reason: environment variable set)\n", "test_checksum_2"); return 0; } /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -5149,7 +8079,6 @@ static int test_checksum_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -5164,7 +8093,6 @@ static int test_checksum_2 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -5173,7 +8101,6 @@ static int test_checksum_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -5213,6 +8140,9 @@ static int test_checksum_3_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "checksum") == NULL; str = getenv ("SKIP_TEST_CHECKSUM_3"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_CHECKSUM"); @@ -5223,14 +8153,13 @@ static int test_checksum_3_skip (void) static int test_checksum_3 (void) { if (test_checksum_3_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_3"); + printf ("%s skipped (reason: environment variable set)\n", "test_checksum_3"); return 0; } /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -5253,7 +8182,6 @@ static int test_checksum_3 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -5268,7 +8196,6 @@ static int test_checksum_3 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -5277,7 +8204,6 @@ static int test_checksum_3 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -5317,6 +8243,9 @@ static int test_checksum_4_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "checksum") == NULL; str = getenv ("SKIP_TEST_CHECKSUM_4"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_CHECKSUM"); @@ -5327,14 +8256,13 @@ static int test_checksum_4_skip (void) static int test_checksum_4 (void) { if (test_checksum_4_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_4"); + printf ("%s skipped (reason: environment variable set)\n", "test_checksum_4"); return 0; } /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -5357,7 +8285,6 @@ static int test_checksum_4 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -5372,7 +8299,6 @@ static int test_checksum_4 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -5381,7 +8307,6 @@ static int test_checksum_4 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -5421,6 +8346,9 @@ static int test_checksum_5_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "checksum") == NULL; str = getenv ("SKIP_TEST_CHECKSUM_5"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_CHECKSUM"); @@ -5431,14 +8359,13 @@ static int test_checksum_5_skip (void) static int test_checksum_5 (void) { if (test_checksum_5_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_5"); + printf ("%s skipped (reason: environment variable set)\n", "test_checksum_5"); return 0; } /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -5461,7 +8388,6 @@ static int test_checksum_5 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -5476,7 +8402,6 @@ static int test_checksum_5 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -5485,7 +8410,6 @@ static int test_checksum_5 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -5525,6 +8449,9 @@ static int test_checksum_6_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "checksum") == NULL; str = getenv ("SKIP_TEST_CHECKSUM_6"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_CHECKSUM"); @@ -5535,14 +8462,13 @@ static int test_checksum_6_skip (void) static int test_checksum_6 (void) { if (test_checksum_6_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_6"); + printf ("%s skipped (reason: environment variable set)\n", "test_checksum_6"); return 0; } /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -5565,7 +8491,6 @@ static int test_checksum_6 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -5580,7 +8505,6 @@ static int test_checksum_6 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -5589,7 +8513,6 @@ static int test_checksum_6 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -5629,6 +8552,9 @@ static int test_checksum_7_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "checksum") == NULL; str = getenv ("SKIP_TEST_CHECKSUM_7"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_CHECKSUM"); @@ -5639,14 +8565,13 @@ static int test_checksum_7_skip (void) static int test_checksum_7 (void) { if (test_checksum_7_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_7"); + printf ("%s skipped (reason: environment variable set)\n", "test_checksum_7"); return 0; } /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -5669,7 +8594,6 @@ static int test_checksum_7 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -5684,7 +8608,6 @@ static int test_checksum_7 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -5693,7 +8616,6 @@ static int test_checksum_7 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -5733,6 +8655,9 @@ static int test_checksum_8_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "checksum") == NULL; str = getenv ("SKIP_TEST_CHECKSUM_8"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_CHECKSUM"); @@ -5743,14 +8668,13 @@ static int test_checksum_8_skip (void) static int test_checksum_8 (void) { if (test_checksum_8_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_8"); + printf ("%s skipped (reason: environment variable set)\n", "test_checksum_8"); return 0; } /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -5773,7 +8697,6 @@ static int test_checksum_8 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -5788,7 +8711,6 @@ static int test_checksum_8 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -5797,7 +8719,6 @@ static int test_checksum_8 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -5808,12 +8729,13 @@ static int test_checksum_8 (void) /* TestOutput for checksum (8) */ char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c"; { + char options[] = "ro"; + char vfstype[] = "squashfs"; char device[] = "/dev/sdd"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; - r = guestfs_mount (g, device, mountpoint); + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); if (r == -1) return -1; } @@ -5838,6 +8760,9 @@ static int test_download_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "download") == NULL; str = getenv ("SKIP_TEST_DOWNLOAD_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_DOWNLOAD"); @@ -5848,14 +8773,13 @@ static int test_download_0_skip (void) static int test_download_0 (void) { if (test_download_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_download_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_download_0"); return 0; } /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -5878,7 +8802,6 @@ static int test_download_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -5893,7 +8816,6 @@ static int test_download_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -5902,7 +8824,6 @@ static int test_download_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -5957,6 +8878,9 @@ static int test_upload_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "upload") == NULL; str = getenv ("SKIP_TEST_UPLOAD_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_UPLOAD"); @@ -5967,14 +8891,13 @@ static int test_upload_0_skip (void) static int test_upload_0 (void) { if (test_upload_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_upload_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_upload_0"); return 0; } /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -5997,7 +8920,6 @@ static int test_upload_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -6012,7 +8934,6 @@ static int test_upload_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -6021,7 +8942,6 @@ static int test_upload_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -6060,6 +8980,9 @@ static int test_blockdev_rereadpt_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "blockdev_rereadpt") == NULL; str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT"); @@ -6070,14 +8993,13 @@ static int test_blockdev_rereadpt_0_skip (void) static int test_blockdev_rereadpt_0 (void) { if (test_blockdev_rereadpt_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_rereadpt_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_rereadpt_0"); return 0; } /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -6101,7 +9023,6 @@ static int test_blockdev_rereadpt_0 (void) /* TestRun for blockdev_rereadpt (0) */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_rereadpt (g, device); @@ -6115,6 +9036,9 @@ static int test_blockdev_flushbufs_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "blockdev_flushbufs") == NULL; str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS"); @@ -6125,14 +9049,13 @@ static int test_blockdev_flushbufs_0_skip (void) static int test_blockdev_flushbufs_0 (void) { if (test_blockdev_flushbufs_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_flushbufs_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_flushbufs_0"); return 0; } /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -6156,7 +9079,6 @@ static int test_blockdev_flushbufs_0 (void) /* TestRun for blockdev_flushbufs (0) */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_flushbufs (g, device); @@ -6170,6 +9092,9 @@ static int test_blockdev_getsize64_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "blockdev_getsize64") == NULL; str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64"); @@ -6180,14 +9105,13 @@ static int test_blockdev_getsize64_0_skip (void) static int test_blockdev_getsize64_0 (void) { if (test_blockdev_getsize64_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsize64_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsize64_0"); return 0; } /* InitNone|InitEmpty for test_blockdev_getsize64_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -6211,7 +9135,6 @@ static int test_blockdev_getsize64_0 (void) /* TestOutputInt for blockdev_getsize64 (0) */ { char device[] = "/dev/sda"; - device[5] = devchar; int64_t r; suppress_error = 0; r = guestfs_blockdev_getsize64 (g, device); @@ -6229,6 +9152,9 @@ static int test_blockdev_getsz_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "blockdev_getsz") == NULL; str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ"); @@ -6239,14 +9165,13 @@ static int test_blockdev_getsz_0_skip (void) static int test_blockdev_getsz_0 (void) { if (test_blockdev_getsz_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsz_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsz_0"); return 0; } /* InitNone|InitEmpty for test_blockdev_getsz_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -6270,7 +9195,6 @@ static int test_blockdev_getsz_0 (void) /* TestOutputInt for blockdev_getsz (0) */ { char device[] = "/dev/sda"; - device[5] = devchar; int64_t r; suppress_error = 0; r = guestfs_blockdev_getsz (g, device); @@ -6288,6 +9212,9 @@ static int test_blockdev_getbsz_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "blockdev_getbsz") == NULL; str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ"); @@ -6298,14 +9225,13 @@ static int test_blockdev_getbsz_0_skip (void) static int test_blockdev_getbsz_0 (void) { if (test_blockdev_getbsz_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getbsz_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getbsz_0"); return 0; } /* InitNone|InitEmpty for test_blockdev_getbsz_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -6329,7 +9255,6 @@ static int test_blockdev_getbsz_0 (void) /* TestOutputInt for blockdev_getbsz (0) */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_getbsz (g, device); @@ -6347,6 +9272,9 @@ static int test_blockdev_getss_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "blockdev_getss") == NULL; str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_BLOCKDEV_GETSS"); @@ -6357,14 +9285,13 @@ static int test_blockdev_getss_0_skip (void) static int test_blockdev_getss_0 (void) { if (test_blockdev_getss_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getss_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getss_0"); return 0; } /* InitNone|InitEmpty for test_blockdev_getss_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -6388,7 +9315,6 @@ static int test_blockdev_getss_0 (void) /* TestOutputInt for blockdev_getss (0) */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_getss (g, device); @@ -6406,6 +9332,9 @@ static int test_blockdev_getro_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "blockdev_getro") == NULL; str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_BLOCKDEV_GETRO"); @@ -6416,14 +9345,13 @@ static int test_blockdev_getro_0_skip (void) static int test_blockdev_getro_0 (void) { if (test_blockdev_getro_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getro_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getro_0"); return 0; } /* InitNone|InitEmpty for test_blockdev_getro_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -6447,7 +9375,6 @@ static int test_blockdev_getro_0 (void) /* TestOutputTrue for blockdev_getro (0) */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setro (g, device); @@ -6456,7 +9383,6 @@ static int test_blockdev_getro_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_getro (g, device); @@ -6474,6 +9400,9 @@ static int test_blockdev_setrw_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "blockdev_setrw") == NULL; str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_BLOCKDEV_SETRW"); @@ -6484,14 +9413,13 @@ static int test_blockdev_setrw_0_skip (void) static int test_blockdev_setrw_0 (void) { if (test_blockdev_setrw_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setrw_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setrw_0"); return 0; } /* InitNone|InitEmpty for test_blockdev_setrw_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -6515,7 +9443,6 @@ static int test_blockdev_setrw_0 (void) /* TestOutputFalse for blockdev_setrw (0) */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -6524,7 +9451,6 @@ static int test_blockdev_setrw_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_getro (g, device); @@ -6542,6 +9468,9 @@ static int test_blockdev_setro_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "blockdev_setro") == NULL; str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_BLOCKDEV_SETRO"); @@ -6552,14 +9481,13 @@ static int test_blockdev_setro_0_skip (void) static int test_blockdev_setro_0 (void) { if (test_blockdev_setro_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setro_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setro_0"); return 0; } /* InitNone|InitEmpty for test_blockdev_setro_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -6583,7 +9511,6 @@ static int test_blockdev_setro_0 (void) /* TestOutputTrue for blockdev_setro (0) */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setro (g, device); @@ -6592,7 +9519,6 @@ static int test_blockdev_setro_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_getro (g, device); @@ -6610,6 +9536,9 @@ static int test_statvfs_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "statvfs") == NULL; str = getenv ("SKIP_TEST_STATVFS_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_STATVFS"); @@ -6620,14 +9549,13 @@ static int test_statvfs_0_skip (void) static int test_statvfs_0 (void) { if (test_statvfs_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_statvfs_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_statvfs_0"); return 0; } /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -6650,7 +9578,6 @@ static int test_statvfs_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -6665,7 +9592,6 @@ static int test_statvfs_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -6674,7 +9600,6 @@ static int test_statvfs_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -6714,6 +9639,9 @@ static int test_lstat_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "lstat") == NULL; str = getenv ("SKIP_TEST_LSTAT_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_LSTAT"); @@ -6724,14 +9652,13 @@ static int test_lstat_0_skip (void) static int test_lstat_0 (void) { if (test_lstat_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lstat_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_lstat_0"); return 0; } /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -6754,7 +9681,6 @@ static int test_lstat_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -6769,7 +9695,6 @@ static int test_lstat_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -6778,7 +9703,6 @@ static int test_lstat_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -6816,6 +9740,9 @@ static int test_stat_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "stat") == NULL; str = getenv ("SKIP_TEST_STAT_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_STAT"); @@ -6826,14 +9753,13 @@ static int test_stat_0_skip (void) static int test_stat_0 (void) { if (test_stat_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_stat_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_stat_0"); return 0; } /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -6856,7 +9782,6 @@ static int test_stat_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -6871,7 +9796,6 @@ static int test_stat_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -6880,7 +9804,6 @@ static int test_stat_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -6918,6 +9841,9 @@ static int test_command_lines_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command_lines") == NULL; str = getenv ("SKIP_TEST_COMMAND_LINES_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND_LINES"); @@ -6928,14 +9854,13 @@ static int test_command_lines_0_skip (void) static int test_command_lines_0 (void) { if (test_command_lines_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_0"); return 0; } /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -6958,7 +9883,6 @@ static int test_command_lines_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -6973,7 +9897,6 @@ static int test_command_lines_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -6982,7 +9905,6 @@ static int test_command_lines_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -7049,6 +9971,9 @@ static int test_command_lines_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command_lines") == NULL; str = getenv ("SKIP_TEST_COMMAND_LINES_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND_LINES"); @@ -7059,14 +9984,13 @@ static int test_command_lines_1_skip (void) static int test_command_lines_1 (void) { if (test_command_lines_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_1"); return 0; } /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -7089,7 +10013,6 @@ static int test_command_lines_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -7104,7 +10027,6 @@ static int test_command_lines_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -7113,7 +10035,6 @@ static int test_command_lines_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -7180,6 +10101,9 @@ static int test_command_lines_2_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command_lines") == NULL; str = getenv ("SKIP_TEST_COMMAND_LINES_2"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND_LINES"); @@ -7190,14 +10114,13 @@ static int test_command_lines_2_skip (void) static int test_command_lines_2 (void) { if (test_command_lines_2_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_2"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_2"); return 0; } /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -7220,7 +10143,6 @@ static int test_command_lines_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -7235,7 +10157,6 @@ static int test_command_lines_2 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -7244,7 +10165,6 @@ static int test_command_lines_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -7323,6 +10243,9 @@ static int test_command_lines_3_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command_lines") == NULL; str = getenv ("SKIP_TEST_COMMAND_LINES_3"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND_LINES"); @@ -7333,14 +10256,13 @@ static int test_command_lines_3_skip (void) static int test_command_lines_3 (void) { if (test_command_lines_3_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_3"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_3"); return 0; } /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -7363,7 +10285,6 @@ static int test_command_lines_3 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -7378,7 +10299,6 @@ static int test_command_lines_3 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -7387,7 +10307,6 @@ static int test_command_lines_3 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -7466,6 +10385,9 @@ static int test_command_lines_4_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command_lines") == NULL; str = getenv ("SKIP_TEST_COMMAND_LINES_4"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND_LINES"); @@ -7476,14 +10398,13 @@ static int test_command_lines_4_skip (void) static int test_command_lines_4 (void) { if (test_command_lines_4_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_4"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_4"); return 0; } /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -7506,7 +10427,6 @@ static int test_command_lines_4 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -7521,7 +10441,6 @@ static int test_command_lines_4 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -7530,7 +10449,6 @@ static int test_command_lines_4 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -7621,6 +10539,9 @@ static int test_command_lines_5_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command_lines") == NULL; str = getenv ("SKIP_TEST_COMMAND_LINES_5"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND_LINES"); @@ -7631,14 +10552,13 @@ static int test_command_lines_5_skip (void) static int test_command_lines_5 (void) { if (test_command_lines_5_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_5"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_5"); return 0; } /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -7661,7 +10581,6 @@ static int test_command_lines_5 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -7676,7 +10595,6 @@ static int test_command_lines_5 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -7685,7 +10603,6 @@ static int test_command_lines_5 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -7788,6 +10705,9 @@ static int test_command_lines_6_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command_lines") == NULL; str = getenv ("SKIP_TEST_COMMAND_LINES_6"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND_LINES"); @@ -7798,14 +10718,13 @@ static int test_command_lines_6_skip (void) static int test_command_lines_6 (void) { if (test_command_lines_6_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_6"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_6"); return 0; } /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -7828,7 +10747,6 @@ static int test_command_lines_6 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -7843,7 +10761,6 @@ static int test_command_lines_6 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -7852,7 +10769,6 @@ static int test_command_lines_6 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -7907,6 +10823,9 @@ static int test_command_lines_7_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command_lines") == NULL; str = getenv ("SKIP_TEST_COMMAND_LINES_7"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND_LINES"); @@ -7917,14 +10836,13 @@ static int test_command_lines_7_skip (void) static int test_command_lines_7 (void) { if (test_command_lines_7_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_7"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_7"); return 0; } /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -7947,7 +10865,6 @@ static int test_command_lines_7 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -7962,7 +10879,6 @@ static int test_command_lines_7 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -7971,7 +10887,6 @@ static int test_command_lines_7 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -8038,6 +10953,9 @@ static int test_command_lines_8_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command_lines") == NULL; str = getenv ("SKIP_TEST_COMMAND_LINES_8"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND_LINES"); @@ -8048,14 +10966,13 @@ static int test_command_lines_8_skip (void) static int test_command_lines_8 (void) { if (test_command_lines_8_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_8"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_8"); return 0; } /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -8078,7 +10995,6 @@ static int test_command_lines_8 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -8093,7 +11009,6 @@ static int test_command_lines_8 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -8102,7 +11017,6 @@ static int test_command_lines_8 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -8181,6 +11095,9 @@ static int test_command_lines_9_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command_lines") == NULL; str = getenv ("SKIP_TEST_COMMAND_LINES_9"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND_LINES"); @@ -8191,14 +11108,13 @@ static int test_command_lines_9_skip (void) static int test_command_lines_9 (void) { if (test_command_lines_9_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_9"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_9"); return 0; } /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -8221,7 +11137,6 @@ static int test_command_lines_9 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -8236,7 +11151,6 @@ static int test_command_lines_9 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -8245,7 +11159,6 @@ static int test_command_lines_9 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -8324,6 +11237,9 @@ static int test_command_lines_10_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command_lines") == NULL; str = getenv ("SKIP_TEST_COMMAND_LINES_10"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND_LINES"); @@ -8334,14 +11250,13 @@ static int test_command_lines_10_skip (void) static int test_command_lines_10 (void) { if (test_command_lines_10_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_10"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_10"); return 0; } /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -8364,7 +11279,6 @@ static int test_command_lines_10 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -8379,7 +11293,6 @@ static int test_command_lines_10 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -8388,7 +11301,6 @@ static int test_command_lines_10 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -8467,6 +11379,9 @@ static int test_command_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command") == NULL; str = getenv ("SKIP_TEST_COMMAND_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND"); @@ -8477,14 +11392,13 @@ static int test_command_0_skip (void) static int test_command_0 (void) { if (test_command_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_0"); return 0; } /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -8507,7 +11421,6 @@ static int test_command_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -8522,7 +11435,6 @@ static int test_command_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -8531,7 +11443,6 @@ static int test_command_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -8583,6 +11494,9 @@ static int test_command_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command") == NULL; str = getenv ("SKIP_TEST_COMMAND_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND"); @@ -8593,14 +11507,13 @@ static int test_command_1_skip (void) static int test_command_1 (void) { if (test_command_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_1"); return 0; } /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -8623,7 +11536,6 @@ static int test_command_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -8638,7 +11550,6 @@ static int test_command_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -8647,7 +11558,6 @@ static int test_command_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -8699,6 +11609,9 @@ static int test_command_2_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command") == NULL; str = getenv ("SKIP_TEST_COMMAND_2"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND"); @@ -8709,14 +11622,13 @@ static int test_command_2_skip (void) static int test_command_2 (void) { if (test_command_2_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_2"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_2"); return 0; } /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -8739,7 +11651,6 @@ static int test_command_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -8754,7 +11665,6 @@ static int test_command_2 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -8763,7 +11673,6 @@ static int test_command_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -8815,6 +11724,9 @@ static int test_command_3_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command") == NULL; str = getenv ("SKIP_TEST_COMMAND_3"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND"); @@ -8825,14 +11737,13 @@ static int test_command_3_skip (void) static int test_command_3 (void) { if (test_command_3_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_3"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_3"); return 0; } /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -8855,7 +11766,6 @@ static int test_command_3 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -8870,7 +11780,6 @@ static int test_command_3 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -8879,7 +11788,6 @@ static int test_command_3 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -8931,6 +11839,9 @@ static int test_command_4_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command") == NULL; str = getenv ("SKIP_TEST_COMMAND_4"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND"); @@ -8941,14 +11852,13 @@ static int test_command_4_skip (void) static int test_command_4 (void) { if (test_command_4_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_4"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_4"); return 0; } /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -8971,7 +11881,6 @@ static int test_command_4 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -8986,7 +11895,6 @@ static int test_command_4 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -8995,7 +11903,6 @@ static int test_command_4 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -9047,6 +11954,9 @@ static int test_command_5_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command") == NULL; str = getenv ("SKIP_TEST_COMMAND_5"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND"); @@ -9057,14 +11967,13 @@ static int test_command_5_skip (void) static int test_command_5 (void) { if (test_command_5_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_5"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_5"); return 0; } /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -9087,7 +11996,6 @@ static int test_command_5 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -9102,7 +12010,6 @@ static int test_command_5 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -9111,7 +12018,6 @@ static int test_command_5 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -9163,6 +12069,9 @@ static int test_command_6_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command") == NULL; str = getenv ("SKIP_TEST_COMMAND_6"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND"); @@ -9173,14 +12082,13 @@ static int test_command_6_skip (void) static int test_command_6 (void) { if (test_command_6_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_6"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_6"); return 0; } /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -9203,7 +12111,6 @@ static int test_command_6 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -9218,7 +12125,6 @@ static int test_command_6 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -9227,7 +12133,6 @@ static int test_command_6 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -9279,6 +12184,9 @@ static int test_command_7_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command") == NULL; str = getenv ("SKIP_TEST_COMMAND_7"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND"); @@ -9289,14 +12197,13 @@ static int test_command_7_skip (void) static int test_command_7 (void) { if (test_command_7_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_7"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_7"); return 0; } /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -9319,7 +12226,6 @@ static int test_command_7 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -9334,7 +12240,6 @@ static int test_command_7 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -9343,7 +12248,6 @@ static int test_command_7 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -9395,6 +12299,9 @@ static int test_command_8_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command") == NULL; str = getenv ("SKIP_TEST_COMMAND_8"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND"); @@ -9405,14 +12312,13 @@ static int test_command_8_skip (void) static int test_command_8 (void) { if (test_command_8_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_8"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_8"); return 0; } /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -9435,7 +12341,6 @@ static int test_command_8 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -9450,7 +12355,6 @@ static int test_command_8 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -9459,7 +12363,6 @@ static int test_command_8 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -9511,6 +12414,9 @@ static int test_command_9_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command") == NULL; str = getenv ("SKIP_TEST_COMMAND_9"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND"); @@ -9521,14 +12427,13 @@ static int test_command_9_skip (void) static int test_command_9 (void) { if (test_command_9_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_9"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_9"); return 0; } /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -9551,7 +12456,6 @@ static int test_command_9 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -9566,7 +12470,6 @@ static int test_command_9 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -9575,7 +12478,6 @@ static int test_command_9 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -9627,6 +12529,9 @@ static int test_command_10_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command") == NULL; str = getenv ("SKIP_TEST_COMMAND_10"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND"); @@ -9637,14 +12542,13 @@ static int test_command_10_skip (void) static int test_command_10 (void) { if (test_command_10_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_10"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_10"); return 0; } /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -9667,7 +12571,6 @@ static int test_command_10 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -9682,7 +12585,6 @@ static int test_command_10 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -9691,7 +12593,6 @@ static int test_command_10 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -9743,6 +12644,9 @@ static int test_command_11_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command") == NULL; str = getenv ("SKIP_TEST_COMMAND_11"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND"); @@ -9753,14 +12657,13 @@ static int test_command_11_skip (void) static int test_command_11 (void) { if (test_command_11_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_11"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_11"); return 0; } /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -9783,7 +12686,6 @@ static int test_command_11 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -9798,7 +12700,6 @@ static int test_command_11 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -9807,7 +12708,6 @@ static int test_command_11 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -9852,6 +12752,9 @@ static int test_file_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "file") == NULL; str = getenv ("SKIP_TEST_FILE_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_FILE"); @@ -9862,14 +12765,13 @@ static int test_file_0_skip (void) static int test_file_0 (void) { if (test_file_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_file_0"); return 0; } /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -9892,7 +12794,6 @@ static int test_file_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -9907,7 +12808,6 @@ static int test_file_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -9916,7 +12816,6 @@ static int test_file_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -9954,6 +12853,9 @@ static int test_file_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "file") == NULL; str = getenv ("SKIP_TEST_FILE_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_FILE"); @@ -9964,14 +12866,13 @@ static int test_file_1_skip (void) static int test_file_1 (void) { if (test_file_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_file_1"); return 0; } /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -9994,7 +12895,6 @@ static int test_file_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -10009,7 +12909,6 @@ static int test_file_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -10018,7 +12917,6 @@ static int test_file_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -10057,6 +12955,9 @@ static int test_file_2_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "file") == NULL; str = getenv ("SKIP_TEST_FILE_2"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_FILE"); @@ -10067,14 +12968,13 @@ static int test_file_2_skip (void) static int test_file_2 (void) { if (test_file_2_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_2"); + printf ("%s skipped (reason: environment variable set)\n", "test_file_2"); return 0; } /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -10097,7 +12997,6 @@ static int test_file_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -10112,7 +13011,6 @@ static int test_file_2 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -10121,7 +13019,6 @@ static int test_file_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -10146,6 +13043,9 @@ static int test_umount_all_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "umount_all") == NULL; str = getenv ("SKIP_TEST_UMOUNT_ALL_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_UMOUNT_ALL"); @@ -10156,14 +13056,13 @@ static int test_umount_all_0_skip (void) static int test_umount_all_0 (void) { if (test_umount_all_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_0"); return 0; } /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -10186,7 +13085,6 @@ static int test_umount_all_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -10201,7 +13099,6 @@ static int test_umount_all_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -10210,7 +13107,6 @@ static int test_umount_all_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -10249,6 +13145,9 @@ static int test_umount_all_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "umount_all") == NULL; str = getenv ("SKIP_TEST_UMOUNT_ALL_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_UMOUNT_ALL"); @@ -10259,14 +13158,13 @@ static int test_umount_all_1_skip (void) static int test_umount_all_1 (void) { if (test_umount_all_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_1"); return 0; } /* InitNone|InitEmpty for test_umount_all_1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -10290,7 +13188,6 @@ static int test_umount_all_1 (void) /* TestOutputList for umount_all (1) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ",10"; char lines_1[] = ",20"; char lines_2[] = ","; @@ -10309,7 +13206,6 @@ static int test_umount_all_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -10319,7 +13215,6 @@ static int test_umount_all_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda2"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -10329,7 +13224,6 @@ static int test_umount_all_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda3"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -10338,7 +13232,6 @@ static int test_umount_all_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -10356,7 +13249,6 @@ static int test_umount_all_1 (void) } { char device[] = "/dev/sda2"; - device[5] = devchar; char mountpoint[] = "/mp1"; int r; suppress_error = 0; @@ -10374,7 +13266,6 @@ static int test_umount_all_1 (void) } { char device[] = "/dev/sda3"; - device[5] = devchar; char mountpoint[] = "/mp1/mp2"; int r; suppress_error = 0; @@ -10420,6 +13311,9 @@ static int test_mounts_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mounts") == NULL; str = getenv ("SKIP_TEST_MOUNTS_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_MOUNTS"); @@ -10430,14 +13324,13 @@ static int test_mounts_0_skip (void) static int test_mounts_0 (void) { if (test_mounts_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mounts_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_mounts_0"); return 0; } /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -10460,7 +13353,6 @@ static int test_mounts_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -10475,7 +13367,6 @@ static int test_mounts_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -10484,7 +13375,6 @@ static int test_mounts_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -10492,7 +13382,7 @@ static int test_mounts_0 (void) if (r == -1) return -1; } - /* TestOutputList for mounts (0) */ + /* TestOutputListOfDevices for mounts (0) */ { char **r; int i; @@ -10507,7 +13397,7 @@ static int test_mounts_0 (void) } { char expected[] = "/dev/sda1"; - expected[5] = devchar; + r[0][5] = 's'; if (strcmp (r[0], expected) != 0) { fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]); return -1; @@ -10529,6 +13419,9 @@ static int test_umount_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "umount") == NULL; str = getenv ("SKIP_TEST_UMOUNT_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_UMOUNT"); @@ -10539,14 +13432,13 @@ static int test_umount_0_skip (void) static int test_umount_0 (void) { if (test_umount_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_umount_0"); return 0; } /* InitNone|InitEmpty for test_umount_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -10567,10 +13459,9 @@ static int test_umount_0 (void) if (r == -1) return -1; } - /* TestOutputList for umount (0) */ + /* TestOutputListOfDevices for umount (0) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -10585,7 +13476,6 @@ static int test_umount_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -10594,7 +13484,6 @@ static int test_umount_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -10616,7 +13505,7 @@ static int test_umount_0 (void) } { char expected[] = "/dev/sda1"; - expected[5] = devchar; + r[0][5] = 's'; if (strcmp (r[0], expected) != 0) { fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]); return -1; @@ -10638,6 +13527,9 @@ static int test_umount_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "umount") == NULL; str = getenv ("SKIP_TEST_UMOUNT_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_UMOUNT"); @@ -10648,14 +13540,13 @@ static int test_umount_1_skip (void) static int test_umount_1 (void) { if (test_umount_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_umount_1"); return 0; } /* InitNone|InitEmpty for test_umount_1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -10679,7 +13570,6 @@ static int test_umount_1 (void) /* TestOutputList for umount (1) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -10694,7 +13584,6 @@ static int test_umount_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -10703,7 +13592,6 @@ static int test_umount_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -10742,6 +13630,9 @@ static int test_write_file_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "write_file") == NULL; str = getenv ("SKIP_TEST_WRITE_FILE_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_WRITE_FILE"); @@ -10752,14 +13643,13 @@ static int test_write_file_0_skip (void) static int test_write_file_0 (void) { if (test_write_file_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_write_file_0"); return 0; } /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -10782,7 +13672,6 @@ static int test_write_file_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -10797,7 +13686,6 @@ static int test_write_file_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -10806,7 +13694,6 @@ static int test_write_file_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -10845,6 +13732,9 @@ static int test_write_file_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "write_file") == NULL; str = getenv ("SKIP_TEST_WRITE_FILE_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_WRITE_FILE"); @@ -10855,14 +13745,13 @@ static int test_write_file_1_skip (void) static int test_write_file_1 (void) { if (test_write_file_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_write_file_1"); return 0; } /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -10885,7 +13774,6 @@ static int test_write_file_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -10900,7 +13788,6 @@ static int test_write_file_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -10909,7 +13796,6 @@ static int test_write_file_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -10948,6 +13834,9 @@ static int test_write_file_2_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "write_file") == NULL; str = getenv ("SKIP_TEST_WRITE_FILE_2"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_WRITE_FILE"); @@ -10958,14 +13847,13 @@ static int test_write_file_2_skip (void) static int test_write_file_2 (void) { if (test_write_file_2_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_2"); + printf ("%s skipped (reason: environment variable set)\n", "test_write_file_2"); return 0; } /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -10988,7 +13876,6 @@ static int test_write_file_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -11003,7 +13890,6 @@ static int test_write_file_2 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -11012,7 +13898,6 @@ static int test_write_file_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -11051,6 +13936,9 @@ static int test_write_file_3_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "write_file") == NULL; str = getenv ("SKIP_TEST_WRITE_FILE_3"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_WRITE_FILE"); @@ -11061,14 +13949,13 @@ static int test_write_file_3_skip (void) static int test_write_file_3 (void) { if (test_write_file_3_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_3"); + printf ("%s skipped (reason: environment variable set)\n", "test_write_file_3"); return 0; } /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -11091,7 +13978,6 @@ static int test_write_file_3 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -11106,7 +13992,6 @@ static int test_write_file_3 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -11115,7 +14000,6 @@ static int test_write_file_3 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -11154,6 +14038,9 @@ static int test_write_file_4_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "write_file") == NULL; str = getenv ("SKIP_TEST_WRITE_FILE_4"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_WRITE_FILE"); @@ -11164,14 +14051,13 @@ static int test_write_file_4_skip (void) static int test_write_file_4 (void) { if (test_write_file_4_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_4"); + printf ("%s skipped (reason: environment variable set)\n", "test_write_file_4"); return 0; } /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -11194,7 +14080,6 @@ static int test_write_file_4 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -11209,7 +14094,6 @@ static int test_write_file_4 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -11218,7 +14102,6 @@ static int test_write_file_4 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -11257,6 +14140,9 @@ static int test_write_file_5_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "write_file") == NULL; str = getenv ("SKIP_TEST_WRITE_FILE_5"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_WRITE_FILE"); @@ -11267,14 +14153,13 @@ static int test_write_file_5_skip (void) static int test_write_file_5 (void) { if (test_write_file_5_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_5"); + printf ("%s skipped (reason: environment variable set)\n", "test_write_file_5"); return 0; } /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -11297,7 +14182,6 @@ static int test_write_file_5 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -11312,7 +14196,6 @@ static int test_write_file_5 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -11321,7 +14204,6 @@ static int test_write_file_5 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -11360,6 +14242,9 @@ static int test_mkfs_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mkfs") == NULL; str = getenv ("SKIP_TEST_MKFS_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_MKFS"); @@ -11370,14 +14255,13 @@ static int test_mkfs_0_skip (void) static int test_mkfs_0 (void) { if (test_mkfs_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkfs_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_mkfs_0"); return 0; } /* InitNone|InitEmpty for test_mkfs_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -11402,7 +14286,6 @@ static int test_mkfs_0 (void) char expected[] = "new file contents"; { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -11417,7 +14300,6 @@ static int test_mkfs_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -11426,7 +14308,6 @@ static int test_mkfs_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -11463,6 +14344,9 @@ static int test_lvcreate_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "lvcreate") == NULL; str = getenv ("SKIP_TEST_LVCREATE_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_LVCREATE"); @@ -11473,14 +14357,13 @@ static int test_lvcreate_0_skip (void) static int test_lvcreate_0 (void) { if (test_lvcreate_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvcreate_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_lvcreate_0"); return 0; } /* InitNone|InitEmpty for test_lvcreate_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -11504,7 +14387,6 @@ static int test_lvcreate_0 (void) /* TestOutputList for lvcreate (0) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ",10"; char lines_1[] = ",20"; char lines_2[] = ","; @@ -11522,7 +14404,6 @@ static int test_lvcreate_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -11531,7 +14412,6 @@ static int test_lvcreate_0 (void) } { char device[] = "/dev/sda2"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -11540,7 +14420,6 @@ static int test_lvcreate_0 (void) } { char device[] = "/dev/sda3"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -11550,9 +14429,7 @@ static int test_lvcreate_0 (void) { char volgroup[] = "VG1"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char physvols_1[] = "/dev/sda2"; - physvols_1[5] = devchar; char *physvols[] = { physvols_0, physvols_1, @@ -11567,7 +14444,6 @@ static int test_lvcreate_0 (void) { char volgroup[] = "VG2"; char physvols_0[] = "/dev/sda3"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -11706,6 +14582,9 @@ static int test_vgcreate_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "vgcreate") == NULL; str = getenv ("SKIP_TEST_VGCREATE_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_VGCREATE"); @@ -11716,14 +14595,13 @@ static int test_vgcreate_0_skip (void) static int test_vgcreate_0 (void) { if (test_vgcreate_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgcreate_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_vgcreate_0"); return 0; } /* InitNone|InitEmpty for test_vgcreate_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -11747,7 +14625,6 @@ static int test_vgcreate_0 (void) /* TestOutputList for vgcreate (0) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ",10"; char lines_1[] = ",20"; char lines_2[] = ","; @@ -11765,7 +14642,6 @@ static int test_vgcreate_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -11774,7 +14650,6 @@ static int test_vgcreate_0 (void) } { char device[] = "/dev/sda2"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -11783,7 +14658,6 @@ static int test_vgcreate_0 (void) } { char device[] = "/dev/sda3"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -11793,9 +14667,7 @@ static int test_vgcreate_0 (void) { char volgroup[] = "VG1"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char physvols_1[] = "/dev/sda2"; - physvols_1[5] = devchar; char *physvols[] = { physvols_0, physvols_1, @@ -11810,7 +14682,6 @@ static int test_vgcreate_0 (void) { char volgroup[] = "VG2"; char physvols_0[] = "/dev/sda3"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -11868,6 +14739,9 @@ static int test_pvcreate_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "pvcreate") == NULL; str = getenv ("SKIP_TEST_PVCREATE_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_PVCREATE"); @@ -11878,14 +14752,13 @@ static int test_pvcreate_0_skip (void) static int test_pvcreate_0 (void) { if (test_pvcreate_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvcreate_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_pvcreate_0"); return 0; } /* InitNone|InitEmpty for test_pvcreate_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -11906,10 +14779,9 @@ static int test_pvcreate_0 (void) if (r == -1) return -1; } - /* TestOutputList for pvcreate (0) */ + /* TestOutputListOfDevices for pvcreate (0) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ",10"; char lines_1[] = ",20"; char lines_2[] = ","; @@ -11927,7 +14799,6 @@ static int test_pvcreate_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -11936,7 +14807,6 @@ static int test_pvcreate_0 (void) } { char device[] = "/dev/sda2"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -11945,7 +14815,6 @@ static int test_pvcreate_0 (void) } { char device[] = "/dev/sda3"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -11966,7 +14835,7 @@ static int test_pvcreate_0 (void) } { char expected[] = "/dev/sda1"; - expected[5] = devchar; + r[0][5] = 's'; if (strcmp (r[0], expected) != 0) { fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]); return -1; @@ -11979,7 +14848,7 @@ static int test_pvcreate_0 (void) } { char expected[] = "/dev/sda2"; - expected[5] = devchar; + r[1][5] = 's'; if (strcmp (r[1], expected) != 0) { fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]); return -1; @@ -11992,7 +14861,7 @@ static int test_pvcreate_0 (void) } { char expected[] = "/dev/sda3"; - expected[5] = devchar; + r[2][5] = 's'; if (strcmp (r[2], expected) != 0) { fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]); return -1; @@ -12014,6 +14883,9 @@ static int test_is_dir_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "is_dir") == NULL; str = getenv ("SKIP_TEST_IS_DIR_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_IS_DIR"); @@ -12024,14 +14896,13 @@ static int test_is_dir_0_skip (void) static int test_is_dir_0 (void) { if (test_is_dir_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_0"); return 0; } /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -12054,7 +14925,6 @@ static int test_is_dir_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -12069,7 +14939,6 @@ static int test_is_dir_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -12078,7 +14947,6 @@ static int test_is_dir_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -12114,6 +14982,9 @@ static int test_is_dir_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "is_dir") == NULL; str = getenv ("SKIP_TEST_IS_DIR_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_IS_DIR"); @@ -12124,14 +14995,13 @@ static int test_is_dir_1_skip (void) static int test_is_dir_1 (void) { if (test_is_dir_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_1"); return 0; } /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -12154,7 +15024,6 @@ static int test_is_dir_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -12169,7 +15038,6 @@ static int test_is_dir_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -12178,7 +15046,6 @@ static int test_is_dir_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -12214,6 +15081,9 @@ static int test_is_file_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "is_file") == NULL; str = getenv ("SKIP_TEST_IS_FILE_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_IS_FILE"); @@ -12224,14 +15094,13 @@ static int test_is_file_0_skip (void) static int test_is_file_0 (void) { if (test_is_file_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_is_file_0"); return 0; } /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -12254,7 +15123,6 @@ static int test_is_file_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -12269,7 +15137,6 @@ static int test_is_file_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -12278,7 +15145,6 @@ static int test_is_file_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -12314,6 +15180,9 @@ static int test_is_file_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "is_file") == NULL; str = getenv ("SKIP_TEST_IS_FILE_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_IS_FILE"); @@ -12324,14 +15193,13 @@ static int test_is_file_1_skip (void) static int test_is_file_1 (void) { if (test_is_file_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_is_file_1"); return 0; } /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -12354,7 +15222,6 @@ static int test_is_file_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -12369,7 +15236,6 @@ static int test_is_file_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -12378,7 +15244,6 @@ static int test_is_file_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -12414,6 +15279,9 @@ static int test_exists_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "exists") == NULL; str = getenv ("SKIP_TEST_EXISTS_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_EXISTS"); @@ -12424,14 +15292,13 @@ static int test_exists_0_skip (void) static int test_exists_0 (void) { if (test_exists_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_exists_0"); return 0; } /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -12454,7 +15321,6 @@ static int test_exists_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -12469,7 +15335,6 @@ static int test_exists_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -12478,7 +15343,6 @@ static int test_exists_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -12514,6 +15378,9 @@ static int test_exists_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "exists") == NULL; str = getenv ("SKIP_TEST_EXISTS_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_EXISTS"); @@ -12524,14 +15391,13 @@ static int test_exists_1_skip (void) static int test_exists_1 (void) { if (test_exists_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_exists_1"); return 0; } /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -12554,7 +15420,6 @@ static int test_exists_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -12569,7 +15434,6 @@ static int test_exists_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -12578,7 +15442,6 @@ static int test_exists_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -12614,6 +15477,9 @@ static int test_mkdir_p_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mkdir_p") == NULL; str = getenv ("SKIP_TEST_MKDIR_P_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_MKDIR_P"); @@ -12624,14 +15490,13 @@ static int test_mkdir_p_0_skip (void) static int test_mkdir_p_0 (void) { if (test_mkdir_p_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_0"); return 0; } /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -12654,7 +15519,6 @@ static int test_mkdir_p_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -12669,7 +15533,6 @@ static int test_mkdir_p_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -12678,7 +15541,6 @@ static int test_mkdir_p_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -12714,6 +15576,9 @@ static int test_mkdir_p_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mkdir_p") == NULL; str = getenv ("SKIP_TEST_MKDIR_P_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_MKDIR_P"); @@ -12724,14 +15589,13 @@ static int test_mkdir_p_1_skip (void) static int test_mkdir_p_1 (void) { if (test_mkdir_p_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_1"); return 0; } /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -12754,7 +15618,6 @@ static int test_mkdir_p_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -12769,7 +15632,6 @@ static int test_mkdir_p_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -12778,7 +15640,6 @@ static int test_mkdir_p_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -12814,6 +15675,9 @@ static int test_mkdir_p_2_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mkdir_p") == NULL; str = getenv ("SKIP_TEST_MKDIR_P_2"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_MKDIR_P"); @@ -12824,14 +15688,13 @@ static int test_mkdir_p_2_skip (void) static int test_mkdir_p_2 (void) { if (test_mkdir_p_2_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_2"); + printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_2"); return 0; } /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -12854,7 +15717,6 @@ static int test_mkdir_p_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -12869,7 +15731,6 @@ static int test_mkdir_p_2 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -12878,7 +15739,6 @@ static int test_mkdir_p_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -12914,6 +15774,9 @@ static int test_mkdir_p_3_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mkdir_p") == NULL; str = getenv ("SKIP_TEST_MKDIR_P_3"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_MKDIR_P"); @@ -12924,14 +15787,13 @@ static int test_mkdir_p_3_skip (void) static int test_mkdir_p_3 (void) { if (test_mkdir_p_3_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_3"); + printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_3"); return 0; } /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -12954,7 +15816,6 @@ static int test_mkdir_p_3 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -12969,7 +15830,6 @@ static int test_mkdir_p_3 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -12978,7 +15838,6 @@ static int test_mkdir_p_3 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -13010,6 +15869,9 @@ static int test_mkdir_p_4_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mkdir_p") == NULL; str = getenv ("SKIP_TEST_MKDIR_P_4"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_MKDIR_P"); @@ -13020,14 +15882,13 @@ static int test_mkdir_p_4_skip (void) static int test_mkdir_p_4 (void) { if (test_mkdir_p_4_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_4"); + printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_4"); return 0; } /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -13050,7 +15911,6 @@ static int test_mkdir_p_4 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -13065,7 +15925,6 @@ static int test_mkdir_p_4 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -13074,7 +15933,6 @@ static int test_mkdir_p_4 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -13106,6 +15964,9 @@ static int test_mkdir_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mkdir") == NULL; str = getenv ("SKIP_TEST_MKDIR_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_MKDIR"); @@ -13116,14 +15977,13 @@ static int test_mkdir_0_skip (void) static int test_mkdir_0 (void) { if (test_mkdir_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_0"); return 0; } /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -13146,7 +16006,6 @@ static int test_mkdir_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -13161,7 +16020,6 @@ static int test_mkdir_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -13170,7 +16028,6 @@ static int test_mkdir_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -13206,6 +16063,9 @@ static int test_mkdir_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mkdir") == NULL; str = getenv ("SKIP_TEST_MKDIR_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_MKDIR"); @@ -13216,14 +16076,13 @@ static int test_mkdir_1_skip (void) static int test_mkdir_1 (void) { if (test_mkdir_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_1"); return 0; } /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -13246,7 +16105,6 @@ static int test_mkdir_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -13261,7 +16119,6 @@ static int test_mkdir_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -13270,7 +16127,6 @@ static int test_mkdir_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -13294,6 +16150,9 @@ static int test_rm_rf_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "rm_rf") == NULL; str = getenv ("SKIP_TEST_RM_RF_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_RM_RF"); @@ -13304,14 +16163,13 @@ static int test_rm_rf_0_skip (void) static int test_rm_rf_0 (void) { if (test_rm_rf_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_rf_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_rm_rf_0"); return 0; } /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -13334,7 +16192,6 @@ static int test_rm_rf_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -13349,7 +16206,6 @@ static int test_rm_rf_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -13358,7 +16214,6 @@ static int test_rm_rf_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -13418,6 +16273,9 @@ static int test_rmdir_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "rmdir") == NULL; str = getenv ("SKIP_TEST_RMDIR_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_RMDIR"); @@ -13428,14 +16286,13 @@ static int test_rmdir_0_skip (void) static int test_rmdir_0 (void) { if (test_rmdir_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_0"); return 0; } /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -13458,7 +16315,6 @@ static int test_rmdir_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -13473,7 +16329,6 @@ static int test_rmdir_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -13482,7 +16337,6 @@ static int test_rmdir_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -13514,6 +16368,9 @@ static int test_rmdir_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "rmdir") == NULL; str = getenv ("SKIP_TEST_RMDIR_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_RMDIR"); @@ -13524,14 +16381,13 @@ static int test_rmdir_1_skip (void) static int test_rmdir_1 (void) { if (test_rmdir_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_1"); return 0; } /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -13554,7 +16410,6 @@ static int test_rmdir_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -13569,7 +16424,6 @@ static int test_rmdir_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -13578,7 +16432,6 @@ static int test_rmdir_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -13602,6 +16455,9 @@ static int test_rmdir_2_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "rmdir") == NULL; str = getenv ("SKIP_TEST_RMDIR_2"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_RMDIR"); @@ -13612,14 +16468,13 @@ static int test_rmdir_2_skip (void) static int test_rmdir_2 (void) { if (test_rmdir_2_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_2"); + printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_2"); return 0; } /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -13642,7 +16497,6 @@ static int test_rmdir_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -13657,7 +16511,6 @@ static int test_rmdir_2 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -13666,7 +16519,6 @@ static int test_rmdir_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -13698,6 +16550,9 @@ static int test_rm_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "rm") == NULL; str = getenv ("SKIP_TEST_RM_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_RM"); @@ -13708,14 +16563,13 @@ static int test_rm_0_skip (void) static int test_rm_0 (void) { if (test_rm_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_rm_0"); return 0; } /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -13738,7 +16592,6 @@ static int test_rm_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -13753,7 +16606,6 @@ static int test_rm_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -13762,7 +16614,6 @@ static int test_rm_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -13794,6 +16645,9 @@ static int test_rm_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "rm") == NULL; str = getenv ("SKIP_TEST_RM_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_RM"); @@ -13804,14 +16658,13 @@ static int test_rm_1_skip (void) static int test_rm_1 (void) { if (test_rm_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_rm_1"); return 0; } /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -13834,7 +16687,6 @@ static int test_rm_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -13849,7 +16701,6 @@ static int test_rm_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -13858,7 +16709,6 @@ static int test_rm_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -13882,6 +16732,9 @@ static int test_rm_2_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "rm") == NULL; str = getenv ("SKIP_TEST_RM_2"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_RM"); @@ -13892,14 +16745,13 @@ static int test_rm_2_skip (void) static int test_rm_2 (void) { if (test_rm_2_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_2"); + printf ("%s skipped (reason: environment variable set)\n", "test_rm_2"); return 0; } /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -13922,7 +16774,6 @@ static int test_rm_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -13937,7 +16788,6 @@ static int test_rm_2 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -13946,7 +16796,6 @@ static int test_rm_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -13978,6 +16827,9 @@ static int test_read_lines_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "read_lines") == NULL; str = getenv ("SKIP_TEST_READ_LINES_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_READ_LINES"); @@ -13988,14 +16840,13 @@ static int test_read_lines_0_skip (void) static int test_read_lines_0 (void) { if (test_read_lines_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_0"); return 0; } /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -14018,7 +16869,6 @@ static int test_read_lines_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -14033,7 +16883,6 @@ static int test_read_lines_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -14042,7 +16891,6 @@ static int test_read_lines_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -14120,6 +16968,9 @@ static int test_read_lines_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "read_lines") == NULL; str = getenv ("SKIP_TEST_READ_LINES_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_READ_LINES"); @@ -14130,14 +16981,13 @@ static int test_read_lines_1_skip (void) static int test_read_lines_1 (void) { if (test_read_lines_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_1"); return 0; } /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -14160,7 +17010,6 @@ static int test_read_lines_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -14175,7 +17024,6 @@ static int test_read_lines_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -14184,7 +17032,6 @@ static int test_read_lines_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -14226,6 +17073,9 @@ static int test_lvs_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "lvs") == NULL; str = getenv ("SKIP_TEST_LVS_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_LVS"); @@ -14236,14 +17086,13 @@ static int test_lvs_0_skip (void) static int test_lvs_0 (void) { if (test_lvs_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_lvs_0"); return 0; } /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -14266,7 +17115,6 @@ static int test_lvs_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -14280,7 +17128,6 @@ static int test_lvs_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -14290,7 +17137,6 @@ static int test_lvs_0 (void) { char volgroup[] = "VG"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -14364,6 +17210,9 @@ static int test_lvs_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "lvs") == NULL; str = getenv ("SKIP_TEST_LVS_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_LVS"); @@ -14374,14 +17223,13 @@ static int test_lvs_1_skip (void) static int test_lvs_1 (void) { if (test_lvs_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_lvs_1"); return 0; } /* InitNone|InitEmpty for test_lvs_1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -14405,7 +17253,6 @@ static int test_lvs_1 (void) /* TestOutputList for lvs (1) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ",10"; char lines_1[] = ",20"; char lines_2[] = ","; @@ -14423,7 +17270,6 @@ static int test_lvs_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -14432,7 +17278,6 @@ static int test_lvs_1 (void) } { char device[] = "/dev/sda2"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -14441,7 +17286,6 @@ static int test_lvs_1 (void) } { char device[] = "/dev/sda3"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -14451,9 +17295,7 @@ static int test_lvs_1 (void) { char volgroup[] = "VG1"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char physvols_1[] = "/dev/sda2"; - physvols_1[5] = devchar; char *physvols[] = { physvols_0, physvols_1, @@ -14468,7 +17310,6 @@ static int test_lvs_1 (void) { char volgroup[] = "VG2"; char physvols_0[] = "/dev/sda3"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -14565,6 +17406,9 @@ static int test_vgs_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "vgs") == NULL; str = getenv ("SKIP_TEST_VGS_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_VGS"); @@ -14575,14 +17419,13 @@ static int test_vgs_0_skip (void) static int test_vgs_0 (void) { if (test_vgs_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_vgs_0"); return 0; } /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -14605,7 +17448,6 @@ static int test_vgs_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -14619,7 +17461,6 @@ static int test_vgs_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -14629,7 +17470,6 @@ static int test_vgs_0 (void) { char volgroup[] = "VG"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -14703,6 +17543,9 @@ static int test_vgs_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "vgs") == NULL; str = getenv ("SKIP_TEST_VGS_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_VGS"); @@ -14713,14 +17556,13 @@ static int test_vgs_1_skip (void) static int test_vgs_1 (void) { if (test_vgs_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_vgs_1"); return 0; } /* InitNone|InitEmpty for test_vgs_1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -14744,7 +17586,6 @@ static int test_vgs_1 (void) /* TestOutputList for vgs (1) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ",10"; char lines_1[] = ",20"; char lines_2[] = ","; @@ -14762,7 +17603,6 @@ static int test_vgs_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -14771,7 +17611,6 @@ static int test_vgs_1 (void) } { char device[] = "/dev/sda2"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -14780,7 +17619,6 @@ static int test_vgs_1 (void) } { char device[] = "/dev/sda3"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -14790,9 +17628,7 @@ static int test_vgs_1 (void) { char volgroup[] = "VG1"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char physvols_1[] = "/dev/sda2"; - physvols_1[5] = devchar; char *physvols[] = { physvols_0, physvols_1, @@ -14807,7 +17643,6 @@ static int test_vgs_1 (void) { char volgroup[] = "VG2"; char physvols_0[] = "/dev/sda3"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -14865,6 +17700,9 @@ static int test_pvs_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "pvs") == NULL; str = getenv ("SKIP_TEST_PVS_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_PVS"); @@ -14875,14 +17713,13 @@ static int test_pvs_0_skip (void) static int test_pvs_0 (void) { if (test_pvs_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_pvs_0"); return 0; } /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -14905,7 +17742,6 @@ static int test_pvs_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -14919,7 +17755,6 @@ static int test_pvs_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -14929,7 +17764,6 @@ static int test_pvs_0 (void) { char volgroup[] = "VG"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -14967,7 +17801,7 @@ static int test_pvs_0 (void) if (r == -1) return -1; } - /* TestOutputList for pvs (0) */ + /* TestOutputListOfDevices for pvs (0) */ { char **r; int i; @@ -14982,7 +17816,7 @@ static int test_pvs_0 (void) } { char expected[] = "/dev/sda1"; - expected[5] = devchar; + r[0][5] = 's'; if (strcmp (r[0], expected) != 0) { fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]); return -1; @@ -15004,6 +17838,9 @@ static int test_pvs_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "pvs") == NULL; str = getenv ("SKIP_TEST_PVS_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_PVS"); @@ -15014,14 +17851,13 @@ static int test_pvs_1_skip (void) static int test_pvs_1 (void) { if (test_pvs_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_pvs_1"); return 0; } /* InitNone|InitEmpty for test_pvs_1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -15042,10 +17878,9 @@ static int test_pvs_1 (void) if (r == -1) return -1; } - /* TestOutputList for pvs (1) */ + /* TestOutputListOfDevices for pvs (1) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ",10"; char lines_1[] = ",20"; char lines_2[] = ","; @@ -15063,7 +17898,6 @@ static int test_pvs_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -15072,7 +17906,6 @@ static int test_pvs_1 (void) } { char device[] = "/dev/sda2"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -15081,7 +17914,6 @@ static int test_pvs_1 (void) } { char device[] = "/dev/sda3"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -15102,7 +17934,7 @@ static int test_pvs_1 (void) } { char expected[] = "/dev/sda1"; - expected[5] = devchar; + r[0][5] = 's'; if (strcmp (r[0], expected) != 0) { fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]); return -1; @@ -15115,7 +17947,7 @@ static int test_pvs_1 (void) } { char expected[] = "/dev/sda2"; - expected[5] = devchar; + r[1][5] = 's'; if (strcmp (r[1], expected) != 0) { fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]); return -1; @@ -15128,7 +17960,7 @@ static int test_pvs_1 (void) } { char expected[] = "/dev/sda3"; - expected[5] = devchar; + r[2][5] = 's'; if (strcmp (r[2], expected) != 0) { fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]); return -1; @@ -15150,6 +17982,9 @@ static int test_list_partitions_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "list_partitions") == NULL; str = getenv ("SKIP_TEST_LIST_PARTITIONS_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_LIST_PARTITIONS"); @@ -15160,14 +17995,13 @@ static int test_list_partitions_0_skip (void) static int test_list_partitions_0 (void) { if (test_list_partitions_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_0"); return 0; } /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -15190,7 +18024,6 @@ static int test_list_partitions_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -15205,7 +18038,6 @@ static int test_list_partitions_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -15214,7 +18046,6 @@ static int test_list_partitions_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -15222,7 +18053,7 @@ static int test_list_partitions_0 (void) if (r == -1) return -1; } - /* TestOutputList for list_partitions (0) */ + /* TestOutputListOfDevices for list_partitions (0) */ { char **r; int i; @@ -15237,7 +18068,7 @@ static int test_list_partitions_0 (void) } { char expected[] = "/dev/sda1"; - expected[5] = devchar; + r[0][5] = 's'; if (strcmp (r[0], expected) != 0) { fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]); return -1; @@ -15259,6 +18090,9 @@ static int test_list_partitions_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "list_partitions") == NULL; str = getenv ("SKIP_TEST_LIST_PARTITIONS_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_LIST_PARTITIONS"); @@ -15269,14 +18103,13 @@ static int test_list_partitions_1_skip (void) static int test_list_partitions_1 (void) { if (test_list_partitions_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_1"); return 0; } /* InitNone|InitEmpty for test_list_partitions_1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -15297,10 +18130,9 @@ static int test_list_partitions_1 (void) if (r == -1) return -1; } - /* TestOutputList for list_partitions (1) */ + /* TestOutputListOfDevices for list_partitions (1) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ",10"; char lines_1[] = ",20"; char lines_2[] = ","; @@ -15330,7 +18162,7 @@ static int test_list_partitions_1 (void) } { char expected[] = "/dev/sda1"; - expected[5] = devchar; + r[0][5] = 's'; if (strcmp (r[0], expected) != 0) { fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]); return -1; @@ -15343,7 +18175,7 @@ static int test_list_partitions_1 (void) } { char expected[] = "/dev/sda2"; - expected[5] = devchar; + r[1][5] = 's'; if (strcmp (r[1], expected) != 0) { fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]); return -1; @@ -15356,7 +18188,7 @@ static int test_list_partitions_1 (void) } { char expected[] = "/dev/sda3"; - expected[5] = devchar; + r[2][5] = 's'; if (strcmp (r[2], expected) != 0) { fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]); return -1; @@ -15378,6 +18210,9 @@ static int test_list_devices_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "list_devices") == NULL; str = getenv ("SKIP_TEST_LIST_DEVICES_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_LIST_DEVICES"); @@ -15388,14 +18223,13 @@ static int test_list_devices_0_skip (void) static int test_list_devices_0 (void) { if (test_list_devices_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_devices_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_list_devices_0"); return 0; } /* InitNone|InitEmpty for test_list_devices_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -15416,7 +18250,7 @@ static int test_list_devices_0 (void) if (r == -1) return -1; } - /* TestOutputList for list_devices (0) */ + /* TestOutputListOfDevices for list_devices (0) */ { char **r; int i; @@ -15431,7 +18265,7 @@ static int test_list_devices_0 (void) } { char expected[] = "/dev/sda"; - expected[5] = devchar; + r[0][5] = 's'; if (strcmp (r[0], expected) != 0) { fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]); return -1; @@ -15444,7 +18278,7 @@ static int test_list_devices_0 (void) } { char expected[] = "/dev/sdb"; - expected[5] = devchar; + r[1][5] = 's'; if (strcmp (r[1], expected) != 0) { fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]); return -1; @@ -15457,7 +18291,7 @@ static int test_list_devices_0 (void) } { char expected[] = "/dev/sdc"; - expected[5] = devchar; + r[2][5] = 's'; if (strcmp (r[2], expected) != 0) { fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]); return -1; @@ -15470,7 +18304,7 @@ static int test_list_devices_0 (void) } { char expected[] = "/dev/sdd"; - expected[5] = devchar; + r[3][5] = 's'; if (strcmp (r[3], expected) != 0) { fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]); return -1; @@ -15492,6 +18326,9 @@ static int test_ls_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "ls") == NULL; str = getenv ("SKIP_TEST_LS_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_LS"); @@ -15502,14 +18339,13 @@ static int test_ls_0_skip (void) static int test_ls_0 (void) { if (test_ls_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ls_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_ls_0"); return 0; } /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -15532,7 +18368,6 @@ static int test_ls_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -15547,7 +18382,6 @@ static int test_ls_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -15556,7 +18390,6 @@ static int test_ls_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -15661,6 +18494,9 @@ static int test_cat_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "cat") == NULL; str = getenv ("SKIP_TEST_CAT_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_CAT"); @@ -15671,14 +18507,13 @@ static int test_cat_0_skip (void) static int test_cat_0 (void) { if (test_cat_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cat_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_cat_0"); return 0; } /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -15701,7 +18536,6 @@ static int test_cat_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -15716,7 +18550,6 @@ static int test_cat_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -15725,7 +18558,6 @@ static int test_cat_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -15764,6 +18596,9 @@ static int test_touch_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "touch") == NULL; str = getenv ("SKIP_TEST_TOUCH_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_TOUCH"); @@ -15774,14 +18609,13 @@ static int test_touch_0_skip (void) static int test_touch_0 (void) { if (test_touch_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_touch_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_touch_0"); return 0; } /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -15804,7 +18638,6 @@ static int test_touch_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -15819,7 +18652,6 @@ static int test_touch_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -15828,7 +18660,6 @@ static int test_touch_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -15864,6 +18695,9 @@ static int test_sync_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "sync") == NULL; str = getenv ("SKIP_TEST_SYNC_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_SYNC"); @@ -15874,14 +18708,13 @@ static int test_sync_0_skip (void) static int test_sync_0 (void) { if (test_sync_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sync_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_sync_0"); return 0; } /* InitNone|InitEmpty for test_sync_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -15917,6 +18750,9 @@ static int test_mount_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mount") == NULL; str = getenv ("SKIP_TEST_MOUNT_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_MOUNT"); @@ -15927,14 +18763,13 @@ static int test_mount_0_skip (void) static int test_mount_0 (void) { if (test_mount_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_mount_0"); return 0; } /* InitNone|InitEmpty for test_mount_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -15959,7 +18794,6 @@ static int test_mount_0 (void) char expected[] = "new file contents"; { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -15974,7 +18808,6 @@ static int test_mount_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -15983,7 +18816,6 @@ static int test_mount_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -16020,11 +18852,9 @@ int main (int argc, char *argv[]) { char c = 0; int failed = 0; - const char *srcdir; const char *filename; - int fd, i; + int fd; int nr_tests, test_num = 0; - char **devs; no_test_warnings (); @@ -16122,8 +18952,8 @@ int main (int argc, char *argv[]) exit (1); } - if (guestfs_add_drive (g, "../images/test.sqsh") == -1) { - printf ("guestfs_add_drive %s FAILED\n", filename); + if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) { + printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n"); exit (1); } @@ -16131,36 +18961,171 @@ int main (int argc, char *argv[]) printf ("guestfs_launch FAILED\n"); exit (1); } + + /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */ + alarm (600); + if (guestfs_wait_ready (g) == -1) { printf ("guestfs_wait_ready FAILED\n"); exit (1); } - /* Detect if the appliance uses /dev/sd* or /dev/hd* in device - * names. This changed between RHEL 5 and RHEL 6 so we have to - * support both. - */ - devs = guestfs_list_devices (g); - if (devs == NULL || devs[0] == NULL) { - printf ("guestfs_list_devices FAILED\n"); - exit (1); - } - if (strncmp (devs[0], "/dev/sd", 7) == 0) - devchar = 's'; - else if (strncmp (devs[0], "/dev/hd", 7) == 0) - devchar = 'h'; - else { - printf ("guestfs_list_devices returned unexpected string '%s'\n", - devs[0]); - exit (1); - } - for (i = 0; devs[i] != NULL; ++i) - free (devs[i]); - free (devs); + /* Cancel previous alarm. */ + alarm (0); - nr_tests = 143; + nr_tests = 169; test_num++; + printf ("%3d/%3d test_mkswap_U_0\n", test_num, nr_tests); + if (test_mkswap_U_0 () == -1) { + printf ("test_mkswap_U_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_mkswap_L_0\n", test_num, nr_tests); + if (test_mkswap_L_0 () == -1) { + printf ("test_mkswap_L_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_mkswap_0\n", test_num, nr_tests); + if (test_mkswap_0 () == -1) { + printf ("test_mkswap_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_initrd_list_0\n", test_num, nr_tests); + if (test_initrd_list_0 () == -1) { + printf ("test_initrd_list_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_du_0\n", test_num, nr_tests); + if (test_du_0 () == -1) { + printf ("test_du_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_tail_n_0\n", test_num, nr_tests); + if (test_tail_n_0 () == -1) { + printf ("test_tail_n_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_tail_n_1\n", test_num, nr_tests); + if (test_tail_n_1 () == -1) { + printf ("test_tail_n_1 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_tail_n_2\n", test_num, nr_tests); + if (test_tail_n_2 () == -1) { + printf ("test_tail_n_2 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_tail_0\n", test_num, nr_tests); + if (test_tail_0 () == -1) { + printf ("test_tail_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_head_n_0\n", test_num, nr_tests); + if (test_head_n_0 () == -1) { + printf ("test_head_n_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_head_n_1\n", test_num, nr_tests); + if (test_head_n_1 () == -1) { + printf ("test_head_n_1 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_head_n_2\n", test_num, nr_tests); + if (test_head_n_2 () == -1) { + printf ("test_head_n_2 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_head_0\n", test_num, nr_tests); + if (test_head_0 () == -1) { + printf ("test_head_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_wc_c_0\n", test_num, nr_tests); + if (test_wc_c_0 () == -1) { + printf ("test_wc_c_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_wc_w_0\n", test_num, nr_tests); + if (test_wc_w_0 () == -1) { + printf ("test_wc_w_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_wc_l_0\n", test_num, nr_tests); + if (test_wc_l_0 () == -1) { + printf ("test_wc_l_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_mkdtemp_0\n", test_num, nr_tests); + if (test_mkdtemp_0 () == -1) { + printf ("test_mkdtemp_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_scrub_file_0\n", test_num, nr_tests); + if (test_scrub_file_0 () == -1) { + printf ("test_scrub_file_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_scrub_device_0\n", test_num, nr_tests); + if (test_scrub_device_0 () == -1) { + printf ("test_scrub_device_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_glob_expand_0\n", test_num, nr_tests); + if (test_glob_expand_0 () == -1) { + printf ("test_glob_expand_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_glob_expand_1\n", test_num, nr_tests); + if (test_glob_expand_1 () == -1) { + printf ("test_glob_expand_1 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_glob_expand_2\n", test_num, nr_tests); + if (test_glob_expand_2 () == -1) { + printf ("test_glob_expand_2 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests); + if (test_ntfs_3g_probe_0 () == -1) { + printf ("test_ntfs_3g_probe_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests); + if (test_ntfs_3g_probe_1 () == -1) { + printf ("test_ntfs_3g_probe_1 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests); + if (test_sleep_0 () == -1) { + printf ("test_sleep_0 FAILED\n"); + failed++; + } + test_num++; printf ("%3d/%3d test_find_0\n", test_num, nr_tests); if (test_find_0 () == -1) { printf ("test_find_0 FAILED\n"); @@ -16197,6 +19162,12 @@ int main (int argc, char *argv[]) failed++; } test_num++; + printf ("%3d/%3d test_hexdump_1\n", test_num, nr_tests); + if (test_hexdump_1 () == -1) { + printf ("test_hexdump_1 FAILED\n"); + failed++; + } + test_num++; printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests); if (test_strings_e_0 () == -1) { printf ("test_strings_e_0 FAILED\n");