Generated code for df / df-h.

[libguestfs.git] / capitests / tests.c

diff --git a/capitests/tests.c b/capitests/tests.c
index 6713a2d..08f64ee 100644 (file)
--- 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)
@@ -153,12 +148,2222 @@ static void no_test_warnings (void)
   fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n");
   fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n");
   fprintf (stderr, "warning: \"guestfs_e2fsck_f\" has no tests\n");
+  fprintf (stderr, "warning: \"guestfs_sh\" has no tests\n");
+  fprintf (stderr, "warning: \"guestfs_sh_lines\" has no tests\n");
+  fprintf (stderr, "warning: \"guestfs_scrub_freespace\" has no tests\n");
+  fprintf (stderr, "warning: \"guestfs_df\" has no tests\n");
+  fprintf (stderr, "warning: \"guestfs_df_h\" has no tests\n");
+}
+
+static int test_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");
@@ -169,14 +2374,13 @@ static int test_ntfs_3g_probe_0_skip (void)
 static int test_ntfs_3g_probe_0 (void)
 {
   if (test_ntfs_3g_probe_0_skip ()) {
-    printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ntfs_3g_probe_0");
+    printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_0");
     return 0;
   }
 
   /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     int r;
     suppress_error = 0;
     r = guestfs_blockdev_setrw (g, device);
@@ -200,7 +2404,6 @@ static int test_ntfs_3g_probe_0 (void)
   /* TestOutputInt for ntfs_3g_probe (0) */
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -215,7 +2418,6 @@ static int test_ntfs_3g_probe_0 (void)
   {
     char fstype[] = "ntfs";
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     int r;
     suppress_error = 0;
     r = guestfs_mkfs (g, fstype, device);
@@ -224,7 +2426,6 @@ static int test_ntfs_3g_probe_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     int r;
     suppress_error = 0;
     r = guestfs_ntfs_3g_probe (g, 1, device);
@@ -242,6 +2443,9 @@ static int test_ntfs_3g_probe_1_skip (void)
 {
   const char *str;
 
+  str = getenv ("TEST_ONLY");
+  if (str)
+    return strstr (str, "ntfs_3g_probe") == NULL;
   str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
   if (str && strcmp (str, "1") == 0) return 1;
   str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
@@ -252,14 +2456,13 @@ static int test_ntfs_3g_probe_1_skip (void)
 static int test_ntfs_3g_probe_1 (void)
 {
   if (test_ntfs_3g_probe_1_skip ()) {
-    printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ntfs_3g_probe_1");
+    printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_1");
     return 0;
   }
 
   /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     int r;
     suppress_error = 0;
     r = guestfs_blockdev_setrw (g, device);
@@ -283,7 +2486,6 @@ static int test_ntfs_3g_probe_1 (void)
   /* TestOutputInt for ntfs_3g_probe (1) */
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -298,7 +2500,6 @@ static int test_ntfs_3g_probe_1 (void)
   {
     char fstype[] = "ext2";
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     int r;
     suppress_error = 0;
     r = guestfs_mkfs (g, fstype, device);
@@ -307,7 +2508,6 @@ static int test_ntfs_3g_probe_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     int r;
     suppress_error = 0;
     r = guestfs_ntfs_3g_probe (g, 1, device);
@@ -325,6 +2525,9 @@ static int test_sleep_0_skip (void)
 {
   const char *str;
 
+  str = getenv ("TEST_ONLY");
+  if (str)
+    return strstr (str, "sleep") == NULL;
   str = getenv ("SKIP_TEST_SLEEP_0");
   if (str && strcmp (str, "1") == 0) return 1;
   str = getenv ("SKIP_TEST_SLEEP");
@@ -335,14 +2538,13 @@ static int test_sleep_0_skip (void)
 static int test_sleep_0 (void)
 {
   if (test_sleep_0_skip ()) {
-    printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sleep_0");
+    printf ("%s skipped (reason: environment variable set)\n", "test_sleep_0");
     return 0;
   }
 
   /* InitNone|InitEmpty for test_sleep_0 */
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     int r;
     suppress_error = 0;
     r = guestfs_blockdev_setrw (g, device);
@@ -378,6 +2580,9 @@ static int test_find_0_skip (void)
 {
   const char *str;
 
+  str = getenv ("TEST_ONLY");
+  if (str)
+    return strstr (str, "find") == NULL;
   str = getenv ("SKIP_TEST_FIND_0");
   if (str && strcmp (str, "1") == 0) return 1;
   str = getenv ("SKIP_TEST_FIND");
@@ -388,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);
@@ -418,7 +2622,6 @@ static int test_find_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -433,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);
@@ -442,7 +2644,6 @@ static int test_find_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -487,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");
@@ -497,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);
@@ -527,7 +2730,6 @@ static int test_find_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -542,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);
@@ -551,7 +2752,6 @@ static int test_find_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -656,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");
@@ -666,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);
@@ -696,7 +2898,6 @@ static int test_find_2 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -711,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);
@@ -720,7 +2920,6 @@ static int test_find_2 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -793,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");
@@ -803,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);
@@ -835,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,
@@ -849,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);
@@ -859,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
@@ -967,6 +3165,9 @@ static int test_zerofree_0_skip (void)
 {
   const char *str;
 
+  str = getenv ("TEST_ONLY");
+  if (str)
+    return strstr (str, "zerofree") == NULL;
   str = getenv ("SKIP_TEST_ZEROFREE_0");
   if (str && strcmp (str, "1") == 0) return 1;
   str = getenv ("SKIP_TEST_ZEROFREE");
@@ -977,14 +3178,13 @@ static int test_zerofree_0_skip (void)
 static int test_zerofree_0 (void)
 {
   if (test_zerofree_0_skip ()) {
-    printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zerofree_0");
+    printf ("%s skipped (reason: environment variable set)\n", "test_zerofree_0");
     return 0;
   }
 
   /* InitNone|InitEmpty for test_zerofree_0 */
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     int r;
     suppress_error = 0;
     r = guestfs_blockdev_setrw (g, device);
@@ -1009,7 +3209,6 @@ static int test_zerofree_0 (void)
   char expected[] = "test file";
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -1024,7 +3223,6 @@ static int test_zerofree_0 (void)
   {
     char fstype[] = "ext3";
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     int r;
     suppress_error = 0;
     r = guestfs_mkfs (g, fstype, device);
@@ -1033,7 +3231,6 @@ static int test_zerofree_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -1052,7 +3249,6 @@ static int test_zerofree_0 (void)
   }
   {
     char pathordevice[] = "/dev/sda1";
-    pathordevice[5] = devchar;
     int r;
     suppress_error = 0;
     r = guestfs_umount (g, pathordevice);
@@ -1061,7 +3257,6 @@ static int test_zerofree_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     int r;
     suppress_error = 0;
     r = guestfs_zerofree (g, device);
@@ -1070,7 +3265,6 @@ static int test_zerofree_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -1098,6 +3292,9 @@ static int test_hexdump_0_skip (void)
 {
   const char *str;
 
+  str = getenv ("TEST_ONLY");
+  if (str)
+    return strstr (str, "hexdump") == NULL;
   str = getenv ("SKIP_TEST_HEXDUMP_0");
   if (str && strcmp (str, "1") == 0) return 1;
   str = getenv ("SKIP_TEST_HEXDUMP");
@@ -1108,14 +3305,13 @@ static int test_hexdump_0_skip (void)
 static int test_hexdump_0 (void)
 {
   if (test_hexdump_0_skip ()) {
-    printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_hexdump_0");
+    printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_0");
     return 0;
   }
 
   /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     int r;
     suppress_error = 0;
     r = guestfs_blockdev_setrw (g, device);
@@ -1138,7 +3334,6 @@ static int test_hexdump_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -1153,7 +3348,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);
@@ -1162,7 +3356,6 @@ static int test_hexdump_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -1197,10 +3390,112 @@ static int test_hexdump_0 (void)
   return 0;
 }
 
+static int test_hexdump_1_skip (void)
+{
+  const char *str;
+
+  str = getenv ("TEST_ONLY");
+  if (str)
+    return strstr (str, "hexdump") == NULL;
+  str = getenv ("SKIP_TEST_HEXDUMP_1");
+  if (str && strcmp (str, "1") == 0) return 1;
+  str = getenv ("SKIP_TEST_HEXDUMP");
+  if (str && strcmp (str, "1") == 0) return 1;
+  return 0;
+}
+
+static int test_hexdump_1 (void)
+{
+  if (test_hexdump_1_skip ()) {
+    printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_1");
+    return 0;
+  }
+
+  /* InitBasicFS for test_hexdump_1: create ext2 on /dev/sda1 */
+  {
+    char device[] = "/dev/sda";
+    int r;
+    suppress_error = 0;
+    r = guestfs_blockdev_setrw (g, device);
+    if (r == -1)
+      return -1;
+  }
+  {
+    int r;
+    suppress_error = 0;
+    r = guestfs_umount_all (g);
+    if (r == -1)
+      return -1;
+  }
+  {
+    int r;
+    suppress_error = 0;
+    r = guestfs_lvm_remove_all (g);
+    if (r == -1)
+      return -1;
+  }
+  {
+    char device[] = "/dev/sda";
+    char lines_0[] = ",";
+    char *lines[] = {
+      lines_0,
+      NULL
+    };
+    int r;
+    suppress_error = 0;
+    r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
+    if (r == -1)
+      return -1;
+  }
+  {
+    char fstype[] = "ext2";
+    char device[] = "/dev/sda1";
+    int r;
+    suppress_error = 0;
+    r = guestfs_mkfs (g, fstype, device);
+    if (r == -1)
+      return -1;
+  }
+  {
+    char device[] = "/dev/sda1";
+    char mountpoint[] = "/";
+    int r;
+    suppress_error = 0;
+    r = guestfs_mount (g, device, mountpoint);
+    if (r == -1)
+      return -1;
+  }
+  /* TestRun for hexdump (1) */
+  {
+    char options[] = "ro";
+    char vfstype[] = "squashfs";
+    char device[] = "/dev/sdd";
+    char mountpoint[] = "/";
+    int r;
+    suppress_error = 0;
+    r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
+    if (r == -1)
+      return -1;
+  }
+  {
+    char path[] = "/100krandom";
+    char *r;
+    suppress_error = 0;
+    r = guestfs_hexdump (g, path);
+    if (r == NULL)
+      return -1;
+    free (r);
+  }
+  return 0;
+}
+
 static int test_strings_e_0_skip (void)
 {
   const char *str;
 
+  str = getenv ("TEST_ONLY");
+  if (str)
+    return strstr (str, "strings_e") == NULL;
   str = getenv ("SKIP_TEST_STRINGS_E_0");
   if (str && strcmp (str, "1") == 0) return 1;
   str = getenv ("SKIP_TEST_STRINGS_E");
@@ -1211,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);
@@ -1241,7 +3535,6 @@ static int test_strings_e_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -1256,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);
@@ -1265,7 +3557,6 @@ static int test_strings_e_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -1308,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");
@@ -1318,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;
   }
 
@@ -1330,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");
@@ -1340,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);
@@ -1370,7 +3666,6 @@ static int test_strings_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -1385,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);
@@ -1394,7 +3688,6 @@ static int test_strings_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -1460,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");
@@ -1470,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);
@@ -1500,7 +3795,6 @@ static int test_strings_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -1515,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);
@@ -1524,7 +3817,6 @@ static int test_strings_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -1565,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");
@@ -1575,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);
@@ -1605,7 +3899,6 @@ static int test_equal_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -1620,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);
@@ -1629,7 +3921,6 @@ static int test_equal_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -1676,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");
@@ -1686,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);
@@ -1716,7 +4009,6 @@ static int test_equal_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -1731,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);
@@ -1740,7 +4031,6 @@ static int test_equal_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -1787,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");
@@ -1797,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);
@@ -1827,7 +4119,6 @@ static int test_equal_2 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -1842,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);
@@ -1851,7 +4141,6 @@ static int test_equal_2 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -1876,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");
@@ -1886,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);
@@ -1929,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");
@@ -1939,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);
@@ -1983,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");
@@ -1993,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);
@@ -2036,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");
@@ -2046,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);
@@ -2076,7 +4373,6 @@ static int test_mv_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -2091,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);
@@ -2100,7 +4395,6 @@ static int test_mv_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -2148,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");
@@ -2158,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);
@@ -2188,7 +4484,6 @@ static int test_mv_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -2203,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);
@@ -2212,7 +4506,6 @@ static int test_mv_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -2258,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");
@@ -2268,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);
@@ -2298,7 +4593,6 @@ static int test_cp_a_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -2313,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);
@@ -2322,7 +4615,6 @@ static int test_cp_a_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -2386,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");
@@ -2396,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);
@@ -2426,7 +4720,6 @@ static int test_cp_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -2441,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);
@@ -2450,7 +4742,6 @@ static int test_cp_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -2498,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");
@@ -2508,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);
@@ -2538,7 +4831,6 @@ static int test_cp_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -2553,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);
@@ -2562,7 +4853,6 @@ static int test_cp_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -2608,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");
@@ -2618,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);
@@ -2648,7 +4940,6 @@ static int test_cp_2 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -2663,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);
@@ -2672,7 +4962,6 @@ static int test_cp_2 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -2728,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");
@@ -2738,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);
@@ -2768,7 +5059,6 @@ static int test_grub_install_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -2783,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);
@@ -2792,7 +5081,6 @@ static int test_grub_install_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -2804,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);
@@ -2830,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");
@@ -2840,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);
@@ -2870,7 +5159,6 @@ static int test_zero_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -2885,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);
@@ -2894,7 +5181,6 @@ static int test_zero_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -2906,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);
@@ -2915,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);
@@ -2924,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);
@@ -2943,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");
@@ -2953,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);
@@ -2983,7 +5268,6 @@ static int test_fsck_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -2998,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);
@@ -3007,7 +5290,6 @@ static int test_fsck_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -3018,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);
@@ -3028,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);
@@ -3046,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");
@@ -3056,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);
@@ -3086,7 +5368,6 @@ static int test_fsck_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -3101,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);
@@ -3110,7 +5390,6 @@ static int test_fsck_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -3121,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);
@@ -3130,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);
@@ -3140,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);
@@ -3158,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");
@@ -3168,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);
@@ -3198,7 +5476,6 @@ static int test_set_e2uuid_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -3213,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);
@@ -3222,7 +5498,6 @@ static int test_set_e2uuid_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -3234,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;
@@ -3244,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);
@@ -3263,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");
@@ -3273,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);
@@ -3303,7 +5578,6 @@ static int test_set_e2uuid_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -3318,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);
@@ -3327,7 +5600,6 @@ static int test_set_e2uuid_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -3339,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;
@@ -3349,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);
@@ -3368,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");
@@ -3378,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);
@@ -3408,7 +5680,6 @@ static int test_set_e2uuid_2 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -3423,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);
@@ -3432,7 +5702,6 @@ static int test_set_e2uuid_2 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -3443,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;
@@ -3458,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");
@@ -3468,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);
@@ -3498,7 +5768,6 @@ static int test_set_e2uuid_3 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -3513,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);
@@ -3522,7 +5790,6 @@ static int test_set_e2uuid_3 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -3533,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;
@@ -3548,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");
@@ -3558,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);
@@ -3588,7 +5856,6 @@ static int test_set_e2label_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -3603,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);
@@ -3612,7 +5878,6 @@ static int test_set_e2label_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -3624,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;
@@ -3634,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);
@@ -3653,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");
@@ -3663,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);
@@ -3691,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,
@@ -3708,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);
@@ -3718,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
@@ -3757,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);
@@ -3787,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");
@@ -3797,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);
@@ -3825,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,
@@ -3842,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);
@@ -3852,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
@@ -3891,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);
@@ -3921,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");
@@ -3931,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);
@@ -3959,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,
@@ -3976,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);
@@ -3986,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
@@ -4025,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);
@@ -4055,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");
@@ -4065,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);
@@ -4096,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,
@@ -4110,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);
@@ -4120,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
@@ -4180,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");
@@ -4190,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);
@@ -4221,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,
@@ -4235,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);
@@ -4245,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
@@ -4305,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");
@@ -4315,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);
@@ -4346,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,
@@ -4360,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);
@@ -4370,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
@@ -4442,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");
@@ -4452,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);
@@ -4483,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,
@@ -4497,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);
@@ -4507,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
@@ -4567,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");
@@ -4577,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);
@@ -4608,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,
@@ -4622,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);
@@ -4632,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
@@ -4704,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");
@@ -4714,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);
@@ -4744,7 +6998,6 @@ static int test_mount_ro_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -4759,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);
@@ -4768,7 +7020,6 @@ static int test_mount_ro_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -4787,7 +7038,6 @@ static int test_mount_ro_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -4810,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");
@@ -4820,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);
@@ -4850,7 +7102,6 @@ static int test_mount_ro_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -4865,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);
@@ -4874,7 +7124,6 @@ static int test_mount_ro_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -4903,7 +7152,6 @@ static int test_mount_ro_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -4931,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");
@@ -4941,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);
@@ -4971,7 +7221,6 @@ static int test_tgz_in_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -4986,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);
@@ -4995,7 +7243,6 @@ static int test_tgz_in_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -5033,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");
@@ -5043,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);
@@ -5073,7 +7322,6 @@ static int test_tar_in_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -5088,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);
@@ -5097,7 +7344,6 @@ static int test_tar_in_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -5135,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");
@@ -5145,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);
@@ -5175,7 +7423,6 @@ static int test_checksum_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -5190,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);
@@ -5199,7 +7445,6 @@ static int test_checksum_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -5239,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");
@@ -5249,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);
@@ -5279,7 +7526,6 @@ static int test_checksum_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -5294,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);
@@ -5303,7 +7548,6 @@ static int test_checksum_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -5329,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");
@@ -5339,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);
@@ -5369,7 +7615,6 @@ static int test_checksum_2 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -5384,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);
@@ -5393,7 +7637,6 @@ static int test_checksum_2 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -5433,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");
@@ -5443,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);
@@ -5473,7 +7718,6 @@ static int test_checksum_3 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -5488,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);
@@ -5497,7 +7740,6 @@ static int test_checksum_3 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -5537,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");
@@ -5547,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);
@@ -5577,7 +7821,6 @@ static int test_checksum_4 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -5592,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);
@@ -5601,7 +7843,6 @@ static int test_checksum_4 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -5641,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");
@@ -5651,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);
@@ -5681,7 +7924,6 @@ static int test_checksum_5 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -5696,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);
@@ -5705,7 +7946,6 @@ static int test_checksum_5 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -5745,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");
@@ -5755,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);
@@ -5785,7 +8027,6 @@ static int test_checksum_6 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -5800,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);
@@ -5809,7 +8049,6 @@ static int test_checksum_6 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -5849,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");
@@ -5859,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);
@@ -5889,7 +8130,6 @@ static int test_checksum_7 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -5904,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);
@@ -5913,7 +8152,6 @@ static int test_checksum_7 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -5953,6 +8191,9 @@ static int test_checksum_8_skip (void)
 {
   const char *str;
 
+  str = getenv ("TEST_ONLY");
+  if (str)
+    return strstr (str, "checksum") == NULL;
   str = getenv ("SKIP_TEST_CHECKSUM_8");
   if (str && strcmp (str, "1") == 0) return 1;
   str = getenv ("SKIP_TEST_CHECKSUM");
@@ -5963,14 +8204,13 @@ static int test_checksum_8_skip (void)
 static int test_checksum_8 (void)
 {
   if (test_checksum_8_skip ()) {
-    printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_8");
+    printf ("%s skipped (reason: environment variable set)\n", "test_checksum_8");
     return 0;
   }
 
   /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     int r;
     suppress_error = 0;
     r = guestfs_blockdev_setrw (g, device);
@@ -5993,7 +8233,6 @@ static int test_checksum_8 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -6008,7 +8247,6 @@ static int test_checksum_8 (void)
   {
     char fstype[] = "ext2";
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     int r;
     suppress_error = 0;
     r = guestfs_mkfs (g, fstype, device);
@@ -6017,7 +8255,6 @@ static int test_checksum_8 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -6028,12 +8265,13 @@ static int test_checksum_8 (void)
   /* TestOutput for checksum (8) */
   char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
   {
+    char options[] = "ro";
+    char vfstype[] = "squashfs";
     char device[] = "/dev/sdd";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
-    r = guestfs_mount (g, device, mountpoint);
+    r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
     if (r == -1)
       return -1;
   }
@@ -6058,6 +8296,9 @@ static int test_download_0_skip (void)
 {
   const char *str;
 
+  str = getenv ("TEST_ONLY");
+  if (str)
+    return strstr (str, "download") == NULL;
   str = getenv ("SKIP_TEST_DOWNLOAD_0");
   if (str && strcmp (str, "1") == 0) return 1;
   str = getenv ("SKIP_TEST_DOWNLOAD");
@@ -6068,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);
@@ -6098,7 +8338,6 @@ static int test_download_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -6113,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);
@@ -6122,7 +8360,6 @@ static int test_download_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -6177,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");
@@ -6187,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);
@@ -6217,7 +8456,6 @@ static int test_upload_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -6232,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);
@@ -6241,7 +8478,6 @@ static int test_upload_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -6280,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");
@@ -6290,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);
@@ -6321,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);
@@ -6335,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");
@@ -6345,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);
@@ -6376,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);
@@ -6390,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");
@@ -6400,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);
@@ -6431,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);
@@ -6449,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");
@@ -6459,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);
@@ -6490,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);
@@ -6508,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");
@@ -6518,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);
@@ -6549,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);
@@ -6567,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");
@@ -6577,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);
@@ -6608,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);
@@ -6626,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");
@@ -6636,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);
@@ -6667,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);
@@ -6676,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);
@@ -6694,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");
@@ -6704,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);
@@ -6735,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);
@@ -6744,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);
@@ -6762,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");
@@ -6772,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);
@@ -6803,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);
@@ -6812,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);
@@ -6830,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");
@@ -6840,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);
@@ -6870,7 +9114,6 @@ static int test_statvfs_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -6885,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);
@@ -6894,7 +9136,6 @@ static int test_statvfs_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -6934,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");
@@ -6944,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);
@@ -6974,7 +9217,6 @@ static int test_lstat_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -6989,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);
@@ -6998,7 +9239,6 @@ static int test_lstat_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -7036,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");
@@ -7046,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);
@@ -7076,7 +9318,6 @@ static int test_stat_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -7091,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);
@@ -7100,7 +9340,6 @@ static int test_stat_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -7138,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");
@@ -7148,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);
@@ -7178,7 +9419,6 @@ static int test_command_lines_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -7193,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);
@@ -7202,7 +9441,6 @@ static int test_command_lines_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -7269,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");
@@ -7279,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);
@@ -7309,7 +9549,6 @@ static int test_command_lines_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -7324,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);
@@ -7333,7 +9571,6 @@ static int test_command_lines_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -7400,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");
@@ -7410,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);
@@ -7440,7 +9679,6 @@ static int test_command_lines_2 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -7455,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);
@@ -7464,7 +9701,6 @@ static int test_command_lines_2 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -7543,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");
@@ -7553,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);
@@ -7583,7 +9821,6 @@ static int test_command_lines_3 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -7598,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);
@@ -7607,7 +9843,6 @@ static int test_command_lines_3 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -7686,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");
@@ -7696,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);
@@ -7726,7 +9963,6 @@ static int test_command_lines_4 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -7741,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);
@@ -7750,7 +9985,6 @@ static int test_command_lines_4 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -7841,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");
@@ -7851,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);
@@ -7881,7 +10117,6 @@ static int test_command_lines_5 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -7896,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);
@@ -7905,7 +10139,6 @@ static int test_command_lines_5 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -8008,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");
@@ -8018,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);
@@ -8048,7 +10283,6 @@ static int test_command_lines_6 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -8063,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);
@@ -8072,7 +10305,6 @@ static int test_command_lines_6 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -8127,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");
@@ -8137,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);
@@ -8167,7 +10401,6 @@ static int test_command_lines_7 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -8182,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);
@@ -8191,7 +10423,6 @@ static int test_command_lines_7 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -8258,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");
@@ -8268,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);
@@ -8298,7 +10531,6 @@ static int test_command_lines_8 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -8313,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);
@@ -8322,7 +10553,6 @@ static int test_command_lines_8 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -8401,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");
@@ -8411,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);
@@ -8441,7 +10673,6 @@ static int test_command_lines_9 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -8456,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);
@@ -8465,7 +10695,6 @@ static int test_command_lines_9 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -8544,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");
@@ -8554,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);
@@ -8584,7 +10815,6 @@ static int test_command_lines_10 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -8599,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);
@@ -8608,7 +10837,6 @@ static int test_command_lines_10 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -8687,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");
@@ -8697,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);
@@ -8727,7 +10957,6 @@ static int test_command_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -8742,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);
@@ -8751,7 +10979,6 @@ static int test_command_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -8803,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");
@@ -8813,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);
@@ -8843,7 +11072,6 @@ static int test_command_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -8858,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);
@@ -8867,7 +11094,6 @@ static int test_command_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -8919,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");
@@ -8929,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);
@@ -8959,7 +11187,6 @@ static int test_command_2 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -8974,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);
@@ -8983,7 +11209,6 @@ static int test_command_2 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -9035,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");
@@ -9045,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);
@@ -9075,7 +11302,6 @@ static int test_command_3 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -9090,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);
@@ -9099,7 +11324,6 @@ static int test_command_3 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -9151,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");
@@ -9161,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);
@@ -9191,7 +11417,6 @@ static int test_command_4 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -9206,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);
@@ -9215,7 +11439,6 @@ static int test_command_4 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -9267,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");
@@ -9277,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);
@@ -9307,7 +11532,6 @@ static int test_command_5 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -9322,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);
@@ -9331,7 +11554,6 @@ static int test_command_5 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -9383,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");
@@ -9393,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);
@@ -9423,7 +11647,6 @@ static int test_command_6 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -9438,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);
@@ -9447,7 +11669,6 @@ static int test_command_6 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -9499,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");
@@ -9509,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);
@@ -9539,7 +11762,6 @@ static int test_command_7 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -9554,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);
@@ -9563,7 +11784,6 @@ static int test_command_7 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -9615,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");
@@ -9625,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);
@@ -9655,7 +11877,6 @@ static int test_command_8 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -9670,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);
@@ -9679,7 +11899,6 @@ static int test_command_8 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -9731,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");
@@ -9741,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);
@@ -9771,7 +11992,6 @@ static int test_command_9 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -9786,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);
@@ -9795,7 +12014,6 @@ static int test_command_9 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -9847,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");
@@ -9857,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);
@@ -9887,7 +12107,6 @@ static int test_command_10 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -9902,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);
@@ -9911,7 +12129,6 @@ static int test_command_10 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -9963,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");
@@ -9973,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);
@@ -10003,7 +12222,6 @@ static int test_command_11 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -10018,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);
@@ -10027,7 +12244,6 @@ static int test_command_11 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -10072,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");
@@ -10082,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);
@@ -10112,7 +12330,6 @@ static int test_file_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -10127,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);
@@ -10136,7 +12352,6 @@ static int test_file_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -10174,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");
@@ -10184,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);
@@ -10214,7 +12431,6 @@ static int test_file_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -10229,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);
@@ -10238,7 +12453,6 @@ static int test_file_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -10277,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");
@@ -10287,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);
@@ -10317,7 +12533,6 @@ static int test_file_2 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -10332,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);
@@ -10341,7 +12555,6 @@ static int test_file_2 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -10366,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");
@@ -10376,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);
@@ -10406,7 +12621,6 @@ static int test_umount_all_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -10421,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);
@@ -10430,7 +12643,6 @@ static int test_umount_all_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -10469,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");
@@ -10479,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);
@@ -10510,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[] = ",";
@@ -10529,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);
@@ -10539,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);
@@ -10549,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);
@@ -10558,7 +12768,6 @@ static int test_umount_all_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -10576,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;
@@ -10594,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;
@@ -10640,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");
@@ -10650,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);
@@ -10680,7 +12889,6 @@ static int test_mounts_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -10695,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);
@@ -10704,7 +12911,6 @@ static int test_mounts_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -10712,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;
@@ -10727,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;
@@ -10749,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");
@@ -10759,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);
@@ -10787,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,
@@ -10805,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);
@@ -10814,7 +13020,6 @@ static int test_umount_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -10836,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;
@@ -10858,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");
@@ -10868,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);
@@ -10899,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,
@@ -10914,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);
@@ -10923,7 +13128,6 @@ static int test_umount_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -10962,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");
@@ -10972,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);
@@ -11002,7 +13208,6 @@ static int test_write_file_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -11017,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);
@@ -11026,7 +13230,6 @@ static int test_write_file_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -11065,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");
@@ -11075,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);
@@ -11105,7 +13310,6 @@ static int test_write_file_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -11120,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);
@@ -11129,7 +13332,6 @@ static int test_write_file_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -11168,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");
@@ -11178,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);
@@ -11208,7 +13412,6 @@ static int test_write_file_2 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -11223,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);
@@ -11232,7 +13434,6 @@ static int test_write_file_2 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -11271,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");
@@ -11281,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);
@@ -11311,7 +13514,6 @@ static int test_write_file_3 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -11326,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);
@@ -11335,7 +13536,6 @@ static int test_write_file_3 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -11374,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");
@@ -11384,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);
@@ -11414,7 +13616,6 @@ static int test_write_file_4 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -11429,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);
@@ -11438,7 +13638,6 @@ static int test_write_file_4 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -11477,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");
@@ -11487,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);
@@ -11517,7 +13718,6 @@ static int test_write_file_5 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -11532,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);
@@ -11541,7 +13740,6 @@ static int test_write_file_5 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -11580,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");
@@ -11590,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);
@@ -11622,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,
@@ -11637,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);
@@ -11646,7 +13844,6 @@ static int test_mkfs_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -11683,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");
@@ -11693,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);
@@ -11724,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[] = ",";
@@ -11742,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);
@@ -11751,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);
@@ -11760,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);
@@ -11770,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,
@@ -11787,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
@@ -11926,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");
@@ -11936,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);
@@ -11967,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[] = ",";
@@ -11985,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);
@@ -11994,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);
@@ -12003,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);
@@ -12013,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,
@@ -12030,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
@@ -12088,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");
@@ -12098,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);
@@ -12126,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[] = ",";
@@ -12147,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);
@@ -12156,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);
@@ -12165,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);
@@ -12186,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;
@@ -12199,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;
@@ -12212,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;
@@ -12234,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");
@@ -12244,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);
@@ -12274,7 +14461,6 @@ static int test_is_dir_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -12289,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);
@@ -12298,7 +14483,6 @@ static int test_is_dir_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -12334,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");
@@ -12344,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);
@@ -12374,7 +14560,6 @@ static int test_is_dir_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -12389,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);
@@ -12398,7 +14582,6 @@ static int test_is_dir_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -12434,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");
@@ -12444,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);
@@ -12474,7 +14659,6 @@ static int test_is_file_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -12489,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);
@@ -12498,7 +14681,6 @@ static int test_is_file_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -12534,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");
@@ -12544,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);
@@ -12574,7 +14758,6 @@ static int test_is_file_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -12589,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);
@@ -12598,7 +14780,6 @@ static int test_is_file_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -12634,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");
@@ -12644,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);
@@ -12674,7 +14857,6 @@ static int test_exists_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -12689,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);
@@ -12698,7 +14879,6 @@ static int test_exists_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -12734,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");
@@ -12744,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);
@@ -12774,7 +14956,6 @@ static int test_exists_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -12789,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);
@@ -12798,7 +14978,6 @@ static int test_exists_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -12834,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");
@@ -12844,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);
@@ -12874,7 +15055,6 @@ static int test_mkdir_p_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -12889,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);
@@ -12898,7 +15077,6 @@ static int test_mkdir_p_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -12934,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");
@@ -12944,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);
@@ -12974,7 +15154,6 @@ static int test_mkdir_p_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -12989,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);
@@ -12998,7 +15176,6 @@ static int test_mkdir_p_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -13034,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");
@@ -13044,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);
@@ -13074,7 +15253,6 @@ static int test_mkdir_p_2 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -13089,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);
@@ -13098,7 +15275,6 @@ static int test_mkdir_p_2 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -13134,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");
@@ -13144,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);
@@ -13174,7 +15352,6 @@ static int test_mkdir_p_3 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -13189,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);
@@ -13198,7 +15374,6 @@ static int test_mkdir_p_3 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -13230,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");
@@ -13240,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);
@@ -13270,7 +15447,6 @@ static int test_mkdir_p_4 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -13285,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);
@@ -13294,7 +15469,6 @@ static int test_mkdir_p_4 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -13326,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");
@@ -13336,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);
@@ -13366,7 +15542,6 @@ static int test_mkdir_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -13381,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);
@@ -13390,7 +15564,6 @@ static int test_mkdir_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -13426,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");
@@ -13436,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);
@@ -13466,7 +15641,6 @@ static int test_mkdir_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -13481,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);
@@ -13490,7 +15663,6 @@ static int test_mkdir_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -13514,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");
@@ -13524,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);
@@ -13554,7 +15728,6 @@ static int test_rm_rf_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -13569,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);
@@ -13578,7 +15750,6 @@ static int test_rm_rf_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -13638,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");
@@ -13648,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);
@@ -13678,7 +15851,6 @@ static int test_rmdir_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -13693,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);
@@ -13702,7 +15873,6 @@ static int test_rmdir_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -13734,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");
@@ -13744,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);
@@ -13774,7 +15946,6 @@ static int test_rmdir_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -13789,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);
@@ -13798,7 +15968,6 @@ static int test_rmdir_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -13822,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");
@@ -13832,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);
@@ -13862,7 +16033,6 @@ static int test_rmdir_2 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -13877,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);
@@ -13886,7 +16055,6 @@ static int test_rmdir_2 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -13918,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");
@@ -13928,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);
@@ -13958,7 +16128,6 @@ static int test_rm_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -13973,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);
@@ -13982,7 +16150,6 @@ static int test_rm_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -14014,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");
@@ -14024,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);
@@ -14054,7 +16223,6 @@ static int test_rm_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -14069,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);
@@ -14078,7 +16245,6 @@ static int test_rm_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -14102,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");
@@ -14112,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);
@@ -14142,7 +16310,6 @@ static int test_rm_2 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -14157,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);
@@ -14166,7 +16332,6 @@ static int test_rm_2 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -14198,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");
@@ -14208,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);
@@ -14238,7 +16405,6 @@ static int test_read_lines_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -14253,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);
@@ -14262,7 +16427,6 @@ static int test_read_lines_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -14340,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");
@@ -14350,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);
@@ -14380,7 +16546,6 @@ static int test_read_lines_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -14395,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);
@@ -14404,7 +16568,6 @@ static int test_read_lines_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -14446,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");
@@ -14456,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);
@@ -14486,7 +16651,6 @@ static int test_lvs_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -14500,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);
@@ -14510,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
@@ -14584,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");
@@ -14594,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);
@@ -14625,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[] = ",";
@@ -14643,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);
@@ -14652,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);
@@ -14661,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);
@@ -14671,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,
@@ -14688,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
@@ -14785,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");
@@ -14795,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);
@@ -14825,7 +16984,6 @@ static int test_vgs_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -14839,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);
@@ -14849,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
@@ -14923,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");
@@ -14933,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);
@@ -14964,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[] = ",";
@@ -14982,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);
@@ -14991,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);
@@ -15000,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);
@@ -15010,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,
@@ -15027,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
@@ -15085,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");
@@ -15095,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);
@@ -15125,7 +17278,6 @@ static int test_pvs_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -15139,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);
@@ -15149,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
@@ -15187,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;
@@ -15202,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;
@@ -15224,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");
@@ -15234,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);
@@ -15262,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[] = ",";
@@ -15283,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);
@@ -15292,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);
@@ -15301,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);
@@ -15322,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;
@@ -15335,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;
@@ -15348,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;
@@ -15370,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");
@@ -15380,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);
@@ -15410,7 +17560,6 @@ static int test_list_partitions_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -15425,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);
@@ -15434,7 +17582,6 @@ static int test_list_partitions_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -15442,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;
@@ -15457,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;
@@ -15479,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");
@@ -15489,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);
@@ -15517,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[] = ",";
@@ -15550,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;
@@ -15563,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;
@@ -15576,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;
@@ -15598,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");
@@ -15608,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);
@@ -15636,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;
@@ -15651,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;
@@ -15664,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;
@@ -15677,7 +17827,7 @@ static int test_list_devices_0 (void)
     }
     {
       char expected[] = "/dev/sdc";
-      expected[5] = devchar;
+      r[2][5] = 's';
       if (strcmp (r[2], expected) != 0) {
         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
         return -1;
@@ -15690,7 +17840,7 @@ static int test_list_devices_0 (void)
     }
     {
       char expected[] = "/dev/sdd";
-      expected[5] = devchar;
+      r[3][5] = 's';
       if (strcmp (r[3], expected) != 0) {
         fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
         return -1;
@@ -15712,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");
@@ -15722,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);
@@ -15752,7 +17904,6 @@ static int test_ls_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -15767,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);
@@ -15776,7 +17926,6 @@ static int test_ls_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -15881,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");
@@ -15891,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);
@@ -15921,7 +18072,6 @@ static int test_cat_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -15936,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);
@@ -15945,7 +18094,6 @@ static int test_cat_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -15984,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");
@@ -15994,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);
@@ -16024,7 +18174,6 @@ static int test_touch_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -16039,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);
@@ -16048,7 +18196,6 @@ static int test_touch_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -16084,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");
@@ -16094,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);
@@ -16137,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");
@@ -16147,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);
@@ -16179,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,
@@ -16194,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);
@@ -16203,7 +18352,6 @@ static int test_mount_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -16241,9 +18389,8 @@ int main (int argc, char *argv[])
   char c = 0;
   int failed = 0;
   const char *filename;
-  int fd, i;
+  int fd;
   int nr_tests, test_num = 0;
-  char **devs;
 
   no_test_warnings ();
 
@@ -16350,36 +18497,123 @@ int main (int argc, char *argv[])
     printf ("guestfs_launch FAILED\n");
     exit (1);
   }
+
+  /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */
+  alarm (600);
+
   if (guestfs_wait_ready (g) == -1) {
     printf ("guestfs_wait_ready FAILED\n");
     exit (1);
   }
 
-  /* Detect if the appliance uses /dev/sd* or /dev/hd* in device
-   * names.  This changed between RHEL 5 and RHEL 6 so we have to
-   * support both.
-   */
-  devs = guestfs_list_devices (g);
-  if (devs == NULL || devs[0] == NULL) {
-    printf ("guestfs_list_devices FAILED\n");
-    exit (1);
-  }
-  if (strncmp (devs[0], "/dev/sd", 7) == 0)
-    devchar = 's';
-  else if (strncmp (devs[0], "/dev/hd", 7) == 0)
-    devchar = 'h';
-  else {
-    printf ("guestfs_list_devices returned unexpected string '%s'\n",
-            devs[0]);
-    exit (1);
-  }
-  for (i = 0; devs[i] != NULL; ++i)
-    free (devs[i]);
-  free (devs);
+  /* Cancel previous alarm. */
+  alarm (0);
 
-  nr_tests = 146;
+  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");
@@ -16434,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");