X-Git-Url: http://git.annexia.org/?p=libguestfs.git;a=blobdiff_plain;f=capitests%2Ftests.c;h=c8686a1ee2862220a473b2ae8bcf9a8de7d956ef;hp=536da7f2f371ca3de95f38e8c476787f10001ffa;hb=f68b3ac861ae607a333211c775dded82ae2b2c4a;hpb=ccc1d216032ff61a81eb1116df44d5bd82079462 diff --git a/capitests/tests.c b/capitests/tests.c index 536da7f..c8686a1 100644 --- a/capitests/tests.c +++ b/capitests/tests.c @@ -109,6 +109,8 @@ static void no_test_warnings (void) fprintf (stderr, "warning: \"guestfs_set_busy\" has no tests\n"); fprintf (stderr, "warning: \"guestfs_set_ready\" has no tests\n"); fprintf (stderr, "warning: \"guestfs_end_busy\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_set_memsize\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_get_memsize\" has no tests\n"); fprintf (stderr, "warning: \"guestfs_ll\" has no tests\n"); fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n"); fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n"); @@ -148,12 +150,2686 @@ static void no_test_warnings (void) fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n"); fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n"); fprintf (stderr, "warning: \"guestfs_e2fsck_f\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_sh\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_sh_lines\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_scrub_freespace\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_df\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_df_h\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_mount_loop\" has no tests\n"); +} + +static int test_mkswap_U_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mkswap_U") == NULL; + str = getenv ("SKIP_TEST_MKSWAP_U_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_MKSWAP_U"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_mkswap_U_0 (void) +{ + if (test_mkswap_U_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_mkswap_U_0"); + return 0; + } + + /* InitNone|InitEmpty for test_mkswap_U_0 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + /* TestRun for mkswap_U (0) */ + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkswap_U (g, uuid, device); + if (r == -1) + return -1; + } + return 0; +} + +static int test_mkswap_L_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mkswap_L") == NULL; + str = getenv ("SKIP_TEST_MKSWAP_L_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_MKSWAP_L"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_mkswap_L_0 (void) +{ + if (test_mkswap_L_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_mkswap_L_0"); + return 0; + } + + /* InitNone|InitEmpty for test_mkswap_L_0 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + /* TestRun for mkswap_L (0) */ + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char label[] = "hello"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkswap_L (g, label, device); + if (r == -1) + return -1; + } + return 0; +} + +static int test_mkswap_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mkswap") == NULL; + str = getenv ("SKIP_TEST_MKSWAP_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_MKSWAP"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_mkswap_0 (void) +{ + if (test_mkswap_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_mkswap_0"); + return 0; + } + + /* InitNone|InitEmpty for test_mkswap_0 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + /* TestRun for mkswap (0) */ + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkswap (g, device); + if (r == -1) + return -1; + } + return 0; +} + +static int test_initrd_list_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "initrd_list") == NULL; + str = getenv ("SKIP_TEST_INITRD_LIST_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_INITRD_LIST"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_initrd_list_0 (void) +{ + if (test_initrd_list_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_initrd_list_0"); + return 0; + } + + /* InitBasicFS for test_initrd_list_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for initrd_list (0) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/initrd"; + char **r; + int i; + suppress_error = 0; + r = guestfs_initrd_list (g, path); + if (r == NULL) + return -1; + if (!r[0]) { + fprintf (stderr, "test_initrd_list_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "empty"; + if (strcmp (r[0], expected) != 0) { + fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[0]); + return -1; + } + } + if (!r[1]) { + fprintf (stderr, "test_initrd_list_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "known-1"; + if (strcmp (r[1], expected) != 0) { + fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[1]); + return -1; + } + } + if (!r[2]) { + fprintf (stderr, "test_initrd_list_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "known-2"; + if (strcmp (r[2], expected) != 0) { + fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[2]); + return -1; + } + } + if (!r[3]) { + fprintf (stderr, "test_initrd_list_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "known-3"; + if (strcmp (r[3], expected) != 0) { + fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[3]); + return -1; + } + } + if (r[4] != NULL) { + fprintf (stderr, "test_initrd_list_0: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_du_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "du") == NULL; + str = getenv ("SKIP_TEST_DU_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_DU"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_du_0 (void) +{ + if (test_du_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_du_0"); + return 0; + } + + /* InitBasicFS for test_du_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputInt for du (0) */ + { + char path[] = "/p"; + int r; + suppress_error = 0; + r = guestfs_mkdir (g, path); + if (r == -1) + return -1; + } + { + char path[] = "/p"; + int64_t r; + suppress_error = 0; + r = guestfs_du (g, path); + if (r == -1) + return -1; + if (r != 1) { + fprintf (stderr, "test_du_0: expected 1 but got %d\n", (int) r); + return -1; + } + } + return 0; +} + +static int test_tail_n_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "tail_n") == NULL; + str = getenv ("SKIP_TEST_TAIL_N_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_TAIL_N"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_tail_n_0 (void) +{ + if (test_tail_n_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_0"); + return 0; + } + + /* InitBasicFS for test_tail_n_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for tail_n (0) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/10klines"; + char **r; + int i; + suppress_error = 0; + r = guestfs_tail_n (g, 3, path); + if (r == NULL) + return -1; + if (!r[0]) { + fprintf (stderr, "test_tail_n_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9997abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[0], expected) != 0) { + fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]); + return -1; + } + } + if (!r[1]) { + fprintf (stderr, "test_tail_n_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9998abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[1], expected) != 0) { + fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]); + return -1; + } + } + if (!r[2]) { + fprintf (stderr, "test_tail_n_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9999abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[2], expected) != 0) { + fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]); + return -1; + } + } + if (r[3] != NULL) { + fprintf (stderr, "test_tail_n_0: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_tail_n_1_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "tail_n") == NULL; + str = getenv ("SKIP_TEST_TAIL_N_1"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_TAIL_N"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_tail_n_1 (void) +{ + if (test_tail_n_1_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_1"); + return 0; + } + + /* InitBasicFS for test_tail_n_1: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for tail_n (1) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/10klines"; + char **r; + int i; + suppress_error = 0; + r = guestfs_tail_n (g, -9998, path); + if (r == NULL) + return -1; + if (!r[0]) { + fprintf (stderr, "test_tail_n_1: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9997abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[0], expected) != 0) { + fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]); + return -1; + } + } + if (!r[1]) { + fprintf (stderr, "test_tail_n_1: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9998abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[1], expected) != 0) { + fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]); + return -1; + } + } + if (!r[2]) { + fprintf (stderr, "test_tail_n_1: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9999abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[2], expected) != 0) { + fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]); + return -1; + } + } + if (r[3] != NULL) { + fprintf (stderr, "test_tail_n_1: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_tail_n_2_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "tail_n") == NULL; + str = getenv ("SKIP_TEST_TAIL_N_2"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_TAIL_N"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_tail_n_2 (void) +{ + if (test_tail_n_2_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_2"); + return 0; + } + + /* InitBasicFS for test_tail_n_2: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for tail_n (2) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/10klines"; + char **r; + int i; + suppress_error = 0; + r = guestfs_tail_n (g, 0, path); + if (r == NULL) + return -1; + if (r[0] != NULL) { + fprintf (stderr, "test_tail_n_2: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_tail_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "tail") == NULL; + str = getenv ("SKIP_TEST_TAIL_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_TAIL"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_tail_0 (void) +{ + if (test_tail_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_tail_0"); + return 0; + } + + /* InitBasicFS for test_tail_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for tail (0) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/10klines"; + char **r; + int i; + suppress_error = 0; + r = guestfs_tail (g, path); + if (r == NULL) + return -1; + if (!r[0]) { + fprintf (stderr, "test_tail_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9990abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[0], expected) != 0) { + fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[0]); + return -1; + } + } + if (!r[1]) { + fprintf (stderr, "test_tail_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9991abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[1], expected) != 0) { + fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[1]); + return -1; + } + } + if (!r[2]) { + fprintf (stderr, "test_tail_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9992abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[2], expected) != 0) { + fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[2]); + return -1; + } + } + if (!r[3]) { + fprintf (stderr, "test_tail_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9993abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[3], expected) != 0) { + fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[3]); + return -1; + } + } + if (!r[4]) { + fprintf (stderr, "test_tail_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9994abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[4], expected) != 0) { + fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[4]); + return -1; + } + } + if (!r[5]) { + fprintf (stderr, "test_tail_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9995abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[5], expected) != 0) { + fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[5]); + return -1; + } + } + if (!r[6]) { + fprintf (stderr, "test_tail_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9996abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[6], expected) != 0) { + fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[6]); + return -1; + } + } + if (!r[7]) { + fprintf (stderr, "test_tail_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9997abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[7], expected) != 0) { + fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[7]); + return -1; + } + } + if (!r[8]) { + fprintf (stderr, "test_tail_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9998abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[8], expected) != 0) { + fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[8]); + return -1; + } + } + if (!r[9]) { + fprintf (stderr, "test_tail_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9999abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[9], expected) != 0) { + fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[9]); + return -1; + } + } + if (r[10] != NULL) { + fprintf (stderr, "test_tail_0: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_head_n_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "head_n") == NULL; + str = getenv ("SKIP_TEST_HEAD_N_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_HEAD_N"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_head_n_0 (void) +{ + if (test_head_n_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_head_n_0"); + return 0; + } + + /* InitBasicFS for test_head_n_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for head_n (0) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/10klines"; + char **r; + int i; + suppress_error = 0; + r = guestfs_head_n (g, 3, path); + if (r == NULL) + return -1; + if (!r[0]) { + fprintf (stderr, "test_head_n_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "0abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[0], expected) != 0) { + fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]); + return -1; + } + } + if (!r[1]) { + fprintf (stderr, "test_head_n_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "1abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[1], expected) != 0) { + fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]); + return -1; + } + } + if (!r[2]) { + fprintf (stderr, "test_head_n_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "2abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[2], expected) != 0) { + fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]); + return -1; + } + } + if (r[3] != NULL) { + fprintf (stderr, "test_head_n_0: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_head_n_1_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "head_n") == NULL; + str = getenv ("SKIP_TEST_HEAD_N_1"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_HEAD_N"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_head_n_1 (void) +{ + if (test_head_n_1_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_head_n_1"); + return 0; + } + + /* InitBasicFS for test_head_n_1: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for head_n (1) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/10klines"; + char **r; + int i; + suppress_error = 0; + r = guestfs_head_n (g, -9997, path); + if (r == NULL) + return -1; + if (!r[0]) { + fprintf (stderr, "test_head_n_1: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "0abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[0], expected) != 0) { + fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]); + return -1; + } + } + if (!r[1]) { + fprintf (stderr, "test_head_n_1: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "1abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[1], expected) != 0) { + fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]); + return -1; + } + } + if (!r[2]) { + fprintf (stderr, "test_head_n_1: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "2abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[2], expected) != 0) { + fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]); + return -1; + } + } + if (r[3] != NULL) { + fprintf (stderr, "test_head_n_1: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_head_n_2_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "head_n") == NULL; + str = getenv ("SKIP_TEST_HEAD_N_2"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_HEAD_N"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_head_n_2 (void) +{ + if (test_head_n_2_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_head_n_2"); + return 0; + } + + /* InitBasicFS for test_head_n_2: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for head_n (2) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/10klines"; + char **r; + int i; + suppress_error = 0; + r = guestfs_head_n (g, 0, path); + if (r == NULL) + return -1; + if (r[0] != NULL) { + fprintf (stderr, "test_head_n_2: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_head_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "head") == NULL; + str = getenv ("SKIP_TEST_HEAD_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_HEAD"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_head_0 (void) +{ + if (test_head_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_head_0"); + return 0; + } + + /* InitBasicFS for test_head_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for head (0) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/10klines"; + char **r; + int i; + suppress_error = 0; + r = guestfs_head (g, path); + if (r == NULL) + return -1; + if (!r[0]) { + fprintf (stderr, "test_head_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "0abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[0], expected) != 0) { + fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[0]); + return -1; + } + } + if (!r[1]) { + fprintf (stderr, "test_head_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "1abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[1], expected) != 0) { + fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[1]); + return -1; + } + } + if (!r[2]) { + fprintf (stderr, "test_head_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "2abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[2], expected) != 0) { + fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[2]); + return -1; + } + } + if (!r[3]) { + fprintf (stderr, "test_head_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "3abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[3], expected) != 0) { + fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[3]); + return -1; + } + } + if (!r[4]) { + fprintf (stderr, "test_head_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "4abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[4], expected) != 0) { + fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[4]); + return -1; + } + } + if (!r[5]) { + fprintf (stderr, "test_head_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "5abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[5], expected) != 0) { + fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[5]); + return -1; + } + } + if (!r[6]) { + fprintf (stderr, "test_head_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "6abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[6], expected) != 0) { + fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[6]); + return -1; + } + } + if (!r[7]) { + fprintf (stderr, "test_head_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "7abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[7], expected) != 0) { + fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[7]); + return -1; + } + } + if (!r[8]) { + fprintf (stderr, "test_head_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "8abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[8], expected) != 0) { + fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[8]); + return -1; + } + } + if (!r[9]) { + fprintf (stderr, "test_head_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[9], expected) != 0) { + fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[9]); + return -1; + } + } + if (r[10] != NULL) { + fprintf (stderr, "test_head_0: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_wc_c_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "wc_c") == NULL; + str = getenv ("SKIP_TEST_WC_C_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_WC_C"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_wc_c_0 (void) +{ + if (test_wc_c_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_wc_c_0"); + return 0; + } + + /* InitBasicFS for test_wc_c_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputInt for wc_c (0) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/100kallspaces"; + int r; + suppress_error = 0; + r = guestfs_wc_c (g, path); + if (r == -1) + return -1; + if (r != 102400) { + fprintf (stderr, "test_wc_c_0: expected 102400 but got %d\n", (int) r); + return -1; + } + } + return 0; +} + +static int test_wc_w_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "wc_w") == NULL; + str = getenv ("SKIP_TEST_WC_W_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_WC_W"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_wc_w_0 (void) +{ + if (test_wc_w_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_wc_w_0"); + return 0; + } + + /* InitBasicFS for test_wc_w_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputInt for wc_w (0) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/10klines"; + int r; + suppress_error = 0; + r = guestfs_wc_w (g, path); + if (r == -1) + return -1; + if (r != 10000) { + fprintf (stderr, "test_wc_w_0: expected 10000 but got %d\n", (int) r); + return -1; + } + } + return 0; +} + +static int test_wc_l_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "wc_l") == NULL; + str = getenv ("SKIP_TEST_WC_L_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_WC_L"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_wc_l_0 (void) +{ + if (test_wc_l_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_wc_l_0"); + return 0; + } + + /* InitBasicFS for test_wc_l_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputInt for wc_l (0) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/10klines"; + int r; + suppress_error = 0; + r = guestfs_wc_l (g, path); + if (r == -1) + return -1; + if (r != 10000) { + fprintf (stderr, "test_wc_l_0: expected 10000 but got %d\n", (int) r); + return -1; + } + } + return 0; +} + +static int test_mkdtemp_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mkdtemp") == NULL; + str = getenv ("SKIP_TEST_MKDTEMP_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_MKDTEMP"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_mkdtemp_0 (void) +{ + if (test_mkdtemp_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_mkdtemp_0"); + return 0; + } + + /* InitBasicFS for test_mkdtemp_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestRun for mkdtemp (0) */ + { + char path[] = "/tmp"; + int r; + suppress_error = 0; + r = guestfs_mkdir (g, path); + if (r == -1) + return -1; + } + { + char template[] = "/tmp/tmpXXXXXX"; + char *r; + suppress_error = 0; + r = guestfs_mkdtemp (g, template); + if (r == NULL) + return -1; + free (r); + } + return 0; +} + +static int test_scrub_file_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "scrub_file") == NULL; + str = getenv ("SKIP_TEST_SCRUB_FILE_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_SCRUB_FILE"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_scrub_file_0 (void) +{ + if (test_scrub_file_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_scrub_file_0"); + return 0; + } + + /* InitBasicFS for test_scrub_file_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestRun for scrub_file (0) */ + { + char path[] = "/file"; + char content[] = "content"; + int r; + suppress_error = 0; + r = guestfs_write_file (g, path, content, 0); + if (r == -1) + return -1; + } + { + char file[] = "/file"; + int r; + suppress_error = 0; + r = guestfs_scrub_file (g, file); + if (r == -1) + return -1; + } + return 0; +} + +static int test_scrub_device_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "scrub_device") == NULL; + str = getenv ("SKIP_TEST_SCRUB_DEVICE_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_SCRUB_DEVICE"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_scrub_device_0 (void) +{ + if (test_scrub_device_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_scrub_device_0"); + return 0; + } + + /* InitNone|InitEmpty for test_scrub_device_0 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + /* TestRun for scrub_device (0) */ + { + char device[] = "/dev/sdc"; + int r; + suppress_error = 0; + r = guestfs_scrub_device (g, device); + if (r == -1) + return -1; + } + return 0; +} + +static int test_glob_expand_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "glob_expand") == NULL; + str = getenv ("SKIP_TEST_GLOB_EXPAND_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_GLOB_EXPAND"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_glob_expand_0 (void) +{ + if (test_glob_expand_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_0"); + return 0; + } + + /* InitBasicFS for test_glob_expand_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for glob_expand (0) */ + { + char path[] = "/a/b/c"; + int r; + suppress_error = 0; + r = guestfs_mkdir_p (g, path); + if (r == -1) + return -1; + } + { + char path[] = "/a/b/c/d"; + int r; + suppress_error = 0; + r = guestfs_touch (g, path); + if (r == -1) + return -1; + } + { + char path[] = "/a/b/c/e"; + int r; + suppress_error = 0; + r = guestfs_touch (g, path); + if (r == -1) + return -1; + } + { + char pattern[] = "/a/b/c/*"; + char **r; + int i; + suppress_error = 0; + r = guestfs_glob_expand (g, pattern); + if (r == NULL) + return -1; + if (!r[0]) { + fprintf (stderr, "test_glob_expand_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "/a/b/c/d"; + if (strcmp (r[0], expected) != 0) { + fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[0]); + return -1; + } + } + if (!r[1]) { + fprintf (stderr, "test_glob_expand_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "/a/b/c/e"; + if (strcmp (r[1], expected) != 0) { + fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[1]); + return -1; + } + } + if (r[2] != NULL) { + fprintf (stderr, "test_glob_expand_0: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_glob_expand_1_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "glob_expand") == NULL; + str = getenv ("SKIP_TEST_GLOB_EXPAND_1"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_GLOB_EXPAND"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_glob_expand_1 (void) +{ + if (test_glob_expand_1_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_1"); + return 0; + } + + /* InitBasicFS for test_glob_expand_1: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for glob_expand (1) */ + { + char path[] = "/a/b/c"; + int r; + suppress_error = 0; + r = guestfs_mkdir_p (g, path); + if (r == -1) + return -1; + } + { + char path[] = "/a/b/c/d"; + int r; + suppress_error = 0; + r = guestfs_touch (g, path); + if (r == -1) + return -1; + } + { + char path[] = "/a/b/c/e"; + int r; + suppress_error = 0; + r = guestfs_touch (g, path); + if (r == -1) + return -1; + } + { + char pattern[] = "/a/*/c/*"; + char **r; + int i; + suppress_error = 0; + r = guestfs_glob_expand (g, pattern); + if (r == NULL) + return -1; + if (!r[0]) { + fprintf (stderr, "test_glob_expand_1: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "/a/b/c/d"; + if (strcmp (r[0], expected) != 0) { + fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[0]); + return -1; + } + } + if (!r[1]) { + fprintf (stderr, "test_glob_expand_1: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "/a/b/c/e"; + if (strcmp (r[1], expected) != 0) { + fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[1]); + return -1; + } + } + if (r[2] != NULL) { + fprintf (stderr, "test_glob_expand_1: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_glob_expand_2_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "glob_expand") == NULL; + str = getenv ("SKIP_TEST_GLOB_EXPAND_2"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_GLOB_EXPAND"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_glob_expand_2 (void) +{ + if (test_glob_expand_2_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_2"); + return 0; + } + + /* InitBasicFS for test_glob_expand_2: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for glob_expand (2) */ + { + char path[] = "/a/b/c"; + int r; + suppress_error = 0; + r = guestfs_mkdir_p (g, path); + if (r == -1) + return -1; + } + { + char path[] = "/a/b/c/d"; + int r; + suppress_error = 0; + r = guestfs_touch (g, path); + if (r == -1) + return -1; + } + { + char path[] = "/a/b/c/e"; + int r; + suppress_error = 0; + r = guestfs_touch (g, path); + if (r == -1) + return -1; + } + { + char pattern[] = "/a/*/x/*"; + char **r; + int i; + suppress_error = 0; + r = guestfs_glob_expand (g, pattern); + if (r == NULL) + return -1; + if (r[0] != NULL) { + fprintf (stderr, "test_glob_expand_2: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; } static int test_ntfs_3g_probe_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "ntfs_3g_probe") == NULL; str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_NTFS_3G_PROBE"); @@ -164,7 +2840,7 @@ static int test_ntfs_3g_probe_0_skip (void) static int test_ntfs_3g_probe_0 (void) { if (test_ntfs_3g_probe_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ntfs_3g_probe_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_0"); return 0; } @@ -233,6 +2909,9 @@ 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"); @@ -243,7 +2922,7 @@ static int test_ntfs_3g_probe_1_skip (void) static int test_ntfs_3g_probe_1 (void) { if (test_ntfs_3g_probe_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ntfs_3g_probe_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_1"); return 0; } @@ -312,6 +2991,9 @@ 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"); @@ -322,7 +3004,7 @@ static int test_sleep_0_skip (void) static int test_sleep_0 (void) { if (test_sleep_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sleep_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_sleep_0"); return 0; } @@ -364,6 +3046,9 @@ 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"); @@ -374,7 +3059,7 @@ 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; } @@ -469,6 +3154,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"); @@ -479,7 +3167,7 @@ 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; } @@ -634,6 +3322,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"); @@ -644,7 +3335,7 @@ 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; } @@ -767,6 +3458,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"); @@ -777,7 +3471,7 @@ 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; } @@ -937,6 +3631,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"); @@ -947,7 +3644,7 @@ 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; } @@ -1061,6 +3758,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"); @@ -1071,7 +3771,7 @@ 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; } @@ -1156,10 +3856,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"); @@ -1170,7 +3972,7 @@ 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; } @@ -1263,6 +4065,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"); @@ -1273,7 +4078,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; } @@ -1285,6 +4090,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"); @@ -1295,7 +4103,7 @@ 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; } @@ -1411,6 +4219,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"); @@ -1421,7 +4232,7 @@ 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; } @@ -1512,6 +4323,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"); @@ -1522,7 +4336,7 @@ 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; } @@ -1619,6 +4433,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"); @@ -1629,7 +4446,7 @@ 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; } @@ -1726,6 +4543,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"); @@ -1736,7 +4556,7 @@ 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; } @@ -1811,6 +4631,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"); @@ -1821,7 +4644,7 @@ 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; } @@ -1863,6 +4686,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"); @@ -1873,7 +4699,7 @@ 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; } @@ -1916,6 +4742,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"); @@ -1926,7 +4755,7 @@ 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; } @@ -1968,6 +4797,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"); @@ -1978,7 +4810,7 @@ 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; } @@ -2076,6 +4908,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"); @@ -2086,7 +4921,7 @@ 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; } @@ -2182,6 +5017,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"); @@ -2192,7 +5030,7 @@ 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; } @@ -2306,6 +5144,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"); @@ -2316,7 +5157,7 @@ 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; } @@ -2414,6 +5255,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"); @@ -2424,7 +5268,7 @@ 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; } @@ -2520,6 +5364,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"); @@ -2530,7 +5377,7 @@ 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; } @@ -2636,6 +5483,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"); @@ -2646,7 +5496,7 @@ 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; } @@ -2733,6 +5583,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"); @@ -2743,7 +5596,7 @@ 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; } @@ -2839,6 +5692,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"); @@ -2849,7 +5705,7 @@ 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; } @@ -2936,6 +5792,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"); @@ -2946,7 +5805,7 @@ 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; } @@ -3041,6 +5900,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"); @@ -3051,7 +5913,7 @@ 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; } @@ -3140,6 +6002,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"); @@ -3150,7 +6015,7 @@ 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; } @@ -3239,6 +6104,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"); @@ -3249,7 +6117,7 @@ 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; } @@ -3324,6 +6192,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"); @@ -3334,7 +6205,7 @@ 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; } @@ -3409,6 +6280,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"); @@ -3419,7 +6293,7 @@ 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; } @@ -3508,6 +6382,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"); @@ -3518,7 +6395,7 @@ 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; } @@ -3637,6 +6514,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"); @@ -3647,7 +6527,7 @@ 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; } @@ -3766,6 +6646,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"); @@ -3776,7 +6659,7 @@ 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; } @@ -3895,6 +6778,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"); @@ -3905,7 +6791,7 @@ 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; } @@ -4016,6 +6902,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"); @@ -4026,7 +6915,7 @@ 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; } @@ -4137,6 +7026,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"); @@ -4147,7 +7039,7 @@ 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; } @@ -4270,6 +7162,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"); @@ -4280,7 +7175,7 @@ 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; } @@ -4391,6 +7286,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"); @@ -4401,7 +7299,7 @@ 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; } @@ -4524,6 +7422,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"); @@ -4534,7 +7435,7 @@ 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; } @@ -4625,6 +7526,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"); @@ -4635,7 +7539,7 @@ 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; } @@ -4741,6 +7645,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"); @@ -4751,7 +7658,7 @@ 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; } @@ -4839,6 +7746,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"); @@ -4849,7 +7759,7 @@ 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; } @@ -4937,6 +7847,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"); @@ -4947,7 +7860,7 @@ 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; } @@ -5037,6 +7950,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"); @@ -5047,7 +7963,7 @@ 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; } @@ -5123,6 +8039,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"); @@ -5133,7 +8052,7 @@ 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; } @@ -5223,6 +8142,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"); @@ -5233,7 +8155,7 @@ 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; } @@ -5323,6 +8245,9 @@ static int test_checksum_4_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "checksum") == NULL; str = getenv ("SKIP_TEST_CHECKSUM_4"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_CHECKSUM"); @@ -5333,7 +8258,7 @@ static int test_checksum_4_skip (void) static int test_checksum_4 (void) { if (test_checksum_4_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_4"); + printf ("%s skipped (reason: environment variable set)\n", "test_checksum_4"); return 0; } @@ -5423,6 +8348,9 @@ static int test_checksum_5_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "checksum") == NULL; str = getenv ("SKIP_TEST_CHECKSUM_5"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_CHECKSUM"); @@ -5433,7 +8361,7 @@ static int test_checksum_5_skip (void) static int test_checksum_5 (void) { if (test_checksum_5_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_5"); + printf ("%s skipped (reason: environment variable set)\n", "test_checksum_5"); return 0; } @@ -5523,6 +8451,9 @@ static int test_checksum_6_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "checksum") == NULL; str = getenv ("SKIP_TEST_CHECKSUM_6"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_CHECKSUM"); @@ -5533,7 +8464,7 @@ static int test_checksum_6_skip (void) static int test_checksum_6 (void) { if (test_checksum_6_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_6"); + printf ("%s skipped (reason: environment variable set)\n", "test_checksum_6"); return 0; } @@ -5623,6 +8554,9 @@ static int test_checksum_7_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "checksum") == NULL; str = getenv ("SKIP_TEST_CHECKSUM_7"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_CHECKSUM"); @@ -5633,7 +8567,7 @@ static int test_checksum_7_skip (void) static int test_checksum_7 (void) { if (test_checksum_7_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_7"); + printf ("%s skipped (reason: environment variable set)\n", "test_checksum_7"); return 0; } @@ -5723,6 +8657,9 @@ static int test_checksum_8_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "checksum") == NULL; str = getenv ("SKIP_TEST_CHECKSUM_8"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_CHECKSUM"); @@ -5733,7 +8670,7 @@ static int test_checksum_8_skip (void) static int test_checksum_8 (void) { if (test_checksum_8_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_8"); + printf ("%s skipped (reason: environment variable set)\n", "test_checksum_8"); return 0; } @@ -5825,6 +8762,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"); @@ -5835,7 +8775,7 @@ 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; } @@ -5940,6 +8880,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"); @@ -5950,7 +8893,7 @@ 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; } @@ -6039,6 +8982,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"); @@ -6049,7 +8995,7 @@ 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; } @@ -6092,6 +9038,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"); @@ -6102,7 +9051,7 @@ 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; } @@ -6145,6 +9094,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"); @@ -6155,7 +9107,7 @@ 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; } @@ -6202,6 +9154,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"); @@ -6212,7 +9167,7 @@ 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; } @@ -6259,6 +9214,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"); @@ -6269,7 +9227,7 @@ 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; } @@ -6316,6 +9274,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"); @@ -6326,7 +9287,7 @@ 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; } @@ -6373,6 +9334,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"); @@ -6383,7 +9347,7 @@ 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; } @@ -6438,6 +9402,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"); @@ -6448,7 +9415,7 @@ 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; } @@ -6503,6 +9470,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"); @@ -6513,7 +9483,7 @@ 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; } @@ -6568,6 +9538,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"); @@ -6578,7 +9551,7 @@ 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; } @@ -6668,6 +9641,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"); @@ -6678,7 +9654,7 @@ 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; } @@ -6766,6 +9742,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"); @@ -6776,7 +9755,7 @@ 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; } @@ -6864,6 +9843,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"); @@ -6874,7 +9856,7 @@ 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; } @@ -6991,6 +9973,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"); @@ -7001,7 +9986,7 @@ 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; } @@ -7118,6 +10103,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"); @@ -7128,7 +10116,7 @@ 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; } @@ -7257,6 +10245,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"); @@ -7267,7 +10258,7 @@ 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; } @@ -7396,6 +10387,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"); @@ -7406,7 +10400,7 @@ 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; } @@ -7547,6 +10541,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"); @@ -7557,7 +10554,7 @@ 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; } @@ -7710,6 +10707,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"); @@ -7720,7 +10720,7 @@ 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; } @@ -7825,6 +10825,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"); @@ -7835,7 +10838,7 @@ 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; } @@ -7952,6 +10955,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"); @@ -7962,7 +10968,7 @@ 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; } @@ -8091,6 +11097,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"); @@ -8101,7 +11110,7 @@ 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; } @@ -8230,6 +11239,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"); @@ -8240,7 +11252,7 @@ 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; } @@ -8369,6 +11381,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"); @@ -8379,7 +11394,7 @@ 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; } @@ -8481,6 +11496,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"); @@ -8491,7 +11509,7 @@ 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; } @@ -8593,6 +11611,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"); @@ -8603,7 +11624,7 @@ 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; } @@ -8705,6 +11726,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"); @@ -8715,7 +11739,7 @@ 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; } @@ -8817,6 +11841,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"); @@ -8827,7 +11854,7 @@ 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; } @@ -8929,6 +11956,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"); @@ -8939,7 +11969,7 @@ 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; } @@ -9041,6 +12071,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"); @@ -9051,7 +12084,7 @@ 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; } @@ -9153,6 +12186,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"); @@ -9163,7 +12199,7 @@ 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; } @@ -9265,6 +12301,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"); @@ -9275,7 +12314,7 @@ 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; } @@ -9377,6 +12416,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"); @@ -9387,7 +12429,7 @@ 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; } @@ -9489,6 +12531,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"); @@ -9499,7 +12544,7 @@ 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; } @@ -9601,6 +12646,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"); @@ -9611,7 +12659,7 @@ 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; } @@ -9706,6 +12754,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"); @@ -9716,7 +12767,7 @@ 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; } @@ -9804,6 +12855,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"); @@ -9814,7 +12868,7 @@ 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; } @@ -9903,6 +12957,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"); @@ -9913,7 +12970,7 @@ 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; } @@ -9988,6 +13045,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"); @@ -9998,7 +13058,7 @@ 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; } @@ -10087,6 +13147,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"); @@ -10097,7 +13160,7 @@ 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; } @@ -10250,6 +13313,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"); @@ -10260,7 +13326,7 @@ 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; } @@ -10355,6 +13421,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"); @@ -10365,7 +13434,7 @@ 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; } @@ -10460,6 +13529,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"); @@ -10470,7 +13542,7 @@ 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; } @@ -10560,6 +13632,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"); @@ -10570,7 +13645,7 @@ 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; } @@ -10659,6 +13734,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"); @@ -10669,7 +13747,7 @@ 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; } @@ -10758,6 +13836,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"); @@ -10768,7 +13849,7 @@ 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; } @@ -10857,6 +13938,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"); @@ -10867,7 +13951,7 @@ 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; } @@ -10956,6 +14040,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"); @@ -10966,7 +14053,7 @@ 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; } @@ -11055,6 +14142,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"); @@ -11065,7 +14155,7 @@ 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; } @@ -11154,6 +14244,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"); @@ -11164,7 +14257,7 @@ 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; } @@ -11253,6 +14346,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"); @@ -11263,7 +14359,7 @@ 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; } @@ -11488,6 +14584,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"); @@ -11498,7 +14597,7 @@ 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; } @@ -11642,6 +14741,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"); @@ -11652,7 +14754,7 @@ 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; } @@ -11783,6 +14885,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"); @@ -11793,7 +14898,7 @@ 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; } @@ -11879,6 +14984,9 @@ static int test_is_dir_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "is_dir") == NULL; str = getenv ("SKIP_TEST_IS_DIR_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_IS_DIR"); @@ -11889,7 +14997,7 @@ static int test_is_dir_1_skip (void) static int test_is_dir_1 (void) { if (test_is_dir_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_1"); return 0; } @@ -11975,6 +15083,9 @@ static int test_is_file_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "is_file") == NULL; str = getenv ("SKIP_TEST_IS_FILE_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_IS_FILE"); @@ -11985,7 +15096,7 @@ static int test_is_file_0_skip (void) static int test_is_file_0 (void) { if (test_is_file_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_is_file_0"); return 0; } @@ -12071,6 +15182,9 @@ static int test_is_file_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "is_file") == NULL; str = getenv ("SKIP_TEST_IS_FILE_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_IS_FILE"); @@ -12081,7 +15195,7 @@ static int test_is_file_1_skip (void) static int test_is_file_1 (void) { if (test_is_file_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_is_file_1"); return 0; } @@ -12167,6 +15281,9 @@ static int test_exists_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "exists") == NULL; str = getenv ("SKIP_TEST_EXISTS_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_EXISTS"); @@ -12177,7 +15294,7 @@ static int test_exists_0_skip (void) static int test_exists_0 (void) { if (test_exists_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_exists_0"); return 0; } @@ -12263,6 +15380,9 @@ static int test_exists_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "exists") == NULL; str = getenv ("SKIP_TEST_EXISTS_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_EXISTS"); @@ -12273,7 +15393,7 @@ static int test_exists_1_skip (void) static int test_exists_1 (void) { if (test_exists_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_exists_1"); return 0; } @@ -12359,6 +15479,9 @@ static int test_mkdir_p_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mkdir_p") == NULL; str = getenv ("SKIP_TEST_MKDIR_P_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_MKDIR_P"); @@ -12369,7 +15492,7 @@ static int test_mkdir_p_0_skip (void) static int test_mkdir_p_0 (void) { if (test_mkdir_p_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_0"); return 0; } @@ -12455,6 +15578,9 @@ static int test_mkdir_p_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mkdir_p") == NULL; str = getenv ("SKIP_TEST_MKDIR_P_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_MKDIR_P"); @@ -12465,7 +15591,7 @@ static int test_mkdir_p_1_skip (void) static int test_mkdir_p_1 (void) { if (test_mkdir_p_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_1"); return 0; } @@ -12551,6 +15677,9 @@ static int test_mkdir_p_2_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mkdir_p") == NULL; str = getenv ("SKIP_TEST_MKDIR_P_2"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_MKDIR_P"); @@ -12561,7 +15690,7 @@ static int test_mkdir_p_2_skip (void) static int test_mkdir_p_2 (void) { if (test_mkdir_p_2_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_2"); + printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_2"); return 0; } @@ -12647,6 +15776,9 @@ static int test_mkdir_p_3_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mkdir_p") == NULL; str = getenv ("SKIP_TEST_MKDIR_P_3"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_MKDIR_P"); @@ -12657,7 +15789,7 @@ static int test_mkdir_p_3_skip (void) static int test_mkdir_p_3 (void) { if (test_mkdir_p_3_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_3"); + printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_3"); return 0; } @@ -12739,6 +15871,9 @@ static int test_mkdir_p_4_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mkdir_p") == NULL; str = getenv ("SKIP_TEST_MKDIR_P_4"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_MKDIR_P"); @@ -12749,7 +15884,7 @@ static int test_mkdir_p_4_skip (void) static int test_mkdir_p_4 (void) { if (test_mkdir_p_4_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_4"); + printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_4"); return 0; } @@ -12831,6 +15966,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"); @@ -12841,7 +15979,7 @@ 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; } @@ -12927,6 +16065,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"); @@ -12937,7 +16078,7 @@ 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; } @@ -13011,6 +16152,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"); @@ -13021,7 +16165,7 @@ 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; } @@ -13131,6 +16275,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"); @@ -13141,7 +16288,7 @@ 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; } @@ -13223,6 +16370,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"); @@ -13233,7 +16383,7 @@ 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; } @@ -13307,6 +16457,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"); @@ -13317,7 +16470,7 @@ 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; } @@ -13399,6 +16552,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"); @@ -13409,7 +16565,7 @@ 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; } @@ -13491,6 +16647,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"); @@ -13501,7 +16660,7 @@ 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; } @@ -13575,6 +16734,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"); @@ -13585,7 +16747,7 @@ 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; } @@ -13667,6 +16829,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"); @@ -13677,7 +16842,7 @@ 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; } @@ -13805,6 +16970,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"); @@ -13815,7 +16983,7 @@ 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; } @@ -13907,6 +17075,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"); @@ -13917,7 +17088,7 @@ 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; } @@ -14041,6 +17212,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"); @@ -14051,7 +17225,7 @@ 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; } @@ -14234,6 +17408,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"); @@ -14244,7 +17421,7 @@ 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; } @@ -14368,6 +17545,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"); @@ -14378,7 +17558,7 @@ 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; } @@ -14522,6 +17702,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"); @@ -14532,7 +17715,7 @@ 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; } @@ -14657,6 +17840,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"); @@ -14667,7 +17853,7 @@ 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; } @@ -14798,6 +17984,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"); @@ -14808,7 +17997,7 @@ 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; } @@ -14903,6 +18092,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"); @@ -14913,7 +18105,7 @@ 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; } @@ -15020,6 +18212,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"); @@ -15030,7 +18225,7 @@ 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; } @@ -15133,6 +18328,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"); @@ -15143,7 +18341,7 @@ 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; } @@ -15298,6 +18496,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"); @@ -15308,7 +18509,7 @@ 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; } @@ -15397,6 +18598,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"); @@ -15407,7 +18611,7 @@ 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; } @@ -15493,6 +18697,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"); @@ -15503,7 +18710,7 @@ 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; } @@ -15545,6 +18752,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"); @@ -15555,7 +18765,7 @@ 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; } @@ -15753,13 +18963,152 @@ int main (int argc, char *argv[]) printf ("guestfs_launch FAILED\n"); exit (1); } + + /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */ + alarm (600); + if (guestfs_wait_ready (g) == -1) { printf ("guestfs_wait_ready FAILED\n"); exit (1); } - nr_tests = 146; + /* Cancel previous alarm. */ + alarm (0); + nr_tests = 169; + + test_num++; + printf ("%3d/%3d test_mkswap_U_0\n", test_num, nr_tests); + if (test_mkswap_U_0 () == -1) { + printf ("test_mkswap_U_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_mkswap_L_0\n", test_num, nr_tests); + if (test_mkswap_L_0 () == -1) { + printf ("test_mkswap_L_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_mkswap_0\n", test_num, nr_tests); + if (test_mkswap_0 () == -1) { + printf ("test_mkswap_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_initrd_list_0\n", test_num, nr_tests); + if (test_initrd_list_0 () == -1) { + printf ("test_initrd_list_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_du_0\n", test_num, nr_tests); + if (test_du_0 () == -1) { + printf ("test_du_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_tail_n_0\n", test_num, nr_tests); + if (test_tail_n_0 () == -1) { + printf ("test_tail_n_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_tail_n_1\n", test_num, nr_tests); + if (test_tail_n_1 () == -1) { + printf ("test_tail_n_1 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_tail_n_2\n", test_num, nr_tests); + if (test_tail_n_2 () == -1) { + printf ("test_tail_n_2 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_tail_0\n", test_num, nr_tests); + if (test_tail_0 () == -1) { + printf ("test_tail_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_head_n_0\n", test_num, nr_tests); + if (test_head_n_0 () == -1) { + printf ("test_head_n_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_head_n_1\n", test_num, nr_tests); + if (test_head_n_1 () == -1) { + printf ("test_head_n_1 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_head_n_2\n", test_num, nr_tests); + if (test_head_n_2 () == -1) { + printf ("test_head_n_2 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_head_0\n", test_num, nr_tests); + if (test_head_0 () == -1) { + printf ("test_head_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_wc_c_0\n", test_num, nr_tests); + if (test_wc_c_0 () == -1) { + printf ("test_wc_c_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_wc_w_0\n", test_num, nr_tests); + if (test_wc_w_0 () == -1) { + printf ("test_wc_w_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_wc_l_0\n", test_num, nr_tests); + if (test_wc_l_0 () == -1) { + printf ("test_wc_l_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_mkdtemp_0\n", test_num, nr_tests); + if (test_mkdtemp_0 () == -1) { + printf ("test_mkdtemp_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_scrub_file_0\n", test_num, nr_tests); + if (test_scrub_file_0 () == -1) { + printf ("test_scrub_file_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_scrub_device_0\n", test_num, nr_tests); + if (test_scrub_device_0 () == -1) { + printf ("test_scrub_device_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_glob_expand_0\n", test_num, nr_tests); + if (test_glob_expand_0 () == -1) { + printf ("test_glob_expand_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_glob_expand_1\n", test_num, nr_tests); + if (test_glob_expand_1 () == -1) { + printf ("test_glob_expand_1 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_glob_expand_2\n", test_num, nr_tests); + if (test_glob_expand_2 () == -1) { + printf ("test_glob_expand_2 FAILED\n"); + failed++; + } test_num++; printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests); if (test_ntfs_3g_probe_0 () == -1) { @@ -15815,6 +19164,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");