Generated code for df / df-h.

[libguestfs.git] / capitests / tests.c

diff --git a/capitests/tests.c b/capitests/tests.c
index 1b751e8..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,2441 @@ 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");
+  if (str && strcmp (str, "1") == 0) return 1;
+  return 0;
+}
+
+static int test_ntfs_3g_probe_0 (void)
+{
+  if (test_ntfs_3g_probe_0_skip ()) {
+    printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_0");
+    return 0;
+  }
+
+  /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
+  {
+    char device[] = "/dev/sda";
+    int r;
+    suppress_error = 0;
+    r = guestfs_blockdev_setrw (g, device);
+    if (r == -1)
+      return -1;
+  }
+  {
+    int r;
+    suppress_error = 0;
+    r = guestfs_umount_all (g);
+    if (r == -1)
+      return -1;
+  }
+  {
+    int r;
+    suppress_error = 0;
+    r = guestfs_lvm_remove_all (g);
+    if (r == -1)
+      return -1;
+  }
+  /* TestOutputInt for ntfs_3g_probe (0) */
+  {
+    char device[] = "/dev/sda";
+    char lines_0[] = ",";
+    char *lines[] = {
+      lines_0,
+      NULL
+    };
+    int r;
+    suppress_error = 0;
+    r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
+    if (r == -1)
+      return -1;
+  }
+  {
+    char fstype[] = "ntfs";
+    char device[] = "/dev/sda1";
+    int r;
+    suppress_error = 0;
+    r = guestfs_mkfs (g, fstype, device);
+    if (r == -1)
+      return -1;
+  }
+  {
+    char device[] = "/dev/sda1";
+    int r;
+    suppress_error = 0;
+    r = guestfs_ntfs_3g_probe (g, 1, device);
+    if (r == -1)
+      return -1;
+    if (r != 0) {
+      fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n",               (int) r);
+      return -1;
+    }
+  }
+  return 0;
+}
+
+static int test_ntfs_3g_probe_1_skip (void)
+{
+  const char *str;
+
+  str = getenv ("TEST_ONLY");
+  if (str)
+    return strstr (str, "ntfs_3g_probe") == NULL;
+  str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
+  if (str && strcmp (str, "1") == 0) return 1;
+  str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
+  if (str && strcmp (str, "1") == 0) return 1;
+  return 0;
+}
+
+static int test_ntfs_3g_probe_1 (void)
+{
+  if (test_ntfs_3g_probe_1_skip ()) {
+    printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_1");
+    return 0;
+  }
+
+  /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
+  {
+    char device[] = "/dev/sda";
+    int r;
+    suppress_error = 0;
+    r = guestfs_blockdev_setrw (g, device);
+    if (r == -1)
+      return -1;
+  }
+  {
+    int r;
+    suppress_error = 0;
+    r = guestfs_umount_all (g);
+    if (r == -1)
+      return -1;
+  }
+  {
+    int r;
+    suppress_error = 0;
+    r = guestfs_lvm_remove_all (g);
+    if (r == -1)
+      return -1;
+  }
+  /* TestOutputInt for ntfs_3g_probe (1) */
+  {
+    char device[] = "/dev/sda";
+    char lines_0[] = ",";
+    char *lines[] = {
+      lines_0,
+      NULL
+    };
+    int r;
+    suppress_error = 0;
+    r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
+    if (r == -1)
+      return -1;
+  }
+  {
+    char fstype[] = "ext2";
+    char device[] = "/dev/sda1";
+    int r;
+    suppress_error = 0;
+    r = guestfs_mkfs (g, fstype, device);
+    if (r == -1)
+      return -1;
+  }
+  {
+    char device[] = "/dev/sda1";
+    int r;
+    suppress_error = 0;
+    r = guestfs_ntfs_3g_probe (g, 1, device);
+    if (r == -1)
+      return -1;
+    if (r != 12) {
+      fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n",               (int) r);
+      return -1;
+    }
+  }
+  return 0;
+}
+
+static int test_sleep_0_skip (void)
+{
+  const char *str;
+
+  str = getenv ("TEST_ONLY");
+  if (str)
+    return strstr (str, "sleep") == NULL;
+  str = getenv ("SKIP_TEST_SLEEP_0");
+  if (str && strcmp (str, "1") == 0) return 1;
+  str = getenv ("SKIP_TEST_SLEEP");
+  if (str && strcmp (str, "1") == 0) return 1;
+  return 0;
+}
+
+static int test_sleep_0 (void)
+{
+  if (test_sleep_0_skip ()) {
+    printf ("%s skipped (reason: environment variable set)\n", "test_sleep_0");
+    return 0;
+  }
+
+  /* InitNone|InitEmpty for test_sleep_0 */
+  {
+    char device[] = "/dev/sda";
+    int r;
+    suppress_error = 0;
+    r = guestfs_blockdev_setrw (g, device);
+    if (r == -1)
+      return -1;
+  }
+  {
+    int r;
+    suppress_error = 0;
+    r = guestfs_umount_all (g);
+    if (r == -1)
+      return -1;
+  }
+  {
+    int r;
+    suppress_error = 0;
+    r = guestfs_lvm_remove_all (g);
+    if (r == -1)
+      return -1;
+  }
+  /* TestRun for sleep (0) */
+  {
+    int r;
+    suppress_error = 0;
+    r = guestfs_sleep (g, 1);
+    if (r == -1)
+      return -1;
+  }
+  return 0;
 }
 
 static int test_find_0_skip (void)
 {
   const char *str;
 
+  str = getenv ("TEST_ONLY");
+  if (str)
+    return strstr (str, "find") == NULL;
   str = getenv ("SKIP_TEST_FIND_0");
   if (str && strcmp (str, "1") == 0) return 1;
   str = getenv ("SKIP_TEST_FIND");
@@ -169,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);
@@ -199,7 +2622,6 @@ static int test_find_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -214,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);
@@ -223,7 +2644,6 @@ static int test_find_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -268,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");
@@ -278,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);
@@ -308,7 +2730,6 @@ static int test_find_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -323,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);
@@ -332,7 +2752,6 @@ static int test_find_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -437,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");
@@ -447,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);
@@ -477,7 +2898,6 @@ static int test_find_2 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -492,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);
@@ -501,7 +2920,6 @@ static int test_find_2 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -574,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");
@@ -584,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);
@@ -616,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,
@@ -630,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);
@@ -640,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
@@ -748,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");
@@ -758,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);
@@ -790,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,
@@ -805,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);
@@ -814,7 +3231,6 @@ static int test_zerofree_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -833,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);
@@ -842,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);
@@ -851,7 +3265,6 @@ static int test_zerofree_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -879,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");
@@ -889,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);
@@ -919,7 +3334,6 @@ static int test_hexdump_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -934,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);
@@ -943,7 +3356,6 @@ static int test_hexdump_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -978,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");
@@ -992,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);
@@ -1022,7 +3535,6 @@ static int test_strings_e_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -1037,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);
@@ -1046,7 +3557,6 @@ static int test_strings_e_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -1089,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");
@@ -1099,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;
   }
 
@@ -1111,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");
@@ -1121,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);
@@ -1151,7 +3666,6 @@ static int test_strings_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -1166,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);
@@ -1175,7 +3688,6 @@ static int test_strings_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -1241,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");
@@ -1251,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);
@@ -1281,7 +3795,6 @@ static int test_strings_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -1296,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);
@@ -1305,7 +3817,6 @@ static int test_strings_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -1346,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");
@@ -1356,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);
@@ -1386,7 +3899,6 @@ static int test_equal_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -1401,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);
@@ -1410,7 +3921,6 @@ static int test_equal_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -1457,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");
@@ -1467,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);
@@ -1497,7 +4009,6 @@ static int test_equal_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -1512,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);
@@ -1521,7 +4031,6 @@ static int test_equal_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -1568,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");
@@ -1578,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);
@@ -1608,7 +4119,6 @@ static int test_equal_2 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -1623,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);
@@ -1632,7 +4141,6 @@ static int test_equal_2 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -1657,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");
@@ -1667,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);
@@ -1710,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");
@@ -1720,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);
@@ -1764,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");
@@ -1774,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);
@@ -1817,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");
@@ -1827,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);
@@ -1857,7 +4373,6 @@ static int test_mv_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -1872,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);
@@ -1881,7 +4395,6 @@ static int test_mv_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -1929,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");
@@ -1939,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);
@@ -1969,7 +4484,6 @@ static int test_mv_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -1984,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);
@@ -1993,7 +4506,6 @@ static int test_mv_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -2039,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");
@@ -2049,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);
@@ -2079,7 +4593,6 @@ static int test_cp_a_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -2094,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);
@@ -2103,7 +4615,6 @@ static int test_cp_a_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -2167,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");
@@ -2177,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);
@@ -2207,7 +4720,6 @@ static int test_cp_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -2222,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);
@@ -2231,7 +4742,6 @@ static int test_cp_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -2279,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");
@@ -2289,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);
@@ -2319,7 +4831,6 @@ static int test_cp_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -2334,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);
@@ -2343,7 +4853,6 @@ static int test_cp_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -2389,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");
@@ -2399,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);
@@ -2429,7 +4940,6 @@ static int test_cp_2 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -2444,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);
@@ -2453,7 +4962,6 @@ static int test_cp_2 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -2509,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");
@@ -2519,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);
@@ -2549,7 +5059,6 @@ static int test_grub_install_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -2564,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);
@@ -2573,7 +5081,6 @@ static int test_grub_install_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -2585,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);
@@ -2611,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");
@@ -2621,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);
@@ -2651,7 +5159,6 @@ static int test_zero_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -2666,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);
@@ -2675,7 +5181,6 @@ static int test_zero_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -2687,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);
@@ -2696,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);
@@ -2705,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);
@@ -2724,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");
@@ -2734,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);
@@ -2764,7 +5268,6 @@ static int test_fsck_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -2779,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);
@@ -2788,7 +5290,6 @@ static int test_fsck_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -2799,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);
@@ -2809,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);
@@ -2827,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");
@@ -2837,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);
@@ -2867,7 +5368,6 @@ static int test_fsck_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -2882,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);
@@ -2891,7 +5390,6 @@ static int test_fsck_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -2902,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);
@@ -2911,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);
@@ -2921,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);
@@ -2939,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");
@@ -2949,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);
@@ -2979,7 +5476,6 @@ static int test_set_e2uuid_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -2994,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);
@@ -3003,7 +5498,6 @@ static int test_set_e2uuid_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -3015,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;
@@ -3025,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);
@@ -3044,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");
@@ -3054,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);
@@ -3084,7 +5578,6 @@ static int test_set_e2uuid_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -3099,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);
@@ -3108,7 +5600,6 @@ static int test_set_e2uuid_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -3120,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;
@@ -3130,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);
@@ -3149,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");
@@ -3159,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);
@@ -3189,7 +5680,6 @@ static int test_set_e2uuid_2 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -3204,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);
@@ -3213,7 +5702,6 @@ static int test_set_e2uuid_2 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -3224,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;
@@ -3239,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");
@@ -3249,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);
@@ -3279,7 +5768,6 @@ static int test_set_e2uuid_3 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -3294,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);
@@ -3303,7 +5790,6 @@ static int test_set_e2uuid_3 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -3314,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;
@@ -3329,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");
@@ -3339,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);
@@ -3369,7 +5856,6 @@ static int test_set_e2label_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -3384,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);
@@ -3393,7 +5878,6 @@ static int test_set_e2label_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -3405,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;
@@ -3415,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);
@@ -3434,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");
@@ -3444,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);
@@ -3472,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,
@@ -3489,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);
@@ -3499,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
@@ -3538,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);
@@ -3568,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");
@@ -3578,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);
@@ -3606,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,
@@ -3623,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);
@@ -3633,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
@@ -3672,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);
@@ -3702,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");
@@ -3712,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);
@@ -3740,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,
@@ -3757,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);
@@ -3767,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
@@ -3806,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);
@@ -3836,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");
@@ -3846,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);
@@ -3877,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,
@@ -3891,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);
@@ -3901,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
@@ -3961,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");
@@ -3971,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);
@@ -4002,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,
@@ -4016,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);
@@ -4026,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
@@ -4086,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");
@@ -4096,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);
@@ -4127,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,
@@ -4141,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);
@@ -4151,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
@@ -4223,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");
@@ -4233,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);
@@ -4264,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,
@@ -4278,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);
@@ -4288,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
@@ -4348,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");
@@ -4358,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);
@@ -4389,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,
@@ -4403,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);
@@ -4413,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
@@ -4485,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");
@@ -4495,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);
@@ -4525,7 +6998,6 @@ static int test_mount_ro_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -4540,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);
@@ -4549,7 +7020,6 @@ static int test_mount_ro_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -4568,7 +7038,6 @@ static int test_mount_ro_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -4591,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");
@@ -4601,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);
@@ -4631,7 +7102,6 @@ static int test_mount_ro_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -4646,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);
@@ -4655,7 +7124,6 @@ static int test_mount_ro_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -4684,7 +7152,6 @@ static int test_mount_ro_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -4712,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");
@@ -4722,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);
@@ -4752,7 +7221,6 @@ static int test_tgz_in_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -4767,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);
@@ -4776,7 +7243,6 @@ static int test_tgz_in_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -4814,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");
@@ -4824,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);
@@ -4854,7 +7322,6 @@ static int test_tar_in_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -4869,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);
@@ -4878,7 +7344,6 @@ static int test_tar_in_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -4916,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");
@@ -4926,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);
@@ -4956,7 +7423,6 @@ static int test_checksum_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -4971,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);
@@ -4980,7 +7445,6 @@ static int test_checksum_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -5020,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");
@@ -5030,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);
@@ -5060,7 +7526,6 @@ static int test_checksum_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -5075,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);
@@ -5084,7 +7548,6 @@ static int test_checksum_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -5110,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");
@@ -5120,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);
@@ -5150,7 +7615,6 @@ static int test_checksum_2 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -5165,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);
@@ -5174,7 +7637,6 @@ static int test_checksum_2 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -5214,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");
@@ -5224,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);
@@ -5254,7 +7718,6 @@ static int test_checksum_3 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -5269,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);
@@ -5278,7 +7740,6 @@ static int test_checksum_3 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -5318,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");
@@ -5328,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);
@@ -5358,7 +7821,6 @@ static int test_checksum_4 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -5373,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);
@@ -5382,7 +7843,6 @@ static int test_checksum_4 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -5422,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");
@@ -5432,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);
@@ -5462,7 +7924,6 @@ static int test_checksum_5 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -5477,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);
@@ -5486,7 +7946,6 @@ static int test_checksum_5 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -5526,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");
@@ -5536,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);
@@ -5566,7 +8027,6 @@ static int test_checksum_6 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -5581,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);
@@ -5590,7 +8049,6 @@ static int test_checksum_6 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -5630,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");
@@ -5640,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);
@@ -5670,7 +8130,6 @@ static int test_checksum_7 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -5685,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);
@@ -5694,7 +8152,6 @@ static int test_checksum_7 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -5734,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");
@@ -5744,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);
@@ -5774,7 +8233,6 @@ static int test_checksum_8 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -5789,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);
@@ -5798,7 +8255,6 @@ static int test_checksum_8 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -5809,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;
   }
@@ -5839,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");
@@ -5849,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);
@@ -5879,7 +8338,6 @@ static int test_download_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -5894,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);
@@ -5903,7 +8360,6 @@ static int test_download_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -5958,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");
@@ -5968,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);
@@ -5998,7 +8456,6 @@ static int test_upload_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -6013,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);
@@ -6022,7 +8478,6 @@ static int test_upload_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -6061,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");
@@ -6071,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);
@@ -6102,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);
@@ -6116,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");
@@ -6126,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);
@@ -6157,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);
@@ -6171,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");
@@ -6181,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);
@@ -6212,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);
@@ -6230,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");
@@ -6240,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);
@@ -6271,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);
@@ -6289,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");
@@ -6299,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);
@@ -6330,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);
@@ -6348,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");
@@ -6358,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);
@@ -6389,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);
@@ -6407,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");
@@ -6417,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);
@@ -6448,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);
@@ -6457,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);
@@ -6475,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");
@@ -6485,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);
@@ -6516,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);
@@ -6525,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);
@@ -6543,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");
@@ -6553,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);
@@ -6584,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);
@@ -6593,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);
@@ -6611,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");
@@ -6621,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);
@@ -6651,7 +9114,6 @@ static int test_statvfs_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -6666,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);
@@ -6675,7 +9136,6 @@ static int test_statvfs_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -6715,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");
@@ -6725,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);
@@ -6755,7 +9217,6 @@ static int test_lstat_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -6770,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);
@@ -6779,7 +9239,6 @@ static int test_lstat_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -6817,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");
@@ -6827,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);
@@ -6857,7 +9318,6 @@ static int test_stat_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -6872,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);
@@ -6881,7 +9340,6 @@ static int test_stat_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -6919,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");
@@ -6929,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);
@@ -6959,7 +9419,6 @@ static int test_command_lines_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -6974,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);
@@ -6983,7 +9441,6 @@ static int test_command_lines_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -7050,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");
@@ -7060,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);
@@ -7090,7 +9549,6 @@ static int test_command_lines_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -7105,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);
@@ -7114,7 +9571,6 @@ static int test_command_lines_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -7181,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");
@@ -7191,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);
@@ -7221,7 +9679,6 @@ static int test_command_lines_2 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -7236,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);
@@ -7245,7 +9701,6 @@ static int test_command_lines_2 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -7324,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");
@@ -7334,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);
@@ -7364,7 +9821,6 @@ static int test_command_lines_3 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -7379,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);
@@ -7388,7 +9843,6 @@ static int test_command_lines_3 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -7467,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");
@@ -7477,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);
@@ -7507,7 +9963,6 @@ static int test_command_lines_4 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -7522,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);
@@ -7531,7 +9985,6 @@ static int test_command_lines_4 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -7622,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");
@@ -7632,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);
@@ -7662,7 +10117,6 @@ static int test_command_lines_5 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -7677,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);
@@ -7686,7 +10139,6 @@ static int test_command_lines_5 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -7789,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");
@@ -7799,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);
@@ -7829,7 +10283,6 @@ static int test_command_lines_6 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -7844,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);
@@ -7853,7 +10305,6 @@ static int test_command_lines_6 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -7908,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");
@@ -7918,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);
@@ -7948,7 +10401,6 @@ static int test_command_lines_7 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -7963,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);
@@ -7972,7 +10423,6 @@ static int test_command_lines_7 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -8039,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");
@@ -8049,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);
@@ -8079,7 +10531,6 @@ static int test_command_lines_8 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -8094,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);
@@ -8103,7 +10553,6 @@ static int test_command_lines_8 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -8182,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");
@@ -8192,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);
@@ -8222,7 +10673,6 @@ static int test_command_lines_9 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -8237,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);
@@ -8246,7 +10695,6 @@ static int test_command_lines_9 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -8325,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");
@@ -8335,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);
@@ -8365,7 +10815,6 @@ static int test_command_lines_10 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -8380,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);
@@ -8389,7 +10837,6 @@ static int test_command_lines_10 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -8468,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");
@@ -8478,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);
@@ -8508,7 +10957,6 @@ static int test_command_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -8523,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);
@@ -8532,7 +10979,6 @@ static int test_command_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -8584,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");
@@ -8594,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);
@@ -8624,7 +11072,6 @@ static int test_command_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -8639,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);
@@ -8648,7 +11094,6 @@ static int test_command_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -8700,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");
@@ -8710,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);
@@ -8740,7 +11187,6 @@ static int test_command_2 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -8755,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);
@@ -8764,7 +11209,6 @@ static int test_command_2 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -8816,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");
@@ -8826,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);
@@ -8856,7 +11302,6 @@ static int test_command_3 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -8871,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);
@@ -8880,7 +11324,6 @@ static int test_command_3 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -8932,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");
@@ -8942,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);
@@ -8972,7 +11417,6 @@ static int test_command_4 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -8987,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);
@@ -8996,7 +11439,6 @@ static int test_command_4 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -9048,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");
@@ -9058,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);
@@ -9088,7 +11532,6 @@ static int test_command_5 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -9103,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);
@@ -9112,7 +11554,6 @@ static int test_command_5 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -9164,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");
@@ -9174,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);
@@ -9204,7 +11647,6 @@ static int test_command_6 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -9219,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);
@@ -9228,7 +11669,6 @@ static int test_command_6 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -9280,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");
@@ -9290,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);
@@ -9320,7 +11762,6 @@ static int test_command_7 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -9335,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);
@@ -9344,7 +11784,6 @@ static int test_command_7 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -9396,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");
@@ -9406,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);
@@ -9436,7 +11877,6 @@ static int test_command_8 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -9451,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);
@@ -9460,7 +11899,6 @@ static int test_command_8 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -9512,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");
@@ -9522,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);
@@ -9552,7 +11992,6 @@ static int test_command_9 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -9567,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);
@@ -9576,7 +12014,6 @@ static int test_command_9 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -9628,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");
@@ -9638,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);
@@ -9668,7 +12107,6 @@ static int test_command_10 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -9683,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);
@@ -9692,7 +12129,6 @@ static int test_command_10 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -9744,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");
@@ -9754,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);
@@ -9784,7 +12222,6 @@ static int test_command_11 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -9799,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);
@@ -9808,7 +12244,6 @@ static int test_command_11 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -9853,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");
@@ -9863,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);
@@ -9893,7 +12330,6 @@ static int test_file_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -9908,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);
@@ -9917,7 +12352,6 @@ static int test_file_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -9955,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");
@@ -9965,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);
@@ -9995,7 +12431,6 @@ static int test_file_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -10010,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);
@@ -10019,7 +12453,6 @@ static int test_file_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -10058,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");
@@ -10068,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);
@@ -10098,7 +12533,6 @@ static int test_file_2 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -10113,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);
@@ -10122,7 +12555,6 @@ static int test_file_2 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -10147,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");
@@ -10157,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);
@@ -10187,7 +12621,6 @@ static int test_umount_all_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -10202,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);
@@ -10211,7 +12643,6 @@ static int test_umount_all_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -10250,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");
@@ -10260,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);
@@ -10291,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[] = ",";
@@ -10310,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);
@@ -10320,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);
@@ -10330,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);
@@ -10339,7 +12768,6 @@ static int test_umount_all_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -10357,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;
@@ -10375,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;
@@ -10421,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");
@@ -10431,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);
@@ -10461,7 +12889,6 @@ static int test_mounts_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -10476,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);
@@ -10485,7 +12911,6 @@ static int test_mounts_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -10493,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;
@@ -10508,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;
@@ -10530,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");
@@ -10540,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);
@@ -10568,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,
@@ -10586,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);
@@ -10595,7 +13020,6 @@ static int test_umount_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -10617,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;
@@ -10639,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");
@@ -10649,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);
@@ -10680,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,
@@ -10695,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);
@@ -10704,7 +13128,6 @@ static int test_umount_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -10743,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");
@@ -10753,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);
@@ -10783,7 +13208,6 @@ static int test_write_file_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -10798,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);
@@ -10807,7 +13230,6 @@ static int test_write_file_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -10846,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");
@@ -10856,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);
@@ -10886,7 +13310,6 @@ static int test_write_file_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -10901,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);
@@ -10910,7 +13332,6 @@ static int test_write_file_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -10949,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");
@@ -10959,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);
@@ -10989,7 +13412,6 @@ static int test_write_file_2 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -11004,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);
@@ -11013,7 +13434,6 @@ static int test_write_file_2 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -11052,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");
@@ -11062,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);
@@ -11092,7 +13514,6 @@ static int test_write_file_3 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -11107,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);
@@ -11116,7 +13536,6 @@ static int test_write_file_3 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -11155,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");
@@ -11165,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);
@@ -11195,7 +13616,6 @@ static int test_write_file_4 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -11210,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);
@@ -11219,7 +13638,6 @@ static int test_write_file_4 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -11258,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");
@@ -11268,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);
@@ -11298,7 +13718,6 @@ static int test_write_file_5 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -11313,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);
@@ -11322,7 +13740,6 @@ static int test_write_file_5 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -11361,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");
@@ -11371,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);
@@ -11403,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,
@@ -11418,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);
@@ -11427,7 +13844,6 @@ static int test_mkfs_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -11464,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");
@@ -11474,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);
@@ -11505,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[] = ",";
@@ -11523,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);
@@ -11532,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);
@@ -11541,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);
@@ -11551,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,
@@ -11568,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
@@ -11707,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");
@@ -11717,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);
@@ -11748,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[] = ",";
@@ -11766,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);
@@ -11775,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);
@@ -11784,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);
@@ -11794,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,
@@ -11811,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
@@ -11869,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");
@@ -11879,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);
@@ -11907,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[] = ",";
@@ -11928,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);
@@ -11937,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);
@@ -11946,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);
@@ -11967,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;
@@ -11980,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;
@@ -11993,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;
@@ -12015,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");
@@ -12025,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);
@@ -12055,7 +14461,6 @@ static int test_is_dir_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -12070,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);
@@ -12079,7 +14483,6 @@ static int test_is_dir_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -12115,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");
@@ -12125,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);
@@ -12155,7 +14560,6 @@ static int test_is_dir_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -12170,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);
@@ -12179,7 +14582,6 @@ static int test_is_dir_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -12215,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");
@@ -12225,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);
@@ -12255,7 +14659,6 @@ static int test_is_file_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -12270,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);
@@ -12279,7 +14681,6 @@ static int test_is_file_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -12315,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");
@@ -12325,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);
@@ -12355,7 +14758,6 @@ static int test_is_file_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -12370,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);
@@ -12379,7 +14780,6 @@ static int test_is_file_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -12415,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");
@@ -12425,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);
@@ -12455,7 +14857,6 @@ static int test_exists_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -12470,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);
@@ -12479,7 +14879,6 @@ static int test_exists_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -12515,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");
@@ -12525,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);
@@ -12555,7 +14956,6 @@ static int test_exists_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -12570,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);
@@ -12579,7 +14978,6 @@ static int test_exists_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -12615,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");
@@ -12625,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);
@@ -12655,7 +15055,6 @@ static int test_mkdir_p_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -12670,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);
@@ -12679,7 +15077,6 @@ static int test_mkdir_p_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -12715,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");
@@ -12725,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);
@@ -12755,7 +15154,6 @@ static int test_mkdir_p_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -12770,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);
@@ -12779,7 +15176,6 @@ static int test_mkdir_p_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -12815,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");
@@ -12825,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);
@@ -12855,7 +15253,6 @@ static int test_mkdir_p_2 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -12870,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);
@@ -12879,7 +15275,6 @@ static int test_mkdir_p_2 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -12915,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");
@@ -12925,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);
@@ -12955,7 +15352,6 @@ static int test_mkdir_p_3 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -12970,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);
@@ -12979,7 +15374,6 @@ static int test_mkdir_p_3 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -13011,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");
@@ -13021,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);
@@ -13051,7 +15447,6 @@ static int test_mkdir_p_4 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -13066,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);
@@ -13075,7 +15469,6 @@ static int test_mkdir_p_4 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -13107,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");
@@ -13117,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);
@@ -13147,7 +15542,6 @@ static int test_mkdir_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -13162,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);
@@ -13171,7 +15564,6 @@ static int test_mkdir_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -13207,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");
@@ -13217,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);
@@ -13247,7 +15641,6 @@ static int test_mkdir_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -13262,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);
@@ -13271,7 +15663,6 @@ static int test_mkdir_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -13295,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");
@@ -13305,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);
@@ -13335,7 +15728,6 @@ static int test_rm_rf_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -13350,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);
@@ -13359,7 +15750,6 @@ static int test_rm_rf_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -13419,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");
@@ -13429,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);
@@ -13459,7 +15851,6 @@ static int test_rmdir_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -13474,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);
@@ -13483,7 +15873,6 @@ static int test_rmdir_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -13515,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");
@@ -13525,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);
@@ -13555,7 +15946,6 @@ static int test_rmdir_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -13570,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);
@@ -13579,7 +15968,6 @@ static int test_rmdir_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -13603,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");
@@ -13613,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);
@@ -13643,7 +16033,6 @@ static int test_rmdir_2 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -13658,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);
@@ -13667,7 +16055,6 @@ static int test_rmdir_2 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -13699,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");
@@ -13709,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);
@@ -13739,7 +16128,6 @@ static int test_rm_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -13754,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);
@@ -13763,7 +16150,6 @@ static int test_rm_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -13795,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");
@@ -13805,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);
@@ -13835,7 +16223,6 @@ static int test_rm_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -13850,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);
@@ -13859,7 +16245,6 @@ static int test_rm_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -13883,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");
@@ -13893,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);
@@ -13923,7 +16310,6 @@ static int test_rm_2 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -13938,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);
@@ -13947,7 +16332,6 @@ static int test_rm_2 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -13979,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");
@@ -13989,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);
@@ -14019,7 +16405,6 @@ static int test_read_lines_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -14034,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);
@@ -14043,7 +16427,6 @@ static int test_read_lines_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -14121,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");
@@ -14131,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);
@@ -14161,7 +16546,6 @@ static int test_read_lines_1 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -14176,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);
@@ -14185,7 +16568,6 @@ static int test_read_lines_1 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -14227,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");
@@ -14237,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);
@@ -14267,7 +16651,6 @@ static int test_lvs_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -14281,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);
@@ -14291,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
@@ -14365,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");
@@ -14375,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);
@@ -14406,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[] = ",";
@@ -14424,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);
@@ -14433,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);
@@ -14442,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);
@@ -14452,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,
@@ -14469,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
@@ -14566,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");
@@ -14576,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);
@@ -14606,7 +16984,6 @@ static int test_vgs_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -14620,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);
@@ -14630,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
@@ -14704,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");
@@ -14714,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);
@@ -14745,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[] = ",";
@@ -14763,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);
@@ -14772,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);
@@ -14781,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);
@@ -14791,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,
@@ -14808,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
@@ -14866,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");
@@ -14876,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);
@@ -14906,7 +17278,6 @@ static int test_pvs_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -14920,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);
@@ -14930,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
@@ -14968,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;
@@ -14983,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;
@@ -15005,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");
@@ -15015,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);
@@ -15043,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[] = ",";
@@ -15064,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);
@@ -15073,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);
@@ -15082,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);
@@ -15103,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;
@@ -15116,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;
@@ -15129,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;
@@ -15151,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");
@@ -15161,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);
@@ -15191,7 +17560,6 @@ static int test_list_partitions_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -15206,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);
@@ -15215,7 +17582,6 @@ static int test_list_partitions_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -15223,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;
@@ -15238,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;
@@ -15260,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");
@@ -15270,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);
@@ -15298,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[] = ",";
@@ -15331,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;
@@ -15344,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;
@@ -15357,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;
@@ -15379,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");
@@ -15389,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);
@@ -15417,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;
@@ -15432,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;
@@ -15445,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;
@@ -15458,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;
@@ -15471,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;
@@ -15493,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");
@@ -15503,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);
@@ -15533,7 +17904,6 @@ static int test_ls_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -15548,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);
@@ -15557,7 +17926,6 @@ static int test_ls_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -15662,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");
@@ -15672,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);
@@ -15702,7 +18072,6 @@ static int test_cat_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -15717,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);
@@ -15726,7 +18094,6 @@ static int test_cat_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -15765,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");
@@ -15775,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);
@@ -15805,7 +18174,6 @@ static int test_touch_0 (void)
   }
   {
     char device[] = "/dev/sda";
-    device[5] = devchar;
     char lines_0[] = ",";
     char *lines[] = {
       lines_0,
@@ -15820,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);
@@ -15829,7 +18196,6 @@ static int test_touch_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -15865,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");
@@ -15875,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);
@@ -15918,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");
@@ -15928,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);
@@ -15960,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,
@@ -15975,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);
@@ -15984,7 +18352,6 @@ static int test_mount_0 (void)
   }
   {
     char device[] = "/dev/sda1";
-    device[5] = devchar;
     char mountpoint[] = "/";
     int r;
     suppress_error = 0;
@@ -16022,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 ();
 
@@ -16131,36 +18497,141 @@ int main (int argc, char *argv[])
     printf ("guestfs_launch FAILED\n");
     exit (1);
   }
+
+  /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */
+  alarm (600);
+
   if (guestfs_wait_ready (g) == -1) {
     printf ("guestfs_wait_ready FAILED\n");
     exit (1);
   }
 
-  /* Detect if the appliance uses /dev/sd* or /dev/hd* in device
-   * names.  This changed between RHEL 5 and RHEL 6 so we have to
-   * support both.
-   */
-  devs = guestfs_list_devices (g);
-  if (devs == NULL || devs[0] == NULL) {
-    printf ("guestfs_list_devices FAILED\n");
-    exit (1);
-  }
-  if (strncmp (devs[0], "/dev/sd", 7) == 0)
-    devchar = 's';
-  else if (strncmp (devs[0], "/dev/hd", 7) == 0)
-    devchar = 'h';
-  else {
-    printf ("guestfs_list_devices returned unexpected string '%s'\n",
-            devs[0]);
-    exit (1);
-  }
-  for (i = 0; devs[i] != NULL; ++i)
-    free (devs[i]);
-  free (devs);
+  /* Cancel previous alarm. */
+  alarm (0);
 
-  nr_tests = 143;
+  nr_tests = 164;
 
   test_num++;
+  printf ("%3d/%3d test_tail_n_0\n", test_num, nr_tests);
+  if (test_tail_n_0 () == -1) {
+    printf ("test_tail_n_0 FAILED\n");
+    failed++;
+  }
+  test_num++;
+  printf ("%3d/%3d test_tail_n_1\n", test_num, nr_tests);
+  if (test_tail_n_1 () == -1) {
+    printf ("test_tail_n_1 FAILED\n");
+    failed++;
+  }
+  test_num++;
+  printf ("%3d/%3d test_tail_n_2\n", test_num, nr_tests);
+  if (test_tail_n_2 () == -1) {
+    printf ("test_tail_n_2 FAILED\n");
+    failed++;
+  }
+  test_num++;
+  printf ("%3d/%3d test_tail_0\n", test_num, nr_tests);
+  if (test_tail_0 () == -1) {
+    printf ("test_tail_0 FAILED\n");
+    failed++;
+  }
+  test_num++;
+  printf ("%3d/%3d test_head_n_0\n", test_num, nr_tests);
+  if (test_head_n_0 () == -1) {
+    printf ("test_head_n_0 FAILED\n");
+    failed++;
+  }
+  test_num++;
+  printf ("%3d/%3d test_head_n_1\n", test_num, nr_tests);
+  if (test_head_n_1 () == -1) {
+    printf ("test_head_n_1 FAILED\n");
+    failed++;
+  }
+  test_num++;
+  printf ("%3d/%3d test_head_n_2\n", test_num, nr_tests);
+  if (test_head_n_2 () == -1) {
+    printf ("test_head_n_2 FAILED\n");
+    failed++;
+  }
+  test_num++;
+  printf ("%3d/%3d test_head_0\n", test_num, nr_tests);
+  if (test_head_0 () == -1) {
+    printf ("test_head_0 FAILED\n");
+    failed++;
+  }
+  test_num++;
+  printf ("%3d/%3d test_wc_c_0\n", test_num, nr_tests);
+  if (test_wc_c_0 () == -1) {
+    printf ("test_wc_c_0 FAILED\n");
+    failed++;
+  }
+  test_num++;
+  printf ("%3d/%3d test_wc_w_0\n", test_num, nr_tests);
+  if (test_wc_w_0 () == -1) {
+    printf ("test_wc_w_0 FAILED\n");
+    failed++;
+  }
+  test_num++;
+  printf ("%3d/%3d test_wc_l_0\n", test_num, nr_tests);
+  if (test_wc_l_0 () == -1) {
+    printf ("test_wc_l_0 FAILED\n");
+    failed++;
+  }
+  test_num++;
+  printf ("%3d/%3d test_mkdtemp_0\n", test_num, nr_tests);
+  if (test_mkdtemp_0 () == -1) {
+    printf ("test_mkdtemp_0 FAILED\n");
+    failed++;
+  }
+  test_num++;
+  printf ("%3d/%3d test_scrub_file_0\n", test_num, nr_tests);
+  if (test_scrub_file_0 () == -1) {
+    printf ("test_scrub_file_0 FAILED\n");
+    failed++;
+  }
+  test_num++;
+  printf ("%3d/%3d test_scrub_device_0\n", test_num, nr_tests);
+  if (test_scrub_device_0 () == -1) {
+    printf ("test_scrub_device_0 FAILED\n");
+    failed++;
+  }
+  test_num++;
+  printf ("%3d/%3d test_glob_expand_0\n", test_num, nr_tests);
+  if (test_glob_expand_0 () == -1) {
+    printf ("test_glob_expand_0 FAILED\n");
+    failed++;
+  }
+  test_num++;
+  printf ("%3d/%3d test_glob_expand_1\n", test_num, nr_tests);
+  if (test_glob_expand_1 () == -1) {
+    printf ("test_glob_expand_1 FAILED\n");
+    failed++;
+  }
+  test_num++;
+  printf ("%3d/%3d test_glob_expand_2\n", test_num, nr_tests);
+  if (test_glob_expand_2 () == -1) {
+    printf ("test_glob_expand_2 FAILED\n");
+    failed++;
+  }
+  test_num++;
+  printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
+  if (test_ntfs_3g_probe_0 () == -1) {
+    printf ("test_ntfs_3g_probe_0 FAILED\n");
+    failed++;
+  }
+  test_num++;
+  printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
+  if (test_ntfs_3g_probe_1 () == -1) {
+    printf ("test_ntfs_3g_probe_1 FAILED\n");
+    failed++;
+  }
+  test_num++;
+  printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
+  if (test_sleep_0 () == -1) {
+    printf ("test_sleep_0 FAILED\n");
+    failed++;
+  }
+  test_num++;
   printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
   if (test_find_0 () == -1) {
     printf ("test_find_0 FAILED\n");
@@ -16197,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");