[svn-r29205] Merge from trunk:

r28635, 28902, 29030, 29034, 29035, 29119, 29132, 29158

Tested on: 64-bit Ubuntu 15.10 (Linux 4.2.0 x86_64) gcc 5.2.1
           autotools serial (debug w/ C++ & Fortran)

5 files changed, 909 insertions, 623 deletions

diff --git a/test/external.c b/test/external.c
index cbc9fc6..181f43b 100644
--- a/test/external.c
+++ b/test/external.c
@@ -17,977 +17,955 @@
  * Programmer:  Robb Matzke <matzke@llnl.gov>
  *              Tuesday, March  3, 1998
  *
- * Purpose:	Tests datasets stored in external raw files.
+ * Purpose:     Tests datasets stored in external raw files.
  */
 #include "h5test.h"
-#include "H5srcdir.h"
-
-/* File for external link test.  Created with gen_udlinks.c */
-#define LINKED_FILE  "be_extlink2.h5"
 
 const char *FILENAME[] = {
     "extern_1",
     "extern_2",
     "extern_3",
-    "extern_4",
     NULL
 };
 
 
 /*-------------------------------------------------------------------------
- * Function:	same_contents
- *
- * Purpose:	Determines whether two files are exactly the same.
+ * Function:    files_have_same_contents
  *
- * Return:	Success:	nonzero if same, zero if different.
+ * Purpose:     Determines whether two files contain the same data.
  *
- *		Failure:	zero
+ * Return:      Success:    nonzero if same, zero if different.
+ *              Failure:    zero
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, March  4, 1998
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
-static int
-same_contents (const char *name1, const char *name2)
+static hbool_t
+files_have_same_contents(const char *name1, const char *name2)
 {
-    int		fd1, fd2;
-    ssize_t	n1, n2;
-    char	buf1[1024], buf2[1024];
+    int     fd1 = 0, fd2 = 0;
+    ssize_t n1, n2;
+    char    buf1[1024], buf2[1024];
+    hbool_t ret = false;            /* not equal until proven otherwise */
 
-    fd1 = HDopen(name1, O_RDONLY, 0666);
-    fd2 = HDopen(name2, O_RDONLY, 0666);
-    assert(fd1 >= 0 && fd2 >= 0);
+    if((fd1 = HDopen(name1, O_RDONLY, 0666)) < 0)
+        goto out;
+    if((fd2 = HDopen(name2, O_RDONLY, 0666)) < 0)
+        goto out;
 
+    /* Loop until files are empty or we encounter a problem */
     while(1) {
-        /* Asserts will catch negative return values */
+        HDmemset(buf1, 0, sizeof(buf1));
+        HDmemset(buf2, 0, sizeof(buf2));
+
         n1 = HDread(fd1, buf1, sizeof(buf1));
+        if(n1 < 0 || (size_t)n1 > sizeof(buf1))
+            break;
         n2 = HDread(fd2, buf2, sizeof(buf2));
-        assert(n1 >= 0 && (size_t)n1 <= sizeof(buf1));
-        assert(n2 >= 0 && (size_t)n2 <= sizeof(buf2));
-        assert(n1 == n2);
+        if(n2 < 0 || (size_t)n2 > sizeof(buf2))
+            break;
+
+        if(n1 != n2)
+            break;
 
-        if(n1 == 0 && n2 == 0)
+        if(n1 == 0 && n2 == 0) {
+            ret = true;
             break;
-        if(HDmemcmp(buf1, buf2, (size_t)n1)) {
-            HDclose(fd1);
-            HDclose(fd2);
-            return 0;
         }
-    }
-    HDclose(fd1);
-    HDclose(fd2);
-    return 1;
-}
+
+        if(HDmemcmp(buf1, buf2, (size_t)n1))
+            break;
+
+    } /* end while */
+
+out:
+    if(fd1)
+        HDclose(fd1);
+    if(fd2)
+        HDclose(fd2);
+    return ret;
+} /* end files_have_same_contents() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	test_1a
+ * Function:    test_non_extendible
  *
- * Purpose:	Tests a non-extendible dataset with a single external file.
+ * Purpose:     Tests a non-extendible dataset with a single external file.
  *
- * Return:	Success:	0
+ * Return:      Success:    0
+ *              Failure:    1
  *
- *		Failure:	number of errors
- *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Monday, November 23, 1998
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static int
-test_1a(hid_t file)
+test_non_extendible(hid_t file)
 {
-    hid_t	dcpl=-1;		/*dataset creation properties	*/
-    hid_t	space=-1;		/*data space			*/
-    hid_t	dset=-1;		/*dataset			*/
-    hsize_t	cur_size[1];		/*data space current size	*/
-    hsize_t	max_size[1];		/*data space maximum size	*/
-    int		n;			/*number of external files	*/
-    char	name[256];		/*external file name		*/
-    off_t	file_offset;		/*external file offset		*/
-    hsize_t	file_size;		/*sizeof external file segment	*/
-    haddr_t     dset_addr;              /*address of dataset            */
+    hid_t   dcpl = -1;          /* dataset creation properties          */
+    hid_t   space = -1;         /* data space                           */
+    hid_t   dset = -1;          /* dataset                              */
+    hsize_t cur_size[1];        /* data space current size              */
+    hsize_t max_size[1];        /* data space maximum size              */
+    int     n;                  /* number of external files             */
+    char    name[256];          /* external file name                   */
+    off_t   file_offset;        /* external file offset                 */
+    hsize_t file_size;          /* sizeof external file segment         */
+    haddr_t dset_addr;          /* address of dataset                   */
 
     TESTING("fixed-size data space, exact storage");
 
     /* Create the dataset */
-    if((dcpl = H5Pcreate(H5P_DATASET_CREATE)) < 0) goto error;
+    if((dcpl = H5Pcreate(H5P_DATASET_CREATE)) < 0)
+        FAIL_STACK_ERROR
     cur_size[0] = max_size[0] = 100;
-    if(H5Pset_external(dcpl, "ext1.data", (off_t)0,
-	(hsize_t)(max_size[0] * sizeof(int))) < 0) goto error;
-    if((space = H5Screate_simple(1, cur_size, max_size)) < 0) goto error;
+    if(H5Pset_external(dcpl, "ext1.data", (off_t)0, (hsize_t)(max_size[0] * sizeof(int))) < 0)
+        FAIL_STACK_ERROR
+    if((space = H5Screate_simple(1, cur_size, max_size)) < 0)
+        FAIL_STACK_ERROR
     if((dset = H5Dcreate2(file, "dset1", H5T_NATIVE_INT, space, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0)
-	goto error;
-    if(H5Dclose(dset) < 0) goto error;
-    if(H5Sclose(space) < 0) goto error;
-    if(H5Pclose(dcpl) < 0) goto error;
+        FAIL_STACK_ERROR
+    if(H5Dclose(dset) < 0)
+        FAIL_STACK_ERROR
+    if(H5Sclose(space) < 0)
+        FAIL_STACK_ERROR
+    if(H5Pclose(dcpl) < 0)
+        FAIL_STACK_ERROR
 
     /* Read dataset creation information */
-    if((dset = H5Dopen2(file, "dset1", H5P_DEFAULT)) < 0) goto error;
+    if((dset = H5Dopen2(file, "dset1", H5P_DEFAULT)) < 0)
+        FAIL_STACK_ERROR
 
     /* Test dataset address.  Should be undefined. */
     H5E_BEGIN_TRY {
         dset_addr = H5Dget_offset(dset);
     } H5E_END_TRY;
-    if(dset_addr != HADDR_UNDEF) goto error;
-
-    if((dcpl = H5Dget_create_plist(dset)) < 0) goto error;
-    if((n = H5Pget_external_count(dcpl)) < 0) goto error;
+    if(dset_addr != HADDR_UNDEF)
+        FAIL_STACK_ERROR
+
+    /* Check external count */
+    if((dcpl = H5Dget_create_plist(dset)) < 0)
+        FAIL_STACK_ERROR
+    if((n = H5Pget_external_count(dcpl)) < 0)
+        FAIL_STACK_ERROR
     if(1 != n) {
-	H5_FAILED();
-	puts("    Returned external count is wrong.");
-	printf("   got: %d\n    ans: 1\n", n);
-	goto error;
-    }
+        H5_FAILED();
+        HDputs("    Returned external count is wrong.");
+        printf("   got: %d\n    ans: 1\n", n);
+        goto error;
+    } /* end if */
+
     HDstrcpy(name + sizeof(name) - 4, "...");
-    if(H5Pget_external(dcpl, 0, sizeof(name) - 4, name, &file_offset,
-			 &file_size) < 0) goto error;
+    if(H5Pget_external(dcpl, 0, sizeof(name) - 4, name, &file_offset, &file_size) < 0)
+        FAIL_STACK_ERROR
+
+    /* Check file offset */
     if(file_offset != 0) {
-	H5_FAILED();
-	puts("    Wrong file offset.");
-	printf("    got: %lu\n    ans: 0\n", (unsigned long)file_offset);
-	goto error;
-    }
+        H5_FAILED();
+        HDputs("    Wrong file offset.");
+        printf("    got: %lu\n    ans: 0\n", (unsigned long)file_offset);
+        goto error;
+    } /* end if */
+
+    /* Check file size */
     if(file_size != (max_size[0] * sizeof(int))) {
-	H5_FAILED();
-	puts("    Wrong file size.");
-	printf("    got: %lu\n    ans: %lu\n", (unsigned long)file_size,
-		(unsigned long)max_size[0]*sizeof(int));
-	goto error;
-    }
-    if (H5Pclose (dcpl) < 0) goto error;
-    if (H5Dclose (dset) < 0) goto error;
+        H5_FAILED();
+        HDputs("    Wrong file size.");
+        printf("    got: %lu\n    ans: %lu\n", (unsigned long)file_size, (unsigned long)max_size[0]*sizeof(int));
+        goto error;
+    } /* end if */
+
+    /* Done (dataspace was previously closed) */
+    if(H5Pclose(dcpl) < 0) FAIL_STACK_ERROR
+    if(H5Dclose(dset) < 0) FAIL_STACK_ERROR
     PASSED();
     return 0;
+
  error:
     H5E_BEGIN_TRY {
-	H5Pclose(dcpl);
-	H5Sclose(space);
-	H5Dclose(dset);
+        H5Pclose(dcpl);
+        H5Sclose(space);
+        H5Dclose(dset);
     } H5E_END_TRY;
     return 1;
-}
+} /* end test_non_extendible() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	test_1b
+ * Function:    test_too_small
  *
- * Purpose:	Test a single external file which is too small to represent
- *		all the data.
+ * Purpose:     Test a single external file which is too small to represent
+ *              all the data.
  *
- * Return:	Success:	0
+ * Return:      Success:    0
+ *              Failure:    1
  *
- *		Failure:	number of errors
- *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Monday, November 23, 1998
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static int
-test_1b(hid_t file)
+test_too_small(hid_t file)
 {
-    hid_t	dcpl = -1;		/*dataset creation properties	*/
-    hid_t	space = -1;		/*data space			*/
-    hid_t	dset = -1;		/*dataset			*/
-    hsize_t	cur_size[1];		/*current data space size	*/
-    hsize_t	max_size[1];		/*maximum data space size	*/
+    hid_t   dcpl = -1;          /* dataset creation properties          */
+    hid_t   space = -1;         /* data space                           */
+    hid_t   dset = -1;          /* dataset                              */
+    hsize_t cur_size[1];        /* current data space size              */
+    hsize_t max_size[1];        /* maximum data space size              */
 
     TESTING("external storage is too small");
-    if((dcpl = H5Pcreate(H5P_DATASET_CREATE)) < 0) goto error;
+
+    if((dcpl = H5Pcreate(H5P_DATASET_CREATE)) < 0)
+        FAIL_STACK_ERROR
     cur_size[0] = max_size[0] = 100;
-    if(H5Pset_external(dcpl, "ext1.data", (off_t)0,
-	(hsize_t)(max_size[0] * sizeof(int) - 1)) < 0) goto error;
-    if((space = H5Screate_simple(1, cur_size, max_size)) < 0) goto error;
+    if(H5Pset_external(dcpl, "ext1.data", (off_t)0, (hsize_t)(max_size[0] * sizeof(int) - 1)) < 0)
+        FAIL_STACK_ERROR
+    if((space = H5Screate_simple(1, cur_size, max_size)) < 0)
+        FAIL_STACK_ERROR
+
     H5E_BEGIN_TRY {
-	dset = H5Dcreate2(file, "dset2", H5T_NATIVE_INT, space, H5P_DEFAULT, dcpl, H5P_DEFAULT);
+        dset = H5Dcreate2(file, "dset2", H5T_NATIVE_INT, space, H5P_DEFAULT, dcpl, H5P_DEFAULT);
     } H5E_END_TRY;
-    if(dset >= 0) {
-	H5_FAILED();
-	puts("    Small external file succeeded instead of failing.");
-	goto error;
-    }
-    if(H5Sclose(space) < 0) goto error;
-    if(H5Pclose(dcpl) < 0) goto error;
+    if(dset >= 0)
+        FAIL_PUTS_ERROR("    Small external file succeeded instead of failing.");
+    if(H5Sclose(space) < 0)
+        FAIL_STACK_ERROR
+    if(H5Pclose(dcpl) < 0)
+        FAIL_STACK_ERROR
 
     PASSED();
     return 0;
 
  error:
     H5E_BEGIN_TRY {
-	H5Sclose(space);
-	H5Pclose(dcpl);
-	H5Dclose(dset);
+        H5Sclose(space);
+        H5Pclose(dcpl);
+        H5Dclose(dset);
     } H5E_END_TRY;
     return 1;
-}
+} /* end test_too_small() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	test_1c
+ * Function:    test_large_enough_current_eventual
  *
- * Purpose:	Test a single external file which is large enough to
- *		represent the current data and large enough to represent the
- *		eventual size of the data.
+ * Purpose:     Test a single external file which is large enough to
+ *              represent the current data and large enough to represent the
+ *              eventual size of the data.
  *
- * Return:	Success:	0
+ * Return:      Success:    0
+ *              Failure:    1
  *
- *		Failure:	number of errors
- *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Monday, November 23, 1998
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static int
-test_1c(hid_t file)
+test_large_enough_current_eventual(hid_t file)
 {
-    hid_t	dcpl=-1;		/*dataset creation properties	*/
-    hid_t	space=-1;		/*data space			*/
-    hid_t	dset=-1;		/*dataset			*/
-    hsize_t	cur_size[1];		/*current data space size       */
-    hsize_t	max_size[1];		/*maximum data space size	*/
+    hid_t   dcpl = -1;          /* dataset creation properties          */
+    hid_t   space = -1;         /* data space                           */
+    hid_t   dset = -1;          /* dataset                              */
+    hsize_t cur_size[1];        /* current data space size              */
+    hsize_t max_size[1];        /* maximum data space size              */
 
     TESTING("extendible dataspace, exact external size");
 
-    if((dcpl = H5Pcreate (H5P_DATASET_CREATE)) < 0) goto error;
+    if((dcpl = H5Pcreate (H5P_DATASET_CREATE)) < 0)
+        FAIL_STACK_ERROR
     cur_size[0] = 100;
     max_size[0] = 200;
-    if(H5Pset_external(dcpl, "ext1.data", (off_t)0,
-	(hsize_t)(max_size[0] * sizeof(int))) < 0) goto error;
-    if((space = H5Screate_simple(1, cur_size, max_size)) < 0) goto error;
+    if(H5Pset_external(dcpl, "ext1.data", (off_t)0, (hsize_t)(max_size[0] * sizeof(int))) < 0)
+        FAIL_STACK_ERROR
+    if((space = H5Screate_simple(1, cur_size, max_size)) < 0)
+        FAIL_STACK_ERROR
     if((dset = H5Dcreate2(file, "dset3", H5T_NATIVE_INT, space, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0)
-	goto error;
-    if(H5Dclose(dset) < 0) goto error;
-    if(H5Sclose(space) < 0) goto error;
-    if(H5Pclose(dcpl) < 0) goto error;
+        FAIL_STACK_ERROR
+
+    if(H5Dclose(dset) < 0) FAIL_STACK_ERROR
+    if(H5Sclose(space) < 0) FAIL_STACK_ERROR
+    if(H5Pclose(dcpl) < 0) FAIL_STACK_ERROR
 
     PASSED();
     return 0;
 
 error:
     H5E_BEGIN_TRY {
-	H5Dclose(dset);
-	H5Pclose(dcpl);
-	H5Sclose(space);
+        H5Dclose(dset);
+        H5Pclose(dcpl);
+        H5Sclose(space);
     } H5E_END_TRY;
     return 1;
-}
+} /* end test_large_enough_current_eventual() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	test_1d
- *
- * Purpose:	Test a single external file which is large enough for the
- *		current data size but not large enough for the eventual size.
+ * Function:    test_large_enough_current_not_eventual
  *
- * Return:	Success:	0
+ * Purpose:     Test a single external file which is large enough for the
+ *              current data size but not large enough for the eventual size.
  *
- *		Failure:	number of errors
+ * Return:      Success:    0
+ *              Failure:    1
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Monday, November 23, 1998
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static int
-test_1d(hid_t file)
+test_large_enough_current_not_eventual(hid_t file)
 {
-    hid_t	dcpl=-1;		/*dataset creation properties	*/
-    hid_t	space=-1;		/*data space			*/
-    hid_t	dset=-1;		/*dataset			*/
-    hsize_t	cur_size[1];		/*current data space size       */
-    hsize_t	max_size[1];		/*maximum data space size	*/
+    hid_t   dcpl = -1;          /* dataset creation properties          */
+    hid_t   space = -1;         /* data space                           */
+    hid_t   dset = -1;          /* dataset                              */
+    hsize_t cur_size[1];        /* current data space size              */
+    hsize_t max_size[1];        /* maximum data space size              */
 
     TESTING("extendible dataspace, external storage is too small");
 
-    if((dcpl = H5Pcreate(H5P_DATASET_CREATE)) < 0) goto error;
+    if((dcpl = H5Pcreate(H5P_DATASET_CREATE)) < 0)
+        FAIL_STACK_ERROR
     cur_size[0] = 100;
     max_size[0] = 200;
-    if(H5Pset_external(dcpl, "ext1.data", (off_t)0,
-	(hsize_t)(max_size[0] * sizeof(int) - 1)) < 0) goto error;
-    if((space = H5Screate_simple(1, cur_size, max_size)) < 0) goto error;
+    if(H5Pset_external(dcpl, "ext1.data", (off_t)0, (hsize_t)(max_size[0] * sizeof(int) - 1)) < 0)
+        FAIL_STACK_ERROR
+    if((space = H5Screate_simple(1, cur_size, max_size)) < 0)
+        FAIL_STACK_ERROR
+
     H5E_BEGIN_TRY {
-	dset = H5Dcreate2(file, "dset4", H5T_NATIVE_INT, space, H5P_DEFAULT, dcpl, H5P_DEFAULT);
+        dset = H5Dcreate2(file, "dset4", H5T_NATIVE_INT, space, H5P_DEFAULT, dcpl, H5P_DEFAULT);
     } H5E_END_TRY;
-    if(dset >= 0) {
-	H5_FAILED();
-	puts("    Small external file succeeded instead of failing.");
-	goto error;
-    }
-    if(H5Sclose(space) < 0) goto error;
-    if(H5Pclose(dcpl) < 0) goto error;
+    if(dset >= 0)
+        FAIL_PUTS_ERROR("    Small external file succeeded instead of failing.");
+
+    if(H5Sclose(space) < 0) FAIL_STACK_ERROR
+    if(H5Pclose(dcpl) < 0) FAIL_STACK_ERROR
 
     PASSED();
     return 0;
 
  error:
     H5E_BEGIN_TRY {
-	H5Dclose(dset);
-	H5Pclose(dcpl);
-	H5Sclose(space);
+        H5Dclose(dset);
+        H5Pclose(dcpl);
+        H5Sclose(space);
     } H5E_END_TRY;
     return 1;
-}
+} /* end test_large_enough_current_not_eventual() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	test_1e
- *
- * Purpose:	Test a single external file of unlimited size and an
- *		unlimited data space.
+ * Function:    test_1e
  *
- * Return:	Success:	0
+ * Purpose:     Test a single external file of unlimited size and an
+ *              unlimited data space.
  *
- *		Failure:	number of errors
+ * Return:      Success:    0
+ *              Failure:    1
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Monday, November 23, 1998
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static int
-test_1e(hid_t file)
+test_unlimited(hid_t file)
 {
-    hid_t	dcpl=-1;		/*dataset creation properties	*/
-    hid_t	space=-1;		/*data space			*/
-    hid_t	dset=-1;		/*dataset			*/
-    hsize_t	cur_size[1];		/*data space current size	*/
-    hsize_t	max_size[1];		/*data space maximum size	*/
-    int		n;			/*number of external files	*/
-    char	name[256];		/*external file name		*/
-    off_t	file_offset;		/*external file offset		*/
-    hsize_t	file_size;		/*sizeof external file segment	*/
+    hid_t   dcpl = -1;          /* dataset creation properties          */
+    hid_t   space = -1;         /* data space                           */
+    hid_t   dset = -1;          /* dataset                              */
+    hsize_t cur_size[1];        /* data space current size              */
+    hsize_t max_size[1];        /* data space maximum size              */
+    int     n;                  /* number of external files             */
+    char    name[256];          /* external file name                   */
+    off_t   file_offset;        /* external file offset                 */
+    hsize_t file_size;          /* sizeof external file segment         */
 
     TESTING("unlimited dataspace, unlimited external storage");
 
     /* Create dataset */
-    if((dcpl = H5Pcreate(H5P_DATASET_CREATE)) < 0) goto error;
-    if(H5Pset_external(dcpl, "ext1.data", (off_t)0, H5F_UNLIMITED) < 0) goto error;
+    if((dcpl = H5Pcreate(H5P_DATASET_CREATE)) < 0)
+        FAIL_STACK_ERROR
+    if(H5Pset_external(dcpl, "ext1.data", (off_t)0, H5F_UNLIMITED) < 0)
+        FAIL_STACK_ERROR
     cur_size[0] = 100;
     max_size[0] = H5S_UNLIMITED;
-    if((space = H5Screate_simple(1, cur_size, max_size)) < 0) goto error;
+    if((space = H5Screate_simple(1, cur_size, max_size)) < 0)
+        FAIL_STACK_ERROR
     if((dset = H5Dcreate2(file, "dset5", H5T_NATIVE_INT, space, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0)
-	goto error;
-    if(H5Dclose(dset) < 0) goto error;
-    if(H5Sclose(space) < 0) goto error;
-    if(H5Pclose(dcpl) < 0) goto error;
+        FAIL_STACK_ERROR
+
+    if(H5Dclose(dset) < 0) FAIL_STACK_ERROR
+    if(H5Sclose(space) < 0) FAIL_STACK_ERROR
+    if(H5Pclose(dcpl) < 0) FAIL_STACK_ERROR
 
     /* Read dataset creation information */
-    if((dset = H5Dopen2(file, "dset5", H5P_DEFAULT)) < 0) goto error;
-    if((dcpl = H5Dget_create_plist(dset)) < 0) goto error;
-    if((n = H5Pget_external_count(dcpl)) < 0) goto error;
+    if((dset = H5Dopen2(file, "dset5", H5P_DEFAULT)) < 0)
+        FAIL_STACK_ERROR
+    if((dcpl = H5Dget_create_plist(dset)) < 0)
+        FAIL_STACK_ERROR
+    if((n = H5Pget_external_count(dcpl)) < 0)
+        FAIL_STACK_ERROR
     if(1 != n) {
-	H5_FAILED();
-	puts("    Returned external count is wrong.");
-	printf("    got: %d\n    ans: 1\n", n);
-	goto error;
-    }
+        H5_FAILED();
+        HDputs("    Returned external count is wrong.");
+        printf("    got: %d\n    ans: 1\n", n);
+        goto error;
+    } /* end if */
+
     HDstrcpy(name + sizeof(name) - 4, "...");
-    if(H5Pget_external(dcpl, 0, sizeof(name) - 4, name, &file_offset,
-			 &file_size) < 0) goto error;
+    if(H5Pget_external(dcpl, 0, sizeof(name) - 4, name, &file_offset, &file_size) < 0)
+        FAIL_STACK_ERROR
     if(file_offset != 0) {
-	H5_FAILED();
-	puts("    Wrong file offset.");
-	printf("    got: %lu\n    ans: 0\n", (unsigned long)file_offset);
-	goto error;
-    }
+        H5_FAILED();
+        HDputs("    Wrong file offset.");
+        printf("    got: %lu\n    ans: 0\n", (unsigned long)file_offset);
+        goto error;
+    } /* end if */
+
     if(H5F_UNLIMITED != file_size) {
-	H5_FAILED();
-	puts("    Wrong file size.");
-	printf("    got: %lu\n    ans: INF\n", (unsigned long)file_size);
-	goto error;
-    }
-    if(H5Pclose(dcpl) < 0) goto error;
-    if(H5Dclose(dset) < 0) goto error;
+        H5_FAILED();
+        HDputs("    Wrong file size.");
+        printf("    got: %lu\n    ans: INF\n", (unsigned long)file_size);
+        goto error;
+    } /* end if */
+
+    if(H5Pclose(dcpl) < 0) FAIL_STACK_ERROR
+    if(H5Dclose(dset) < 0) FAIL_STACK_ERROR
 
     PASSED();
     return 0;
 
  error:
     H5E_BEGIN_TRY {
-	H5Dclose(dset);
-	H5Pclose(dcpl);
-	H5Sclose(space);
+        H5Dclose(dset);
+        H5Pclose(dcpl);
+        H5Sclose(space);
     } H5E_END_TRY;
     return 1;
-}
+} /* end test_unlimited() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	test_1f
- *
- * Purpose:	Test multiple external files for a dataset.
+ * Function:    test_multiple_files
  *
- * Return:	Success:	0
+ * Purpose:     Test multiple external files for a dataset.
  *
- *		Failure:	number of errors
+ * Return:      Success:    0
+ *              Failure:    1
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Monday, November 23, 1998
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static int
-test_1f(hid_t file)
+test_multiple_files(hid_t file)
 {
-    hid_t	dcpl=-1;		/*dataset creation properties	*/
-    hid_t	space=-1;		/*data space			*/
-    hid_t	dset=-1;		/*dataset			*/
-    hsize_t	cur_size[1];		/*data space current size	*/
-    hsize_t	max_size[1];		/*data space maximum size	*/
+    hid_t   dcpl = -1;          /* dataset creation properties          */
+    hid_t   space = -1;         /* dataspace                            */
+    hid_t   dset = -1;          /* dataset                              */
+    hsize_t cur_size[1];        /* data space current size              */
+    hsize_t max_size[1];        /* data space maximum size              */
 
     TESTING("multiple external files");
 
-    if((dcpl = H5Pcreate(H5P_DATASET_CREATE)) < 0) goto error;
+    if((dcpl = H5Pcreate(H5P_DATASET_CREATE)) < 0)
+        FAIL_STACK_ERROR
+
     cur_size[0] = max_size[0] = 100;
-    if(H5Pset_external(dcpl, "ext1.data", (off_t)0,
-	(hsize_t)(max_size[0]*sizeof(int)/4)) < 0) goto error;
-    if(H5Pset_external(dcpl, "ext2.data", (off_t)0,
-	(hsize_t)(max_size[0]*sizeof(int)/4)) < 0) goto error;
-    if(H5Pset_external(dcpl, "ext3.data", (off_t)0,
-	(hsize_t)(max_size[0]*sizeof(int)/4)) < 0) goto error;
-    if(H5Pset_external(dcpl, "ext4.data", (off_t)0,
-	(hsize_t)(max_size[0]*sizeof(int)/4)) < 0) goto error;
-    if((space = H5Screate_simple(1, cur_size, max_size)) < 0) goto error;
+
+    if(H5Pset_external(dcpl, "ext1.data", (off_t)0, (hsize_t)(max_size[0]*sizeof(int)/4)) < 0)
+        FAIL_STACK_ERROR
+    if(H5Pset_external(dcpl, "ext2.data", (off_t)0, (hsize_t)(max_size[0]*sizeof(int)/4)) < 0)
+        FAIL_STACK_ERROR
+    if(H5Pset_external(dcpl, "ext3.data", (off_t)0, (hsize_t)(max_size[0]*sizeof(int)/4)) < 0)
+        FAIL_STACK_ERROR
+    if(H5Pset_external(dcpl, "ext4.data", (off_t)0, (hsize_t)(max_size[0]*sizeof(int)/4)) < 0)
+        FAIL_STACK_ERROR
+    if((space = H5Screate_simple(1, cur_size, max_size)) < 0)
+        FAIL_STACK_ERROR
     if((dset = H5Dcreate2(file, "dset6", H5T_NATIVE_INT, space, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0)
-	goto error;
-    if(H5Dclose(dset) < 0) goto error;
-    if(H5Sclose(space) < 0) goto error;
-    if(H5Pclose(dcpl) < 0) goto error;
+        FAIL_STACK_ERROR
+
+    if(H5Dclose(dset) < 0) FAIL_STACK_ERROR
+    if(H5Sclose(space) < 0) FAIL_STACK_ERROR
+    if(H5Pclose(dcpl) < 0) FAIL_STACK_ERROR
 
     PASSED();
     return 0;
 
 error:
     H5E_BEGIN_TRY {
-	H5Dclose(dset);
-	H5Pclose(dcpl);
-	H5Sclose(space);
+        H5Dclose(dset);
+        H5Pclose(dcpl);
+        H5Sclose(space);
     } H5E_END_TRY;
     return 1;
-}
+} /* end test_multiple_files() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	test_1g
- *
- * Purpose:	It should be impossible to define an unlimited external file
- *		and then follow it with another external file.
+ * Function:    test_add_to_unlimited
  *
- * Return:	Success:	0
+ * Purpose:     It should be impossible to define an unlimited external file
+ *              and then follow it with another external file.
  *
- *		Failure:	number of errors
+ * Return:      Success:    0
+ *              Failure:    1
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Monday, November 23, 1998
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static int
-test_1g(void)
+test_add_to_unlimited(void)
 {
-    hid_t	dcpl=-1;		/*dataset creation properties	*/
-    herr_t	status;			/*function return status	*/
-    int		n;			/*number of external files	*/
+    hid_t   dcpl = -1;          /* dataset creation properties          */
+    herr_t  status;             /* function return status               */
+    int     n;                  /* number of external files             */
 
     TESTING("external file following unlimited file");
-    if ((dcpl=H5Pcreate (H5P_DATASET_CREATE)) < 0) goto error;
-    if (H5Pset_external(dcpl, "ext1.data", (off_t)0, H5F_UNLIMITED) < 0) goto error;
+
+    if((dcpl = H5Pcreate (H5P_DATASET_CREATE)) < 0)
+        FAIL_STACK_ERROR
+    if(H5Pset_external(dcpl, "ext1.data", (off_t)0, H5F_UNLIMITED) < 0)
+        FAIL_STACK_ERROR
+
     H5E_BEGIN_TRY {
-	status = H5Pset_external(dcpl, "ext2.data", (off_t)0, (hsize_t)100);
+        status = H5Pset_external(dcpl, "ext2.data", (off_t)0, (hsize_t)100);
     } H5E_END_TRY;
-    if (status>=0) {
-	H5_FAILED();
-	puts ("    H5Pset_external() succeeded when it should have failed.");
-	goto error;
-    }
-    if ((n = H5Pget_external_count(dcpl)) < 0) goto error;
-    if (1!=n) {
-	H5_FAILED();
-	puts("    Wrong external file count returned.");
-	goto error;
-    }
-    if (H5Pclose(dcpl) < 0) goto error;
+    if(status >= 0)
+        FAIL_PUTS_ERROR("    H5Pset_external() succeeded when it should have failed.");
+
+    if((n = H5Pget_external_count(dcpl)) < 0)
+        FAIL_STACK_ERROR
+    if(1 != n)
+        FAIL_PUTS_ERROR("    Wrong external file count returned.");
+
+    if(H5Pclose(dcpl) < 0) FAIL_STACK_ERROR
     PASSED();
     return 0;
 
  error:
     H5E_BEGIN_TRY {
-	H5Pclose(dcpl);
+        H5Pclose(dcpl);
     } H5E_END_TRY;
     return 1;
-}
+} /* end test_add_to_unlimited() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	test_1h
+ * Function:    test_overflow
  *
- * Purpose:	It should be impossible to create a set of external files
- *		whose total size overflows a size_t integer.
+ * Purpose:     It should be impossible to create a set of external files
+ *              whose total size overflows a size_t integer.
  *
- * Return:	Success:	0
+ * Return:      Success:    0
+ *              Failure:    1
  *
- *		Failure:	number of errors
- *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Monday, November 23, 1998
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static int
-test_1h(void)
+test_overflow(void)
 {
-    hid_t	dcpl=-1;		/*dataset creation properties	*/
-    herr_t	status;			/*return status			*/
+    hid_t   dcpl = -1;          /* dataset creation properties          */
+    herr_t  status;             /* return status                        */
 
     TESTING("address overflow in external files");
-    if((dcpl=H5Pcreate(H5P_DATASET_CREATE)) < 0) goto error;
-    if (H5Pset_external(dcpl, "ext1.data", (off_t)0, H5F_UNLIMITED-1) < 0) goto error;
+
+    if((dcpl=H5Pcreate(H5P_DATASET_CREATE)) < 0)
+        FAIL_STACK_ERROR
+    if(H5Pset_external(dcpl, "ext1.data", (off_t)0, H5F_UNLIMITED-1) < 0)
+        FAIL_STACK_ERROR
+
     H5E_BEGIN_TRY {
-	status = H5Pset_external(dcpl, "ext2.data", (off_t)0, (hsize_t)100);
+        status = H5Pset_external(dcpl, "ext2.data", (off_t)0, (hsize_t)100);
     } H5E_END_TRY;
-    if (status>=0) {
-	H5_FAILED();
-	puts("    H5Pset_external() succeeded when it should have failed.");
-	goto error;
-    }
-    if (H5Pclose(dcpl) < 0) goto error;
+    if(status >= 0)
+        FAIL_PUTS_ERROR("    H5Pset_external() succeeded when it should have failed.");
+
+    if(H5Pclose(dcpl) < 0) FAIL_STACK_ERROR
+
     PASSED();
     return 0;
 
  error:
     H5E_BEGIN_TRY {
-	H5Pclose(dcpl);
+        H5Pclose(dcpl);
     } H5E_END_TRY;
     return 1;
-}
+} /* end test_overflow() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	test_2
+ * Function:    test_read_file_set
  *
- * Purpose:	Tests reading from an external file set.
+ * Purpose:     Tests reading from an external file set.
  *
- * Return:	Success:	0
+ * Return:      Success:    0
+ *              Failure:    1
  *
- * 		Failure:	number of errors
- *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, March  4, 1998
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static int
-test_2 (hid_t fapl)
+test_read_file_set(hid_t fapl)
 {
-    hid_t	file=-1;		/*file to write to		*/
-    hid_t	dcpl=-1;		/*dataset creation properties	*/
-    hid_t	space=-1;		/*data space			*/
-    hid_t	dset=-1;		/*dataset			*/
-    hid_t	grp=-1;			/*group to emit diagnostics	*/
-    int		fd;			/*external file descriptors	*/
-    size_t	i, j;			/*miscellaneous counters	*/
-    hssize_t	n;			/*bytes of I/O			*/
-    char	filename[1024];		/*file names			*/
-    int		part[25], whole[100];	/*raw data buffers		*/
-    hsize_t	cur_size;		/*current data space size	*/
-    hid_t	hs_space;		/*hyperslab data space		*/
-    hsize_t	hs_start = 30;		/*hyperslab starting offset	*/
-    hsize_t	hs_count = 25;		/*hyperslab size		*/
-	int temparray[10] = {0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f};
+    hid_t   file = -1;          /* file to write to                     */
+    hid_t   dcpl = -1;          /* dataset creation properties          */
+    hid_t   space = -1;         /* data space                           */
+    hid_t   dset = -1;          /* dataset                              */
+    hid_t   grp = -1;           /* group to emit diagnostics            */
+    int     fd = -1;            /* external file descriptors            */
+    size_t  i, j;               /* miscellaneous counters               */
+    hssize_t    n;              /* bytes of I/O                         */
+    char    filename[1024];     /* file names                           */
+    int     part[25], whole[100];   /* raw data buffers                 */
+    hsize_t cur_size;           /* current data space size              */
+    hid_t   hs_space;           /* hyperslab data space                 */
+    hsize_t hs_start = 30;      /* hyperslab starting offset            */
+    hsize_t hs_count = 25;      /* hyperslab size                       */
+    int temparray[10] = {0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f};
 
     TESTING("read external dataset");
 
     /* Write the data to external files directly */
-    for (i=0; i<4; i++) {
-	for (j=0; j<25; j++) {
-	    part[j] = (int)(i*25+j);
-	}
-	sprintf (filename, "extern_%lua.raw", (unsigned long)i+1);
-	fd = HDopen(filename, O_RDWR|O_CREAT|O_TRUNC, 0666);
-	assert (fd>=0);
-/*	n = lseek (fd, (off_t)(i*10), SEEK_SET);
-*/
-	n = HDwrite(fd,temparray,(size_t)i*10);
-	assert (n>=0 && (size_t)n==i*10);
-	n = HDwrite(fd, part, sizeof(part));
-	assert (n==sizeof(part));
-	HDclose(fd);
-    }
+    for(i=0; i<4; i++) {
+        for(j=0; j<25; j++) {
+            part[j] = (int)(i*25+j);
+        } /* end for */
+        HDsprintf(filename, "extern_%lua.raw", (unsigned long)i+1);
+        if((fd = HDopen(filename, O_RDWR|O_CREAT|O_TRUNC, 0666)) < 0)
+            TEST_ERROR
+        n = HDwrite(fd, temparray, (size_t)i*10);
+        if(n < 0 || (size_t)n != i*10)
+            TEST_ERROR
+        n = HDwrite(fd, part, sizeof(part));
+        if(n != sizeof(part))
+        TEST_ERROR
+        HDclose(fd);
+    } /* end for */
 
     /*
      * Create the file and an initial group.  This causes messages about
      * debugging to be emitted before we start playing games with what the
      * output looks like.
      */
-    h5_fixname(FILENAME[1], fapl, filename, sizeof filename);
-    if((file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0) FAIL_STACK_ERROR
-    if((grp = H5Gcreate2(file, "emit-diagnostics", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) FAIL_STACK_ERROR
+    h5_fixname(FILENAME[1], fapl, filename, sizeof(filename));
+    if((file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
+        FAIL_STACK_ERROR
+    if((grp = H5Gcreate2(file, "emit-diagnostics", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+        FAIL_STACK_ERROR
     if(H5Gclose(grp) < 0) FAIL_STACK_ERROR
 
     /* Create the dataset */
-    if((dcpl = H5Pcreate(H5P_DATASET_CREATE)) < 0) goto error;
+    if((dcpl = H5Pcreate(H5P_DATASET_CREATE)) < 0)
+        FAIL_STACK_ERROR
     if(H5Pset_external(dcpl, "extern_1a.raw",  (off_t)0, (hsize_t)sizeof part) < 0 ||
             H5Pset_external(dcpl, "extern_2a.raw", (off_t)10, (hsize_t)sizeof part) < 0 ||
             H5Pset_external(dcpl, "extern_3a.raw", (off_t)20, (hsize_t)sizeof part) < 0 ||
             H5Pset_external(dcpl, "extern_4a.raw", (off_t)30, (hsize_t)sizeof part) < 0)
-	goto error;
+        FAIL_STACK_ERROR
     cur_size = 100;
-    if((space = H5Screate_simple(1, &cur_size, NULL)) < 0) goto error;
-    if((dset = H5Dcreate2(file, "dset1", H5T_NATIVE_INT, space, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0) goto error;
+    if((space = H5Screate_simple(1, &cur_size, NULL)) < 0)
+        FAIL_STACK_ERROR
+    if((dset = H5Dcreate2(file, "dset1", H5T_NATIVE_INT, space, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0)
+        FAIL_STACK_ERROR
 
     /*
      * Read the entire dataset and compare with the original
      */
-    memset(whole, 0, sizeof(whole));
-    if(H5Dread(dset, H5T_NATIVE_INT, space, space, H5P_DEFAULT, whole) < 0) goto error;
-    for(i = 0; i < 100; i++)
-	if(whole[i] != (signed)i) {
-	    H5_FAILED();
-	    puts("    Incorrect value(s) read.");
-	    goto error;
-	} /* end if */
-
-    /*
-     * Read the middle of the dataset
-     */
-    if((hs_space = H5Scopy(space)) < 0) goto error;
-    if(H5Sselect_hyperslab(hs_space, H5S_SELECT_SET, &hs_start, NULL,
-			    &hs_count, NULL) < 0) goto error;
     HDmemset(whole, 0, sizeof(whole));
-    if(H5Dread(dset, H5T_NATIVE_INT, hs_space, hs_space, H5P_DEFAULT,
-		 whole) < 0) goto error;
-    if(H5Sclose(hs_space) < 0) goto error;
-    for(i = hs_start; i<hs_start+hs_count; i++) {
-	if(whole[i] != (signed)i) {
-	    H5_FAILED();
-	    puts("    Incorrect value(s) read.");
-	    goto error;
-	}
-    }
-
-    if (H5Dclose(dset) < 0) goto error;
-    if (H5Pclose(dcpl) < 0) goto error;
-    if (H5Sclose(space) < 0) goto error;
-    if (H5Fclose(file) < 0) goto error;
+    if(H5Dread(dset, H5T_NATIVE_INT, space, space, H5P_DEFAULT, whole) < 0)
+        FAIL_STACK_ERROR
+    for(i = 0; i < 100; i++)
+        if(whole[i] != (signed)i)
+            FAIL_PUTS_ERROR("    Incorrect value(s) read.");
+
+        /* Read the middle of the dataset */
+        if((hs_space = H5Scopy(space)) < 0)
+            FAIL_STACK_ERROR
+        if(H5Sselect_hyperslab(hs_space, H5S_SELECT_SET, &hs_start, NULL, &hs_count, NULL) < 0)
+            FAIL_STACK_ERROR
+
+        HDmemset(whole, 0, sizeof(whole));
+        if(H5Dread(dset, H5T_NATIVE_INT, hs_space, hs_space, H5P_DEFAULT, whole) < 0)
+            FAIL_STACK_ERROR
+
+        if(H5Sclose(hs_space) < 0) FAIL_STACK_ERROR
+
+        for(i = hs_start; i<hs_start+hs_count; i++) {
+            if(whole[i] != (signed)i)
+                FAIL_PUTS_ERROR("    Incorrect value(s) read.");
+        } /* end for */
+
+    if(H5Dclose(dset) < 0) FAIL_STACK_ERROR
+    if(H5Pclose(dcpl) < 0) FAIL_STACK_ERROR
+    if(H5Sclose(space) < 0) FAIL_STACK_ERROR
+    if(H5Fclose(file) < 0) FAIL_STACK_ERROR
     PASSED();
     return 0;
 
  error:
     H5E_BEGIN_TRY {
-	H5Dclose(dset);
-	H5Pclose(dcpl);
-	H5Sclose(space);
-	H5Fclose(file);
+        H5Dclose(dset);
+        H5Pclose(dcpl);
+        H5Sclose(space);
+        H5Fclose(file);
     } H5E_END_TRY;
     return 1;
-}
+} /* end test_read_file_set() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	test_3
+ * Function:    test_write_file_set
  *
- * Purpose:	Tests writing to an external file set.
+ * Purpose:     Tests writing to an external file set.
  *
- * Return:	Success:	0
+ * Return:      Success:    0
+ *              Failure:    1
  *
- * 		Failure:	number of errors
- *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, March  4, 1998
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static int
-test_3 (hid_t fapl)
+test_write_file_set(hid_t fapl)
 {
-    hid_t	file=-1;		/*file to which to write	*/
-    hid_t	dcpl=-1;		/*dataset creation properties	*/
-    hid_t	mem_space=-1;		/*memory data space		*/
-    hid_t	file_space=-1;		/*file data space		*/
-    hid_t	dset=-1;		/*dataset			*/
-    unsigned	i;			/*miscellaneous counters	*/
-    int		fd;			/*external file descriptor	*/
-    int	    part[25],whole[100];	/*raw data buffers		*/
-    hsize_t	cur_size=100;		/*current data space size	*/
-    hsize_t	max_size=200;		/*maximum data space size	*/
-    hsize_t	hs_start=100;		/*hyperslab starting offset	*/
-    hsize_t	hs_count=100;		/*hyperslab size		*/
-    char	filename[1024];		/*file name			*/
-	int temparray[10] = {0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f};
+    hid_t   file = -1;          /* file to which to write               */
+    hid_t   dcpl = -1;          /* dataset creation properties          */
+    hid_t   mem_space = -1;     /* memory data space                    */
+    hid_t   file_space = -1;    /* file data space                      */
+    hid_t   dset = -1;          /* dataset                              */
+    unsigned i;                 /* miscellaneous counters               */
+    int     fd = -1;            /* external file descriptor             */
+    int     part[25], whole[100];   /* raw data buffers                 */
+    hsize_t cur_size = 100;     /* current data space size              */
+    hsize_t max_size = 200;     /* maximum data space size              */
+    hsize_t hs_start = 100;     /* hyperslab starting offset            */
+    hsize_t hs_count = 100;     /* hyperslab size                       */
+    char    filename[1024];     /* file name                            */
+    int temparray[10] = {0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f,0x0f0f0f0f};
 
     TESTING("write external dataset");
 
     /* Create another file */
     h5_fixname(FILENAME[2], fapl, filename, sizeof filename);
-    if ((file=H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0) {
-	goto error;
-    }
+    if((file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
+        FAIL_STACK_ERROR
 
     /* Create the external file list */
-    if((dcpl=H5Pcreate(H5P_DATASET_CREATE)) < 0) goto error;
-    if (H5Pset_external(dcpl, "extern_1b.raw", (off_t)0, (hsize_t)sizeof part) < 0 ||
-	H5Pset_external(dcpl, "extern_2b.raw", (off_t)10, (hsize_t)sizeof part) < 0 ||
-	H5Pset_external(dcpl, "extern_3b.raw", (off_t)20, (hsize_t)sizeof part) < 0 ||
-	H5Pset_external(dcpl, "extern_4b.raw", (off_t)30, H5F_UNLIMITED) < 0)
-	goto error;
+    if((dcpl=H5Pcreate(H5P_DATASET_CREATE)) < 0)
+        FAIL_STACK_ERROR
+    if(H5Pset_external(dcpl, "extern_1b.raw", (off_t)0, (hsize_t)sizeof part) < 0 ||
+            H5Pset_external(dcpl, "extern_2b.raw", (off_t)10, (hsize_t)sizeof part) < 0 ||
+            H5Pset_external(dcpl, "extern_3b.raw", (off_t)20, (hsize_t)sizeof part) < 0 ||
+            H5Pset_external(dcpl, "extern_4b.raw", (off_t)30, H5F_UNLIMITED) < 0)
+        FAIL_STACK_ERROR
 
     /* Make sure the output files are fresh*/
-    for (i=1; i<=4; i++) {
-	sprintf(filename, "extern_%db.raw", i);
-	if ((fd= HDopen(filename, O_RDWR|O_CREAT|O_TRUNC, 0666)) < 0) {
-	    H5_FAILED();
-	    printf("    cannot open %s: %s\n", filename, strerror(errno));
-	    goto error;
-	}
-
-	HDwrite(fd, temparray, (i-1)*10);
-	HDclose(fd);
-    }
+    for(i=1; i<=4; i++) {
+        HDsprintf(filename, "extern_%db.raw", i);
+        if((fd= HDopen(filename, O_RDWR|O_CREAT|O_TRUNC, 0666)) < 0) {
+            H5_FAILED();
+            printf("    cannot open %s: %s\n", filename, HDstrerror(errno));
+            goto error;
+        } /* end if */
+
+        if(HDwrite(fd, temparray, (i-1)*10) < 0) {
+            H5_FAILED();
+            printf("    write error to file %s: %s\n", filename, HDstrerror(errno));
+            goto error;
+        }
+        HDclose(fd);
+    } /* end for */
 
     /* Create the dataset */
-    if((mem_space = H5Screate_simple(1, &cur_size, &max_size)) < 0) goto error;
-    if((file_space = H5Scopy(mem_space)) < 0) goto error;
+    if((mem_space = H5Screate_simple(1, &cur_size, &max_size)) < 0)
+        FAIL_STACK_ERROR
+    if((file_space = H5Scopy(mem_space)) < 0)
+        FAIL_STACK_ERROR
     if((dset = H5Dcreate2(file, "dset1", H5T_NATIVE_INT, file_space, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0)
-	goto error;
+        FAIL_STACK_ERROR
 
     /* Write the entire dataset and compare with the original */
     for(i = 0; i < cur_size; i++)
-        whole[i] = i;
-    if(H5Dwrite(dset, H5T_NATIVE_INT, mem_space, file_space, H5P_DEFAULT, whole) < 0) goto error;
+        whole[i] = (int)i;
+    if(H5Dwrite(dset, H5T_NATIVE_INT, mem_space, file_space, H5P_DEFAULT, whole) < 0)
+        FAIL_STACK_ERROR
     for(i = 0; i < 4; i++) {
-	char name1[64], name2[64];
-
-	sprintf(name1, "extern_%da.raw", i + 1);
-	sprintf(name2, "extern_%db.raw", i + 1);
-	if(!same_contents(name1, name2)) {
-	    H5_FAILED();
-	    puts ("   Output differs from expected value.");
-	    goto error;
-	} /* end if */
+        char name1[64], name2[64];
+
+        HDsprintf(name1, "extern_%da.raw", i + 1);
+        HDsprintf(name2, "extern_%db.raw", i + 1);
+        if(!files_have_same_contents(name1, name2))
+            FAIL_PUTS_ERROR("   Output differs from expected value.")
     } /* end for */
 
     /* Extend the dataset by another 100 elements */
-    if(H5Dset_extent(dset, &max_size) < 0) goto error;
-    if(H5Sclose(file_space) < 0) goto error;
-    if((file_space = H5Dget_space(dset)) < 0) goto error;
+    if(H5Dset_extent(dset, &max_size) < 0)
+        FAIL_STACK_ERROR
+    if(H5Sclose(file_space) < 0)
+        FAIL_STACK_ERROR
+    if((file_space = H5Dget_space(dset)) < 0)
+        FAIL_STACK_ERROR
 
     /* Write second half of dataset */
     for(i = 0; i < hs_count; i++)
-        whole[i] = 100 + i;
-    if(H5Sselect_hyperslab(file_space, H5S_SELECT_SET, &hs_start, NULL, &hs_count, NULL) < 0) goto error;
-    if(H5Dwrite(dset, H5T_NATIVE_INT, mem_space, file_space, H5P_DEFAULT, whole) < 0) goto error;
+        whole[i] = 100 + (int)i;
+    if(H5Sselect_hyperslab(file_space, H5S_SELECT_SET, &hs_start, NULL, &hs_count, NULL) < 0)
+        FAIL_STACK_ERROR
+    if(H5Dwrite(dset, H5T_NATIVE_INT, mem_space, file_space, H5P_DEFAULT, whole) < 0)
+        FAIL_STACK_ERROR
 
 
-    if(H5Dclose(dset) < 0) goto error;
-    if(H5Pclose(dcpl) < 0) goto error;
-    if(H5Sclose(mem_space) < 0) goto error;
-    if(H5Sclose(file_space) < 0) goto error;
-    if(H5Fclose(file) < 0) goto error;
+    if(H5Dclose(dset) < 0) FAIL_STACK_ERROR
+    if(H5Pclose(dcpl) < 0) FAIL_STACK_ERROR
+    if(H5Sclose(mem_space) < 0) FAIL_STACK_ERROR
+    if(H5Sclose(file_space) < 0) FAIL_STACK_ERROR
+    if(H5Fclose(file) < 0) FAIL_STACK_ERROR
 
     PASSED();
     return 0;
 
  error:
     H5E_BEGIN_TRY {
-	H5Dclose(dset);
-	H5Pclose(dcpl);
-	H5Sclose(mem_space);
-	H5Sclose(file_space);
-	H5Fclose(file);
+        H5Dclose(dset);
+        H5Pclose(dcpl);
+        H5Sclose(mem_space);
+        H5Sclose(file_space);
+        H5Fclose(file);
     } H5E_END_TRY;
     return 1;
-}
+} /* end test_write_file_set() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	test_4
+ * Function:    main
  *
- * Purpose:	Tests opening an external link twice.  It exposed a bug
- *              in the library.  This function tests the fix.  This test
- *              doesn't work with MULTI driver.
+ * Purpose:     Runs external dataset tests.
  *
- * Return:	Success:	0
+ * Return:      Success:    exit(0)
+ *              Failure:    exit(non-zero)
  *
- * 		Failure:	number of errors
- *
- * Programmer:	Raymond Lu
- *              5 November 2007
- *
- * Modifications:
+ * Programmer:  Robb Matzke
+ *              Tuesday, March  3, 1998
  *
  *-------------------------------------------------------------------------
  */
-static int
-test_4 (hid_t fapl)
+int
+main(void)
 {
-    hid_t fid = -1;
-    hid_t gid = -1;
-    hid_t xid = -1;
-    hid_t xid2 = -1;
-    char  filename[1024];		/*file name			*/
-    const char *pathname = H5_get_srcdir_filename(LINKED_FILE); /* Corrected test file name */
-
-    TESTING("opening external link twice");
-
-    /* Make a copy of the FAPL, in order to switch to the sec2 driver */
-    /* (useful when running test with another VFD) */
-    if((fapl = H5Pcopy(fapl)) < 0) FAIL_STACK_ERROR;
-
-    /* Switch local copy of the fapl to the sec2 driver */
-    if(H5Pset_fapl_sec2(fapl) < 0) FAIL_STACK_ERROR;
-
-    h5_fixname(FILENAME[3], fapl, filename, sizeof filename);
+    hid_t   fapl_id_old = -1;   /* file access properties (old format)  */
+    hid_t   fapl_id_new = -1;   /* file access properties (new format)  */
+    hid_t   fid = -1;           /* file for test_1* functions           */
+    hid_t   gid = -1;           /* group to emit diagnostics            */
+    char    filename[1024];     /* file name for test_1* funcs          */
+    unsigned    latest_format;  /* default or latest file format        */
+    int     nerrors = 0;        /* number of errors                     */
 
-    if((fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
-        goto error;
-
-    if((gid = H5Gopen2(fid, "/", H5P_DEFAULT)) < 0)
-        goto error;
-
-    /* Create an external link to an existing file*/
-    if(H5Lcreate_external(pathname, "/group", gid, " link", H5P_DEFAULT, H5P_DEFAULT) < 0)
-        goto error;
-
-    if(H5Gclose(gid) < 0)
-        goto error;
-
-    if(H5Fclose(fid) < 0)
-        goto error;
-
-    /* Reopen the file */
-    if((fid = H5Fopen(filename, H5F_ACC_RDONLY, fapl)) < 0)
-        goto error;
-
-    /* Open the external link which is "/ link" as created previously via H5Lcreate_external() */
-    if((xid = H5Gopen2(fid, "/ link", H5P_DEFAULT)) < 0)
-        goto error;
-
-    /* Open the external link twice */
-    if((xid2 = H5Gopen2(xid, ".", H5P_DEFAULT)) < 0)
-        goto error;
-
-    if(H5Gclose(xid2) < 0)
-        goto error;
+    h5_reset();
 
-    if(H5Gclose(xid) < 0)
-        goto error;
+    /* Get a fapl for the old (default) file format */
+    fapl_id_old = h5_fileaccess();
+    h5_fixname(FILENAME[0], fapl_id_old, filename, sizeof(filename));
+
+    /* Copy and set up a fapl for the latest file format */
+    if((fapl_id_new = H5Pcopy(fapl_id_old)) < 0)
+        FAIL_STACK_ERROR
+    if(H5Pset_libver_bounds(fapl_id_new, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST) < 0)
+        FAIL_STACK_ERROR
+
+    /* Test with old & new format groups */
+    for(latest_format = FALSE; latest_format <= TRUE; latest_format++) {
+        hid_t current_fapl_id = -1;
+
+        /* Set the fapl for different file formats */
+        if(latest_format) {
+            puts("\nTesting with the latest file format:");
+            current_fapl_id = fapl_id_new;
+        } /* end if */
+        else {
+            puts("Testing with the default file format:");
+            current_fapl_id = fapl_id_old;
+        } /* end else */
+
+        /* Create the common file used by some of the tests */
+        if((fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, current_fapl_id)) < 0)
+            FAIL_STACK_ERROR
+
+        /* Create a group that will be used in the file set read test */
+        if((gid = H5Gcreate2(fid, "emit-diagnostics", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+            FAIL_STACK_ERROR
+        if(H5Gclose(gid) < 0) FAIL_STACK_ERROR
+
+        /* These tests use a common file */
+        nerrors += test_non_extendible(fid);
+        nerrors += test_too_small(fid);
+        nerrors += test_large_enough_current_eventual(fid);
+        nerrors += test_large_enough_current_not_eventual(fid);
+        nerrors += test_unlimited(fid);
+        nerrors += test_multiple_files(fid);
+
+        /* These tests use no file */
+        nerrors += test_add_to_unlimited();
+        nerrors += test_overflow();
+
+        /* These tests use the VFD-aware fapl */
+        nerrors += test_read_file_set(current_fapl_id);
+        nerrors += test_write_file_set(current_fapl_id);
+
+        /* Verify symbol table messages are cached */
+        nerrors += (h5_verify_cached_stabs(FILENAME, current_fapl_id) < 0 ? 1 : 0);
+
+        /* Close the common file */
+        if(H5Fclose(fid) < 0) FAIL_STACK_ERROR
 
-    if(H5Fclose(fid) < 0)
-        goto error;
-
-    if(H5Pclose(fapl) < 0)
-        TEST_ERROR
+    } /* end for */
 
-    PASSED();
+    if(nerrors > 0) goto error;
 
-    return 0;
+    /* Close the new ff fapl. h5_cleanup will take care of the old ff fapl */
+    if(H5Pclose(fapl_id_new) < 0) FAIL_STACK_ERROR
 
- error:
-    H5E_BEGIN_TRY {
-        H5Gclose(gid);
-        H5Gclose(xid);
-        H5Gclose(xid2);
-        H5Fclose(fid);
-    } H5E_END_TRY;
-    return 1;
-}
-
-
-/*-------------------------------------------------------------------------
- * Function:	main
- *
- * Purpose:	Runs external dataset tests.
- *
- * Return:	Success:	exit(0)
- *
- *		Failure:	exit(non-zero)
- *
- * Programmer:	Robb Matzke
- *              Tuesday, March  3, 1998
- *
- * Modifications:
- *
- *-------------------------------------------------------------------------
- */
-int
-main (void)
-{
-    hid_t	fapl=-1;		/*file access properties	*/
-    hid_t	file=-1;		/*file for test_1* functions	*/
-    char	filename[1024];		/*file name for test_1* funcs	*/
-    hid_t	grp=-1;			/*group to emit diagnostics	*/
-    int		nerrors=0;		/*number of errors		*/
+    HDputs("All external storage tests passed.");
 
-    h5_reset();
-    fapl = h5_fileaccess();
-    h5_fixname(FILENAME[0], fapl, filename, sizeof filename);
-    if((file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0) FAIL_STACK_ERROR
-    if((grp = H5Gcreate2(file, "emit-diagnostics", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) FAIL_STACK_ERROR
-    if(H5Gclose(grp) < 0) goto error;
-
-    nerrors += test_1a(file);
-    nerrors += test_1b(file);
-    nerrors += test_1c(file);
-    nerrors += test_1d(file);
-    nerrors += test_1e(file);
-    nerrors += test_1f(file);
-    nerrors += test_1g();
-    nerrors += test_1h();
-    nerrors += test_2(fapl);
-    nerrors += test_3(fapl);
-    nerrors += test_4(fapl);
-
-    /* Verify symbol table messages are cached */
-    nerrors += (h5_verify_cached_stabs(FILENAME, fapl) < 0 ? 1 : 0);
-
-    if (nerrors>0) goto error;
-
-    if (H5Fclose(file) < 0) goto error;
-    puts("All external storage tests passed.");
-    if (h5_cleanup(FILENAME, fapl)) {
-        remove("extern_1a.raw");
-        remove("extern_1b.raw");
-        remove("extern_2a.raw");
-        remove("extern_2b.raw");
-        remove("extern_3a.raw");
-        remove("extern_3b.raw");
-        remove("extern_4a.raw");
-        remove("extern_4b.raw");
-    }
+    /* Clean up files used by file set tests */
+    if(h5_cleanup(FILENAME, fapl_id_old)) {
+        HDremove("extern_1a.raw");
+        HDremove("extern_1b.raw");
+        HDremove("extern_2a.raw");
+        HDremove("extern_2b.raw");
+        HDremove("extern_3a.raw");
+        HDremove("extern_3b.raw");
+        HDremove("extern_4a.raw");
+        HDremove("extern_4b.raw");
+    } /* end if */
 
-    return 0;
+    return EXIT_SUCCESS;
 
 error:
     H5E_BEGIN_TRY {
-        H5Fclose(file);
-        H5Pclose(fapl);
+        H5Fclose(fid);
+        H5Pclose(fapl_id_old);
+        H5Pclose(fapl_id_new);
+        H5Gclose(gid);
     } H5E_END_TRY;
     nerrors = MAX(1, nerrors);
     printf ("%d TEST%s FAILED.\n", nerrors, 1==nerrors?"":"s");
-    return 1;
-}
+    return EXIT_FAILURE;
+} /* end main() */
diff --git a/test/gen_udlinks.c b/test/gen_udlinks.c
index fc044da..55abab0 100644
--- a/test/gen_udlinks.c
+++ b/test/gen_udlinks.c
@@ -22,9 +22,6 @@
  *  They will be named according to the platform and should
  *  be placed in the hdf5/test directory so that the links test can use them.
  *
- * Note: The be_extlink2.h5 is also used by external.c to test opening
- *  external link twice. -SLU 2007/11/7
- *
  */
 
 #include "hdf5.h"
diff --git a/test/h5test.c b/test/h5test.c
index cbe067f..723ecdc 100644
--- a/test/h5test.c
+++ b/test/h5test.c
@@ -193,6 +193,107 @@ h5_clean_files(const char *base_name[], hid_t fapl)
 
 
 /*-------------------------------------------------------------------------
+ * Function:    h5_delete_test_file
+ *
+ * Purpose      Clean up temporary test files.
+ *
+ *              When a test calls h5_fixname() get a VFD-dependent
+ *              test file name, this function can be used to clean it up.
+ *
+ * Return:      void
+ *
+ *              Since this is a cleanup file, we don't care if it fails.
+ *
+ * Programmer:  Dana Robinson
+ *              February 2016
+ *
+ *-------------------------------------------------------------------------
+ */
+void
+h5_delete_test_file(const char *base_name, hid_t fapl)
+{
+    char filename[1024];        /* VFD-dependent filename to delete     */
+    char sub_filename[2048];    /* sub-files in multi & family VFDs     */
+    hid_t driver = -1;          /* VFD ID                               */
+
+    /* Get the VFD-dependent filename */
+    if(NULL == h5_fixname(base_name, fapl, filename, sizeof(filename)))
+        return;
+
+    driver = H5Pget_driver(fapl);
+
+    if(driver == H5FD_FAMILY) {
+        int j;
+        for(j = 0; /*void*/; j++) {
+            HDsnprintf(sub_filename, sizeof(sub_filename), filename, j);
+
+            /* If we can't access the file, it probably doesn't exist
+             * and we are done deleting the sub-files.
+             */
+            if(HDaccess(sub_filename, F_OK) < 0)
+                break;
+
+            HDremove(sub_filename);
+        } /* end for */
+    } else if(driver == H5FD_CORE) {
+        hbool_t backing;        /* Whether the core file has backing store */
+
+        H5Pget_fapl_core(fapl, NULL, &backing);
+
+        /* If the file was stored to disk with bacing store, remove it */
+        if(backing)
+            HDremove(filename);
+    } else if (driver == H5FD_MULTI) {
+        H5FD_mem_t mt;
+
+        HDassert(HDstrlen(multi_letters) == H5FD_MEM_NTYPES);
+
+        for(mt = H5FD_MEM_DEFAULT; mt < H5FD_MEM_NTYPES; H5_INC_ENUM(H5FD_mem_t,mt)) {
+            HDsnprintf(sub_filename, sizeof(sub_filename), "%s-%c.h5", filename, multi_letters[mt]);
+            HDremove(sub_filename);
+        } /* end for */
+    } else {
+        HDremove(filename);
+    } /* end if */
+
+    return;
+} /* end h5_delete_test_file() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    h5_delete_all_test_files
+ *
+ * Purpose      Clean up temporary test files.
+ *
+ *              When a test calls h5_fixname() get a VFD-dependent
+ *              test file name, this function can be used to clean it up.
+ *
+ *              This function takes an array of filenames that ends with
+ *              a NULL string and cleans them all.
+ *
+ * Return:      void
+ *
+ *              Since this is a cleanup file, we don't care if it fails.
+ *
+ * Programmer:  Dana Robinson
+ *              February 2016
+ *
+ *-------------------------------------------------------------------------
+ */
+void
+h5_delete_all_test_files(const char *base_name[], hid_t fapl)
+{
+    int i;                      /* iterator                             */
+
+    for(i = 0; base_name[i]; i++) {
+        h5_delete_test_file(base_name[i], fapl);
+    } /* end for */
+
+    return;
+} /* end h5_delete_all_test_files() */
+
+
+/*-------------------------------------------------------------------------
  * Function:  h5_cleanup
  *
  * Purpose:  Cleanup temporary test files.
@@ -226,6 +327,35 @@ h5_cleanup(const char *base_name[], hid_t fapl)
 
 
 /*-------------------------------------------------------------------------
+ * Function:    h5_test_shutdown
+ *
+ * Purpose:     Performs any special test cleanup required before the test
+ *              ends.
+ *
+ *              NOTE: This function should normally only be called once
+ *              in a given test, usually just before leaving main(). It
+ *              is intended for use in the single-file unit tests, not
+ *              testhdf5.
+ *
+ * Return:      void
+ *
+ * Programmer:  Dana Robinson
+ *              February 2016
+ *
+ *-------------------------------------------------------------------------
+ */
+void
+h5_test_shutdown(void)
+{
+
+    /* Restore the original error reporting routine */
+    h5_restore_err();
+
+    return;
+} /* end h5_test_shutdown() */
+
+
+/*-------------------------------------------------------------------------
  * Function:    h5_restore_err
  *
  * Purpose:     Restore the default error handler.
@@ -303,6 +433,39 @@ h5_reset(void)
 
 
 /*-------------------------------------------------------------------------
+ * Function:    h5_test_init
+ *
+ * Purpose:     Performs any special actions before the test begins.
+ *
+ *              NOTE: This function should normally only be called once
+ *              in a given test, usually at the beginning of main(). It
+ *              is intended for use in the single-file unit tests, not
+ *              testhdf5.
+ *
+ * Return:      void
+ *
+ * Programmer:  Dana Robinson
+ *              February 2016
+ *
+ *-------------------------------------------------------------------------
+ */
+void
+h5_test_init(void)
+{
+    HDfflush(stdout);
+    HDfflush(stderr);
+    H5close();
+
+    /* Save current error stack reporting routine and redirect to our local one */
+    HDassert(err_func == NULL);
+    H5Eget_auto2(H5E_DEFAULT, &err_func, NULL);
+    H5Eset_auto2(H5E_DEFAULT, h5_errors, NULL);
+
+    return;
+} /* end h5_test_init() */
+
+
+/*-------------------------------------------------------------------------
  * Function:  h5_fixname
  *
  * Purpose:  Create a file name from a file base name like `test' and
@@ -744,6 +907,137 @@ h5_fileaccess(void)
 
 
 /*-------------------------------------------------------------------------
+ * Function:    h5_get_vfd_fapl
+ *
+ * Purpose:     Returns a file access property list which is the default
+ *              fapl but with a file driver set according to the constant or
+ *              environment variable HDF5_DRIVER.
+ *
+ * Return:      Success:    A file access property list ID
+ *              Failure:    -1
+ *
+ * Programmer:  Dana Robinson
+ *              February 2016
+ *
+ *-------------------------------------------------------------------------
+ */
+hid_t
+h5_get_vfd_fapl(void)
+{
+    const char  *env = NULL;    /* HDF5_DRIVER environment variable     */
+    const char  *tok = NULL;    /* strtok pointer                       */
+    char        buf[1024];      /* buffer for tokenizing HDF5_DRIVER    */
+    hid_t       fapl = -1;      /* fapl to be returned                  */
+
+    /* Get the environment variable, if it exists */
+    env = HDgetenv("HDF5_DRIVER");
+
+    /* Create a default fapl */
+    if((fapl = H5Pcreate(H5P_FILE_ACCESS)) < 0)
+        return -1;
+
+    /* If the environment variable was not set, just return
+     * the default fapl.
+     */
+    if(!env || !*env)
+        return fapl;
+
+    /* Get the first 'word' of the environment variable.
+     * If it's nothing (environment variable was whitespace)
+     * just return the default fapl.
+     */
+    HDstrncpy(buf, env, sizeof(buf));
+    HDmemset(buf, 0, sizeof(buf));
+    if(NULL == (tok = HDstrtok(buf, " \t\n\r")))
+        return fapl;
+
+    if(!HDstrcmp(tok, "sec2")) {
+        /* POSIX (section 2) read() and write() system calls */
+        if(H5Pset_fapl_sec2(fapl) < 0)
+            return -1;
+    } else if(!HDstrcmp(tok, "stdio")) {
+        /* Standard C fread() and fwrite() system calls */
+        if(H5Pset_fapl_stdio(fapl) < 0)
+            return -1;
+    } else if(!HDstrcmp(tok, "core")) {
+        /* In-memory driver settings (backing store on, 1 MB increment) */
+        if(H5Pset_fapl_core(fapl, (size_t)1, TRUE) < 0)
+            return -1;
+    } else if(!HDstrcmp(tok, "core_paged")) {
+        /* In-memory driver with write tracking and paging on */
+        if(H5Pset_fapl_core(fapl, (size_t)1, TRUE) < 0)
+            return -1;
+        if(H5Pset_core_write_tracking(fapl, TRUE, (size_t)4096) < 0)
+            return -1;
+     } else if(!HDstrcmp(tok, "split")) {
+        /* Split meta data and raw data each using default driver */
+        if(H5Pset_fapl_split(fapl,
+            "-m.h5", H5P_DEFAULT,
+            "-r.h5", H5P_DEFAULT) < 0)
+            return -1;
+    } else if(!HDstrcmp(tok, "multi")) {
+        /* Multi-file driver, general case of the split driver */
+        H5FD_mem_t  memb_map[H5FD_MEM_NTYPES];
+        hid_t       memb_fapl[H5FD_MEM_NTYPES];
+        const char  *memb_name[H5FD_MEM_NTYPES];
+        char        sv[H5FD_MEM_NTYPES][1024];
+        haddr_t     memb_addr[H5FD_MEM_NTYPES];
+        H5FD_mem_t  mt;
+
+        HDmemset(memb_map, 0, sizeof(memb_map));
+        HDmemset(memb_fapl, 0, sizeof(memb_fapl));
+        HDmemset(memb_name, 0, sizeof(memb_name));
+        HDmemset(memb_addr, 0, sizeof(memb_addr));
+
+        HDassert(HDstrlen(multi_letters) == H5FD_MEM_NTYPES);
+        for(mt = H5FD_MEM_DEFAULT; mt < H5FD_MEM_NTYPES; H5_INC_ENUM(H5FD_mem_t, mt)) {
+            memb_fapl[mt] = H5P_DEFAULT;
+            HDsprintf(sv[mt], "%%s-%c.h5", multi_letters[mt]);
+            memb_name[mt] = sv[mt];
+            memb_addr[mt] = (haddr_t)MAX(mt - 1, 0) * (HADDR_MAX / 10);
+        } /* end for */
+
+        if(H5Pset_fapl_multi(fapl, memb_map, memb_fapl, memb_name,
+          memb_addr, FALSE) < 0) {
+            return -1;
+        } /* end if */
+    } else if(!HDstrcmp(tok, "family")) {
+        /* Family of files, each 1MB and using the default driver */
+        hsize_t fam_size = 100*1024*1024; /*100 MB*/
+
+        /* Was a family size specified in the environment variable? */
+        if((tok = HDstrtok(NULL, " \t\n\r")))
+            fam_size = (hsize_t)(HDstrtod(tok, NULL) * 1024*1024);
+        if(H5Pset_fapl_family(fapl, fam_size, H5P_DEFAULT) < 0)
+            return -1;
+    } else if(!HDstrcmp(tok, "log")) {
+        /* Log file access */
+        unsigned log_flags = H5FD_LOG_LOC_IO | H5FD_LOG_ALLOC;
+
+        /* Were special log file flags specified in the environment variable? */
+        if((tok = HDstrtok(NULL, " \t\n\r")))
+            log_flags = (unsigned)HDstrtol(tok, NULL, 0);
+
+        if(H5Pset_fapl_log(fapl, NULL, log_flags, (size_t)0) < 0)
+            return -1;
+#ifdef H5_HAVE_DIRECT
+    } else if(!HDstrcmp(tok, "direct")) {
+        /* Linux direct read() and write() system calls.  Set memory boundary,
+         * file block size, and copy buffer size to the default values.
+         */
+        if(H5Pset_fapl_direct(fapl, 1024, 4096, 8*4096)<0)
+            return -1;
+#endif
+    } else {
+        /* Unknown driver */
+        return -1;
+    } /* end if */
+
+    return fapl;
+} /* end h5_get_vfd_fapl() */
+
+
+/*-------------------------------------------------------------------------
  * Function:  h5_no_hwconv
  *
  * Purpose:  Turn off hardware data type conversions.
diff --git a/test/h5test.h b/test/h5test.h
index a91da5d..450099a 100644
--- a/test/h5test.h
+++ b/test/h5test.h
@@ -142,6 +142,23 @@ H5TEST_DLL int print_func(const char *format, ...);
 H5TEST_DLL int h5_make_local_copy(const char *origfilename, const char *local_copy_name);
 H5TEST_DLL herr_t h5_verify_cached_stabs(const char *base_name[], hid_t fapl);
 
+/* Functions that will replace VFD-dependent functions that violate
+ * the single responsibility principle. Unlike their predecessors,
+ * these new functions do not have hidden side effects.
+ */
+/* h5_fileaccess() replacement */
+H5TEST_DLL hid_t h5_get_vfd_fapl(void);
+
+/* h5_clean_files() replacements */
+H5TEST_DLL void h5_delete_test_file(const char *base_name, hid_t fapl);
+H5TEST_DLL void h5_delete_all_test_files(const char *base_name[], hid_t fapl);
+
+/* h5_reset() replacement */
+H5TEST_DLL void h5_test_init(void);
+
+/* h5_cleanup() replacement */
+H5TEST_DLL void h5_test_shutdown(void);
+
 /* Routines for operating on the list of tests (for the "all in one" tests) */
 H5TEST_DLL void TestUsage(void);
 H5TEST_DLL void AddTest(const char *TheName, void (*TheCall) (void),
diff --git a/test/links.c b/test/links.c
index db43cf3..a791c89 100644
--- a/test/links.c
+++ b/test/links.c
@@ -7399,7 +7399,7 @@ error:
     } H5E_END_TRY
 
     return -1;
-} /* end efc_open_twice */
+} /* end external_open_twice() */
 
 
 /*-------------------------------------------------------------------------