X-Git-Url: http://git.annexia.org/?a=blobdiff_plain;ds=sidebyside;f=capitests%2Ftests.c;h=08f64ee1eadd674e68dae1a9ce9c188ae5f1c301;hb=b2ed0f4c55c2bd3d07341ba2207f0cb238eb4e18;hp=959d09b03640fdf9b9bc670e69e7ccc99a71a2ba;hpb=f6e36bf361c587e0dbb2f0c71f5d22a7cf7f4f42;p=libguestfs.git diff --git a/capitests/tests.c b/capitests/tests.c index 959d09b..08f64ee 100644 --- a/capitests/tests.c +++ b/capitests/tests.c @@ -31,11 +31,6 @@ static guestfs_h *g; static int suppress_error = 0; -/* This will be 's' or 'h' depending on whether the guest kernel - * names IDE devices /dev/sd* or /dev/hd*. - */ -static char devchar = 's'; - static void print_error (guestfs_h *g, void *data, const char *msg) { if (!suppress_error) @@ -50,114 +45,2544 @@ static void print_strings (char * const * const argv) printf ("\t%s\n", argv[argc]); } -/* -static void print_table (char * const * const argv) +/* +static void print_table (char * const * const argv) +{ + int i; + + for (i = 0; argv[i] != NULL; i += 2) + printf ("%s: %s\n", argv[i], argv[i+1]); +} +*/ + +static void no_test_warnings (void) +{ + fprintf (stderr, "warning: \"guestfs_test0\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_test0rint\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_test0rinterr\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_test0rint64\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_test0rint64err\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_test0rbool\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_test0rboolerr\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_test0rconststring\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_test0rconststringerr\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_test0rstring\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_test0rstringerr\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_test0rstringlist\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_test0rstringlisterr\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_test0rintbool\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_test0rintboolerr\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_test0rpvlist\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_test0rpvlisterr\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_test0rvglist\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_test0rvglisterr\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_test0rlvlist\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_test0rlvlisterr\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_test0rstat\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_test0rstaterr\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_test0rstatvfs\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_test0rstatvfserr\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_test0rhashtable\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_test0rhashtableerr\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_launch\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_wait_ready\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_kill_subprocess\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_add_drive\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_add_cdrom\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_add_drive_ro\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_config\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_set_qemu\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_get_qemu\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_set_path\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_get_path\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_set_append\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_get_append\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_set_autosync\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_get_autosync\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_set_verbose\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_get_verbose\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_is_ready\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_is_config\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_is_launching\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_is_busy\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_get_state\" has no tests\n"); + 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_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"); + fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_pvresize\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_sfdisk_N\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_sfdisk_l\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_sfdisk_kernel_geometry\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_sfdisk_disk_geometry\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_vg_activate_all\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_e2fsck_f\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_sh\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_sh_lines\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_scrub_freespace\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_df\" has no tests\n"); + fprintf (stderr, "warning: \"guestfs_df_h\" has no tests\n"); +} + +static int test_tail_n_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "tail_n") == NULL; + str = getenv ("SKIP_TEST_TAIL_N_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_TAIL_N"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_tail_n_0 (void) +{ + if (test_tail_n_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_0"); + return 0; + } + + /* InitBasicFS for test_tail_n_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for tail_n (0) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/10klines"; + char **r; + int i; + suppress_error = 0; + r = guestfs_tail_n (g, 3, path); + if (r == NULL) + return -1; + if (!r[0]) { + fprintf (stderr, "test_tail_n_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9997abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[0], expected) != 0) { + fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]); + return -1; + } + } + if (!r[1]) { + fprintf (stderr, "test_tail_n_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9998abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[1], expected) != 0) { + fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]); + return -1; + } + } + if (!r[2]) { + fprintf (stderr, "test_tail_n_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9999abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[2], expected) != 0) { + fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]); + return -1; + } + } + if (r[3] != NULL) { + fprintf (stderr, "test_tail_n_0: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_tail_n_1_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "tail_n") == NULL; + str = getenv ("SKIP_TEST_TAIL_N_1"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_TAIL_N"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_tail_n_1 (void) +{ + if (test_tail_n_1_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_1"); + return 0; + } + + /* InitBasicFS for test_tail_n_1: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for tail_n (1) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/10klines"; + char **r; + int i; + suppress_error = 0; + r = guestfs_tail_n (g, -9998, path); + if (r == NULL) + return -1; + if (!r[0]) { + fprintf (stderr, "test_tail_n_1: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9997abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[0], expected) != 0) { + fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]); + return -1; + } + } + if (!r[1]) { + fprintf (stderr, "test_tail_n_1: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9998abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[1], expected) != 0) { + fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]); + return -1; + } + } + if (!r[2]) { + fprintf (stderr, "test_tail_n_1: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9999abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[2], expected) != 0) { + fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]); + return -1; + } + } + if (r[3] != NULL) { + fprintf (stderr, "test_tail_n_1: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_tail_n_2_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "tail_n") == NULL; + str = getenv ("SKIP_TEST_TAIL_N_2"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_TAIL_N"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_tail_n_2 (void) +{ + if (test_tail_n_2_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_2"); + return 0; + } + + /* InitBasicFS for test_tail_n_2: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for tail_n (2) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/10klines"; + char **r; + int i; + suppress_error = 0; + r = guestfs_tail_n (g, 0, path); + if (r == NULL) + return -1; + if (r[0] != NULL) { + fprintf (stderr, "test_tail_n_2: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_tail_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "tail") == NULL; + str = getenv ("SKIP_TEST_TAIL_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_TAIL"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_tail_0 (void) +{ + if (test_tail_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_tail_0"); + return 0; + } + + /* InitBasicFS for test_tail_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for tail (0) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/10klines"; + char **r; + int i; + suppress_error = 0; + r = guestfs_tail (g, path); + if (r == NULL) + return -1; + if (!r[0]) { + fprintf (stderr, "test_tail_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9990abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[0], expected) != 0) { + fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[0]); + return -1; + } + } + if (!r[1]) { + fprintf (stderr, "test_tail_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9991abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[1], expected) != 0) { + fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[1]); + return -1; + } + } + if (!r[2]) { + fprintf (stderr, "test_tail_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9992abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[2], expected) != 0) { + fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[2]); + return -1; + } + } + if (!r[3]) { + fprintf (stderr, "test_tail_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9993abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[3], expected) != 0) { + fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[3]); + return -1; + } + } + if (!r[4]) { + fprintf (stderr, "test_tail_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9994abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[4], expected) != 0) { + fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[4]); + return -1; + } + } + if (!r[5]) { + fprintf (stderr, "test_tail_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9995abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[5], expected) != 0) { + fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[5]); + return -1; + } + } + if (!r[6]) { + fprintf (stderr, "test_tail_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9996abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[6], expected) != 0) { + fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[6]); + return -1; + } + } + if (!r[7]) { + fprintf (stderr, "test_tail_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9997abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[7], expected) != 0) { + fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[7]); + return -1; + } + } + if (!r[8]) { + fprintf (stderr, "test_tail_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9998abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[8], expected) != 0) { + fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[8]); + return -1; + } + } + if (!r[9]) { + fprintf (stderr, "test_tail_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9999abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[9], expected) != 0) { + fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[9]); + return -1; + } + } + if (r[10] != NULL) { + fprintf (stderr, "test_tail_0: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_head_n_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "head_n") == NULL; + str = getenv ("SKIP_TEST_HEAD_N_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_HEAD_N"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_head_n_0 (void) +{ + if (test_head_n_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_head_n_0"); + return 0; + } + + /* InitBasicFS for test_head_n_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for head_n (0) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/10klines"; + char **r; + int i; + suppress_error = 0; + r = guestfs_head_n (g, 3, path); + if (r == NULL) + return -1; + if (!r[0]) { + fprintf (stderr, "test_head_n_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "0abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[0], expected) != 0) { + fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]); + return -1; + } + } + if (!r[1]) { + fprintf (stderr, "test_head_n_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "1abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[1], expected) != 0) { + fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]); + return -1; + } + } + if (!r[2]) { + fprintf (stderr, "test_head_n_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "2abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[2], expected) != 0) { + fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]); + return -1; + } + } + if (r[3] != NULL) { + fprintf (stderr, "test_head_n_0: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_head_n_1_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "head_n") == NULL; + str = getenv ("SKIP_TEST_HEAD_N_1"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_HEAD_N"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_head_n_1 (void) +{ + if (test_head_n_1_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_head_n_1"); + return 0; + } + + /* InitBasicFS for test_head_n_1: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for head_n (1) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/10klines"; + char **r; + int i; + suppress_error = 0; + r = guestfs_head_n (g, -9997, path); + if (r == NULL) + return -1; + if (!r[0]) { + fprintf (stderr, "test_head_n_1: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "0abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[0], expected) != 0) { + fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]); + return -1; + } + } + if (!r[1]) { + fprintf (stderr, "test_head_n_1: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "1abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[1], expected) != 0) { + fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]); + return -1; + } + } + if (!r[2]) { + fprintf (stderr, "test_head_n_1: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "2abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[2], expected) != 0) { + fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]); + return -1; + } + } + if (r[3] != NULL) { + fprintf (stderr, "test_head_n_1: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_head_n_2_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "head_n") == NULL; + str = getenv ("SKIP_TEST_HEAD_N_2"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_HEAD_N"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_head_n_2 (void) +{ + if (test_head_n_2_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_head_n_2"); + return 0; + } + + /* InitBasicFS for test_head_n_2: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for head_n (2) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/10klines"; + char **r; + int i; + suppress_error = 0; + r = guestfs_head_n (g, 0, path); + if (r == NULL) + return -1; + if (r[0] != NULL) { + fprintf (stderr, "test_head_n_2: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_head_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "head") == NULL; + str = getenv ("SKIP_TEST_HEAD_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_HEAD"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_head_0 (void) +{ + if (test_head_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_head_0"); + return 0; + } + + /* InitBasicFS for test_head_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for head (0) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/10klines"; + char **r; + int i; + suppress_error = 0; + r = guestfs_head (g, path); + if (r == NULL) + return -1; + if (!r[0]) { + fprintf (stderr, "test_head_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "0abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[0], expected) != 0) { + fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[0]); + return -1; + } + } + if (!r[1]) { + fprintf (stderr, "test_head_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "1abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[1], expected) != 0) { + fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[1]); + return -1; + } + } + if (!r[2]) { + fprintf (stderr, "test_head_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "2abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[2], expected) != 0) { + fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[2]); + return -1; + } + } + if (!r[3]) { + fprintf (stderr, "test_head_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "3abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[3], expected) != 0) { + fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[3]); + return -1; + } + } + if (!r[4]) { + fprintf (stderr, "test_head_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "4abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[4], expected) != 0) { + fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[4]); + return -1; + } + } + if (!r[5]) { + fprintf (stderr, "test_head_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "5abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[5], expected) != 0) { + fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[5]); + return -1; + } + } + if (!r[6]) { + fprintf (stderr, "test_head_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "6abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[6], expected) != 0) { + fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[6]); + return -1; + } + } + if (!r[7]) { + fprintf (stderr, "test_head_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "7abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[7], expected) != 0) { + fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[7]); + return -1; + } + } + if (!r[8]) { + fprintf (stderr, "test_head_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "8abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[8], expected) != 0) { + fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[8]); + return -1; + } + } + if (!r[9]) { + fprintf (stderr, "test_head_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "9abcdefghijklmnopqrstuvwxyz"; + if (strcmp (r[9], expected) != 0) { + fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[9]); + return -1; + } + } + if (r[10] != NULL) { + fprintf (stderr, "test_head_0: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_wc_c_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "wc_c") == NULL; + str = getenv ("SKIP_TEST_WC_C_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_WC_C"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_wc_c_0 (void) +{ + if (test_wc_c_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_wc_c_0"); + return 0; + } + + /* InitBasicFS for test_wc_c_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputInt for wc_c (0) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/100kallspaces"; + int r; + suppress_error = 0; + r = guestfs_wc_c (g, path); + if (r == -1) + return -1; + if (r != 102400) { + fprintf (stderr, "test_wc_c_0: expected 102400 but got %d\n", (int) r); + return -1; + } + } + return 0; +} + +static int test_wc_w_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "wc_w") == NULL; + str = getenv ("SKIP_TEST_WC_W_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_WC_W"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_wc_w_0 (void) +{ + if (test_wc_w_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_wc_w_0"); + return 0; + } + + /* InitBasicFS for test_wc_w_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputInt for wc_w (0) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/10klines"; + int r; + suppress_error = 0; + r = guestfs_wc_w (g, path); + if (r == -1) + return -1; + if (r != 10000) { + fprintf (stderr, "test_wc_w_0: expected 10000 but got %d\n", (int) r); + return -1; + } + } + return 0; +} + +static int test_wc_l_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "wc_l") == NULL; + str = getenv ("SKIP_TEST_WC_L_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_WC_L"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_wc_l_0 (void) +{ + if (test_wc_l_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_wc_l_0"); + return 0; + } + + /* InitBasicFS for test_wc_l_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputInt for wc_l (0) */ + { + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/10klines"; + int r; + suppress_error = 0; + r = guestfs_wc_l (g, path); + if (r == -1) + return -1; + if (r != 10000) { + fprintf (stderr, "test_wc_l_0: expected 10000 but got %d\n", (int) r); + return -1; + } + } + return 0; +} + +static int test_mkdtemp_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mkdtemp") == NULL; + str = getenv ("SKIP_TEST_MKDTEMP_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_MKDTEMP"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_mkdtemp_0 (void) +{ + if (test_mkdtemp_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_mkdtemp_0"); + return 0; + } + + /* InitBasicFS for test_mkdtemp_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestRun for mkdtemp (0) */ + { + char path[] = "/tmp"; + int r; + suppress_error = 0; + r = guestfs_mkdir (g, path); + if (r == -1) + return -1; + } + { + char template[] = "/tmp/tmpXXXXXX"; + char *r; + suppress_error = 0; + r = guestfs_mkdtemp (g, template); + if (r == NULL) + return -1; + free (r); + } + return 0; +} + +static int test_scrub_file_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "scrub_file") == NULL; + str = getenv ("SKIP_TEST_SCRUB_FILE_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_SCRUB_FILE"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_scrub_file_0 (void) +{ + if (test_scrub_file_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_scrub_file_0"); + return 0; + } + + /* InitBasicFS for test_scrub_file_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestRun for scrub_file (0) */ + { + char path[] = "/file"; + char content[] = "content"; + int r; + suppress_error = 0; + r = guestfs_write_file (g, path, content, 0); + if (r == -1) + return -1; + } + { + char file[] = "/file"; + int r; + suppress_error = 0; + r = guestfs_scrub_file (g, file); + if (r == -1) + return -1; + } + return 0; +} + +static int test_scrub_device_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "scrub_device") == NULL; + str = getenv ("SKIP_TEST_SCRUB_DEVICE_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_SCRUB_DEVICE"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_scrub_device_0 (void) +{ + if (test_scrub_device_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_scrub_device_0"); + return 0; + } + + /* InitNone|InitEmpty for test_scrub_device_0 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + /* TestRun for scrub_device (0) */ + { + char device[] = "/dev/sdc"; + int r; + suppress_error = 0; + r = guestfs_scrub_device (g, device); + if (r == -1) + return -1; + } + return 0; +} + +static int test_glob_expand_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "glob_expand") == NULL; + str = getenv ("SKIP_TEST_GLOB_EXPAND_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_GLOB_EXPAND"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_glob_expand_0 (void) +{ + if (test_glob_expand_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_0"); + return 0; + } + + /* InitBasicFS for test_glob_expand_0: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for glob_expand (0) */ + { + char path[] = "/a/b/c"; + int r; + suppress_error = 0; + r = guestfs_mkdir_p (g, path); + if (r == -1) + return -1; + } + { + char path[] = "/a/b/c/d"; + int r; + suppress_error = 0; + r = guestfs_touch (g, path); + if (r == -1) + return -1; + } + { + char path[] = "/a/b/c/e"; + int r; + suppress_error = 0; + r = guestfs_touch (g, path); + if (r == -1) + return -1; + } + { + char pattern[] = "/a/b/c/*"; + char **r; + int i; + suppress_error = 0; + r = guestfs_glob_expand (g, pattern); + if (r == NULL) + return -1; + if (!r[0]) { + fprintf (stderr, "test_glob_expand_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "/a/b/c/d"; + if (strcmp (r[0], expected) != 0) { + fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[0]); + return -1; + } + } + if (!r[1]) { + fprintf (stderr, "test_glob_expand_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "/a/b/c/e"; + if (strcmp (r[1], expected) != 0) { + fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[1]); + return -1; + } + } + if (r[2] != NULL) { + fprintf (stderr, "test_glob_expand_0: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_glob_expand_1_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "glob_expand") == NULL; + str = getenv ("SKIP_TEST_GLOB_EXPAND_1"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_GLOB_EXPAND"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_glob_expand_1 (void) +{ + if (test_glob_expand_1_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_1"); + return 0; + } + + /* InitBasicFS for test_glob_expand_1: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for glob_expand (1) */ + { + char path[] = "/a/b/c"; + int r; + suppress_error = 0; + r = guestfs_mkdir_p (g, path); + if (r == -1) + return -1; + } + { + char path[] = "/a/b/c/d"; + int r; + suppress_error = 0; + r = guestfs_touch (g, path); + if (r == -1) + return -1; + } + { + char path[] = "/a/b/c/e"; + int r; + suppress_error = 0; + r = guestfs_touch (g, path); + if (r == -1) + return -1; + } + { + char pattern[] = "/a/*/c/*"; + char **r; + int i; + suppress_error = 0; + r = guestfs_glob_expand (g, pattern); + if (r == NULL) + return -1; + if (!r[0]) { + fprintf (stderr, "test_glob_expand_1: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "/a/b/c/d"; + if (strcmp (r[0], expected) != 0) { + fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[0]); + return -1; + } + } + if (!r[1]) { + fprintf (stderr, "test_glob_expand_1: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "/a/b/c/e"; + if (strcmp (r[1], expected) != 0) { + fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[1]); + return -1; + } + } + if (r[2] != NULL) { + fprintf (stderr, "test_glob_expand_1: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_glob_expand_2_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "glob_expand") == NULL; + str = getenv ("SKIP_TEST_GLOB_EXPAND_2"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_GLOB_EXPAND"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_glob_expand_2 (void) +{ + if (test_glob_expand_2_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_2"); + return 0; + } + + /* InitBasicFS for test_glob_expand_2: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutputList for glob_expand (2) */ + { + char path[] = "/a/b/c"; + int r; + suppress_error = 0; + r = guestfs_mkdir_p (g, path); + if (r == -1) + return -1; + } + { + char path[] = "/a/b/c/d"; + int r; + suppress_error = 0; + r = guestfs_touch (g, path); + if (r == -1) + return -1; + } + { + char path[] = "/a/b/c/e"; + int r; + suppress_error = 0; + r = guestfs_touch (g, path); + if (r == -1) + return -1; + } + { + char pattern[] = "/a/*/x/*"; + char **r; + int i; + suppress_error = 0; + r = guestfs_glob_expand (g, pattern); + if (r == NULL) + return -1; + if (r[0] != NULL) { + fprintf (stderr, "test_glob_expand_2: extra elements returned from command\n"); + print_strings (r); + return -1; + } + for (i = 0; r[i] != NULL; ++i) + free (r[i]); + free (r); + } + return 0; +} + +static int test_ntfs_3g_probe_0_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "ntfs_3g_probe") == NULL; + str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_NTFS_3G_PROBE"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_ntfs_3g_probe_0 (void) +{ + if (test_ntfs_3g_probe_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_0"); + return 0; + } + + /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + /* TestOutputInt for ntfs_3g_probe (0) */ + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ntfs"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_ntfs_3g_probe (g, 1, device); + if (r == -1) + return -1; + if (r != 0) { + fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n", (int) r); + return -1; + } + } + return 0; +} + +static int test_ntfs_3g_probe_1_skip (void) +{ + const char *str; + + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "ntfs_3g_probe") == NULL; + str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_NTFS_3G_PROBE"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_ntfs_3g_probe_1 (void) +{ + if (test_ntfs_3g_probe_1_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_1"); + return 0; + } + + /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + /* TestOutputInt for ntfs_3g_probe (1) */ + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_ntfs_3g_probe (g, 1, device); + if (r == -1) + return -1; + if (r != 12) { + fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n", (int) r); + return -1; + } + } + return 0; +} + +static int test_sleep_0_skip (void) { - int i; + const char *str; - for (i = 0; argv[i] != NULL; i += 2) - printf ("%s: %s\n", argv[i], argv[i+1]); + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "sleep") == NULL; + str = getenv ("SKIP_TEST_SLEEP_0"); + if (str && strcmp (str, "1") == 0) return 1; + str = getenv ("SKIP_TEST_SLEEP"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; } -*/ -static void no_test_warnings (void) +static int test_sleep_0 (void) { - fprintf (stderr, "warning: \"guestfs_test0\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_test0rint\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_test0rinterr\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_test0rint64\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_test0rint64err\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_test0rbool\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_test0rboolerr\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_test0rconststring\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_test0rconststringerr\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_test0rstring\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_test0rstringerr\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_test0rstringlist\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_test0rstringlisterr\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_test0rintbool\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_test0rintboolerr\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_test0rpvlist\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_test0rpvlisterr\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_test0rvglist\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_test0rvglisterr\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_test0rlvlist\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_test0rlvlisterr\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_test0rstat\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_test0rstaterr\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_test0rstatvfs\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_test0rstatvfserr\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_test0rhashtable\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_test0rhashtableerr\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_launch\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_wait_ready\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_kill_subprocess\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_add_drive\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_add_cdrom\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_config\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_set_qemu\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_get_qemu\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_set_path\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_get_path\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_set_append\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_get_append\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_set_autosync\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_get_autosync\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_set_verbose\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_get_verbose\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_is_ready\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_is_config\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_is_launching\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_is_busy\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_get_state\" has no tests\n"); - 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_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"); - fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_pvresize\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_sfdisk_N\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_sfdisk_l\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_sfdisk_kernel_geometry\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_sfdisk_disk_geometry\" has no tests\n"); - fprintf (stderr, "warning: \"guestfs_vg_activate_all\" has no tests\n"); - 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"); + if (test_sleep_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_sleep_0"); + return 0; + } + + /* InitNone|InitEmpty for test_sleep_0 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + /* TestRun for sleep (0) */ + { + int r; + suppress_error = 0; + r = guestfs_sleep (g, 1); + if (r == -1) + return -1; + } + return 0; } static int test_find_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "find") == NULL; str = getenv ("SKIP_TEST_FIND_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_FIND"); @@ -168,14 +2593,13 @@ static int test_find_0_skip (void) static int test_find_0 (void) { if (test_find_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_find_0"); return 0; } /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -198,7 +2622,6 @@ static int test_find_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -213,7 +2636,6 @@ static int test_find_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -222,7 +2644,6 @@ static int test_find_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -267,6 +2688,9 @@ static int test_find_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "find") == NULL; str = getenv ("SKIP_TEST_FIND_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_FIND"); @@ -277,14 +2701,13 @@ static int test_find_1_skip (void) static int test_find_1 (void) { if (test_find_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_find_1"); return 0; } /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -307,7 +2730,6 @@ static int test_find_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -322,7 +2744,6 @@ static int test_find_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -331,7 +2752,6 @@ static int test_find_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -436,6 +2856,9 @@ static int test_find_2_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "find") == NULL; str = getenv ("SKIP_TEST_FIND_2"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_FIND"); @@ -446,14 +2869,13 @@ static int test_find_2_skip (void) static int test_find_2 (void) { if (test_find_2_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_2"); + printf ("%s skipped (reason: environment variable set)\n", "test_find_2"); return 0; } /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -476,7 +2898,6 @@ static int test_find_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -491,7 +2912,6 @@ static int test_find_2 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -500,7 +2920,6 @@ static int test_find_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -573,6 +2992,9 @@ static int test_lvresize_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "lvresize") == NULL; str = getenv ("SKIP_TEST_LVRESIZE_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_LVRESIZE"); @@ -583,14 +3005,13 @@ static int test_lvresize_0_skip (void) static int test_lvresize_0 (void) { if (test_lvresize_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvresize_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_lvresize_0"); return 0; } /* InitNone|InitEmpty for test_lvresize_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -615,7 +3036,6 @@ static int test_lvresize_0 (void) char expected[] = "test content"; { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -629,7 +3049,6 @@ static int test_lvresize_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -639,7 +3058,6 @@ static int test_lvresize_0 (void) { char volgroup[] = "VG"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -698,28 +3116,155 @@ static int test_lvresize_0 (void) char device[] = "/dev/VG/LV"; int r; suppress_error = 0; - r = guestfs_lvresize (g, device, 20); + r = guestfs_lvresize (g, device, 20); + if (r == -1) + return -1; + } + { + char device[] = "/dev/VG/LV"; + int r; + suppress_error = 0; + r = guestfs_e2fsck_f (g, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/VG/LV"; + int r; + suppress_error = 0; + r = guestfs_resize2fs (g, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/VG/LV"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + { + char path[] = "/new"; + char *r; + suppress_error = 0; + r = guestfs_cat (g, path); + if (r == NULL) + return -1; + if (strcmp (r, expected) != 0) { + fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r); + return -1; + } + free (r); + } + return 0; +} + +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"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_zerofree_0 (void) +{ + if (test_zerofree_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_zerofree_0"); + return 0; + } + + /* InitNone|InitEmpty for test_zerofree_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; + } + /* TestOutput for zerofree (0) */ + char expected[] = "test file"; + { + 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[] = "ext3"; + 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; + } + { + char path[] = "/new"; + char content[] = "test file"; + int r; + suppress_error = 0; + r = guestfs_write_file (g, path, content, 0); if (r == -1) return -1; } { - char device[] = "/dev/VG/LV"; + char pathordevice[] = "/dev/sda1"; int r; suppress_error = 0; - r = guestfs_e2fsck_f (g, device); + r = guestfs_umount (g, pathordevice); if (r == -1) return -1; } { - char device[] = "/dev/VG/LV"; + char device[] = "/dev/sda1"; int r; suppress_error = 0; - r = guestfs_resize2fs (g, device); + r = guestfs_zerofree (g, device); if (r == -1) return -1; } { - char device[] = "/dev/VG/LV"; + char device[] = "/dev/sda1"; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -735,7 +3280,7 @@ static int test_lvresize_0 (void) if (r == NULL) return -1; if (strcmp (r, expected) != 0) { - fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r); + fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r); return -1; } free (r); @@ -743,28 +3288,30 @@ static int test_lvresize_0 (void) return 0; } -static int test_zerofree_0_skip (void) +static int test_hexdump_0_skip (void) { const char *str; - str = getenv ("SKIP_TEST_ZEROFREE_0"); + 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_ZEROFREE"); + str = getenv ("SKIP_TEST_HEXDUMP"); if (str && strcmp (str, "1") == 0) return 1; return 0; } -static int test_zerofree_0 (void) +static int test_hexdump_0 (void) { - if (test_zerofree_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zerofree_0"); + if (test_hexdump_0_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_0"); return 0; } - /* InitNone|InitEmpty for test_zerofree_0 */ + /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -785,11 +3332,8 @@ static int test_zerofree_0 (void) if (r == -1) return -1; } - /* TestOutput for zerofree (0) */ - char expected[] = "test file"; { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -802,9 +3346,8 @@ static int test_zerofree_0 (void) return -1; } { - char fstype[] = "ext3"; + char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -813,7 +3356,6 @@ static int test_zerofree_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -821,40 +3363,14 @@ static int test_zerofree_0 (void) if (r == -1) return -1; } + /* TestOutput for hexdump (0) */ + char expected[] = "00000000 68 65 6c 6c 6f 0a 77 6f 72 6c 64 0a |hello.world.|\n0000000c\n"; { char path[] = "/new"; - char content[] = "test file"; - int r; - suppress_error = 0; - r = guestfs_write_file (g, path, content, 0); - if (r == -1) - return -1; - } - { - char pathordevice[] = "/dev/sda1"; - pathordevice[5] = devchar; - int r; - suppress_error = 0; - r = guestfs_umount (g, pathordevice); - if (r == -1) - return -1; - } - { - char device[] = "/dev/sda1"; - device[5] = devchar; - int r; - suppress_error = 0; - r = guestfs_zerofree (g, device); - if (r == -1) - return -1; - } - { - char device[] = "/dev/sda1"; - device[5] = devchar; - char mountpoint[] = "/"; + char content[] = "hello\nworld\n"; int r; suppress_error = 0; - r = guestfs_mount (g, device, mountpoint); + r = guestfs_write_file (g, path, content, 12); if (r == -1) return -1; } @@ -862,11 +3378,11 @@ static int test_zerofree_0 (void) char path[] = "/new"; char *r; suppress_error = 0; - r = guestfs_cat (g, path); + r = guestfs_hexdump (g, path); if (r == NULL) return -1; if (strcmp (r, expected) != 0) { - fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r); + fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r); return -1; } free (r); @@ -874,28 +3390,30 @@ static int test_zerofree_0 (void) return 0; } -static int test_hexdump_0_skip (void) +static int test_hexdump_1_skip (void) { const char *str; - str = getenv ("SKIP_TEST_HEXDUMP_0"); + 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_0 (void) +static int test_hexdump_1 (void) { - if (test_hexdump_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_hexdump_0"); + if (test_hexdump_1_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_1"); return 0; } - /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */ + /* InitBasicFS for test_hexdump_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -918,7 +3436,6 @@ static int test_hexdump_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -933,7 +3450,6 @@ static int test_hexdump_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -942,7 +3458,6 @@ static int test_hexdump_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -950,28 +3465,25 @@ static int test_hexdump_0 (void) if (r == -1) return -1; } - /* TestOutput for hexdump (0) */ - char expected[] = "00000000 68 65 6c 6c 6f 0a 77 6f 72 6c 64 0a |hello.world.|\n0000000c\n"; + /* TestRun for hexdump (1) */ { - char path[] = "/new"; - char content[] = "hello\nworld\n"; + char options[] = "ro"; + char vfstype[] = "squashfs"; + char device[] = "/dev/sdd"; + char mountpoint[] = "/"; int r; suppress_error = 0; - r = guestfs_write_file (g, path, content, 12); + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); if (r == -1) return -1; } { - char path[] = "/new"; + char path[] = "/100krandom"; char *r; suppress_error = 0; r = guestfs_hexdump (g, path); if (r == NULL) return -1; - if (strcmp (r, expected) != 0) { - fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r); - return -1; - } free (r); } return 0; @@ -981,6 +3493,9 @@ static int test_strings_e_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "strings_e") == NULL; str = getenv ("SKIP_TEST_STRINGS_E_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_STRINGS_E"); @@ -991,14 +3506,13 @@ static int test_strings_e_0_skip (void) static int test_strings_e_0 (void) { if (test_strings_e_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_0"); return 0; } /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -1021,7 +3535,6 @@ static int test_strings_e_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -1036,7 +3549,6 @@ static int test_strings_e_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -1045,7 +3557,6 @@ static int test_strings_e_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -1088,6 +3599,9 @@ static int test_strings_e_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "strings_e") == NULL; str = getenv ("SKIP_TEST_STRINGS_E_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_STRINGS_E"); @@ -1098,7 +3612,7 @@ static int test_strings_e_1_skip (void) static int test_strings_e_1 (void) { if (test_strings_e_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_1"); return 0; } @@ -1110,6 +3624,9 @@ static int test_strings_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "strings") == NULL; str = getenv ("SKIP_TEST_STRINGS_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_STRINGS"); @@ -1120,14 +3637,13 @@ static int test_strings_0_skip (void) static int test_strings_0 (void) { if (test_strings_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_strings_0"); return 0; } /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -1150,7 +3666,6 @@ static int test_strings_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -1165,7 +3680,6 @@ static int test_strings_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -1174,7 +3688,6 @@ static int test_strings_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -1240,6 +3753,9 @@ static int test_strings_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "strings") == NULL; str = getenv ("SKIP_TEST_STRINGS_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_STRINGS"); @@ -1250,14 +3766,13 @@ static int test_strings_1_skip (void) static int test_strings_1 (void) { if (test_strings_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_strings_1"); return 0; } /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -1280,7 +3795,6 @@ static int test_strings_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -1295,7 +3809,6 @@ static int test_strings_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -1304,7 +3817,6 @@ static int test_strings_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -1345,6 +3857,9 @@ static int test_equal_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "equal") == NULL; str = getenv ("SKIP_TEST_EQUAL_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_EQUAL"); @@ -1355,14 +3870,13 @@ static int test_equal_0_skip (void) static int test_equal_0 (void) { if (test_equal_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_equal_0"); return 0; } /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -1385,7 +3899,6 @@ static int test_equal_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -1400,7 +3913,6 @@ static int test_equal_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -1409,7 +3921,6 @@ static int test_equal_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -1456,6 +3967,9 @@ static int test_equal_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "equal") == NULL; str = getenv ("SKIP_TEST_EQUAL_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_EQUAL"); @@ -1466,14 +3980,13 @@ static int test_equal_1_skip (void) static int test_equal_1 (void) { if (test_equal_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_equal_1"); return 0; } /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -1496,7 +4009,6 @@ static int test_equal_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -1511,7 +4023,6 @@ static int test_equal_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -1520,7 +4031,6 @@ static int test_equal_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -1567,6 +4077,9 @@ static int test_equal_2_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "equal") == NULL; str = getenv ("SKIP_TEST_EQUAL_2"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_EQUAL"); @@ -1577,14 +4090,13 @@ static int test_equal_2_skip (void) static int test_equal_2 (void) { if (test_equal_2_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_2"); + printf ("%s skipped (reason: environment variable set)\n", "test_equal_2"); return 0; } /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -1607,7 +4119,6 @@ static int test_equal_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -1622,7 +4133,6 @@ static int test_equal_2 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -1631,7 +4141,6 @@ static int test_equal_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -1656,6 +4165,9 @@ static int test_ping_daemon_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "ping_daemon") == NULL; str = getenv ("SKIP_TEST_PING_DAEMON_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_PING_DAEMON"); @@ -1666,14 +4178,13 @@ static int test_ping_daemon_0_skip (void) static int test_ping_daemon_0 (void) { if (test_ping_daemon_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ping_daemon_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_ping_daemon_0"); return 0; } /* InitNone|InitEmpty for test_ping_daemon_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -1709,6 +4220,9 @@ static int test_dmesg_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "dmesg") == NULL; str = getenv ("SKIP_TEST_DMESG_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_DMESG"); @@ -1719,14 +4233,13 @@ static int test_dmesg_0_skip (void) static int test_dmesg_0 (void) { if (test_dmesg_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_dmesg_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_dmesg_0"); return 0; } /* InitNone|InitEmpty for test_dmesg_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -1763,6 +4276,9 @@ static int test_drop_caches_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "drop_caches") == NULL; str = getenv ("SKIP_TEST_DROP_CACHES_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_DROP_CACHES"); @@ -1773,14 +4289,13 @@ static int test_drop_caches_0_skip (void) static int test_drop_caches_0 (void) { if (test_drop_caches_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_drop_caches_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_drop_caches_0"); return 0; } /* InitNone|InitEmpty for test_drop_caches_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -1816,6 +4331,9 @@ static int test_mv_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mv") == NULL; str = getenv ("SKIP_TEST_MV_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_MV"); @@ -1826,14 +4344,13 @@ static int test_mv_0_skip (void) static int test_mv_0 (void) { if (test_mv_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_mv_0"); return 0; } /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -1856,7 +4373,6 @@ static int test_mv_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -1871,7 +4387,6 @@ static int test_mv_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -1880,7 +4395,6 @@ static int test_mv_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -1928,6 +4442,9 @@ static int test_mv_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mv") == NULL; str = getenv ("SKIP_TEST_MV_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_MV"); @@ -1938,14 +4455,13 @@ static int test_mv_1_skip (void) static int test_mv_1 (void) { if (test_mv_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_mv_1"); return 0; } /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -1968,7 +4484,6 @@ static int test_mv_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -1983,7 +4498,6 @@ static int test_mv_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -1992,7 +4506,6 @@ static int test_mv_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -2038,6 +4551,9 @@ static int test_cp_a_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "cp_a") == NULL; str = getenv ("SKIP_TEST_CP_A_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_CP_A"); @@ -2048,14 +4564,13 @@ static int test_cp_a_0_skip (void) static int test_cp_a_0 (void) { if (test_cp_a_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_a_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_cp_a_0"); return 0; } /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -2078,7 +4593,6 @@ static int test_cp_a_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -2093,7 +4607,6 @@ static int test_cp_a_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -2102,7 +4615,6 @@ static int test_cp_a_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -2166,6 +4678,9 @@ static int test_cp_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "cp") == NULL; str = getenv ("SKIP_TEST_CP_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_CP"); @@ -2176,14 +4691,13 @@ static int test_cp_0_skip (void) static int test_cp_0 (void) { if (test_cp_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_cp_0"); return 0; } /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -2206,7 +4720,6 @@ static int test_cp_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -2221,7 +4734,6 @@ static int test_cp_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -2230,7 +4742,6 @@ static int test_cp_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -2278,6 +4789,9 @@ static int test_cp_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "cp") == NULL; str = getenv ("SKIP_TEST_CP_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_CP"); @@ -2288,14 +4802,13 @@ static int test_cp_1_skip (void) static int test_cp_1 (void) { if (test_cp_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_cp_1"); return 0; } /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -2318,7 +4831,6 @@ static int test_cp_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -2333,7 +4845,6 @@ static int test_cp_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -2342,7 +4853,6 @@ static int test_cp_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -2388,6 +4898,9 @@ static int test_cp_2_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "cp") == NULL; str = getenv ("SKIP_TEST_CP_2"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_CP"); @@ -2398,14 +4911,13 @@ static int test_cp_2_skip (void) static int test_cp_2 (void) { if (test_cp_2_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_2"); + printf ("%s skipped (reason: environment variable set)\n", "test_cp_2"); return 0; } /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -2428,7 +4940,6 @@ static int test_cp_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -2443,7 +4954,6 @@ static int test_cp_2 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -2452,7 +4962,6 @@ static int test_cp_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -2508,6 +5017,9 @@ static int test_grub_install_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "grub_install") == NULL; str = getenv ("SKIP_TEST_GRUB_INSTALL_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_GRUB_INSTALL"); @@ -2518,14 +5030,13 @@ static int test_grub_install_0_skip (void) static int test_grub_install_0 (void) { if (test_grub_install_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_grub_install_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_grub_install_0"); return 0; } /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -2548,7 +5059,6 @@ static int test_grub_install_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -2563,7 +5073,6 @@ static int test_grub_install_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -2572,7 +5081,6 @@ static int test_grub_install_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -2584,7 +5092,6 @@ static int test_grub_install_0 (void) { char root[] = "/"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_grub_install (g, root, device); @@ -2610,6 +5117,9 @@ static int test_zero_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "zero") == NULL; str = getenv ("SKIP_TEST_ZERO_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_ZERO"); @@ -2620,14 +5130,13 @@ static int test_zero_0_skip (void) static int test_zero_0 (void) { if (test_zero_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zero_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_zero_0"); return 0; } /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -2650,7 +5159,6 @@ static int test_zero_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -2665,7 +5173,6 @@ static int test_zero_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -2674,7 +5181,6 @@ static int test_zero_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -2686,7 +5192,6 @@ static int test_zero_0 (void) char expected[] = "data"; { char pathordevice[] = "/dev/sda1"; - pathordevice[5] = devchar; int r; suppress_error = 0; r = guestfs_umount (g, pathordevice); @@ -2695,7 +5200,6 @@ static int test_zero_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_zero (g, device); @@ -2704,7 +5208,6 @@ static int test_zero_0 (void) } { char path[] = "/dev/sda1"; - path[5] = devchar; char *r; suppress_error = 0; r = guestfs_file (g, path); @@ -2723,6 +5226,9 @@ static int test_fsck_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "fsck") == NULL; str = getenv ("SKIP_TEST_FSCK_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_FSCK"); @@ -2733,14 +5239,13 @@ static int test_fsck_0_skip (void) static int test_fsck_0 (void) { if (test_fsck_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_fsck_0"); return 0; } /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -2763,7 +5268,6 @@ static int test_fsck_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -2778,7 +5282,6 @@ static int test_fsck_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -2787,7 +5290,6 @@ static int test_fsck_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -2798,7 +5300,6 @@ static int test_fsck_0 (void) /* TestOutputInt for fsck (0) */ { char pathordevice[] = "/dev/sda1"; - pathordevice[5] = devchar; int r; suppress_error = 0; r = guestfs_umount (g, pathordevice); @@ -2808,7 +5309,6 @@ static int test_fsck_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_fsck (g, fstype, device); @@ -2826,6 +5326,9 @@ static int test_fsck_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "fsck") == NULL; str = getenv ("SKIP_TEST_FSCK_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_FSCK"); @@ -2836,14 +5339,13 @@ static int test_fsck_1_skip (void) static int test_fsck_1 (void) { if (test_fsck_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_fsck_1"); return 0; } /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -2866,7 +5368,6 @@ static int test_fsck_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -2881,7 +5382,6 @@ static int test_fsck_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -2890,7 +5390,6 @@ static int test_fsck_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -2901,7 +5400,6 @@ static int test_fsck_1 (void) /* TestOutputInt for fsck (1) */ { char pathordevice[] = "/dev/sda1"; - pathordevice[5] = devchar; int r; suppress_error = 0; r = guestfs_umount (g, pathordevice); @@ -2910,7 +5408,6 @@ static int test_fsck_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_zero (g, device); @@ -2920,7 +5417,6 @@ static int test_fsck_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_fsck (g, fstype, device); @@ -2938,6 +5434,9 @@ static int test_set_e2uuid_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "set_e2uuid") == NULL; str = getenv ("SKIP_TEST_SET_E2UUID_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_SET_E2UUID"); @@ -2948,14 +5447,13 @@ static int test_set_e2uuid_0_skip (void) static int test_set_e2uuid_0 (void) { if (test_set_e2uuid_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_0"); return 0; } /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -2978,7 +5476,6 @@ static int test_set_e2uuid_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -2993,7 +5490,6 @@ static int test_set_e2uuid_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -3002,7 +5498,6 @@ static int test_set_e2uuid_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -3014,7 +5509,6 @@ static int test_set_e2uuid_0 (void) char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d"; { char device[] = "/dev/sda1"; - device[5] = devchar; char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d"; int r; suppress_error = 0; @@ -3024,7 +5518,6 @@ static int test_set_e2uuid_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char *r; suppress_error = 0; r = guestfs_get_e2uuid (g, device); @@ -3043,6 +5536,9 @@ static int test_set_e2uuid_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "set_e2uuid") == NULL; str = getenv ("SKIP_TEST_SET_E2UUID_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_SET_E2UUID"); @@ -3053,14 +5549,13 @@ static int test_set_e2uuid_1_skip (void) static int test_set_e2uuid_1 (void) { if (test_set_e2uuid_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_1"); return 0; } /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -3083,7 +5578,6 @@ static int test_set_e2uuid_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -3098,7 +5592,6 @@ static int test_set_e2uuid_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -3107,7 +5600,6 @@ static int test_set_e2uuid_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -3119,7 +5611,6 @@ static int test_set_e2uuid_1 (void) char expected[] = ""; { char device[] = "/dev/sda1"; - device[5] = devchar; char uuid[] = "clear"; int r; suppress_error = 0; @@ -3129,7 +5620,6 @@ static int test_set_e2uuid_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char *r; suppress_error = 0; r = guestfs_get_e2uuid (g, device); @@ -3148,6 +5638,9 @@ static int test_set_e2uuid_2_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "set_e2uuid") == NULL; str = getenv ("SKIP_TEST_SET_E2UUID_2"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_SET_E2UUID"); @@ -3158,14 +5651,13 @@ static int test_set_e2uuid_2_skip (void) static int test_set_e2uuid_2 (void) { if (test_set_e2uuid_2_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_2"); + printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_2"); return 0; } /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -3188,7 +5680,6 @@ static int test_set_e2uuid_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -3203,7 +5694,6 @@ static int test_set_e2uuid_2 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -3212,7 +5702,6 @@ static int test_set_e2uuid_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -3223,7 +5712,6 @@ static int test_set_e2uuid_2 (void) /* TestRun for set_e2uuid (2) */ { char device[] = "/dev/sda1"; - device[5] = devchar; char uuid[] = "random"; int r; suppress_error = 0; @@ -3238,6 +5726,9 @@ static int test_set_e2uuid_3_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "set_e2uuid") == NULL; str = getenv ("SKIP_TEST_SET_E2UUID_3"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_SET_E2UUID"); @@ -3248,14 +5739,13 @@ static int test_set_e2uuid_3_skip (void) static int test_set_e2uuid_3 (void) { if (test_set_e2uuid_3_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_3"); + printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_3"); return 0; } /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -3278,7 +5768,6 @@ static int test_set_e2uuid_3 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -3293,7 +5782,6 @@ static int test_set_e2uuid_3 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -3302,7 +5790,6 @@ static int test_set_e2uuid_3 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -3313,7 +5800,6 @@ static int test_set_e2uuid_3 (void) /* TestRun for set_e2uuid (3) */ { char device[] = "/dev/sda1"; - device[5] = devchar; char uuid[] = "time"; int r; suppress_error = 0; @@ -3328,6 +5814,9 @@ static int test_set_e2label_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "set_e2label") == NULL; str = getenv ("SKIP_TEST_SET_E2LABEL_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_SET_E2LABEL"); @@ -3338,14 +5827,13 @@ static int test_set_e2label_0_skip (void) static int test_set_e2label_0 (void) { if (test_set_e2label_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2label_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_set_e2label_0"); return 0; } /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -3368,7 +5856,6 @@ static int test_set_e2label_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -3383,7 +5870,6 @@ static int test_set_e2label_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -3392,7 +5878,6 @@ static int test_set_e2label_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -3404,7 +5889,6 @@ static int test_set_e2label_0 (void) char expected[] = "testlabel"; { char device[] = "/dev/sda1"; - device[5] = devchar; char label[] = "testlabel"; int r; suppress_error = 0; @@ -3414,7 +5898,6 @@ static int test_set_e2label_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char *r; suppress_error = 0; r = guestfs_get_e2label (g, device); @@ -3433,6 +5916,9 @@ static int test_pvremove_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "pvremove") == NULL; str = getenv ("SKIP_TEST_PVREMOVE_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_PVREMOVE"); @@ -3443,14 +5929,13 @@ static int test_pvremove_0_skip (void) static int test_pvremove_0 (void) { if (test_pvremove_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_0"); return 0; } /* InitNone|InitEmpty for test_pvremove_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -3471,10 +5956,9 @@ static int test_pvremove_0 (void) if (r == -1) return -1; } - /* TestOutputList for pvremove (0) */ + /* TestOutputListOfDevices for pvremove (0) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -3488,7 +5972,6 @@ static int test_pvremove_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -3498,7 +5981,6 @@ static int test_pvremove_0 (void) { char volgroup[] = "VG"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -3537,7 +6019,6 @@ static int test_pvremove_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvremove (g, device); @@ -3567,6 +6048,9 @@ static int test_pvremove_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "pvremove") == NULL; str = getenv ("SKIP_TEST_PVREMOVE_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_PVREMOVE"); @@ -3577,14 +6061,13 @@ static int test_pvremove_1_skip (void) static int test_pvremove_1 (void) { if (test_pvremove_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_1"); return 0; } /* InitNone|InitEmpty for test_pvremove_1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -3605,10 +6088,9 @@ static int test_pvremove_1 (void) if (r == -1) return -1; } - /* TestOutputList for pvremove (1) */ + /* TestOutputListOfDevices for pvremove (1) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -3622,7 +6104,6 @@ static int test_pvremove_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -3632,7 +6113,6 @@ static int test_pvremove_1 (void) { char volgroup[] = "VG"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -3671,7 +6151,6 @@ static int test_pvremove_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvremove (g, device); @@ -3701,6 +6180,9 @@ static int test_pvremove_2_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "pvremove") == NULL; str = getenv ("SKIP_TEST_PVREMOVE_2"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_PVREMOVE"); @@ -3711,14 +6193,13 @@ static int test_pvremove_2_skip (void) static int test_pvremove_2 (void) { if (test_pvremove_2_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_2"); + printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_2"); return 0; } /* InitNone|InitEmpty for test_pvremove_2 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -3739,10 +6220,9 @@ static int test_pvremove_2 (void) if (r == -1) return -1; } - /* TestOutputList for pvremove (2) */ + /* TestOutputListOfDevices for pvremove (2) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -3756,7 +6236,6 @@ static int test_pvremove_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -3766,7 +6245,6 @@ static int test_pvremove_2 (void) { char volgroup[] = "VG"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -3805,7 +6283,6 @@ static int test_pvremove_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvremove (g, device); @@ -3835,6 +6312,9 @@ static int test_vgremove_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "vgremove") == NULL; str = getenv ("SKIP_TEST_VGREMOVE_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_VGREMOVE"); @@ -3845,14 +6325,13 @@ static int test_vgremove_0_skip (void) static int test_vgremove_0 (void) { if (test_vgremove_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_0"); return 0; } /* InitNone|InitEmpty for test_vgremove_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -3876,7 +6355,6 @@ static int test_vgremove_0 (void) /* TestOutputList for vgremove (0) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -3890,7 +6368,6 @@ static int test_vgremove_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -3900,7 +6377,6 @@ static int test_vgremove_0 (void) { char volgroup[] = "VG"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -3960,6 +6436,9 @@ static int test_vgremove_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "vgremove") == NULL; str = getenv ("SKIP_TEST_VGREMOVE_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_VGREMOVE"); @@ -3970,14 +6449,13 @@ static int test_vgremove_1_skip (void) static int test_vgremove_1 (void) { if (test_vgremove_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_1"); return 0; } /* InitNone|InitEmpty for test_vgremove_1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -4001,7 +6479,6 @@ static int test_vgremove_1 (void) /* TestOutputList for vgremove (1) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -4015,7 +6492,6 @@ static int test_vgremove_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -4025,7 +6501,6 @@ static int test_vgremove_1 (void) { char volgroup[] = "VG"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -4085,6 +6560,9 @@ static int test_lvremove_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "lvremove") == NULL; str = getenv ("SKIP_TEST_LVREMOVE_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_LVREMOVE"); @@ -4095,14 +6573,13 @@ static int test_lvremove_0_skip (void) static int test_lvremove_0 (void) { if (test_lvremove_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_0"); return 0; } /* InitNone|InitEmpty for test_lvremove_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -4126,7 +6603,6 @@ static int test_lvremove_0 (void) /* TestOutputList for lvremove (0) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -4140,7 +6616,6 @@ static int test_lvremove_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -4150,7 +6625,6 @@ static int test_lvremove_0 (void) { char volgroup[] = "VG"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -4222,6 +6696,9 @@ static int test_lvremove_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "lvremove") == NULL; str = getenv ("SKIP_TEST_LVREMOVE_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_LVREMOVE"); @@ -4232,14 +6709,13 @@ static int test_lvremove_1_skip (void) static int test_lvremove_1 (void) { if (test_lvremove_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_1"); return 0; } /* InitNone|InitEmpty for test_lvremove_1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -4263,7 +6739,6 @@ static int test_lvremove_1 (void) /* TestOutputList for lvremove (1) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -4277,7 +6752,6 @@ static int test_lvremove_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -4287,7 +6761,6 @@ static int test_lvremove_1 (void) { char volgroup[] = "VG"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -4347,6 +6820,9 @@ static int test_lvremove_2_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "lvremove") == NULL; str = getenv ("SKIP_TEST_LVREMOVE_2"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_LVREMOVE"); @@ -4357,14 +6833,13 @@ static int test_lvremove_2_skip (void) static int test_lvremove_2 (void) { if (test_lvremove_2_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_2"); + printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_2"); return 0; } /* InitNone|InitEmpty for test_lvremove_2 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -4388,7 +6863,6 @@ static int test_lvremove_2 (void) /* TestOutputList for lvremove (2) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -4402,7 +6876,6 @@ static int test_lvremove_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -4412,7 +6885,6 @@ static int test_lvremove_2 (void) { char volgroup[] = "VG"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -4484,6 +6956,9 @@ static int test_mount_ro_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mount_ro") == NULL; str = getenv ("SKIP_TEST_MOUNT_RO_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_MOUNT_RO"); @@ -4494,14 +6969,13 @@ static int test_mount_ro_0_skip (void) static int test_mount_ro_0 (void) { if (test_mount_ro_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_0"); return 0; } /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -4524,7 +6998,6 @@ static int test_mount_ro_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -4539,7 +7012,6 @@ static int test_mount_ro_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -4548,7 +7020,6 @@ static int test_mount_ro_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -4567,7 +7038,6 @@ static int test_mount_ro_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -4590,6 +7060,9 @@ static int test_mount_ro_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mount_ro") == NULL; str = getenv ("SKIP_TEST_MOUNT_RO_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_MOUNT_RO"); @@ -4600,14 +7073,13 @@ static int test_mount_ro_1_skip (void) static int test_mount_ro_1 (void) { if (test_mount_ro_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_1"); return 0; } /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -4630,7 +7102,6 @@ static int test_mount_ro_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -4645,7 +7116,6 @@ static int test_mount_ro_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -4654,7 +7124,6 @@ static int test_mount_ro_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -4683,7 +7152,6 @@ static int test_mount_ro_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -4711,6 +7179,9 @@ static int test_tgz_in_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "tgz_in") == NULL; str = getenv ("SKIP_TEST_TGZ_IN_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_TGZ_IN"); @@ -4721,14 +7192,13 @@ static int test_tgz_in_0_skip (void) static int test_tgz_in_0 (void) { if (test_tgz_in_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tgz_in_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_tgz_in_0"); return 0; } /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -4751,7 +7221,6 @@ static int test_tgz_in_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -4766,7 +7235,6 @@ static int test_tgz_in_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -4775,7 +7243,6 @@ static int test_tgz_in_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -4813,6 +7280,9 @@ static int test_tar_in_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "tar_in") == NULL; str = getenv ("SKIP_TEST_TAR_IN_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_TAR_IN"); @@ -4823,14 +7293,13 @@ static int test_tar_in_0_skip (void) static int test_tar_in_0 (void) { if (test_tar_in_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tar_in_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_tar_in_0"); return 0; } /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -4853,7 +7322,6 @@ static int test_tar_in_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -4868,7 +7336,6 @@ static int test_tar_in_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -4877,7 +7344,6 @@ static int test_tar_in_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -4915,6 +7381,9 @@ static int test_checksum_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "checksum") == NULL; str = getenv ("SKIP_TEST_CHECKSUM_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_CHECKSUM"); @@ -4925,14 +7394,13 @@ static int test_checksum_0_skip (void) static int test_checksum_0 (void) { if (test_checksum_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_checksum_0"); return 0; } /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -4955,7 +7423,6 @@ static int test_checksum_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -4970,7 +7437,6 @@ static int test_checksum_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -4979,7 +7445,6 @@ static int test_checksum_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -5019,6 +7484,9 @@ static int test_checksum_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "checksum") == NULL; str = getenv ("SKIP_TEST_CHECKSUM_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_CHECKSUM"); @@ -5029,14 +7497,13 @@ static int test_checksum_1_skip (void) static int test_checksum_1 (void) { if (test_checksum_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_checksum_1"); return 0; } /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -5059,7 +7526,6 @@ static int test_checksum_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -5074,7 +7540,6 @@ static int test_checksum_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -5083,7 +7548,6 @@ static int test_checksum_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -5109,6 +7573,9 @@ static int test_checksum_2_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "checksum") == NULL; str = getenv ("SKIP_TEST_CHECKSUM_2"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_CHECKSUM"); @@ -5119,14 +7586,13 @@ static int test_checksum_2_skip (void) static int test_checksum_2 (void) { if (test_checksum_2_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_2"); + printf ("%s skipped (reason: environment variable set)\n", "test_checksum_2"); return 0; } /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -5149,7 +7615,6 @@ static int test_checksum_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -5164,7 +7629,6 @@ static int test_checksum_2 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -5173,7 +7637,6 @@ static int test_checksum_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -5213,6 +7676,9 @@ static int test_checksum_3_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "checksum") == NULL; str = getenv ("SKIP_TEST_CHECKSUM_3"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_CHECKSUM"); @@ -5223,14 +7689,13 @@ static int test_checksum_3_skip (void) static int test_checksum_3 (void) { if (test_checksum_3_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_3"); + printf ("%s skipped (reason: environment variable set)\n", "test_checksum_3"); return 0; } /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -5253,7 +7718,6 @@ static int test_checksum_3 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -5268,7 +7732,6 @@ static int test_checksum_3 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -5277,7 +7740,6 @@ static int test_checksum_3 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -5317,6 +7779,9 @@ static int test_checksum_4_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "checksum") == NULL; str = getenv ("SKIP_TEST_CHECKSUM_4"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_CHECKSUM"); @@ -5327,14 +7792,13 @@ static int test_checksum_4_skip (void) static int test_checksum_4 (void) { if (test_checksum_4_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_4"); + printf ("%s skipped (reason: environment variable set)\n", "test_checksum_4"); return 0; } /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -5357,7 +7821,6 @@ static int test_checksum_4 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -5372,7 +7835,6 @@ static int test_checksum_4 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -5381,7 +7843,6 @@ static int test_checksum_4 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -5421,6 +7882,9 @@ static int test_checksum_5_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "checksum") == NULL; str = getenv ("SKIP_TEST_CHECKSUM_5"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_CHECKSUM"); @@ -5431,14 +7895,13 @@ static int test_checksum_5_skip (void) static int test_checksum_5 (void) { if (test_checksum_5_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_5"); + printf ("%s skipped (reason: environment variable set)\n", "test_checksum_5"); return 0; } /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -5461,7 +7924,6 @@ static int test_checksum_5 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -5476,7 +7938,6 @@ static int test_checksum_5 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -5485,7 +7946,6 @@ static int test_checksum_5 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -5525,6 +7985,9 @@ static int test_checksum_6_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "checksum") == NULL; str = getenv ("SKIP_TEST_CHECKSUM_6"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_CHECKSUM"); @@ -5535,14 +7998,13 @@ static int test_checksum_6_skip (void) static int test_checksum_6 (void) { if (test_checksum_6_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_6"); + printf ("%s skipped (reason: environment variable set)\n", "test_checksum_6"); return 0; } /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -5565,7 +8027,6 @@ static int test_checksum_6 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -5580,7 +8041,6 @@ static int test_checksum_6 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -5589,7 +8049,6 @@ static int test_checksum_6 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -5629,6 +8088,9 @@ static int test_checksum_7_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "checksum") == NULL; str = getenv ("SKIP_TEST_CHECKSUM_7"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_CHECKSUM"); @@ -5639,14 +8101,13 @@ static int test_checksum_7_skip (void) static int test_checksum_7 (void) { if (test_checksum_7_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_7"); + printf ("%s skipped (reason: environment variable set)\n", "test_checksum_7"); return 0; } /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -5669,7 +8130,6 @@ static int test_checksum_7 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -5684,7 +8144,6 @@ static int test_checksum_7 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -5693,7 +8152,6 @@ static int test_checksum_7 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -5729,10 +8187,118 @@ static int test_checksum_7 (void) return 0; } +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"); + if (str && strcmp (str, "1") == 0) return 1; + return 0; +} + +static int test_checksum_8 (void) +{ + if (test_checksum_8_skip ()) { + printf ("%s skipped (reason: environment variable set)\n", "test_checksum_8"); + return 0; + } + + /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */ + { + char device[] = "/dev/sda"; + int r; + suppress_error = 0; + r = guestfs_blockdev_setrw (g, device); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_umount_all (g); + if (r == -1) + return -1; + } + { + int r; + suppress_error = 0; + r = guestfs_lvm_remove_all (g); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda"; + char lines_0[] = ","; + char *lines[] = { + lines_0, + NULL + }; + int r; + suppress_error = 0; + r = guestfs_sfdisk (g, device, 0, 0, 0, lines); + if (r == -1) + return -1; + } + { + char fstype[] = "ext2"; + char device[] = "/dev/sda1"; + int r; + suppress_error = 0; + r = guestfs_mkfs (g, fstype, device); + if (r == -1) + return -1; + } + { + char device[] = "/dev/sda1"; + char mountpoint[] = "/"; + int r; + suppress_error = 0; + r = guestfs_mount (g, device, mountpoint); + if (r == -1) + return -1; + } + /* TestOutput for checksum (8) */ + char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c"; + { + 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 csumtype[] = "md5"; + char path[] = "/known-3"; + char *r; + suppress_error = 0; + r = guestfs_checksum (g, csumtype, path); + if (r == NULL) + return -1; + if (strcmp (r, expected) != 0) { + fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r); + return -1; + } + free (r); + } + return 0; +} + static int test_download_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "download") == NULL; str = getenv ("SKIP_TEST_DOWNLOAD_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_DOWNLOAD"); @@ -5743,14 +8309,13 @@ static int test_download_0_skip (void) static int test_download_0 (void) { if (test_download_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_download_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_download_0"); return 0; } /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -5773,7 +8338,6 @@ static int test_download_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -5788,7 +8352,6 @@ static int test_download_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -5797,7 +8360,6 @@ static int test_download_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -5852,6 +8414,9 @@ static int test_upload_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "upload") == NULL; str = getenv ("SKIP_TEST_UPLOAD_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_UPLOAD"); @@ -5862,14 +8427,13 @@ static int test_upload_0_skip (void) static int test_upload_0 (void) { if (test_upload_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_upload_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_upload_0"); return 0; } /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -5892,7 +8456,6 @@ static int test_upload_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -5907,7 +8470,6 @@ static int test_upload_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -5916,7 +8478,6 @@ static int test_upload_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -5955,6 +8516,9 @@ static int test_blockdev_rereadpt_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "blockdev_rereadpt") == NULL; str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT"); @@ -5965,14 +8529,13 @@ static int test_blockdev_rereadpt_0_skip (void) static int test_blockdev_rereadpt_0 (void) { if (test_blockdev_rereadpt_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_rereadpt_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_rereadpt_0"); return 0; } /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -5996,7 +8559,6 @@ static int test_blockdev_rereadpt_0 (void) /* TestRun for blockdev_rereadpt (0) */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_rereadpt (g, device); @@ -6010,6 +8572,9 @@ static int test_blockdev_flushbufs_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "blockdev_flushbufs") == NULL; str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS"); @@ -6020,14 +8585,13 @@ static int test_blockdev_flushbufs_0_skip (void) static int test_blockdev_flushbufs_0 (void) { if (test_blockdev_flushbufs_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_flushbufs_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_flushbufs_0"); return 0; } /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -6051,7 +8615,6 @@ static int test_blockdev_flushbufs_0 (void) /* TestRun for blockdev_flushbufs (0) */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_flushbufs (g, device); @@ -6065,6 +8628,9 @@ static int test_blockdev_getsize64_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "blockdev_getsize64") == NULL; str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64"); @@ -6075,14 +8641,13 @@ static int test_blockdev_getsize64_0_skip (void) static int test_blockdev_getsize64_0 (void) { if (test_blockdev_getsize64_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsize64_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsize64_0"); return 0; } /* InitNone|InitEmpty for test_blockdev_getsize64_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -6106,7 +8671,6 @@ static int test_blockdev_getsize64_0 (void) /* TestOutputInt for blockdev_getsize64 (0) */ { char device[] = "/dev/sda"; - device[5] = devchar; int64_t r; suppress_error = 0; r = guestfs_blockdev_getsize64 (g, device); @@ -6124,6 +8688,9 @@ static int test_blockdev_getsz_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "blockdev_getsz") == NULL; str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ"); @@ -6134,14 +8701,13 @@ static int test_blockdev_getsz_0_skip (void) static int test_blockdev_getsz_0 (void) { if (test_blockdev_getsz_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsz_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsz_0"); return 0; } /* InitNone|InitEmpty for test_blockdev_getsz_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -6165,7 +8731,6 @@ static int test_blockdev_getsz_0 (void) /* TestOutputInt for blockdev_getsz (0) */ { char device[] = "/dev/sda"; - device[5] = devchar; int64_t r; suppress_error = 0; r = guestfs_blockdev_getsz (g, device); @@ -6183,6 +8748,9 @@ static int test_blockdev_getbsz_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "blockdev_getbsz") == NULL; str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ"); @@ -6193,14 +8761,13 @@ static int test_blockdev_getbsz_0_skip (void) static int test_blockdev_getbsz_0 (void) { if (test_blockdev_getbsz_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getbsz_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getbsz_0"); return 0; } /* InitNone|InitEmpty for test_blockdev_getbsz_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -6224,7 +8791,6 @@ static int test_blockdev_getbsz_0 (void) /* TestOutputInt for blockdev_getbsz (0) */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_getbsz (g, device); @@ -6242,6 +8808,9 @@ static int test_blockdev_getss_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "blockdev_getss") == NULL; str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_BLOCKDEV_GETSS"); @@ -6252,14 +8821,13 @@ static int test_blockdev_getss_0_skip (void) static int test_blockdev_getss_0 (void) { if (test_blockdev_getss_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getss_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getss_0"); return 0; } /* InitNone|InitEmpty for test_blockdev_getss_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -6283,7 +8851,6 @@ static int test_blockdev_getss_0 (void) /* TestOutputInt for blockdev_getss (0) */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_getss (g, device); @@ -6301,6 +8868,9 @@ static int test_blockdev_getro_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "blockdev_getro") == NULL; str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_BLOCKDEV_GETRO"); @@ -6311,14 +8881,13 @@ static int test_blockdev_getro_0_skip (void) static int test_blockdev_getro_0 (void) { if (test_blockdev_getro_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getro_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getro_0"); return 0; } /* InitNone|InitEmpty for test_blockdev_getro_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -6342,7 +8911,6 @@ static int test_blockdev_getro_0 (void) /* TestOutputTrue for blockdev_getro (0) */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setro (g, device); @@ -6351,7 +8919,6 @@ static int test_blockdev_getro_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_getro (g, device); @@ -6369,6 +8936,9 @@ static int test_blockdev_setrw_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "blockdev_setrw") == NULL; str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_BLOCKDEV_SETRW"); @@ -6379,14 +8949,13 @@ static int test_blockdev_setrw_0_skip (void) static int test_blockdev_setrw_0 (void) { if (test_blockdev_setrw_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setrw_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setrw_0"); return 0; } /* InitNone|InitEmpty for test_blockdev_setrw_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -6410,7 +8979,6 @@ static int test_blockdev_setrw_0 (void) /* TestOutputFalse for blockdev_setrw (0) */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -6419,7 +8987,6 @@ static int test_blockdev_setrw_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_getro (g, device); @@ -6437,6 +9004,9 @@ static int test_blockdev_setro_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "blockdev_setro") == NULL; str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_BLOCKDEV_SETRO"); @@ -6447,14 +9017,13 @@ static int test_blockdev_setro_0_skip (void) static int test_blockdev_setro_0 (void) { if (test_blockdev_setro_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setro_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setro_0"); return 0; } /* InitNone|InitEmpty for test_blockdev_setro_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -6478,7 +9047,6 @@ static int test_blockdev_setro_0 (void) /* TestOutputTrue for blockdev_setro (0) */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setro (g, device); @@ -6487,7 +9055,6 @@ static int test_blockdev_setro_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_getro (g, device); @@ -6505,6 +9072,9 @@ static int test_statvfs_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "statvfs") == NULL; str = getenv ("SKIP_TEST_STATVFS_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_STATVFS"); @@ -6515,14 +9085,13 @@ static int test_statvfs_0_skip (void) static int test_statvfs_0 (void) { if (test_statvfs_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_statvfs_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_statvfs_0"); return 0; } /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -6545,7 +9114,6 @@ static int test_statvfs_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -6560,7 +9128,6 @@ static int test_statvfs_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -6569,7 +9136,6 @@ static int test_statvfs_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -6609,6 +9175,9 @@ static int test_lstat_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "lstat") == NULL; str = getenv ("SKIP_TEST_LSTAT_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_LSTAT"); @@ -6619,14 +9188,13 @@ static int test_lstat_0_skip (void) static int test_lstat_0 (void) { if (test_lstat_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lstat_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_lstat_0"); return 0; } /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -6649,7 +9217,6 @@ static int test_lstat_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -6664,7 +9231,6 @@ static int test_lstat_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -6673,7 +9239,6 @@ static int test_lstat_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -6711,6 +9276,9 @@ static int test_stat_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "stat") == NULL; str = getenv ("SKIP_TEST_STAT_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_STAT"); @@ -6721,14 +9289,13 @@ static int test_stat_0_skip (void) static int test_stat_0 (void) { if (test_stat_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_stat_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_stat_0"); return 0; } /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -6751,7 +9318,6 @@ static int test_stat_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -6766,7 +9332,6 @@ static int test_stat_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -6775,7 +9340,6 @@ static int test_stat_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -6813,6 +9377,9 @@ static int test_command_lines_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command_lines") == NULL; str = getenv ("SKIP_TEST_COMMAND_LINES_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND_LINES"); @@ -6823,14 +9390,13 @@ static int test_command_lines_0_skip (void) static int test_command_lines_0 (void) { if (test_command_lines_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_0"); return 0; } /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -6853,7 +9419,6 @@ static int test_command_lines_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -6868,7 +9433,6 @@ static int test_command_lines_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -6877,7 +9441,6 @@ static int test_command_lines_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -6944,6 +9507,9 @@ static int test_command_lines_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command_lines") == NULL; str = getenv ("SKIP_TEST_COMMAND_LINES_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND_LINES"); @@ -6954,14 +9520,13 @@ static int test_command_lines_1_skip (void) static int test_command_lines_1 (void) { if (test_command_lines_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_1"); return 0; } /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -6984,7 +9549,6 @@ static int test_command_lines_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -6999,7 +9563,6 @@ static int test_command_lines_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -7008,7 +9571,6 @@ static int test_command_lines_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -7075,6 +9637,9 @@ static int test_command_lines_2_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command_lines") == NULL; str = getenv ("SKIP_TEST_COMMAND_LINES_2"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND_LINES"); @@ -7085,14 +9650,13 @@ static int test_command_lines_2_skip (void) static int test_command_lines_2 (void) { if (test_command_lines_2_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_2"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_2"); return 0; } /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -7115,7 +9679,6 @@ static int test_command_lines_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -7130,7 +9693,6 @@ static int test_command_lines_2 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -7139,7 +9701,6 @@ static int test_command_lines_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -7218,6 +9779,9 @@ static int test_command_lines_3_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command_lines") == NULL; str = getenv ("SKIP_TEST_COMMAND_LINES_3"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND_LINES"); @@ -7228,14 +9792,13 @@ static int test_command_lines_3_skip (void) static int test_command_lines_3 (void) { if (test_command_lines_3_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_3"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_3"); return 0; } /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -7258,7 +9821,6 @@ static int test_command_lines_3 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -7273,7 +9835,6 @@ static int test_command_lines_3 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -7282,7 +9843,6 @@ static int test_command_lines_3 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -7361,6 +9921,9 @@ static int test_command_lines_4_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command_lines") == NULL; str = getenv ("SKIP_TEST_COMMAND_LINES_4"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND_LINES"); @@ -7371,14 +9934,13 @@ static int test_command_lines_4_skip (void) static int test_command_lines_4 (void) { if (test_command_lines_4_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_4"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_4"); return 0; } /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -7401,7 +9963,6 @@ static int test_command_lines_4 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -7416,7 +9977,6 @@ static int test_command_lines_4 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -7425,7 +9985,6 @@ static int test_command_lines_4 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -7516,6 +10075,9 @@ static int test_command_lines_5_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command_lines") == NULL; str = getenv ("SKIP_TEST_COMMAND_LINES_5"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND_LINES"); @@ -7526,14 +10088,13 @@ static int test_command_lines_5_skip (void) static int test_command_lines_5 (void) { if (test_command_lines_5_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_5"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_5"); return 0; } /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -7556,7 +10117,6 @@ static int test_command_lines_5 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -7571,7 +10131,6 @@ static int test_command_lines_5 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -7580,7 +10139,6 @@ static int test_command_lines_5 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -7683,6 +10241,9 @@ static int test_command_lines_6_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command_lines") == NULL; str = getenv ("SKIP_TEST_COMMAND_LINES_6"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND_LINES"); @@ -7693,14 +10254,13 @@ static int test_command_lines_6_skip (void) static int test_command_lines_6 (void) { if (test_command_lines_6_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_6"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_6"); return 0; } /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -7723,7 +10283,6 @@ static int test_command_lines_6 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -7738,7 +10297,6 @@ static int test_command_lines_6 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -7747,7 +10305,6 @@ static int test_command_lines_6 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -7802,6 +10359,9 @@ static int test_command_lines_7_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command_lines") == NULL; str = getenv ("SKIP_TEST_COMMAND_LINES_7"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND_LINES"); @@ -7812,14 +10372,13 @@ static int test_command_lines_7_skip (void) static int test_command_lines_7 (void) { if (test_command_lines_7_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_7"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_7"); return 0; } /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -7842,7 +10401,6 @@ static int test_command_lines_7 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -7857,7 +10415,6 @@ static int test_command_lines_7 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -7866,7 +10423,6 @@ static int test_command_lines_7 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -7933,6 +10489,9 @@ static int test_command_lines_8_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command_lines") == NULL; str = getenv ("SKIP_TEST_COMMAND_LINES_8"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND_LINES"); @@ -7943,14 +10502,13 @@ static int test_command_lines_8_skip (void) static int test_command_lines_8 (void) { if (test_command_lines_8_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_8"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_8"); return 0; } /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -7973,7 +10531,6 @@ static int test_command_lines_8 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -7988,7 +10545,6 @@ static int test_command_lines_8 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -7997,7 +10553,6 @@ static int test_command_lines_8 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -8076,6 +10631,9 @@ static int test_command_lines_9_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command_lines") == NULL; str = getenv ("SKIP_TEST_COMMAND_LINES_9"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND_LINES"); @@ -8086,14 +10644,13 @@ static int test_command_lines_9_skip (void) static int test_command_lines_9 (void) { if (test_command_lines_9_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_9"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_9"); return 0; } /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -8116,7 +10673,6 @@ static int test_command_lines_9 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -8131,7 +10687,6 @@ static int test_command_lines_9 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -8140,7 +10695,6 @@ static int test_command_lines_9 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -8219,6 +10773,9 @@ static int test_command_lines_10_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command_lines") == NULL; str = getenv ("SKIP_TEST_COMMAND_LINES_10"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND_LINES"); @@ -8229,14 +10786,13 @@ static int test_command_lines_10_skip (void) static int test_command_lines_10 (void) { if (test_command_lines_10_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_10"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_10"); return 0; } /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -8259,7 +10815,6 @@ static int test_command_lines_10 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -8274,7 +10829,6 @@ static int test_command_lines_10 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -8283,7 +10837,6 @@ static int test_command_lines_10 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -8362,6 +10915,9 @@ static int test_command_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command") == NULL; str = getenv ("SKIP_TEST_COMMAND_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND"); @@ -8372,14 +10928,13 @@ static int test_command_0_skip (void) static int test_command_0 (void) { if (test_command_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_0"); return 0; } /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -8402,7 +10957,6 @@ static int test_command_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -8417,7 +10971,6 @@ static int test_command_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -8426,7 +10979,6 @@ static int test_command_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -8478,6 +11030,9 @@ static int test_command_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command") == NULL; str = getenv ("SKIP_TEST_COMMAND_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND"); @@ -8488,14 +11043,13 @@ static int test_command_1_skip (void) static int test_command_1 (void) { if (test_command_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_1"); return 0; } /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -8518,7 +11072,6 @@ static int test_command_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -8533,7 +11086,6 @@ static int test_command_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -8542,7 +11094,6 @@ static int test_command_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -8594,6 +11145,9 @@ static int test_command_2_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command") == NULL; str = getenv ("SKIP_TEST_COMMAND_2"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND"); @@ -8604,14 +11158,13 @@ static int test_command_2_skip (void) static int test_command_2 (void) { if (test_command_2_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_2"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_2"); return 0; } /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -8634,7 +11187,6 @@ static int test_command_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -8649,7 +11201,6 @@ static int test_command_2 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -8658,7 +11209,6 @@ static int test_command_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -8710,6 +11260,9 @@ static int test_command_3_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command") == NULL; str = getenv ("SKIP_TEST_COMMAND_3"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND"); @@ -8720,14 +11273,13 @@ static int test_command_3_skip (void) static int test_command_3 (void) { if (test_command_3_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_3"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_3"); return 0; } /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -8750,7 +11302,6 @@ static int test_command_3 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -8765,7 +11316,6 @@ static int test_command_3 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -8774,7 +11324,6 @@ static int test_command_3 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -8826,6 +11375,9 @@ static int test_command_4_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command") == NULL; str = getenv ("SKIP_TEST_COMMAND_4"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND"); @@ -8836,14 +11388,13 @@ static int test_command_4_skip (void) static int test_command_4 (void) { if (test_command_4_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_4"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_4"); return 0; } /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -8866,7 +11417,6 @@ static int test_command_4 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -8881,7 +11431,6 @@ static int test_command_4 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -8890,7 +11439,6 @@ static int test_command_4 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -8942,6 +11490,9 @@ static int test_command_5_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command") == NULL; str = getenv ("SKIP_TEST_COMMAND_5"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND"); @@ -8952,14 +11503,13 @@ static int test_command_5_skip (void) static int test_command_5 (void) { if (test_command_5_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_5"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_5"); return 0; } /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -8982,7 +11532,6 @@ static int test_command_5 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -8997,7 +11546,6 @@ static int test_command_5 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -9006,7 +11554,6 @@ static int test_command_5 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -9058,6 +11605,9 @@ static int test_command_6_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command") == NULL; str = getenv ("SKIP_TEST_COMMAND_6"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND"); @@ -9068,14 +11618,13 @@ static int test_command_6_skip (void) static int test_command_6 (void) { if (test_command_6_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_6"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_6"); return 0; } /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -9098,7 +11647,6 @@ static int test_command_6 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -9113,7 +11661,6 @@ static int test_command_6 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -9122,7 +11669,6 @@ static int test_command_6 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -9174,6 +11720,9 @@ static int test_command_7_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command") == NULL; str = getenv ("SKIP_TEST_COMMAND_7"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND"); @@ -9184,14 +11733,13 @@ static int test_command_7_skip (void) static int test_command_7 (void) { if (test_command_7_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_7"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_7"); return 0; } /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -9214,7 +11762,6 @@ static int test_command_7 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -9229,7 +11776,6 @@ static int test_command_7 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -9238,7 +11784,6 @@ static int test_command_7 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -9290,6 +11835,9 @@ static int test_command_8_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command") == NULL; str = getenv ("SKIP_TEST_COMMAND_8"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND"); @@ -9300,14 +11848,13 @@ static int test_command_8_skip (void) static int test_command_8 (void) { if (test_command_8_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_8"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_8"); return 0; } /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -9330,7 +11877,6 @@ static int test_command_8 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -9345,7 +11891,6 @@ static int test_command_8 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -9354,7 +11899,6 @@ static int test_command_8 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -9406,6 +11950,9 @@ static int test_command_9_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command") == NULL; str = getenv ("SKIP_TEST_COMMAND_9"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND"); @@ -9416,14 +11963,13 @@ static int test_command_9_skip (void) static int test_command_9 (void) { if (test_command_9_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_9"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_9"); return 0; } /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -9446,7 +11992,6 @@ static int test_command_9 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -9461,7 +12006,6 @@ static int test_command_9 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -9470,7 +12014,6 @@ static int test_command_9 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -9522,6 +12065,9 @@ static int test_command_10_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command") == NULL; str = getenv ("SKIP_TEST_COMMAND_10"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND"); @@ -9532,14 +12078,13 @@ static int test_command_10_skip (void) static int test_command_10 (void) { if (test_command_10_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_10"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_10"); return 0; } /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -9562,7 +12107,6 @@ static int test_command_10 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -9577,7 +12121,6 @@ static int test_command_10 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -9586,7 +12129,6 @@ static int test_command_10 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -9638,6 +12180,9 @@ static int test_command_11_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "command") == NULL; str = getenv ("SKIP_TEST_COMMAND_11"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_COMMAND"); @@ -9648,14 +12193,13 @@ static int test_command_11_skip (void) static int test_command_11 (void) { if (test_command_11_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_11"); + printf ("%s skipped (reason: environment variable set)\n", "test_command_11"); return 0; } /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -9678,7 +12222,6 @@ static int test_command_11 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -9693,7 +12236,6 @@ static int test_command_11 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -9702,7 +12244,6 @@ static int test_command_11 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -9747,6 +12288,9 @@ static int test_file_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "file") == NULL; str = getenv ("SKIP_TEST_FILE_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_FILE"); @@ -9757,14 +12301,13 @@ static int test_file_0_skip (void) static int test_file_0 (void) { if (test_file_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_file_0"); return 0; } /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -9787,7 +12330,6 @@ static int test_file_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -9802,7 +12344,6 @@ static int test_file_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -9811,7 +12352,6 @@ static int test_file_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -9849,6 +12389,9 @@ static int test_file_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "file") == NULL; str = getenv ("SKIP_TEST_FILE_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_FILE"); @@ -9859,14 +12402,13 @@ static int test_file_1_skip (void) static int test_file_1 (void) { if (test_file_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_file_1"); return 0; } /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -9889,7 +12431,6 @@ static int test_file_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -9904,7 +12445,6 @@ static int test_file_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -9913,7 +12453,6 @@ static int test_file_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -9952,6 +12491,9 @@ static int test_file_2_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "file") == NULL; str = getenv ("SKIP_TEST_FILE_2"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_FILE"); @@ -9962,14 +12504,13 @@ static int test_file_2_skip (void) static int test_file_2 (void) { if (test_file_2_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_2"); + printf ("%s skipped (reason: environment variable set)\n", "test_file_2"); return 0; } /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -9992,7 +12533,6 @@ static int test_file_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -10007,7 +12547,6 @@ static int test_file_2 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -10016,7 +12555,6 @@ static int test_file_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -10041,6 +12579,9 @@ static int test_umount_all_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "umount_all") == NULL; str = getenv ("SKIP_TEST_UMOUNT_ALL_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_UMOUNT_ALL"); @@ -10051,14 +12592,13 @@ static int test_umount_all_0_skip (void) static int test_umount_all_0 (void) { if (test_umount_all_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_0"); return 0; } /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -10081,7 +12621,6 @@ static int test_umount_all_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -10096,7 +12635,6 @@ static int test_umount_all_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -10105,7 +12643,6 @@ static int test_umount_all_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -10144,6 +12681,9 @@ static int test_umount_all_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "umount_all") == NULL; str = getenv ("SKIP_TEST_UMOUNT_ALL_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_UMOUNT_ALL"); @@ -10154,14 +12694,13 @@ static int test_umount_all_1_skip (void) static int test_umount_all_1 (void) { if (test_umount_all_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_1"); return 0; } /* InitNone|InitEmpty for test_umount_all_1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -10185,7 +12724,6 @@ static int test_umount_all_1 (void) /* TestOutputList for umount_all (1) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ",10"; char lines_1[] = ",20"; char lines_2[] = ","; @@ -10204,7 +12742,6 @@ static int test_umount_all_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -10214,7 +12751,6 @@ static int test_umount_all_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda2"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -10224,7 +12760,6 @@ static int test_umount_all_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda3"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -10233,7 +12768,6 @@ static int test_umount_all_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -10251,7 +12785,6 @@ static int test_umount_all_1 (void) } { char device[] = "/dev/sda2"; - device[5] = devchar; char mountpoint[] = "/mp1"; int r; suppress_error = 0; @@ -10269,7 +12802,6 @@ static int test_umount_all_1 (void) } { char device[] = "/dev/sda3"; - device[5] = devchar; char mountpoint[] = "/mp1/mp2"; int r; suppress_error = 0; @@ -10315,6 +12847,9 @@ static int test_mounts_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mounts") == NULL; str = getenv ("SKIP_TEST_MOUNTS_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_MOUNTS"); @@ -10325,14 +12860,13 @@ static int test_mounts_0_skip (void) static int test_mounts_0 (void) { if (test_mounts_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mounts_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_mounts_0"); return 0; } /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -10355,7 +12889,6 @@ static int test_mounts_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -10370,7 +12903,6 @@ static int test_mounts_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -10379,7 +12911,6 @@ static int test_mounts_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -10387,7 +12918,7 @@ static int test_mounts_0 (void) if (r == -1) return -1; } - /* TestOutputList for mounts (0) */ + /* TestOutputListOfDevices for mounts (0) */ { char **r; int i; @@ -10402,7 +12933,7 @@ static int test_mounts_0 (void) } { char expected[] = "/dev/sda1"; - expected[5] = devchar; + r[0][5] = 's'; if (strcmp (r[0], expected) != 0) { fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]); return -1; @@ -10424,6 +12955,9 @@ static int test_umount_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "umount") == NULL; str = getenv ("SKIP_TEST_UMOUNT_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_UMOUNT"); @@ -10434,14 +12968,13 @@ static int test_umount_0_skip (void) static int test_umount_0 (void) { if (test_umount_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_umount_0"); return 0; } /* InitNone|InitEmpty for test_umount_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -10462,10 +12995,9 @@ static int test_umount_0 (void) if (r == -1) return -1; } - /* TestOutputList for umount (0) */ + /* TestOutputListOfDevices for umount (0) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -10480,7 +13012,6 @@ static int test_umount_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -10489,7 +13020,6 @@ static int test_umount_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -10511,7 +13041,7 @@ static int test_umount_0 (void) } { char expected[] = "/dev/sda1"; - expected[5] = devchar; + r[0][5] = 's'; if (strcmp (r[0], expected) != 0) { fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]); return -1; @@ -10533,6 +13063,9 @@ static int test_umount_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "umount") == NULL; str = getenv ("SKIP_TEST_UMOUNT_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_UMOUNT"); @@ -10543,14 +13076,13 @@ static int test_umount_1_skip (void) static int test_umount_1 (void) { if (test_umount_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_umount_1"); return 0; } /* InitNone|InitEmpty for test_umount_1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -10574,7 +13106,6 @@ static int test_umount_1 (void) /* TestOutputList for umount (1) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -10589,7 +13120,6 @@ static int test_umount_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -10598,7 +13128,6 @@ static int test_umount_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -10637,6 +13166,9 @@ static int test_write_file_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "write_file") == NULL; str = getenv ("SKIP_TEST_WRITE_FILE_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_WRITE_FILE"); @@ -10647,14 +13179,13 @@ static int test_write_file_0_skip (void) static int test_write_file_0 (void) { if (test_write_file_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_write_file_0"); return 0; } /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -10677,7 +13208,6 @@ static int test_write_file_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -10692,7 +13222,6 @@ static int test_write_file_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -10701,7 +13230,6 @@ static int test_write_file_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -10740,6 +13268,9 @@ static int test_write_file_1_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "write_file") == NULL; str = getenv ("SKIP_TEST_WRITE_FILE_1"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_WRITE_FILE"); @@ -10750,14 +13281,13 @@ static int test_write_file_1_skip (void) static int test_write_file_1 (void) { if (test_write_file_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_write_file_1"); return 0; } /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -10780,7 +13310,6 @@ static int test_write_file_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -10795,7 +13324,6 @@ static int test_write_file_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -10804,7 +13332,6 @@ static int test_write_file_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -10843,6 +13370,9 @@ static int test_write_file_2_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "write_file") == NULL; str = getenv ("SKIP_TEST_WRITE_FILE_2"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_WRITE_FILE"); @@ -10853,14 +13383,13 @@ static int test_write_file_2_skip (void) static int test_write_file_2 (void) { if (test_write_file_2_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_2"); + printf ("%s skipped (reason: environment variable set)\n", "test_write_file_2"); return 0; } /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -10883,7 +13412,6 @@ static int test_write_file_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -10898,7 +13426,6 @@ static int test_write_file_2 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -10907,7 +13434,6 @@ static int test_write_file_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -10946,6 +13472,9 @@ static int test_write_file_3_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "write_file") == NULL; str = getenv ("SKIP_TEST_WRITE_FILE_3"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_WRITE_FILE"); @@ -10956,14 +13485,13 @@ static int test_write_file_3_skip (void) static int test_write_file_3 (void) { if (test_write_file_3_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_3"); + printf ("%s skipped (reason: environment variable set)\n", "test_write_file_3"); return 0; } /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -10986,7 +13514,6 @@ static int test_write_file_3 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -11001,7 +13528,6 @@ static int test_write_file_3 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -11010,7 +13536,6 @@ static int test_write_file_3 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -11049,6 +13574,9 @@ static int test_write_file_4_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "write_file") == NULL; str = getenv ("SKIP_TEST_WRITE_FILE_4"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_WRITE_FILE"); @@ -11059,14 +13587,13 @@ static int test_write_file_4_skip (void) static int test_write_file_4 (void) { if (test_write_file_4_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_4"); + printf ("%s skipped (reason: environment variable set)\n", "test_write_file_4"); return 0; } /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -11089,7 +13616,6 @@ static int test_write_file_4 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -11104,7 +13630,6 @@ static int test_write_file_4 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -11113,7 +13638,6 @@ static int test_write_file_4 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -11152,6 +13676,9 @@ static int test_write_file_5_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "write_file") == NULL; str = getenv ("SKIP_TEST_WRITE_FILE_5"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_WRITE_FILE"); @@ -11162,14 +13689,13 @@ static int test_write_file_5_skip (void) static int test_write_file_5 (void) { if (test_write_file_5_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_5"); + printf ("%s skipped (reason: environment variable set)\n", "test_write_file_5"); return 0; } /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -11192,7 +13718,6 @@ static int test_write_file_5 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -11207,7 +13732,6 @@ static int test_write_file_5 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -11216,7 +13740,6 @@ static int test_write_file_5 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -11255,6 +13778,9 @@ static int test_mkfs_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "mkfs") == NULL; str = getenv ("SKIP_TEST_MKFS_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_MKFS"); @@ -11265,14 +13791,13 @@ static int test_mkfs_0_skip (void) static int test_mkfs_0 (void) { if (test_mkfs_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkfs_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_mkfs_0"); return 0; } /* InitNone|InitEmpty for test_mkfs_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -11297,7 +13822,6 @@ static int test_mkfs_0 (void) char expected[] = "new file contents"; { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -11312,7 +13836,6 @@ static int test_mkfs_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -11321,7 +13844,6 @@ static int test_mkfs_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -11358,6 +13880,9 @@ static int test_lvcreate_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "lvcreate") == NULL; str = getenv ("SKIP_TEST_LVCREATE_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_LVCREATE"); @@ -11368,14 +13893,13 @@ static int test_lvcreate_0_skip (void) static int test_lvcreate_0 (void) { if (test_lvcreate_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvcreate_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_lvcreate_0"); return 0; } /* InitNone|InitEmpty for test_lvcreate_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -11399,7 +13923,6 @@ static int test_lvcreate_0 (void) /* TestOutputList for lvcreate (0) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ",10"; char lines_1[] = ",20"; char lines_2[] = ","; @@ -11417,7 +13940,6 @@ static int test_lvcreate_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -11426,7 +13948,6 @@ static int test_lvcreate_0 (void) } { char device[] = "/dev/sda2"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -11435,7 +13956,6 @@ static int test_lvcreate_0 (void) } { char device[] = "/dev/sda3"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -11445,9 +13965,7 @@ static int test_lvcreate_0 (void) { char volgroup[] = "VG1"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char physvols_1[] = "/dev/sda2"; - physvols_1[5] = devchar; char *physvols[] = { physvols_0, physvols_1, @@ -11462,7 +13980,6 @@ static int test_lvcreate_0 (void) { char volgroup[] = "VG2"; char physvols_0[] = "/dev/sda3"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -11601,6 +14118,9 @@ static int test_vgcreate_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "vgcreate") == NULL; str = getenv ("SKIP_TEST_VGCREATE_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_VGCREATE"); @@ -11611,14 +14131,13 @@ static int test_vgcreate_0_skip (void) static int test_vgcreate_0 (void) { if (test_vgcreate_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgcreate_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_vgcreate_0"); return 0; } /* InitNone|InitEmpty for test_vgcreate_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -11642,7 +14161,6 @@ static int test_vgcreate_0 (void) /* TestOutputList for vgcreate (0) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ",10"; char lines_1[] = ",20"; char lines_2[] = ","; @@ -11660,7 +14178,6 @@ static int test_vgcreate_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -11669,7 +14186,6 @@ static int test_vgcreate_0 (void) } { char device[] = "/dev/sda2"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -11678,7 +14194,6 @@ static int test_vgcreate_0 (void) } { char device[] = "/dev/sda3"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -11688,9 +14203,7 @@ static int test_vgcreate_0 (void) { char volgroup[] = "VG1"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char physvols_1[] = "/dev/sda2"; - physvols_1[5] = devchar; char *physvols[] = { physvols_0, physvols_1, @@ -11705,7 +14218,6 @@ static int test_vgcreate_0 (void) { char volgroup[] = "VG2"; char physvols_0[] = "/dev/sda3"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -11763,6 +14275,9 @@ static int test_pvcreate_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "pvcreate") == NULL; str = getenv ("SKIP_TEST_PVCREATE_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_PVCREATE"); @@ -11773,14 +14288,13 @@ static int test_pvcreate_0_skip (void) static int test_pvcreate_0 (void) { if (test_pvcreate_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvcreate_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_pvcreate_0"); return 0; } /* InitNone|InitEmpty for test_pvcreate_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -11801,10 +14315,9 @@ static int test_pvcreate_0 (void) if (r == -1) return -1; } - /* TestOutputList for pvcreate (0) */ + /* TestOutputListOfDevices for pvcreate (0) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ",10"; char lines_1[] = ",20"; char lines_2[] = ","; @@ -11822,7 +14335,6 @@ static int test_pvcreate_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -11831,7 +14343,6 @@ static int test_pvcreate_0 (void) } { char device[] = "/dev/sda2"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -11840,7 +14351,6 @@ static int test_pvcreate_0 (void) } { char device[] = "/dev/sda3"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -11861,7 +14371,7 @@ static int test_pvcreate_0 (void) } { char expected[] = "/dev/sda1"; - expected[5] = devchar; + r[0][5] = 's'; if (strcmp (r[0], expected) != 0) { fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]); return -1; @@ -11874,7 +14384,7 @@ static int test_pvcreate_0 (void) } { char expected[] = "/dev/sda2"; - expected[5] = devchar; + r[1][5] = 's'; if (strcmp (r[1], expected) != 0) { fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]); return -1; @@ -11887,7 +14397,7 @@ static int test_pvcreate_0 (void) } { char expected[] = "/dev/sda3"; - expected[5] = devchar; + r[2][5] = 's'; if (strcmp (r[2], expected) != 0) { fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]); return -1; @@ -11909,6 +14419,9 @@ static int test_is_dir_0_skip (void) { const char *str; + str = getenv ("TEST_ONLY"); + if (str) + return strstr (str, "is_dir") == NULL; str = getenv ("SKIP_TEST_IS_DIR_0"); if (str && strcmp (str, "1") == 0) return 1; str = getenv ("SKIP_TEST_IS_DIR"); @@ -11919,14 +14432,13 @@ static int test_is_dir_0_skip (void) static int test_is_dir_0 (void) { if (test_is_dir_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_0"); return 0; } /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -11949,7 +14461,6 @@ static int test_is_dir_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -11964,7 +14475,6 @@ static int test_is_dir_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -11973,7 +14483,6 @@ static int test_is_dir_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -12009,6 +14518,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"); @@ -12019,14 +14531,13 @@ static int test_is_dir_1_skip (void) static int test_is_dir_1 (void) { if (test_is_dir_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_1"); return 0; } /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -12049,7 +14560,6 @@ static int test_is_dir_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -12064,7 +14574,6 @@ static int test_is_dir_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -12073,7 +14582,6 @@ static int test_is_dir_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -12109,6 +14617,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"); @@ -12119,14 +14630,13 @@ static int test_is_file_0_skip (void) static int test_is_file_0 (void) { if (test_is_file_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_is_file_0"); return 0; } /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -12149,7 +14659,6 @@ static int test_is_file_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -12164,7 +14673,6 @@ static int test_is_file_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -12173,7 +14681,6 @@ static int test_is_file_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -12209,6 +14716,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"); @@ -12219,14 +14729,13 @@ static int test_is_file_1_skip (void) static int test_is_file_1 (void) { if (test_is_file_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_is_file_1"); return 0; } /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -12249,7 +14758,6 @@ static int test_is_file_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -12264,7 +14772,6 @@ static int test_is_file_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -12273,7 +14780,6 @@ static int test_is_file_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -12309,6 +14815,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"); @@ -12319,14 +14828,13 @@ static int test_exists_0_skip (void) static int test_exists_0 (void) { if (test_exists_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_exists_0"); return 0; } /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -12349,7 +14857,6 @@ static int test_exists_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -12364,7 +14871,6 @@ static int test_exists_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -12373,7 +14879,6 @@ static int test_exists_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -12409,6 +14914,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"); @@ -12419,14 +14927,13 @@ static int test_exists_1_skip (void) static int test_exists_1 (void) { if (test_exists_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_exists_1"); return 0; } /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -12449,7 +14956,6 @@ static int test_exists_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -12464,7 +14970,6 @@ static int test_exists_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -12473,7 +14978,6 @@ static int test_exists_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -12509,6 +15013,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"); @@ -12519,14 +15026,13 @@ static int test_mkdir_p_0_skip (void) static int test_mkdir_p_0 (void) { if (test_mkdir_p_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_0"); return 0; } /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -12549,7 +15055,6 @@ static int test_mkdir_p_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -12564,7 +15069,6 @@ static int test_mkdir_p_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -12573,7 +15077,6 @@ static int test_mkdir_p_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -12609,6 +15112,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"); @@ -12619,14 +15125,13 @@ static int test_mkdir_p_1_skip (void) static int test_mkdir_p_1 (void) { if (test_mkdir_p_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_1"); return 0; } /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -12649,7 +15154,6 @@ static int test_mkdir_p_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -12664,7 +15168,6 @@ static int test_mkdir_p_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -12673,7 +15176,6 @@ static int test_mkdir_p_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -12709,6 +15211,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"); @@ -12719,14 +15224,13 @@ static int test_mkdir_p_2_skip (void) static int test_mkdir_p_2 (void) { if (test_mkdir_p_2_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_2"); + printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_2"); return 0; } /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -12749,7 +15253,6 @@ static int test_mkdir_p_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -12764,7 +15267,6 @@ static int test_mkdir_p_2 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -12773,7 +15275,6 @@ static int test_mkdir_p_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -12809,6 +15310,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"); @@ -12819,14 +15323,13 @@ static int test_mkdir_p_3_skip (void) static int test_mkdir_p_3 (void) { if (test_mkdir_p_3_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_3"); + printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_3"); return 0; } /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -12849,7 +15352,6 @@ static int test_mkdir_p_3 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -12864,7 +15366,6 @@ static int test_mkdir_p_3 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -12873,7 +15374,6 @@ static int test_mkdir_p_3 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -12905,6 +15405,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"); @@ -12915,14 +15418,13 @@ static int test_mkdir_p_4_skip (void) static int test_mkdir_p_4 (void) { if (test_mkdir_p_4_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_4"); + printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_4"); return 0; } /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -12945,7 +15447,6 @@ static int test_mkdir_p_4 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -12960,7 +15461,6 @@ static int test_mkdir_p_4 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -12969,7 +15469,6 @@ static int test_mkdir_p_4 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -13001,6 +15500,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"); @@ -13011,14 +15513,13 @@ static int test_mkdir_0_skip (void) static int test_mkdir_0 (void) { if (test_mkdir_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_0"); return 0; } /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -13041,7 +15542,6 @@ static int test_mkdir_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -13056,7 +15556,6 @@ static int test_mkdir_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -13065,7 +15564,6 @@ static int test_mkdir_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -13101,6 +15599,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"); @@ -13111,14 +15612,13 @@ static int test_mkdir_1_skip (void) static int test_mkdir_1 (void) { if (test_mkdir_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_1"); return 0; } /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -13141,7 +15641,6 @@ static int test_mkdir_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -13156,7 +15655,6 @@ static int test_mkdir_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -13165,7 +15663,6 @@ static int test_mkdir_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -13189,6 +15686,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"); @@ -13199,14 +15699,13 @@ static int test_rm_rf_0_skip (void) static int test_rm_rf_0 (void) { if (test_rm_rf_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_rf_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_rm_rf_0"); return 0; } /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -13229,7 +15728,6 @@ static int test_rm_rf_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -13244,7 +15742,6 @@ static int test_rm_rf_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -13253,7 +15750,6 @@ static int test_rm_rf_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -13313,6 +15809,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"); @@ -13323,14 +15822,13 @@ static int test_rmdir_0_skip (void) static int test_rmdir_0 (void) { if (test_rmdir_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_0"); return 0; } /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -13353,7 +15851,6 @@ static int test_rmdir_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -13368,7 +15865,6 @@ static int test_rmdir_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -13377,7 +15873,6 @@ static int test_rmdir_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -13409,6 +15904,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"); @@ -13419,14 +15917,13 @@ static int test_rmdir_1_skip (void) static int test_rmdir_1 (void) { if (test_rmdir_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_1"); return 0; } /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -13449,7 +15946,6 @@ static int test_rmdir_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -13464,7 +15960,6 @@ static int test_rmdir_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -13473,7 +15968,6 @@ static int test_rmdir_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -13497,6 +15991,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"); @@ -13507,14 +16004,13 @@ static int test_rmdir_2_skip (void) static int test_rmdir_2 (void) { if (test_rmdir_2_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_2"); + printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_2"); return 0; } /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -13537,7 +16033,6 @@ static int test_rmdir_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -13552,7 +16047,6 @@ static int test_rmdir_2 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -13561,7 +16055,6 @@ static int test_rmdir_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -13593,6 +16086,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"); @@ -13603,14 +16099,13 @@ static int test_rm_0_skip (void) static int test_rm_0 (void) { if (test_rm_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_rm_0"); return 0; } /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -13633,7 +16128,6 @@ static int test_rm_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -13648,7 +16142,6 @@ static int test_rm_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -13657,7 +16150,6 @@ static int test_rm_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -13689,6 +16181,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"); @@ -13699,14 +16194,13 @@ static int test_rm_1_skip (void) static int test_rm_1 (void) { if (test_rm_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_rm_1"); return 0; } /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -13729,7 +16223,6 @@ static int test_rm_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -13744,7 +16237,6 @@ static int test_rm_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -13753,7 +16245,6 @@ static int test_rm_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -13777,6 +16268,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"); @@ -13787,14 +16281,13 @@ static int test_rm_2_skip (void) static int test_rm_2 (void) { if (test_rm_2_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_2"); + printf ("%s skipped (reason: environment variable set)\n", "test_rm_2"); return 0; } /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -13817,7 +16310,6 @@ static int test_rm_2 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -13832,7 +16324,6 @@ static int test_rm_2 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -13841,7 +16332,6 @@ static int test_rm_2 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -13873,6 +16363,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"); @@ -13883,14 +16376,13 @@ static int test_read_lines_0_skip (void) static int test_read_lines_0 (void) { if (test_read_lines_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_0"); return 0; } /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -13913,7 +16405,6 @@ static int test_read_lines_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -13928,7 +16419,6 @@ static int test_read_lines_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -13937,7 +16427,6 @@ static int test_read_lines_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -14015,6 +16504,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"); @@ -14025,14 +16517,13 @@ static int test_read_lines_1_skip (void) static int test_read_lines_1 (void) { if (test_read_lines_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_1"); return 0; } /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -14055,7 +16546,6 @@ static int test_read_lines_1 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -14070,7 +16560,6 @@ static int test_read_lines_1 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -14079,7 +16568,6 @@ static int test_read_lines_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -14121,6 +16609,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"); @@ -14131,14 +16622,13 @@ static int test_lvs_0_skip (void) static int test_lvs_0 (void) { if (test_lvs_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_lvs_0"); return 0; } /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -14161,7 +16651,6 @@ static int test_lvs_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -14175,7 +16664,6 @@ static int test_lvs_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -14185,7 +16673,6 @@ static int test_lvs_0 (void) { char volgroup[] = "VG"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -14259,6 +16746,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"); @@ -14269,14 +16759,13 @@ static int test_lvs_1_skip (void) static int test_lvs_1 (void) { if (test_lvs_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_lvs_1"); return 0; } /* InitNone|InitEmpty for test_lvs_1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -14300,7 +16789,6 @@ static int test_lvs_1 (void) /* TestOutputList for lvs (1) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ",10"; char lines_1[] = ",20"; char lines_2[] = ","; @@ -14318,7 +16806,6 @@ static int test_lvs_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -14327,7 +16814,6 @@ static int test_lvs_1 (void) } { char device[] = "/dev/sda2"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -14336,7 +16822,6 @@ static int test_lvs_1 (void) } { char device[] = "/dev/sda3"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -14346,9 +16831,7 @@ static int test_lvs_1 (void) { char volgroup[] = "VG1"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char physvols_1[] = "/dev/sda2"; - physvols_1[5] = devchar; char *physvols[] = { physvols_0, physvols_1, @@ -14363,7 +16846,6 @@ static int test_lvs_1 (void) { char volgroup[] = "VG2"; char physvols_0[] = "/dev/sda3"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -14460,6 +16942,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"); @@ -14470,14 +16955,13 @@ static int test_vgs_0_skip (void) static int test_vgs_0 (void) { if (test_vgs_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_vgs_0"); return 0; } /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -14500,7 +16984,6 @@ static int test_vgs_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -14514,7 +16997,6 @@ static int test_vgs_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -14524,7 +17006,6 @@ static int test_vgs_0 (void) { char volgroup[] = "VG"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -14598,6 +17079,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"); @@ -14608,14 +17092,13 @@ static int test_vgs_1_skip (void) static int test_vgs_1 (void) { if (test_vgs_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_vgs_1"); return 0; } /* InitNone|InitEmpty for test_vgs_1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -14639,7 +17122,6 @@ static int test_vgs_1 (void) /* TestOutputList for vgs (1) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ",10"; char lines_1[] = ",20"; char lines_2[] = ","; @@ -14657,7 +17139,6 @@ static int test_vgs_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -14666,7 +17147,6 @@ static int test_vgs_1 (void) } { char device[] = "/dev/sda2"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -14675,7 +17155,6 @@ static int test_vgs_1 (void) } { char device[] = "/dev/sda3"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -14685,9 +17164,7 @@ static int test_vgs_1 (void) { char volgroup[] = "VG1"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char physvols_1[] = "/dev/sda2"; - physvols_1[5] = devchar; char *physvols[] = { physvols_0, physvols_1, @@ -14702,7 +17179,6 @@ static int test_vgs_1 (void) { char volgroup[] = "VG2"; char physvols_0[] = "/dev/sda3"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -14760,6 +17236,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"); @@ -14770,14 +17249,13 @@ static int test_pvs_0_skip (void) static int test_pvs_0 (void) { if (test_pvs_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_pvs_0"); return 0; } /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -14800,7 +17278,6 @@ static int test_pvs_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -14814,7 +17291,6 @@ static int test_pvs_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -14824,7 +17300,6 @@ static int test_pvs_0 (void) { char volgroup[] = "VG"; char physvols_0[] = "/dev/sda1"; - physvols_0[5] = devchar; char *physvols[] = { physvols_0, NULL @@ -14862,7 +17337,7 @@ static int test_pvs_0 (void) if (r == -1) return -1; } - /* TestOutputList for pvs (0) */ + /* TestOutputListOfDevices for pvs (0) */ { char **r; int i; @@ -14877,7 +17352,7 @@ static int test_pvs_0 (void) } { char expected[] = "/dev/sda1"; - expected[5] = devchar; + r[0][5] = 's'; if (strcmp (r[0], expected) != 0) { fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]); return -1; @@ -14899,6 +17374,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"); @@ -14909,14 +17387,13 @@ static int test_pvs_1_skip (void) static int test_pvs_1 (void) { if (test_pvs_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_pvs_1"); return 0; } /* InitNone|InitEmpty for test_pvs_1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -14937,10 +17414,9 @@ static int test_pvs_1 (void) if (r == -1) return -1; } - /* TestOutputList for pvs (1) */ + /* TestOutputListOfDevices for pvs (1) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ",10"; char lines_1[] = ",20"; char lines_2[] = ","; @@ -14958,7 +17434,6 @@ static int test_pvs_1 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -14967,7 +17442,6 @@ static int test_pvs_1 (void) } { char device[] = "/dev/sda2"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -14976,7 +17450,6 @@ static int test_pvs_1 (void) } { char device[] = "/dev/sda3"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_pvcreate (g, device); @@ -14997,7 +17470,7 @@ static int test_pvs_1 (void) } { char expected[] = "/dev/sda1"; - expected[5] = devchar; + r[0][5] = 's'; if (strcmp (r[0], expected) != 0) { fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]); return -1; @@ -15010,7 +17483,7 @@ static int test_pvs_1 (void) } { char expected[] = "/dev/sda2"; - expected[5] = devchar; + r[1][5] = 's'; if (strcmp (r[1], expected) != 0) { fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]); return -1; @@ -15023,7 +17496,7 @@ static int test_pvs_1 (void) } { char expected[] = "/dev/sda3"; - expected[5] = devchar; + r[2][5] = 's'; if (strcmp (r[2], expected) != 0) { fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]); return -1; @@ -15045,6 +17518,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"); @@ -15055,14 +17531,13 @@ static int test_list_partitions_0_skip (void) static int test_list_partitions_0 (void) { if (test_list_partitions_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_0"); return 0; } /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -15085,7 +17560,6 @@ static int test_list_partitions_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -15100,7 +17574,6 @@ static int test_list_partitions_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -15109,7 +17582,6 @@ static int test_list_partitions_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -15117,7 +17589,7 @@ static int test_list_partitions_0 (void) if (r == -1) return -1; } - /* TestOutputList for list_partitions (0) */ + /* TestOutputListOfDevices for list_partitions (0) */ { char **r; int i; @@ -15132,7 +17604,7 @@ static int test_list_partitions_0 (void) } { char expected[] = "/dev/sda1"; - expected[5] = devchar; + r[0][5] = 's'; if (strcmp (r[0], expected) != 0) { fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]); return -1; @@ -15154,6 +17626,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"); @@ -15164,14 +17639,13 @@ static int test_list_partitions_1_skip (void) static int test_list_partitions_1 (void) { if (test_list_partitions_1_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_1"); + printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_1"); return 0; } /* InitNone|InitEmpty for test_list_partitions_1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -15192,10 +17666,9 @@ static int test_list_partitions_1 (void) if (r == -1) return -1; } - /* TestOutputList for list_partitions (1) */ + /* TestOutputListOfDevices for list_partitions (1) */ { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ",10"; char lines_1[] = ",20"; char lines_2[] = ","; @@ -15225,7 +17698,7 @@ static int test_list_partitions_1 (void) } { char expected[] = "/dev/sda1"; - expected[5] = devchar; + r[0][5] = 's'; if (strcmp (r[0], expected) != 0) { fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]); return -1; @@ -15238,7 +17711,7 @@ static int test_list_partitions_1 (void) } { char expected[] = "/dev/sda2"; - expected[5] = devchar; + r[1][5] = 's'; if (strcmp (r[1], expected) != 0) { fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]); return -1; @@ -15251,7 +17724,7 @@ static int test_list_partitions_1 (void) } { char expected[] = "/dev/sda3"; - expected[5] = devchar; + r[2][5] = 's'; if (strcmp (r[2], expected) != 0) { fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]); return -1; @@ -15273,6 +17746,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"); @@ -15283,14 +17759,13 @@ static int test_list_devices_0_skip (void) static int test_list_devices_0 (void) { if (test_list_devices_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_devices_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_list_devices_0"); return 0; } /* InitNone|InitEmpty for test_list_devices_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -15311,7 +17786,7 @@ static int test_list_devices_0 (void) if (r == -1) return -1; } - /* TestOutputList for list_devices (0) */ + /* TestOutputListOfDevices for list_devices (0) */ { char **r; int i; @@ -15326,7 +17801,7 @@ static int test_list_devices_0 (void) } { char expected[] = "/dev/sda"; - expected[5] = devchar; + r[0][5] = 's'; if (strcmp (r[0], expected) != 0) { fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]); return -1; @@ -15339,7 +17814,7 @@ static int test_list_devices_0 (void) } { char expected[] = "/dev/sdb"; - expected[5] = devchar; + r[1][5] = 's'; if (strcmp (r[1], expected) != 0) { fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]); return -1; @@ -15352,13 +17827,26 @@ static int test_list_devices_0 (void) } { char expected[] = "/dev/sdc"; - expected[5] = devchar; + r[2][5] = 's'; if (strcmp (r[2], expected) != 0) { fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]); return -1; } } - if (r[3] != NULL) { + if (!r[3]) { + fprintf (stderr, "test_list_devices_0: short list returned from command\n"); + print_strings (r); + return -1; + } + { + char expected[] = "/dev/sdd"; + r[3][5] = 's'; + if (strcmp (r[3], expected) != 0) { + fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]); + return -1; + } + } + if (r[4] != NULL) { fprintf (stderr, "test_list_devices_0: extra elements returned from command\n"); print_strings (r); return -1; @@ -15374,6 +17862,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"); @@ -15384,14 +17875,13 @@ static int test_ls_0_skip (void) static int test_ls_0 (void) { if (test_ls_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ls_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_ls_0"); return 0; } /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -15414,7 +17904,6 @@ static int test_ls_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -15429,7 +17918,6 @@ static int test_ls_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -15438,7 +17926,6 @@ static int test_ls_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -15543,6 +18030,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"); @@ -15553,14 +18043,13 @@ static int test_cat_0_skip (void) static int test_cat_0 (void) { if (test_cat_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cat_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_cat_0"); return 0; } /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -15583,7 +18072,6 @@ static int test_cat_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -15598,7 +18086,6 @@ static int test_cat_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -15607,7 +18094,6 @@ static int test_cat_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -15646,6 +18132,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"); @@ -15656,14 +18145,13 @@ static int test_touch_0_skip (void) static int test_touch_0 (void) { if (test_touch_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_touch_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_touch_0"); return 0; } /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -15686,7 +18174,6 @@ static int test_touch_0 (void) } { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -15701,7 +18188,6 @@ static int test_touch_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -15710,7 +18196,6 @@ static int test_touch_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -15746,6 +18231,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"); @@ -15756,14 +18244,13 @@ static int test_sync_0_skip (void) static int test_sync_0 (void) { if (test_sync_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sync_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_sync_0"); return 0; } /* InitNone|InitEmpty for test_sync_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -15799,6 +18286,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"); @@ -15809,14 +18299,13 @@ static int test_mount_0_skip (void) static int test_mount_0 (void) { if (test_mount_0_skip ()) { - printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_0"); + printf ("%s skipped (reason: environment variable set)\n", "test_mount_0"); return 0; } /* InitNone|InitEmpty for test_mount_0 */ { char device[] = "/dev/sda"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_blockdev_setrw (g, device); @@ -15841,7 +18330,6 @@ static int test_mount_0 (void) char expected[] = "new file contents"; { char device[] = "/dev/sda"; - device[5] = devchar; char lines_0[] = ","; char *lines[] = { lines_0, @@ -15856,7 +18344,6 @@ static int test_mount_0 (void) { char fstype[] = "ext2"; char device[] = "/dev/sda1"; - device[5] = devchar; int r; suppress_error = 0; r = guestfs_mkfs (g, fstype, device); @@ -15865,7 +18352,6 @@ static int test_mount_0 (void) } { char device[] = "/dev/sda1"; - device[5] = devchar; char mountpoint[] = "/"; int r; suppress_error = 0; @@ -15902,11 +18388,9 @@ int main (int argc, char *argv[]) { char c = 0; int failed = 0; - const char *srcdir; const char *filename; - int fd, i; + int fd; int nr_tests, test_num = 0; - char **devs; no_test_warnings (); @@ -16004,40 +18488,150 @@ int main (int argc, char *argv[]) exit (1); } + if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) { + printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n"); + exit (1); + } + if (guestfs_launch (g) == -1) { printf ("guestfs_launch FAILED\n"); exit (1); } + + /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */ + alarm (600); + if (guestfs_wait_ready (g) == -1) { printf ("guestfs_wait_ready FAILED\n"); exit (1); } - /* Detect if the appliance uses /dev/sd* or /dev/hd* in device - * names. This changed between RHEL 5 and RHEL 6 so we have to - * support both. - */ - devs = guestfs_list_devices (g); - if (devs == NULL || devs[0] == NULL) { - printf ("guestfs_list_devices FAILED\n"); - exit (1); - } - if (strncmp (devs[0], "/dev/sd", 7) == 0) - devchar = 's'; - else if (strncmp (devs[0], "/dev/hd", 7) == 0) - devchar = 'h'; - else { - printf ("guestfs_list_devices returned unexpected string '%s'\n", - devs[0]); - exit (1); - } - for (i = 0; devs[i] != NULL; ++i) - free (devs[i]); - free (devs); + /* Cancel previous alarm. */ + alarm (0); - nr_tests = 142; + nr_tests = 164; test_num++; + printf ("%3d/%3d test_tail_n_0\n", test_num, nr_tests); + if (test_tail_n_0 () == -1) { + printf ("test_tail_n_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_tail_n_1\n", test_num, nr_tests); + if (test_tail_n_1 () == -1) { + printf ("test_tail_n_1 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_tail_n_2\n", test_num, nr_tests); + if (test_tail_n_2 () == -1) { + printf ("test_tail_n_2 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_tail_0\n", test_num, nr_tests); + if (test_tail_0 () == -1) { + printf ("test_tail_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_head_n_0\n", test_num, nr_tests); + if (test_head_n_0 () == -1) { + printf ("test_head_n_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_head_n_1\n", test_num, nr_tests); + if (test_head_n_1 () == -1) { + printf ("test_head_n_1 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_head_n_2\n", test_num, nr_tests); + if (test_head_n_2 () == -1) { + printf ("test_head_n_2 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_head_0\n", test_num, nr_tests); + if (test_head_0 () == -1) { + printf ("test_head_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_wc_c_0\n", test_num, nr_tests); + if (test_wc_c_0 () == -1) { + printf ("test_wc_c_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_wc_w_0\n", test_num, nr_tests); + if (test_wc_w_0 () == -1) { + printf ("test_wc_w_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_wc_l_0\n", test_num, nr_tests); + if (test_wc_l_0 () == -1) { + printf ("test_wc_l_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_mkdtemp_0\n", test_num, nr_tests); + if (test_mkdtemp_0 () == -1) { + printf ("test_mkdtemp_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_scrub_file_0\n", test_num, nr_tests); + if (test_scrub_file_0 () == -1) { + printf ("test_scrub_file_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_scrub_device_0\n", test_num, nr_tests); + if (test_scrub_device_0 () == -1) { + printf ("test_scrub_device_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_glob_expand_0\n", test_num, nr_tests); + if (test_glob_expand_0 () == -1) { + printf ("test_glob_expand_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_glob_expand_1\n", test_num, nr_tests); + if (test_glob_expand_1 () == -1) { + printf ("test_glob_expand_1 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_glob_expand_2\n", test_num, nr_tests); + if (test_glob_expand_2 () == -1) { + printf ("test_glob_expand_2 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests); + if (test_ntfs_3g_probe_0 () == -1) { + printf ("test_ntfs_3g_probe_0 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests); + if (test_ntfs_3g_probe_1 () == -1) { + printf ("test_ntfs_3g_probe_1 FAILED\n"); + failed++; + } + test_num++; + printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests); + if (test_sleep_0 () == -1) { + printf ("test_sleep_0 FAILED\n"); + failed++; + } + test_num++; printf ("%3d/%3d test_find_0\n", test_num, nr_tests); if (test_find_0 () == -1) { printf ("test_find_0 FAILED\n"); @@ -16074,6 +18668,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"); @@ -16344,6 +18944,12 @@ int main (int argc, char *argv[]) failed++; } test_num++; + printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests); + if (test_checksum_8 () == -1) { + printf ("test_checksum_8 FAILED\n"); + failed++; + } + test_num++; printf ("%3d/%3d test_download_0\n", test_num, nr_tests); if (test_download_0 () == -1) { printf ("test_download_0 FAILED\n");