X-Git-Url: http://git.annexia.org/?p=libguestfs.git;a=blobdiff_plain;f=capitests%2Ftests.c;h=ba2e806d4ca9c1eef0e139f0a986131edd1102eb;hp=c0c359797bf1f2e77f6be978b5c7911a5fe17f99;hb=c6d6f5ae1b76ec9aa5c540906aeed73d25d13eb9;hpb=c41fe04a652437c920acb0e820762c53bf44a139 diff --git a/capitests/tests.c b/capitests/tests.c index c0c3597..ba2e806 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,2695 @@ 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"); +} + +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 +2847,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 +2876,6 @@ static int test_find_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -213,7 +2890,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 +2898,6 @@ static int test_find_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -267,6 +2942,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 +2955,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 +2984,6 @@ static int test_find_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -322,7 +2998,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 +3006,6 @@ static int test_find_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -436,6 +3110,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 +3123,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 +3152,6 @@ static int test_find_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -491,7 +3166,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 +3174,6 @@ static int test_find_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -573,6 +3246,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 +3259,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 +3290,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 +3303,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 +3312,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 +3419,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 +3432,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 +3463,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 +3477,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 +3485,6 @@ static int test_zerofree_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -832,7 +3503,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 +3511,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 +3519,6 @@ static int test_zerofree_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -878,6 +3546,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 +3559,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 +3588,6 @@ static int test_hexdump_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -933,7 +3602,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 +3610,6 @@ static int test_hexdump_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -977,10 +3644,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 +3760,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 +3789,6 @@ static int test_strings_e_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -1036,7 +3803,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 +3811,6 @@ static int test_strings_e_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -1088,6 +3853,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 +3866,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 +3878,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 +3891,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 +3920,6 @@ static int test_strings_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -1165,7 +3934,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 +3942,6 @@ static int test_strings_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -1240,6 +4007,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 +4020,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 +4049,6 @@ static int test_strings_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -1295,7 +4063,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 +4071,6 @@ static int test_strings_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -1345,6 +4111,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 +4124,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 +4153,6 @@ static int test_equal_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -1400,7 +4167,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 +4175,6 @@ static int test_equal_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -1456,6 +4221,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 +4234,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 +4263,6 @@ static int test_equal_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -1511,7 +4277,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 +4285,6 @@ static int test_equal_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -1567,6 +4331,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 +4344,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 +4373,6 @@ static int test_equal_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -1622,7 +4387,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 +4395,6 @@ static int test_equal_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -1656,6 +4419,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 +4432,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 +4474,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 +4487,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 +4530,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 +4543,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 +4585,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 +4598,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 +4627,6 @@ static int test_mv_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -1871,7 +4641,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 +4649,6 @@ static int test_mv_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -1928,6 +4696,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 +4709,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 +4738,6 @@ static int test_mv_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -1983,7 +4752,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 +4760,6 @@ static int test_mv_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -2038,6 +4805,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 +4818,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 +4847,6 @@ static int test_cp_a_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -2093,7 +4861,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 +4869,6 @@ static int test_cp_a_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -2166,6 +4932,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 +4945,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 +4974,6 @@ static int test_cp_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -2221,7 +4988,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 +4996,6 @@ static int test_cp_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -2278,6 +5043,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 +5056,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 +5085,6 @@ static int test_cp_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -2333,7 +5099,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 +5107,6 @@ static int test_cp_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -2388,6 +5152,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 +5165,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 +5194,6 @@ static int test_cp_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -2443,7 +5208,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 +5216,6 @@ static int test_cp_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -2508,6 +5271,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 +5284,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 +5313,6 @@ static int test_grub_install_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -2563,7 +5327,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 +5335,6 @@ static int test_grub_install_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -2584,7 +5346,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 +5371,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 +5384,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 +5413,6 @@ static int test_zero_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -2665,7 +5427,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 +5435,6 @@ static int test_zero_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -2686,7 +5446,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 +5454,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 +5462,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 +5480,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 +5493,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 +5522,6 @@ static int test_fsck_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -2778,7 +5536,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 +5544,6 @@ static int test_fsck_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -2798,7 +5554,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 +5563,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 +5580,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 +5593,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 +5622,6 @@ static int test_fsck_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -2881,7 +5636,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 +5644,6 @@ static int test_fsck_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -2901,7 +5654,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 +5662,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 +5671,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 +5688,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 +5701,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 +5730,6 @@ static int test_set_e2uuid_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -2993,7 +5744,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 +5752,6 @@ static int test_set_e2uuid_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -3014,7 +5763,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 +5772,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 +5790,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 +5803,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 +5832,6 @@ static int test_set_e2uuid_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -3098,7 +5846,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 +5854,6 @@ static int test_set_e2uuid_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -3119,7 +5865,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 +5874,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 +5892,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 +5905,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 +5934,6 @@ static int test_set_e2uuid_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -3203,7 +5948,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 +5956,6 @@ static int test_set_e2uuid_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -3223,7 +5966,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 +5980,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 +5993,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 +6022,6 @@ static int test_set_e2uuid_3 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -3293,7 +6036,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 +6044,6 @@ static int test_set_e2uuid_3 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -3313,7 +6054,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 +6068,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 +6081,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 +6110,6 @@ static int test_set_e2label_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -3383,7 +6124,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 +6132,6 @@ static int test_set_e2label_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -3404,7 +6143,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 +6152,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 +6170,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 +6183,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 +6210,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 +6226,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 +6235,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 +6273,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 +6302,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 +6315,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 +6342,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 +6358,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 +6367,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 +6405,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 +6434,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 +6447,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 +6474,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 +6490,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 +6499,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 +6537,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 +6566,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 +6579,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 +6609,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 +6622,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 +6631,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 +6690,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 +6703,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 +6733,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 +6746,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 +6755,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 +6814,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 +6827,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 +6857,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 +6870,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 +6879,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 +6950,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 +6963,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 +6993,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 +7006,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 +7015,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 +7074,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 +7087,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 +7117,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 +7130,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 +7139,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 +7210,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 +7223,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 +7252,6 @@ static int test_mount_ro_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -4539,7 +7266,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 +7274,6 @@ static int test_mount_ro_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -4567,7 +7292,6 @@ static int test_mount_ro_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -4590,6 +7314,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 +7327,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 +7356,6 @@ static int test_mount_ro_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -4645,7 +7370,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 +7378,6 @@ static int test_mount_ro_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -4683,7 +7406,6 @@ static int test_mount_ro_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -4711,6 +7433,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 +7446,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 +7475,6 @@ static int test_tgz_in_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -4766,7 +7489,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 +7497,6 @@ static int test_tgz_in_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -4813,6 +7534,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 +7547,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 +7576,6 @@ static int test_tar_in_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -4868,7 +7590,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 +7598,6 @@ static int test_tar_in_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -4915,6 +7635,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 +7648,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 +7677,6 @@ static int test_checksum_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -4970,7 +7691,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 +7699,6 @@ static int test_checksum_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -5019,6 +7738,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 +7751,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 +7780,6 @@ static int test_checksum_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -5074,7 +7794,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 +7802,6 @@ static int test_checksum_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -5109,6 +7827,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 +7840,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 +7869,6 @@ static int test_checksum_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -5164,7 +7883,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 +7891,6 @@ static int test_checksum_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -5213,6 +7930,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 +7943,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 +7972,6 @@ static int test_checksum_3 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -5268,7 +7986,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 +7994,6 @@ static int test_checksum_3 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -5317,24 +8033,129 @@ static int test_checksum_4_skip (void) { const char *str; - str = getenv ("SKIP_TEST_CHECKSUM_4"); + 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"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_checksum_4 (void) +{ + if (test_checksum_4_skip ()) { + 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"; + 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; + } + /* TestOutput for checksum (4) */ + char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec"; + { + char path[] = "/new"; + char content[] = "test\n"; + int r; + suppress_error = 0; + r = guestfs_write_file (g, path, content, 0); + if (r == -1) + return -1; + } + { + char csumtype[] = "sha224"; + char path[] = "/new"; + char *r; + suppress_error = 0; + r = guestfs_checksum (g, csumtype, path); + if (r == NULL) + return -1; + if (strcmp (r, expected) != 0) { + fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r); + return -1; + } + free (r); + } + return 0; +} + +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"); if (str && strcmp (str, "1") == 0) return 1; return 0; } -static int test_checksum_4 (void) +static int test_checksum_5 (void) { - if (test_checksum_4_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_4"); + if (test_checksum_5_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_checksum_5"); return 0; } - /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */ + /* 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); @@ -5357,7 +8178,6 @@ static int test_checksum_4 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -5372,7 +8192,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 +8200,6 @@ static int test_checksum_4 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -5389,8 +8207,8 @@ static int test_checksum_4 (void) if (r == -1) return -1; } - /* TestOutput for checksum (4) */ - char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec"; + /* TestOutput for checksum (5) */ + char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2"; { char path[] = "/new"; char content[] = "test\n"; @@ -5401,7 +8219,7 @@ static int test_checksum_4 (void) return -1; } { - char csumtype[] = "sha224"; + char csumtype[] = "sha256"; char path[] = "/new"; char *r; suppress_error = 0; @@ -5409,7 +8227,7 @@ static int test_checksum_4 (void) if (r == NULL) return -1; if (strcmp (r, expected) != 0) { - fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r); + fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r); return -1; } free (r); @@ -5417,28 +8235,30 @@ static int test_checksum_4 (void) return 0; } -static int test_checksum_5_skip (void) +static int test_checksum_6_skip (void) { const char *str; - str = getenv ("SKIP_TEST_CHECKSUM_5"); + 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"); if (str && strcmp (str, "1") == 0) return 1; return 0; } -static int test_checksum_5 (void) +static int test_checksum_6 (void) { - if (test_checksum_5_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_5"); + if (test_checksum_6_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_checksum_6"); return 0; } - /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */ + /* 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); @@ -5461,7 +8281,6 @@ static int test_checksum_5 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -5476,7 +8295,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 +8303,6 @@ static int test_checksum_5 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -5493,8 +8310,8 @@ static int test_checksum_5 (void) if (r == -1) return -1; } - /* TestOutput for checksum (5) */ - char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2"; + /* TestOutput for checksum (6) */ + char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d"; { char path[] = "/new"; char content[] = "test\n"; @@ -5505,7 +8322,7 @@ static int test_checksum_5 (void) return -1; } { - char csumtype[] = "sha256"; + char csumtype[] = "sha384"; char path[] = "/new"; char *r; suppress_error = 0; @@ -5513,7 +8330,7 @@ static int test_checksum_5 (void) if (r == NULL) return -1; if (strcmp (r, expected) != 0) { - fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r); + fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r); return -1; } free (r); @@ -5521,28 +8338,30 @@ static int test_checksum_5 (void) return 0; } -static int test_checksum_6_skip (void) +static int test_checksum_7_skip (void) { const char *str; - str = getenv ("SKIP_TEST_CHECKSUM_6"); + 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"); if (str && strcmp (str, "1") == 0) return 1; return 0; } -static int test_checksum_6 (void) +static int test_checksum_7 (void) { - if (test_checksum_6_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_6"); + if (test_checksum_7_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_checksum_7"); return 0; } - /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */ + /* 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); @@ -5565,7 +8384,6 @@ static int test_checksum_6 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -5580,7 +8398,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 +8406,6 @@ static int test_checksum_6 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -5597,8 +8413,8 @@ static int test_checksum_6 (void) if (r == -1) return -1; } - /* TestOutput for checksum (6) */ - char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d"; + /* TestOutput for checksum (7) */ + char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123"; { char path[] = "/new"; char content[] = "test\n"; @@ -5609,7 +8425,7 @@ static int test_checksum_6 (void) return -1; } { - char csumtype[] = "sha384"; + char csumtype[] = "sha512"; char path[] = "/new"; char *r; suppress_error = 0; @@ -5617,7 +8433,7 @@ static int test_checksum_6 (void) if (r == NULL) return -1; if (strcmp (r, expected) != 0) { - fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r); + fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r); return -1; } free (r); @@ -5625,28 +8441,30 @@ static int test_checksum_6 (void) return 0; } -static int test_checksum_7_skip (void) +static int test_checksum_8_skip (void) { const char *str; - str = getenv ("SKIP_TEST_CHECKSUM_7"); + 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"); if (str && strcmp (str, "1") == 0) return 1; return 0; } -static int test_checksum_7 (void) +static int test_checksum_8 (void) { - if (test_checksum_7_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_7"); + if (test_checksum_8_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_checksum_8"); return 0; } - /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */ + /* 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); @@ -5669,7 +8487,6 @@ static int test_checksum_7 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -5684,7 +8501,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 +8509,6 @@ static int test_checksum_7 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -5701,27 +8516,29 @@ static int test_checksum_7 (void) if (r == -1) return -1; } - /* TestOutput for checksum (7) */ - char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123"; + /* TestOutput for checksum (8) */ + char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c"; { - char path[] = "/new"; - char content[] = "test\n"; + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; int r; suppress_error = 0; - r = guestfs_write_file (g, path, content, 0); + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); if (r == -1) return -1; } { - char csumtype[] = "sha512"; - char path[] = "/new"; + char csumtype[] = "md5"; + char path[] = "/known-3"; char *r; suppress_error = 0; r = guestfs_checksum (g, csumtype, path); if (r == NULL) return -1; if (strcmp (r, expected) != 0) { - fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r); + fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r); return -1; } free (r); @@ -5733,6 +8550,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"); @@ -5743,14 +8563,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); @@ -5773,7 +8592,6 @@ static int test_download_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -5788,7 +8606,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); @@ -5797,7 +8614,6 @@ static int test_download_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -5811,7 +8627,7 @@ static int test_download_0 (void) char remotefilename[] = "/COPYING.LIB"; int r; suppress_error = 0; - r = guestfs_upload (g, "COPYING.LIB", remotefilename); + r = guestfs_upload (g, "../COPYING.LIB", remotefilename); if (r == -1) return -1; } @@ -5852,6 +8668,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"); @@ -5862,14 +8681,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); @@ -5892,7 +8710,6 @@ static int test_upload_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -5907,7 +8724,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); @@ -5916,7 +8732,6 @@ static int test_upload_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -5930,7 +8745,7 @@ static int test_upload_0 (void) char remotefilename[] = "/COPYING.LIB"; int r; suppress_error = 0; - r = guestfs_upload (g, "COPYING.LIB", remotefilename); + r = guestfs_upload (g, "../COPYING.LIB", remotefilename); if (r == -1) return -1; } @@ -5955,6 +8770,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"); @@ -5965,14 +8783,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); @@ -5996,7 +8813,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); @@ -6010,6 +8826,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"); @@ -6020,14 +8839,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); @@ -6051,7 +8869,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); @@ -6065,6 +8882,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"); @@ -6075,14 +8895,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); @@ -6106,7 +8925,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); @@ -6124,6 +8942,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"); @@ -6134,14 +8955,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); @@ -6165,7 +8985,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); @@ -6183,6 +9002,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"); @@ -6193,14 +9015,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); @@ -6224,7 +9045,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); @@ -6242,6 +9062,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"); @@ -6252,14 +9075,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); @@ -6283,7 +9105,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); @@ -6301,6 +9122,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"); @@ -6311,14 +9135,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); @@ -6342,7 +9165,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); @@ -6351,7 +9173,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); @@ -6369,6 +9190,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"); @@ -6379,14 +9203,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); @@ -6410,7 +9233,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); @@ -6419,7 +9241,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); @@ -6437,6 +9258,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"); @@ -6447,14 +9271,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); @@ -6478,7 +9301,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); @@ -6487,7 +9309,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); @@ -6505,6 +9326,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"); @@ -6515,14 +9339,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); @@ -6545,7 +9368,6 @@ static int test_statvfs_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -6560,7 +9382,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); @@ -6569,7 +9390,6 @@ static int test_statvfs_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -6609,6 +9429,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"); @@ -6619,14 +9442,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); @@ -6649,7 +9471,6 @@ static int test_lstat_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -6664,7 +9485,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); @@ -6673,7 +9493,6 @@ static int test_lstat_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -6711,6 +9530,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"); @@ -6721,14 +9543,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); @@ -6751,7 +9572,6 @@ static int test_stat_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -6766,7 +9586,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); @@ -6775,7 +9594,6 @@ static int test_stat_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -6813,6 +9631,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"); @@ -6823,14 +9644,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); @@ -6853,7 +9673,6 @@ static int test_command_lines_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -6868,7 +9687,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); @@ -6877,7 +9695,6 @@ static int test_command_lines_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -6944,6 +9761,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"); @@ -6954,14 +9774,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); @@ -6984,7 +9803,6 @@ static int test_command_lines_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -6999,7 +9817,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); @@ -7008,7 +9825,6 @@ static int test_command_lines_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -7075,6 +9891,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"); @@ -7085,14 +9904,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); @@ -7115,7 +9933,6 @@ static int test_command_lines_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -7130,7 +9947,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); @@ -7139,7 +9955,6 @@ static int test_command_lines_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -7218,6 +10033,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"); @@ -7228,14 +10046,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); @@ -7258,7 +10075,6 @@ static int test_command_lines_3 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -7273,7 +10089,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); @@ -7282,7 +10097,6 @@ static int test_command_lines_3 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -7361,6 +10175,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"); @@ -7371,14 +10188,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); @@ -7401,7 +10217,6 @@ static int test_command_lines_4 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -7416,7 +10231,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); @@ -7425,7 +10239,6 @@ static int test_command_lines_4 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -7516,6 +10329,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"); @@ -7526,14 +10342,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); @@ -7556,7 +10371,6 @@ static int test_command_lines_5 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -7571,7 +10385,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); @@ -7580,7 +10393,6 @@ static int test_command_lines_5 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -7683,6 +10495,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"); @@ -7693,14 +10508,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); @@ -7723,7 +10537,6 @@ static int test_command_lines_6 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -7738,7 +10551,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); @@ -7747,7 +10559,6 @@ static int test_command_lines_6 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -7802,6 +10613,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"); @@ -7812,14 +10626,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); @@ -7842,7 +10655,6 @@ static int test_command_lines_7 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -7857,7 +10669,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); @@ -7866,7 +10677,6 @@ static int test_command_lines_7 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -7933,6 +10743,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"); @@ -7943,14 +10756,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); @@ -7973,7 +10785,6 @@ static int test_command_lines_8 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -7988,7 +10799,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); @@ -7997,7 +10807,6 @@ static int test_command_lines_8 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -8076,6 +10885,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"); @@ -8086,14 +10898,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); @@ -8116,7 +10927,6 @@ static int test_command_lines_9 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -8131,7 +10941,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); @@ -8140,7 +10949,6 @@ static int test_command_lines_9 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -8219,6 +11027,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"); @@ -8229,14 +11040,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); @@ -8259,7 +11069,6 @@ static int test_command_lines_10 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -8274,7 +11083,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); @@ -8283,7 +11091,6 @@ static int test_command_lines_10 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -8362,6 +11169,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"); @@ -8372,14 +11182,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); @@ -8402,7 +11211,6 @@ static int test_command_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -8417,7 +11225,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); @@ -8426,7 +11233,6 @@ static int test_command_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -8478,6 +11284,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"); @@ -8488,14 +11297,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); @@ -8518,7 +11326,6 @@ static int test_command_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -8533,7 +11340,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); @@ -8542,7 +11348,6 @@ static int test_command_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -8594,6 +11399,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"); @@ -8604,14 +11412,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); @@ -8634,7 +11441,6 @@ static int test_command_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -8649,7 +11455,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); @@ -8658,7 +11463,6 @@ static int test_command_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -8710,6 +11514,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"); @@ -8720,14 +11527,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); @@ -8750,7 +11556,6 @@ static int test_command_3 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -8765,7 +11570,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); @@ -8774,7 +11578,6 @@ static int test_command_3 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -8826,6 +11629,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"); @@ -8836,14 +11642,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); @@ -8866,7 +11671,6 @@ static int test_command_4 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -8881,7 +11685,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); @@ -8890,7 +11693,6 @@ static int test_command_4 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -8942,6 +11744,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"); @@ -8952,14 +11757,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); @@ -8982,7 +11786,6 @@ static int test_command_5 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -8997,7 +11800,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); @@ -9006,7 +11808,6 @@ static int test_command_5 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -9058,6 +11859,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"); @@ -9068,14 +11872,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); @@ -9098,7 +11901,6 @@ static int test_command_6 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -9113,7 +11915,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); @@ -9122,7 +11923,6 @@ static int test_command_6 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -9174,6 +11974,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"); @@ -9184,14 +11987,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); @@ -9214,7 +12016,6 @@ static int test_command_7 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -9229,7 +12030,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); @@ -9238,7 +12038,6 @@ static int test_command_7 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -9290,6 +12089,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"); @@ -9300,14 +12102,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); @@ -9330,7 +12131,6 @@ static int test_command_8 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -9345,7 +12145,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); @@ -9354,7 +12153,6 @@ static int test_command_8 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -9406,6 +12204,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"); @@ -9416,14 +12217,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); @@ -9446,7 +12246,6 @@ static int test_command_9 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -9461,7 +12260,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); @@ -9470,7 +12268,6 @@ static int test_command_9 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -9522,6 +12319,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"); @@ -9532,14 +12332,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); @@ -9562,7 +12361,6 @@ static int test_command_10 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -9577,7 +12375,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); @@ -9586,7 +12383,6 @@ static int test_command_10 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -9638,6 +12434,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"); @@ -9648,14 +12447,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); @@ -9678,7 +12476,6 @@ static int test_command_11 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -9693,7 +12490,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); @@ -9702,7 +12498,6 @@ static int test_command_11 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -9747,6 +12542,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"); @@ -9757,14 +12555,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); @@ -9787,7 +12584,6 @@ static int test_file_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -9802,7 +12598,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); @@ -9811,7 +12606,6 @@ static int test_file_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -9849,6 +12643,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"); @@ -9859,14 +12656,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); @@ -9889,7 +12685,6 @@ static int test_file_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -9904,7 +12699,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); @@ -9913,7 +12707,6 @@ static int test_file_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -9952,6 +12745,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"); @@ -9962,14 +12758,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); @@ -9992,7 +12787,6 @@ static int test_file_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -10007,7 +12801,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); @@ -10016,7 +12809,6 @@ static int test_file_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -10041,6 +12833,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"); @@ -10051,14 +12846,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); @@ -10081,7 +12875,6 @@ static int test_umount_all_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -10096,7 +12889,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); @@ -10105,7 +12897,6 @@ static int test_umount_all_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -10144,6 +12935,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"); @@ -10154,14 +12948,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); @@ -10185,7 +12978,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[] = ","; @@ -10204,7 +12996,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); @@ -10214,7 +13005,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); @@ -10224,7 +13014,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); @@ -10233,7 +13022,6 @@ static int test_umount_all_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -10251,7 +13039,6 @@ static int test_umount_all_1 (void) } { char device[] = "/dev/sda2"; - device[5] = devchar; char mountpoint[] = "/mp1"; int r; suppress_error = 0; @@ -10269,7 +13056,6 @@ static int test_umount_all_1 (void) } { char device[] = "/dev/sda3"; - device[5] = devchar; char mountpoint[] = "/mp1/mp2"; int r; suppress_error = 0; @@ -10315,6 +13101,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"); @@ -10325,14 +13114,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); @@ -10355,7 +13143,6 @@ static int test_mounts_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -10370,7 +13157,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); @@ -10379,7 +13165,6 @@ static int test_mounts_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -10387,7 +13172,7 @@ static int test_mounts_0 (void) if (r == -1) return -1; } - /* TestOutputList for mounts (0) */ + /* TestOutputListOfDevices for mounts (0) */ { char **r; int i; @@ -10402,7 +13187,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; @@ -10424,6 +13209,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"); @@ -10434,14 +13222,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); @@ -10462,10 +13249,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, @@ -10480,7 +13266,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); @@ -10489,7 +13274,6 @@ static int test_umount_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -10511,7 +13295,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; @@ -10533,6 +13317,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"); @@ -10543,14 +13330,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); @@ -10574,7 +13360,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, @@ -10589,7 +13374,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); @@ -10598,7 +13382,6 @@ static int test_umount_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -10637,6 +13420,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"); @@ -10647,14 +13433,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); @@ -10677,7 +13462,6 @@ static int test_write_file_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -10692,7 +13476,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); @@ -10701,7 +13484,6 @@ static int test_write_file_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -10740,6 +13522,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"); @@ -10750,14 +13535,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); @@ -10780,7 +13564,6 @@ static int test_write_file_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -10795,7 +13578,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); @@ -10804,7 +13586,6 @@ static int test_write_file_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -10843,6 +13624,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"); @@ -10853,14 +13637,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); @@ -10883,7 +13666,6 @@ static int test_write_file_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -10898,7 +13680,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); @@ -10907,7 +13688,6 @@ static int test_write_file_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -10946,6 +13726,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"); @@ -10956,14 +13739,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); @@ -10986,7 +13768,6 @@ static int test_write_file_3 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -11001,7 +13782,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); @@ -11010,7 +13790,6 @@ static int test_write_file_3 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -11049,6 +13828,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"); @@ -11059,14 +13841,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); @@ -11089,7 +13870,6 @@ static int test_write_file_4 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -11104,7 +13884,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); @@ -11113,7 +13892,6 @@ static int test_write_file_4 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -11152,6 +13930,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"); @@ -11162,14 +13943,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); @@ -11192,7 +13972,6 @@ static int test_write_file_5 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -11207,7 +13986,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); @@ -11216,7 +13994,6 @@ static int test_write_file_5 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -11255,6 +14032,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"); @@ -11265,14 +14045,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); @@ -11297,7 +14076,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, @@ -11312,7 +14090,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); @@ -11321,7 +14098,6 @@ static int test_mkfs_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -11358,6 +14134,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"); @@ -11368,14 +14147,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); @@ -11399,7 +14177,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[] = ","; @@ -11417,7 +14194,6 @@ static int test_lvcreate_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -11426,7 +14202,6 @@ static int test_lvcreate_0 (void) } { char device[] = "/dev/sda2"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -11435,7 +14210,6 @@ static int test_lvcreate_0 (void) } { char device[] = "/dev/sda3"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -11445,9 +14219,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, @@ -11462,7 +14234,6 @@ static int test_lvcreate_0 (void) { char volgroup[] = "VG2"; char physvols_0[] = "/dev/sda3"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -11601,6 +14372,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"); @@ -11611,14 +14385,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); @@ -11642,7 +14415,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[] = ","; @@ -11660,7 +14432,6 @@ static int test_vgcreate_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -11669,7 +14440,6 @@ static int test_vgcreate_0 (void) } { char device[] = "/dev/sda2"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -11678,7 +14448,6 @@ static int test_vgcreate_0 (void) } { char device[] = "/dev/sda3"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -11688,9 +14457,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, @@ -11705,7 +14472,6 @@ static int test_vgcreate_0 (void) { char volgroup[] = "VG2"; char physvols_0[] = "/dev/sda3"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -11763,6 +14529,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"); @@ -11773,14 +14542,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); @@ -11801,10 +14569,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[] = ","; @@ -11822,7 +14589,6 @@ static int test_pvcreate_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -11831,7 +14597,6 @@ static int test_pvcreate_0 (void) } { char device[] = "/dev/sda2"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -11840,7 +14605,6 @@ static int test_pvcreate_0 (void) } { char device[] = "/dev/sda3"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -11861,7 +14625,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; @@ -11874,7 +14638,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; @@ -11887,7 +14651,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; @@ -11909,6 +14673,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"); @@ -11919,14 +14686,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); @@ -11949,7 +14715,6 @@ static int test_is_dir_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -11964,7 +14729,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); @@ -11973,7 +14737,6 @@ static int test_is_dir_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -12009,24 +14772,224 @@ 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"); + str = getenv ("SKIP_TEST_IS_DIR"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_is_dir_1 (void) +{ + if (test_is_dir_1_skip ()) { + 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"; + 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; + } + /* TestOutputTrue for is_dir (1) */ + { + char path[] = "/new"; + int r; + suppress_error = 0; + r = guestfs_mkdir (g, path); + if (r == -1) + return -1; + } + { + char path[] = "/new"; + int r; + suppress_error = 0; + r = guestfs_is_dir (g, path); + if (r == -1) + return -1; + if (!r) { + fprintf (stderr, "test_is_dir_1: expected true, got false\n"); + return -1; + } + } + return 0; +} + +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"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_is_file_0 (void) +{ + if (test_is_file_0_skip ()) { + 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"; + 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; + } + /* TestOutputTrue for is_file (0) */ + { + char path[] = "/new"; + int r; + suppress_error = 0; + r = guestfs_touch (g, path); + if (r == -1) + return -1; + } + { + char path[] = "/new"; + int r; + suppress_error = 0; + r = guestfs_is_file (g, path); + if (r == -1) + return -1; + if (!r) { + fprintf (stderr, "test_is_file_0: expected true, got false\n"); + return -1; + } + } + return 0; +} + +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"); if (str && strcmp (str, "1") == 0) return 1; return 0; } -static int test_is_dir_1 (void) +static int test_is_file_1 (void) { - if (test_is_dir_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_1"); + if (test_is_file_1_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_is_file_1"); return 0; } - /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */ + /* 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); @@ -12049,7 +15012,6 @@ static int test_is_dir_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -12064,7 +15026,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); @@ -12073,7 +15034,6 @@ static int test_is_dir_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -12081,7 +15041,7 @@ static int test_is_dir_1 (void) if (r == -1) return -1; } - /* TestOutputTrue for is_dir (1) */ + /* TestOutputFalse for is_file (1) */ { char path[] = "/new"; int r; @@ -12094,39 +15054,41 @@ static int test_is_dir_1 (void) char path[] = "/new"; int r; suppress_error = 0; - r = guestfs_is_dir (g, path); + r = guestfs_is_file (g, path); if (r == -1) return -1; - if (!r) { - fprintf (stderr, "test_is_dir_1: expected true, got false\n"); + if (r) { + fprintf (stderr, "test_is_file_1: expected false, got true\n"); return -1; } } return 0; } -static int test_is_file_0_skip (void) +static int test_exists_0_skip (void) { const char *str; - str = getenv ("SKIP_TEST_IS_FILE_0"); + 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_IS_FILE"); + str = getenv ("SKIP_TEST_EXISTS"); if (str && strcmp (str, "1") == 0) return 1; return 0; } -static int test_is_file_0 (void) +static int test_exists_0 (void) { - if (test_is_file_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_0"); + if (test_exists_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_exists_0"); return 0; } - /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */ + /* 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); @@ -12149,7 +15111,6 @@ static int test_is_file_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -12164,7 +15125,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); @@ -12173,7 +15133,6 @@ static int test_is_file_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -12181,7 +15140,7 @@ static int test_is_file_0 (void) if (r == -1) return -1; } - /* TestOutputTrue for is_file (0) */ + /* TestOutputTrue for exists (0) */ { char path[] = "/new"; int r; @@ -12194,39 +15153,41 @@ static int test_is_file_0 (void) char path[] = "/new"; int r; suppress_error = 0; - r = guestfs_is_file (g, path); + r = guestfs_exists (g, path); if (r == -1) return -1; if (!r) { - fprintf (stderr, "test_is_file_0: expected true, got false\n"); + fprintf (stderr, "test_exists_0: expected true, got false\n"); return -1; } } return 0; } -static int test_is_file_1_skip (void) +static int test_exists_1_skip (void) { const char *str; - str = getenv ("SKIP_TEST_IS_FILE_1"); + 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_IS_FILE"); + str = getenv ("SKIP_TEST_EXISTS"); if (str && strcmp (str, "1") == 0) return 1; return 0; } -static int test_is_file_1 (void) +static int test_exists_1 (void) { - if (test_is_file_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_1"); + if (test_exists_1_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_exists_1"); return 0; } - /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */ + /* 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); @@ -12249,7 +15210,6 @@ static int test_is_file_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -12264,7 +15224,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); @@ -12273,7 +15232,6 @@ static int test_is_file_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -12281,7 +15239,7 @@ static int test_is_file_1 (void) if (r == -1) return -1; } - /* TestOutputFalse for is_file (1) */ + /* TestOutputTrue for exists (1) */ { char path[] = "/new"; int r; @@ -12294,39 +15252,41 @@ static int test_is_file_1 (void) char path[] = "/new"; int r; suppress_error = 0; - r = guestfs_is_file (g, path); + r = guestfs_exists (g, path); if (r == -1) return -1; - if (r) { - fprintf (stderr, "test_is_file_1: expected false, got true\n"); + if (!r) { + fprintf (stderr, "test_exists_1: expected true, got false\n"); return -1; } } return 0; } -static int test_exists_0_skip (void) +static int test_mkdir_p_0_skip (void) { const char *str; - str = getenv ("SKIP_TEST_EXISTS_0"); + 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_EXISTS"); + str = getenv ("SKIP_TEST_MKDIR_P"); if (str && strcmp (str, "1") == 0) return 1; return 0; } -static int test_exists_0 (void) +static int test_mkdir_p_0 (void) { - if (test_exists_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_0"); + if (test_mkdir_p_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_0"); return 0; } - /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */ + /* 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); @@ -12349,7 +15309,6 @@ static int test_exists_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -12364,7 +15323,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); @@ -12373,7 +15331,6 @@ static int test_exists_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -12381,52 +15338,54 @@ static int test_exists_0 (void) if (r == -1) return -1; } - /* TestOutputTrue for exists (0) */ + /* TestOutputTrue for mkdir_p (0) */ { - char path[] = "/new"; + char path[] = "/new/foo/bar"; int r; suppress_error = 0; - r = guestfs_touch (g, path); + r = guestfs_mkdir_p (g, path); if (r == -1) return -1; } { - char path[] = "/new"; + char path[] = "/new/foo/bar"; int r; suppress_error = 0; - r = guestfs_exists (g, path); + r = guestfs_is_dir (g, path); if (r == -1) return -1; if (!r) { - fprintf (stderr, "test_exists_0: expected true, got false\n"); + fprintf (stderr, "test_mkdir_p_0: expected true, got false\n"); return -1; } } return 0; } -static int test_exists_1_skip (void) +static int test_mkdir_p_1_skip (void) { const char *str; - str = getenv ("SKIP_TEST_EXISTS_1"); + 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_EXISTS"); + str = getenv ("SKIP_TEST_MKDIR_P"); if (str && strcmp (str, "1") == 0) return 1; return 0; } -static int test_exists_1 (void) +static int test_mkdir_p_1 (void) { - if (test_exists_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_1"); + if (test_mkdir_p_1_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_1"); return 0; } - /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */ + /* 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); @@ -12449,7 +15408,6 @@ static int test_exists_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -12464,7 +15422,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); @@ -12473,7 +15430,6 @@ static int test_exists_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -12481,52 +15437,54 @@ static int test_exists_1 (void) if (r == -1) return -1; } - /* TestOutputTrue for exists (1) */ + /* TestOutputTrue for mkdir_p (1) */ { - char path[] = "/new"; + char path[] = "/new/foo/bar"; int r; suppress_error = 0; - r = guestfs_mkdir (g, path); + r = guestfs_mkdir_p (g, path); if (r == -1) return -1; } { - char path[] = "/new"; + char path[] = "/new/foo"; int r; suppress_error = 0; - r = guestfs_exists (g, path); + r = guestfs_is_dir (g, path); if (r == -1) return -1; if (!r) { - fprintf (stderr, "test_exists_1: expected true, got false\n"); + fprintf (stderr, "test_mkdir_p_1: expected true, got false\n"); return -1; } } return 0; } -static int test_mkdir_p_0_skip (void) +static int test_mkdir_p_2_skip (void) { const char *str; - str = getenv ("SKIP_TEST_MKDIR_P_0"); + 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"); if (str && strcmp (str, "1") == 0) return 1; return 0; } -static int test_mkdir_p_0 (void) +static int test_mkdir_p_2 (void) { - if (test_mkdir_p_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_0"); + if (test_mkdir_p_2_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_2"); return 0; } - /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */ + /* 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); @@ -12549,7 +15507,6 @@ static int test_mkdir_p_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -12564,7 +15521,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); @@ -12573,7 +15529,6 @@ static int test_mkdir_p_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -12581,7 +15536,7 @@ static int test_mkdir_p_0 (void) if (r == -1) return -1; } - /* TestOutputTrue for mkdir_p (0) */ + /* TestOutputTrue for mkdir_p (2) */ { char path[] = "/new/foo/bar"; int r; @@ -12591,42 +15546,44 @@ static int test_mkdir_p_0 (void) return -1; } { - char path[] = "/new/foo/bar"; + char path[] = "/new"; int r; suppress_error = 0; r = guestfs_is_dir (g, path); if (r == -1) return -1; if (!r) { - fprintf (stderr, "test_mkdir_p_0: expected true, got false\n"); + fprintf (stderr, "test_mkdir_p_2: expected true, got false\n"); return -1; } } return 0; } -static int test_mkdir_p_1_skip (void) +static int test_mkdir_p_3_skip (void) { const char *str; - str = getenv ("SKIP_TEST_MKDIR_P_1"); + 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"); if (str && strcmp (str, "1") == 0) return 1; return 0; } -static int test_mkdir_p_1 (void) +static int test_mkdir_p_3 (void) { - if (test_mkdir_p_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_1"); + if (test_mkdir_p_3_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_3"); return 0; } - /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */ + /* 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); @@ -12649,7 +15606,6 @@ static int test_mkdir_p_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -12664,7 +15620,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); @@ -12673,7 +15628,6 @@ static int test_mkdir_p_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -12681,52 +15635,50 @@ static int test_mkdir_p_1 (void) if (r == -1) return -1; } - /* TestOutputTrue for mkdir_p (1) */ + /* TestRun for mkdir_p (3) */ { - char path[] = "/new/foo/bar"; + char path[] = "/new"; int r; suppress_error = 0; - r = guestfs_mkdir_p (g, path); + r = guestfs_mkdir (g, path); if (r == -1) return -1; } { - char path[] = "/new/foo"; + char path[] = "/new"; int r; suppress_error = 0; - r = guestfs_is_dir (g, path); + r = guestfs_mkdir_p (g, path); if (r == -1) return -1; - if (!r) { - fprintf (stderr, "test_mkdir_p_1: expected true, got false\n"); - return -1; - } } return 0; } -static int test_mkdir_p_2_skip (void) +static int test_mkdir_p_4_skip (void) { const char *str; - str = getenv ("SKIP_TEST_MKDIR_P_2"); + 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"); if (str && strcmp (str, "1") == 0) return 1; return 0; } -static int test_mkdir_p_2 (void) +static int test_mkdir_p_4 (void) { - if (test_mkdir_p_2_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_2"); + if (test_mkdir_p_4_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_4"); return 0; } - /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */ + /* 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); @@ -12749,7 +15701,6 @@ static int test_mkdir_p_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -12764,7 +15715,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); @@ -12773,7 +15723,6 @@ static int test_mkdir_p_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -12781,26 +15730,22 @@ static int test_mkdir_p_2 (void) if (r == -1) return -1; } - /* TestOutputTrue for mkdir_p (2) */ + /* TestLastFail for mkdir_p (4) */ { - char path[] = "/new/foo/bar"; + char path[] = "/new"; int r; suppress_error = 0; - r = guestfs_mkdir_p (g, path); + r = guestfs_touch (g, path); if (r == -1) return -1; } { char path[] = "/new"; int r; - suppress_error = 0; - r = guestfs_is_dir (g, path); - if (r == -1) - return -1; - if (!r) { - fprintf (stderr, "test_mkdir_p_2: expected true, got false\n"); + suppress_error = 1; + r = guestfs_mkdir_p (g, path); + if (r != -1) return -1; - } } return 0; } @@ -12809,6 +15754,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"); @@ -12819,14 +15767,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); @@ -12849,7 +15796,6 @@ static int test_mkdir_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -12864,7 +15810,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); @@ -12873,7 +15818,6 @@ static int test_mkdir_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -12909,6 +15853,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"); @@ -12919,14 +15866,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); @@ -12949,7 +15895,6 @@ static int test_mkdir_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -12964,7 +15909,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); @@ -12973,7 +15917,6 @@ static int test_mkdir_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -12997,6 +15940,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"); @@ -13007,14 +15953,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); @@ -13037,7 +15982,6 @@ static int test_rm_rf_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -13052,7 +15996,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); @@ -13061,7 +16004,6 @@ static int test_rm_rf_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -13121,6 +16063,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"); @@ -13131,14 +16076,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); @@ -13161,7 +16105,6 @@ static int test_rmdir_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -13176,7 +16119,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); @@ -13185,7 +16127,6 @@ static int test_rmdir_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -13217,6 +16158,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"); @@ -13227,14 +16171,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); @@ -13257,7 +16200,6 @@ static int test_rmdir_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -13272,7 +16214,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); @@ -13281,7 +16222,6 @@ static int test_rmdir_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -13305,6 +16245,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"); @@ -13315,14 +16258,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); @@ -13345,7 +16287,6 @@ static int test_rmdir_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -13360,7 +16301,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); @@ -13369,7 +16309,6 @@ static int test_rmdir_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -13401,6 +16340,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"); @@ -13411,14 +16353,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); @@ -13441,7 +16382,6 @@ static int test_rm_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -13456,7 +16396,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); @@ -13465,7 +16404,6 @@ static int test_rm_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -13497,6 +16435,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"); @@ -13507,14 +16448,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); @@ -13537,7 +16477,6 @@ static int test_rm_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -13552,7 +16491,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); @@ -13561,7 +16499,6 @@ static int test_rm_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -13585,6 +16522,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"); @@ -13595,14 +16535,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); @@ -13625,7 +16564,6 @@ static int test_rm_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -13640,7 +16578,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); @@ -13649,7 +16586,6 @@ static int test_rm_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -13681,6 +16617,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"); @@ -13691,14 +16630,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); @@ -13721,7 +16659,6 @@ static int test_read_lines_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -13736,7 +16673,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); @@ -13745,7 +16681,6 @@ static int test_read_lines_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -13823,6 +16758,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"); @@ -13833,14 +16771,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); @@ -13863,7 +16800,6 @@ static int test_read_lines_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -13878,7 +16814,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); @@ -13887,7 +16822,6 @@ static int test_read_lines_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -13929,6 +16863,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"); @@ -13939,14 +16876,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); @@ -13969,7 +16905,6 @@ static int test_lvs_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -13983,7 +16918,6 @@ static int test_lvs_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -13993,7 +16927,6 @@ static int test_lvs_0 (void) { char volgroup[] = "VG"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -14067,6 +17000,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"); @@ -14077,14 +17013,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); @@ -14108,7 +17043,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[] = ","; @@ -14126,7 +17060,6 @@ static int test_lvs_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -14135,7 +17068,6 @@ static int test_lvs_1 (void) } { char device[] = "/dev/sda2"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -14144,7 +17076,6 @@ static int test_lvs_1 (void) } { char device[] = "/dev/sda3"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -14154,9 +17085,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, @@ -14171,7 +17100,6 @@ static int test_lvs_1 (void) { char volgroup[] = "VG2"; char physvols_0[] = "/dev/sda3"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -14268,6 +17196,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"); @@ -14278,14 +17209,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); @@ -14308,7 +17238,6 @@ static int test_vgs_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -14322,7 +17251,6 @@ static int test_vgs_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -14332,7 +17260,6 @@ static int test_vgs_0 (void) { char volgroup[] = "VG"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -14406,6 +17333,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"); @@ -14416,14 +17346,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); @@ -14447,7 +17376,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[] = ","; @@ -14465,7 +17393,6 @@ static int test_vgs_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -14474,7 +17401,6 @@ static int test_vgs_1 (void) } { char device[] = "/dev/sda2"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -14483,7 +17409,6 @@ static int test_vgs_1 (void) } { char device[] = "/dev/sda3"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -14493,9 +17418,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, @@ -14510,7 +17433,6 @@ static int test_vgs_1 (void) { char volgroup[] = "VG2"; char physvols_0[] = "/dev/sda3"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -14568,6 +17490,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"); @@ -14578,14 +17503,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); @@ -14608,7 +17532,6 @@ static int test_pvs_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -14622,7 +17545,6 @@ static int test_pvs_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -14632,7 +17554,6 @@ static int test_pvs_0 (void) { char volgroup[] = "VG"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -14670,7 +17591,7 @@ static int test_pvs_0 (void) if (r == -1) return -1; } - /* TestOutputList for pvs (0) */ + /* TestOutputListOfDevices for pvs (0) */ { char **r; int i; @@ -14685,7 +17606,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; @@ -14707,6 +17628,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"); @@ -14717,14 +17641,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); @@ -14745,10 +17668,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[] = ","; @@ -14766,7 +17688,6 @@ static int test_pvs_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -14775,7 +17696,6 @@ static int test_pvs_1 (void) } { char device[] = "/dev/sda2"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -14784,7 +17704,6 @@ static int test_pvs_1 (void) } { char device[] = "/dev/sda3"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -14805,7 +17724,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; @@ -14818,7 +17737,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; @@ -14831,7 +17750,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; @@ -14853,6 +17772,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"); @@ -14863,14 +17785,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); @@ -14893,7 +17814,6 @@ static int test_list_partitions_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -14908,7 +17828,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); @@ -14917,7 +17836,6 @@ static int test_list_partitions_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -14925,7 +17843,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; @@ -14940,7 +17858,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; @@ -14962,6 +17880,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"); @@ -14972,14 +17893,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); @@ -15000,10 +17920,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[] = ","; @@ -15033,7 +17952,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; @@ -15046,7 +17965,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; @@ -15059,7 +17978,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; @@ -15081,6 +18000,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"); @@ -15091,14 +18013,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); @@ -15119,7 +18040,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; @@ -15134,7 +18055,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; @@ -15147,7 +18068,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; @@ -15160,13 +18081,26 @@ 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; } } - if (r[3] != NULL) { + if (!r[3]) { + fprintf (stderr, "test_list_devices_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "/dev/sdd"; + 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; + } + } + if (r[4] != NULL) { fprintf (stderr, "test_list_devices_0: extra elements returned from command\n"); print_strings (r); return -1; @@ -15182,6 +18116,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"); @@ -15192,14 +18129,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); @@ -15222,7 +18158,6 @@ static int test_ls_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -15237,7 +18172,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); @@ -15246,7 +18180,6 @@ static int test_ls_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -15351,6 +18284,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"); @@ -15361,14 +18297,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); @@ -15391,7 +18326,6 @@ static int test_cat_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -15406,7 +18340,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); @@ -15415,7 +18348,6 @@ static int test_cat_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -15454,6 +18386,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"); @@ -15464,14 +18399,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); @@ -15494,7 +18428,6 @@ static int test_touch_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -15509,7 +18442,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); @@ -15518,7 +18450,6 @@ static int test_touch_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -15554,6 +18485,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"); @@ -15564,14 +18498,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); @@ -15607,6 +18540,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"); @@ -15617,14 +18553,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); @@ -15649,7 +18584,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, @@ -15664,7 +18598,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); @@ -15673,7 +18606,6 @@ static int test_mount_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -15710,11 +18642,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 (); @@ -15812,40 +18742,162 @@ int main (int argc, char *argv[]) exit (1); } + if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) { + printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n"); + exit (1); + } + if (guestfs_launch (g) == -1) { 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 = 140; + nr_tests = 166; 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"); @@ -15882,6 +18934,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"); @@ -16152,6 +19210,12 @@ int main (int argc, char *argv[]) failed++; } test_num++; + printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests); + if (test_checksum_8 () == -1) { + printf ("test_checksum_8 FAILED\n"); + failed++; + } + test_num++; printf ("%3d/%3d test_download_0\n", test_num, nr_tests); if (test_download_0 () == -1) { printf ("test_download_0 FAILED\n"); @@ -16536,6 +19600,18 @@ int main (int argc, char *argv[]) failed++; } test_num++; + printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests); + if (test_mkdir_p_3 () == -1) { + printf ("test_mkdir_p_3 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests); + if (test_mkdir_p_4 () == -1) { + printf ("test_mkdir_p_4 FAILED\n"); + failed++; + } + test_num++; printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests); if (test_mkdir_0 () == -1) { printf ("test_mkdir_0 FAILED\n");