Merge branch 'develop' into feature/coding_standardsfeature/coding_standards

1 files changed, 821 insertions, 551 deletions

diff --git a/test/h5test.c b/test/h5test.c
index dd8d906..ac15043 100644
--- a/test/h5test.c
+++ b/test/h5test.c
@@ -6,32 +6,33 @@
  * This file is part of HDF5.  The full HDF5 copyright notice, including     *
  * terms governing use, modification, and redistribution, is contained in    *
  * the COPYING file, which can be found at the root of the source code       *
- * distribution tree, or in https://support.hdfgroup.org/ftp/HDF5/releases.  *
+ * distribution tree, or in https://www.hdfgroup.org/licenses.               *
  * If you do not have access to either file, you may request a copy from     *
  * help@hdfgroup.org.                                                        *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 /*
- * Programmer:  Robb Matzke <matzke@llnl.gov>
+ * Programmer:  Robb Matzke
  *              Thursday, November 19, 1998
  *
  * Purpose:  Provides support functions for most of the hdf5 tests cases.
  *
  */
 
-#undef NDEBUG      /*override -DNDEBUG      */
+#undef NDEBUG /*override -DNDEBUG      */
 
 #include "h5test.h"
 #include "H5srcdir.h"
+#include "H5srcdir_str.h"
 
 /* Necessary for h5_verify_cached_stabs() */
-#define H5G_FRIEND        /*suppress error about including H5Gpkg      */
+#define H5G_FRIEND /*suppress error about including H5Gpkg      */
 #define H5G_TESTING
 #include "H5Gpkg.h"
 
 #ifdef H5_HAVE_WIN32_API
 #include <process.h>
-#endif  /* H5_HAVE_WIN32_API */
+#endif /* H5_HAVE_WIN32_API */
 
 /*
  * Define these environment variables or constants to influence functions in
@@ -39,10 +40,7 @@
  * to the cpp constant.  If neither is defined then use some default value.
  *
  * HDF5_DRIVER:    This string describes what low level file driver to
- *      use for HDF5 file access.  The first word in the
- *      value is the name of the driver and subsequent data
- *      is interpreted according to the driver.  See
- *      h5_get_vfd_fapl() for details.
+ *      use for HDF5 file access.
  *
  * HDF5_LIBVER_BOUNDS:    This string describes what library version bounds to
  *      use for HDF5 file access.  See h5_get_libver_fapl() for details.
@@ -70,12 +68,12 @@
 #ifndef HDF5_PARAPREFIX
 #define HDF5_PARAPREFIX ""
 #endif
-char  *paraprefix = NULL;  /* for command line option para-prefix */
+char *paraprefix = NULL; /* for command line option para-prefix */
 #ifdef H5_HAVE_PARALLEL
-MPI_Info    h5_io_info_g=MPI_INFO_NULL;/* MPI INFO object for IO */
+MPI_Info h5_io_info_g = MPI_INFO_NULL; /* MPI INFO object for IO */
 #endif
 
-#define READ_BUF_SIZE           65536
+#define READ_BUF_SIZE 65536
 
 /*
  * These are the letters that are appended to the file name when generating
@@ -92,31 +90,35 @@ MPI_Info    h5_io_info_g=MPI_INFO_NULL;/* MPI INFO object for IO */
 static const char *multi_letters = "msbrglo";
 
 /* Length of multi-file VFD filename buffers */
-#define H5TEST_MULTI_FILENAME_LEN       1024
+#define H5TEST_MULTI_FILENAME_LEN 1024
 
 /* Temporary file for sending signal messages */
 #define TMP_SIGNAL_FILE "tmp_signal_file"
 
 /* The # of seconds to wait for the message file--used by h5_wait_message() */
-#define MESSAGE_TIMEOUT         300             /* Timeout in seconds */
+#define MESSAGE_TIMEOUT 300 /* Timeout in seconds */
+
+/* Buffer to construct path in and return pointer to */
+static char srcdir_path[1024] = "";
+
+/* Buffer to construct file in and return pointer to */
+static char srcdir_testpath[1024] = "";
 
 /*  The strings that correspond to library version bounds H5F_libver_t in H5Fpublic.h */
 /*  This is used by h5_get_version_string() */
-const char *LIBVER_NAMES[] = {
-    "earliest", /* H5F_LIBVER_EARLIEST = 0  */
-    "v18",      /* H5F_LIBVER_V18 = 1       */
-    "v110",     /* H5F_LIBVER_V110 = 2      */
-    "latest",   /* H5F_LIBVER_V112 = 3      */
-    NULL
-};
+const char *LIBVER_NAMES[] = {"earliest", /* H5F_LIBVER_EARLIEST = 0  */
+                              "v18",      /* H5F_LIBVER_V18 = 1       */
+                              "v110",     /* H5F_LIBVER_V110 = 2      */
+                              "v112",     /* H5F_LIBVER_V112 = 3      */
+                              "latest",   /* H5F_LIBVER_V114 = 4      */
+                              NULL};
 
 /* Previous error reporting function */
 static H5E_auto2_t err_func = NULL;
 
 static herr_t h5_errors(hid_t estack, void *client_data);
-static char *h5_fixname_real(const char *base_name, hid_t fapl, const char *_suffix,
-    char *fullname, size_t size, hbool_t nest_printf, hbool_t subst_for_superblock);
-
+static char * h5_fixname_real(const char *base_name, hid_t fapl, const char *_suffix, char *fullname,
+                              size_t size, hbool_t nest_printf, hbool_t subst_for_superblock);
 
 /*-------------------------------------------------------------------------
  * Function:  h5_errors
@@ -142,7 +144,6 @@ h5_errors(hid_t estack, void H5_ATTR_UNUSED *client_data)
     return 0;
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:  h5_clean_files
  *
@@ -161,17 +162,14 @@ h5_clean_files(const char *base_name[], hid_t fapl)
 {
     int i;
 
-    for(i = 0; base_name[i]; i++) {
+    for (i = 0; base_name[i]; i++) {
         h5_delete_test_file(base_name[i], fapl);
     }
 
     /* Close the FAPL used to access the file */
     H5Pclose(fapl);
-
-    return;
 } /* end h5_clean_files() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    h5_delete_test_file
  *
@@ -189,65 +187,22 @@ h5_clean_files(const char *base_name[], hid_t fapl)
  *
  *-------------------------------------------------------------------------
  */
-/* Disable warning for "format not a string literal" here -QAK */
-/*
- *      This pragma only needs to surround the snprintf() calls with
- *      sub_filename in the code below, but early (4.4.7, at least) gcc only
- *      allows diagnostic pragmas to be toggled outside of functions.
- */
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wformat-nonliteral"
 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                               */
+    char filename[1024]; /* VFD-dependent filename to delete */
 
     /* Get the VFD-dependent filename */
-    if(NULL == h5_fixname(base_name, fapl, filename, sizeof(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);
-        }
-    } else {
-        HDremove(filename);
-    } /* end driver selection tree */
+    H5E_BEGIN_TRY
+    {
+        H5Fdelete(filename, fapl);
+    }
+    H5E_END_TRY;
 
-    return;
 } /* end h5_delete_test_file() */
-#pragma GCC diagnostic pop
-
 
 /*-------------------------------------------------------------------------
  * Function:    h5_delete_all_test_files
@@ -272,16 +227,14 @@ h5_delete_test_file(const char *base_name, hid_t fapl)
 void
 h5_delete_all_test_files(const char *base_name[], hid_t fapl)
 {
-    int i;                      /* iterator                             */
+    int i; /* iterator                             */
 
-    for(i = 0; base_name[i]; i++) {
+    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
  *
@@ -299,9 +252,9 @@ h5_delete_all_test_files(const char *base_name[], hid_t fapl)
 int
 h5_cleanup(const char *base_name[], hid_t fapl)
 {
-    int    retval = 0;
+    int retval = 0;
 
-    if(GetTestCleanup()) {
+    if (GetTestCleanup()) {
         /* Clean up files in base_name, and the FAPL */
         h5_clean_files(base_name, fapl);
 
@@ -314,7 +267,6 @@ h5_cleanup(const char *base_name[], hid_t fapl)
     return retval;
 } /* end h5_cleanup() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    h5_test_shutdown
  *
@@ -339,11 +291,8 @@ h5_test_shutdown(void)
 
     /* Restore the original error reporting routine */
     h5_restore_err();
-
-    return;
 } /* end h5_test_shutdown() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    h5_restore_err
  *
@@ -365,7 +314,6 @@ h5_restore_err(void)
     err_func = NULL;
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:  h5_reset
  *
@@ -400,27 +348,27 @@ h5_reset(void)
  *      appropriate configure flags/macros.  QAK - 2007/12/20
  */
 #ifdef OLD_WAY
-{
-    char  filename[1024];
+    {
+        char filename[1024];
 
-    /*
-     * Cause the library to emit some diagnostics early so they don't
-     * interfere with other formatted output.
-     */
-    HDsprintf(filename, "/tmp/h5emit-%05d.h5", HDgetpid());
-    H5E_BEGIN_TRY {
-        hid_t file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT,
-                 H5P_DEFAULT);
-        hid_t grp = H5Gcreate2(file, "emit", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
-        H5Gclose(grp);
-        H5Fclose(file);
-        HDunlink(filename);
-    } H5E_END_TRY;
-}
+        /*
+         * Cause the library to emit some diagnostics early so they don't
+         * interfere with other formatted output.
+         */
+        HDsprintf(filename, "/tmp/h5emit-%05d.h5", HDgetpid());
+        H5E_BEGIN_TRY
+        {
+            hid_t file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+            hid_t grp  = H5Gcreate2(file, "emit", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+            H5Gclose(grp);
+            H5Fclose(file);
+            HDunlink(filename);
+        }
+        H5E_END_TRY;
+    }
 #endif /* OLD_WAY */
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:    h5_test_init
  *
@@ -449,11 +397,8 @@ h5_test_init(void)
     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
  *
@@ -482,7 +427,6 @@ h5_fixname(const char *base_name, hid_t fapl, char *fullname, size_t size)
     return (h5_fixname_real(base_name, fapl, ".h5", fullname, size, FALSE, FALSE));
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:    h5_fixname_superblock
  *
@@ -508,7 +452,6 @@ h5_fixname_superblock(const char *base_name, hid_t fapl_id, char *fullname, size
     return (h5_fixname_real(base_name, fapl_id, ".h5", fullname, size, FALSE, TRUE));
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:  h5_fixname_no_suffix
  *
@@ -528,7 +471,6 @@ h5_fixname_no_suffix(const char *base_name, hid_t fapl, char *fullname, size_t s
     return (h5_fixname_real(base_name, fapl, NULL, fullname, size, FALSE, FALSE));
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:  h5_fixname_printf
  *
@@ -554,7 +496,6 @@ h5_fixname_printf(const char *base_name, hid_t fapl, char *fullname, size_t size
     return (h5_fixname_real(base_name, fapl, ".h5", fullname, size, TRUE, FALSE));
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:  h5_fixname_real
  *
@@ -578,56 +519,60 @@ h5_fixname_printf(const char *base_name, hid_t fapl, char *fullname, size_t size
  *-------------------------------------------------------------------------
  */
 static char *
-h5_fixname_real(const char *base_name, hid_t fapl, const char *_suffix,
-    char *fullname, size_t size, hbool_t nest_printf, hbool_t subst_for_superblock)
+h5_fixname_real(const char *base_name, hid_t fapl, const char *_suffix, char *fullname, size_t size,
+                hbool_t nest_printf, hbool_t subst_for_superblock)
 {
-    const char     *prefix = NULL;
-    const char     *env = NULL;    /* HDF5_DRIVER environment variable     */
-    char           *ptr, last = '\0';
-    const char     *suffix = _suffix;
-    size_t          i, j;
-    hid_t           driver = -1;
-    int             isppdriver = 0;  /* if the driver is MPI parallel */
+    const char *prefix         = NULL;
+    const char *driver_env_var = NULL; /* HDF5_DRIVER environment variable     */
+    char *      ptr, last = '\0';
+    const char *suffix = _suffix;
+    size_t      i, j;
+    hid_t       driver     = -1;
+    int         isppdriver = 0; /* if the driver is MPI parallel */
 
     if (!base_name || !fullname || size < 1)
         return NULL;
 
     HDmemset(fullname, 0, size);
 
+    /* Determine if driver is set by environment variable. If it is,
+     * only generate a suffix if fixing the filename for the superblock
+     * file. */
+    driver_env_var = HDgetenv(HDF5_DRIVER);
+    if (driver_env_var && (H5P_DEFAULT == fapl) && subst_for_superblock)
+        fapl = H5P_FILE_ACCESS_DEFAULT;
+
     /* figure out the suffix */
-    if(H5P_DEFAULT != fapl) {
-        if((driver = H5Pget_driver(fapl)) < 0)
+    if (H5P_DEFAULT != fapl) {
+        if ((driver = H5Pget_driver(fapl)) < 0)
             return NULL;
 
-        if(suffix) {
-            if(H5FD_FAMILY == driver) {
-                if(subst_for_superblock)
-                    suffix = "00000.h5";
+        if (suffix) {
+            if (H5FD_FAMILY == driver) {
+                if (subst_for_superblock)
+                    suffix = "-000000.h5";
                 else
-                    suffix = nest_printf ? "%%05d.h5" : "%05d.h5";
+                    suffix = nest_printf ? "-%%06d.h5" : "-%06d.h5";
             }
             else if (H5FD_MULTI == driver) {
 
-                /* Get the environment variable, if it exists, in case
+                /* Check the HDF5_DRIVER environment variable in case
                  * we are using the split driver since both of those
                  * use the multi VFD under the hood.
                  */
-                env = HDgetenv("HDF5_DRIVER");
 #ifdef HDF5_DRIVER
                 /* Use the environment variable, then the compile-time constant */
-                if(!env)
-                    env = HDF5_DRIVER;
+                if (!driver_env_var)
+                    driver_env_var = HDF5_DRIVER;
 #endif
-                if(env && !HDstrcmp(env, "split")) {
+                if (driver_env_var && !HDstrcmp(driver_env_var, "split")) {
                     /* split VFD */
-                    if(subst_for_superblock)
-                        suffix = "-m.h5";
-                    else
-                        suffix = NULL;
+                    if (subst_for_superblock)
+                        suffix = ".h5.meta";
                 }
                 else {
                     /* multi VFD */
-                    if(subst_for_superblock)
+                    if (subst_for_superblock)
                         suffix = "-s.h5";
                     else
                         suffix = NULL;
@@ -639,19 +584,20 @@ h5_fixname_real(const char *base_name, hid_t fapl, const char *_suffix,
     /* Must first check fapl is not H5P_DEFAULT (-1) because H5FD_XXX
      * could be of value -1 if it is not defined.
      */
-    isppdriver = H5P_DEFAULT != fapl && (H5FD_MPIO == driver);
+    isppdriver = ((H5P_DEFAULT != fapl) || driver_env_var) && (H5FD_MPIO == driver);
 
     /* Check HDF5_NOCLEANUP environment setting.
      * (The #ifdef is needed to prevent compile failure in case MPI is not
      * configured.)
      */
-    if(isppdriver) {
+    if (isppdriver) {
 #ifdef H5_HAVE_PARALLEL
-        if(getenv_all(MPI_COMM_WORLD, 0, "HDF5_NOCLEANUP"))
+        if (getenv_all(MPI_COMM_WORLD, 0, HDF5_NOCLEANUP))
             SetTestNoCleanup();
-#endif  /* H5_HAVE_PARALLEL */
-    } else {
-        if(HDgetenv("HDF5_NOCLEANUP"))
+#endif /* H5_HAVE_PARALLEL */
+    }
+    else {
+        if (HDgetenv(HDF5_NOCLEANUP))
             SetTestNoCleanup();
     }
 
@@ -661,7 +607,7 @@ h5_fixname_real(const char *base_name, hid_t fapl, const char *_suffix,
      * (The #ifdef is needed to prevent compile failure in case MPI is not
      * configured.)
      */
-    if(isppdriver) {
+    if (isppdriver) {
 #ifdef H5_HAVE_PARALLEL
         /*
          * For parallel:
@@ -680,20 +626,21 @@ h5_fixname_real(const char *base_name, hid_t fapl, const char *_suffix,
 
             if (mpi_rank == 0)
                 HDprintf("*** Hint ***\n"
-                       "You can use environment variable HDF5_PARAPREFIX to "
-                       "run parallel test files in a\n"
-                       "different directory or to add file type prefix. e.g.,\n"
-                       "   HDF5_PARAPREFIX=pfs:/PFS/user/me\n"
-                       "   export HDF5_PARAPREFIX\n"
-                       "*** End of Hint ***\n");
+                         "You can use environment variable HDF5_PARAPREFIX to "
+                         "run parallel test files in a\n"
+                         "different directory or to add file type prefix. e.g.,\n"
+                         "   HDF5_PARAPREFIX=pfs:/PFS/user/me\n"
+                         "   export HDF5_PARAPREFIX\n"
+                         "*** End of Hint ***\n");
 
             explained = TRUE;
 #ifdef HDF5_PARAPREFIX
             prefix = HDF5_PARAPREFIX;
-#endif  /* HDF5_PARAPREFIX */
+#endif /* HDF5_PARAPREFIX */
         }
-#endif  /* H5_HAVE_PARALLEL */
-    } else {
+#endif /* H5_HAVE_PARALLEL */
+    }
+    else {
         /*
          * For serial:
          *      First use the environment variable, then try the constant
@@ -703,7 +650,7 @@ h5_fixname_real(const char *base_name, hid_t fapl, const char *_suffix,
 #ifdef HDF5_PREFIX
         if (!prefix)
             prefix = HDF5_PREFIX;
-#endif  /* HDF5_PREFIX */
+#endif /* HDF5_PREFIX */
     }
 
     /* Prepend the prefix value to the base name */
@@ -720,8 +667,8 @@ h5_fixname_real(const char *base_name, hid_t fapl, const char *_suffix,
                  */
                 char *user, *login;
 
-                user = HDgetenv("USER");
-                login = HDgetenv("LOGIN");
+                user   = HDgetenv("USER");
+                login  = HDgetenv("LOGIN");
                 subdir = (user ? user : login);
 
                 if (subdir) {
@@ -738,7 +685,7 @@ h5_fixname_real(const char *base_name, hid_t fapl, const char *_suffix,
             if (!fullname[0]) {
                 /* We didn't append the prefix yet */
                 HDstrncpy(fullname, prefix, size);
-                fullname[size -1] = '\0';
+                fullname[size - 1] = '\0';
             }
 
             if (HDstrlen(fullname) + HDstrlen(base_name) + 1 < size) {
@@ -760,19 +707,23 @@ h5_fixname_real(const char *base_name, hid_t fapl, const char *_suffix,
 
                 HDstrcat(fullname, "/");
                 HDstrcat(fullname, base_name);
-            } else {
+            }
+            else {
                 /* Buffer is too small */
                 return NULL;
             }
-        } else {
+        }
+        else {
             if (HDsnprintf(fullname, size, "%s/%s", prefix, base_name) == (int)size)
                 /* Buffer is too small */
                 return NULL;
         }
-    } else if (HDstrlen(base_name) >= size) {
+    }
+    else if (HDstrlen(base_name) >= size) {
         /* Buffer is too small */
         return NULL;
-    } else {
+    }
+    else {
         HDstrcpy(fullname, base_name);
     }
 
@@ -795,7 +746,6 @@ h5_fixname_real(const char *base_name, hid_t fapl, const char *_suffix,
     return fullname;
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:  h5_rmprefix
  *
@@ -823,10 +773,9 @@ h5_rmprefix(const char *filename)
     else
         ret_ptr++;
 
-    return(ret_ptr);
+    return (ret_ptr);
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:    h5_fileaccess
  *
@@ -845,28 +794,23 @@ h5_rmprefix(const char *filename)
 hid_t
 h5_fileaccess(void)
 {
-    hid_t       fapl_id = H5I_INVALID_HID;
-
-    if((fapl_id = H5Pcreate(H5P_FILE_ACCESS)) < 0)
-        goto error;
+    hid_t fapl_id = H5I_INVALID_HID;
 
-    /* Attempt to set up a file driver first */
-    if(h5_get_vfd_fapl(fapl_id) < 0)
+    if ((fapl_id = H5Pcreate(H5P_FILE_ACCESS)) < 0)
         goto error;
 
-    /* Finally, check for libver bounds */
-    if(h5_get_libver_fapl(fapl_id) < 0)
+    /* Check for libver bounds */
+    if (h5_get_libver_fapl(fapl_id) < 0)
         goto error;
 
     return fapl_id;
 
 error:
-    if(fapl_id != H5I_INVALID_HID)
+    if (fapl_id != H5I_INVALID_HID)
         H5Pclose(fapl_id);
     return H5I_INVALID_HID;
 } /* end h5_fileaccess() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    h5_fileaccess_flags
  *
@@ -885,164 +829,23 @@ error:
 hid_t
 h5_fileaccess_flags(unsigned flags)
 {
-    hid_t       fapl_id = H5I_INVALID_HID;
-
-    if((fapl_id = H5Pcreate(H5P_FILE_ACCESS)) < 0)
-        goto error;
+    hid_t fapl_id = H5I_INVALID_HID;
 
-    /* Attempt to set up a file driver first */
-    if((flags & H5_FILEACCESS_VFD) && h5_get_vfd_fapl(fapl_id) < 0)
+    if ((fapl_id = H5Pcreate(H5P_FILE_ACCESS)) < 0)
         goto error;
 
-    /* Finally, check for libver bounds */
-    if((flags & H5_FILEACCESS_LIBVER) && h5_get_libver_fapl(fapl_id) < 0)
+    /* Check for libver bounds */
+    if ((flags & H5_FILEACCESS_LIBVER) && h5_get_libver_fapl(fapl_id) < 0)
         goto error;
 
     return fapl_id;
 
 error:
-    if(fapl_id != H5I_INVALID_HID)
+    if (fapl_id != H5I_INVALID_HID)
         H5Pclose(fapl_id);
     return H5I_INVALID_HID;
 } /* end h5_fileaccess_flags() */
 
-
-/*-------------------------------------------------------------------------
- * Function:    h5_get_vfd_fapl
- *
- * Purpose:     Sets the file driver for a FAPL according to the value specified
- *              in the constant or environment variable "HDF5_DRIVER".
- *
- * Return:      Success:    0
- *              Failure:    -1
- *
- * Programmer:  Dana Robinson
- *              February 2016
- *
- *-------------------------------------------------------------------------
- */
-herr_t
-h5_get_vfd_fapl(hid_t fapl)
-{
-    const char  *env = NULL;    /* HDF5_DRIVER environment variable     */
-    const char  *tok = NULL;    /* strtok pointer                       */
-    char        *lasts = NULL;  /* Context pointer for strtok_r() call */
-    char        buf[1024];      /* buffer for tokenizing HDF5_DRIVER    */
-
-    /* Get the environment variable, if it exists */
-    env = HDgetenv("HDF5_DRIVER");
-#ifdef HDF5_DRIVER
-    /* Use the environment variable, then the compile-time constant */
-    if(!env)
-        env = HDF5_DRIVER;
-#endif
-
-    /* If the environment variable was not set, just return
-     * without modifying the FAPL.
-     */
-    if(!env || !*env)
-        goto done;
-
-    /* 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));
-    buf[sizeof(buf) - 1] = '\0';
-    if(NULL == (tok = HDstrtok_r(buf, " \t\n\r", &lasts)))
-        goto done;
-
-    if(!HDstrcmp(tok, "sec2")) {
-        /* POSIX (section 2) read() and write() system calls */
-        if(H5Pset_fapl_sec2(fapl) < 0)
-            goto error;
-    } else if(!HDstrcmp(tok, "stdio")) {
-        /* Standard C fread() and fwrite() system calls */
-        if(H5Pset_fapl_stdio(fapl) < 0)
-            goto error;
-    } else if(!HDstrcmp(tok, "core")) {
-        /* In-memory driver settings (backing store on, 1 MB increment) */
-        if(H5Pset_fapl_core(fapl, (size_t)H5_MB, TRUE) < 0)
-            goto error;
-    } else if(!HDstrcmp(tok, "core_paged")) {
-        /* In-memory driver with write tracking and paging on */
-        if(H5Pset_fapl_core(fapl, (size_t)H5_MB, TRUE) < 0)
-            goto error;
-        if(H5Pset_core_write_tracking(fapl, TRUE, (size_t)4096) < 0)
-            goto error;
-     } 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)
-            goto error;
-    } 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];
-        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;
-            sv[mt] = (char *)HDmalloc(H5TEST_MULTI_FILENAME_LEN);
-            HDassert(sv[mt]);
-            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)
-            goto error;
-
-        for(mt = H5FD_MEM_DEFAULT; mt < H5FD_MEM_NTYPES; H5_INC_ENUM(H5FD_mem_t, mt))
-            HDfree(sv[mt]);
-    } 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_r(NULL, " \t\n\r", &lasts)))
-            fam_size = (hsize_t)(HDstrtod(tok, NULL) * 1024 * 1024);
-        if(H5Pset_fapl_family(fapl, fam_size, H5P_DEFAULT) < 0)
-            goto error;
-    } 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_r(NULL, " \t\n\r", &lasts)))
-            log_flags = (unsigned)HDstrtol(tok, NULL, 0);
-
-        if(H5Pset_fapl_log(fapl, NULL, log_flags, (size_t)0) < 0)
-            goto error;
-#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)
-            goto error;
-#endif
-    } else {
-        /* Unknown driver */
-        goto error;
-    } /* end if */
-
-done:
-    return 0;
-
-error:
-    return -1;
-} /* end h5_get_vfd_fapl() */
-
-
 /*-------------------------------------------------------------------------
  * Function:    h5_get_libver_fapl
  *
@@ -1060,23 +863,23 @@ error:
 herr_t
 h5_get_libver_fapl(hid_t fapl)
 {
-    const char  *env = NULL;    /* HDF5_DRIVER environment variable     */
-    const char  *tok = NULL;    /* strtok pointer                       */
-    char        *lasts = NULL;  /* Context pointer for strtok_r() call */
-    char        buf[1024];      /* buffer for tokenizing HDF5_DRIVER    */
+    const char *env   = NULL; /* HDF5_DRIVER environment variable     */
+    const char *tok   = NULL; /* strtok pointer                       */
+    char *      lasts = NULL; /* Context pointer for strtok_r() call */
+    char        buf[1024];    /* buffer for tokenizing HDF5_DRIVER    */
 
     /* Get the environment variable, if it exists */
     env = HDgetenv("HDF5_LIBVER_BOUNDS");
 #ifdef HDF5_LIBVER_BOUNDS
     /* Use the environment variable, then the compile-time constant */
-    if(!env)
+    if (!env)
         env = HDF5_LIBVER_BOUNDS;
 #endif
 
     /* If the environment variable was not set, just return
      * without modifying the FAPL.
      */
-    if(!env || !*env)
+    if (!env || !*env)
         goto done;
 
     /* Get the first 'word' of the environment variable.
@@ -1085,12 +888,12 @@ h5_get_libver_fapl(hid_t fapl)
      */
     HDstrncpy(buf, env, sizeof(buf));
     buf[sizeof(buf) - 1] = '\0';
-    if(NULL == (tok = HDstrtok_r(buf, " \t\n\r", &lasts)))
+    if (NULL == (tok = HDstrtok_r(buf, " \t\n\r", &lasts)))
         goto done;
 
-    if(!HDstrcmp(tok, "latest")) {
+    if (!HDstrcmp(tok, "latest")) {
         /* use the latest format */
-        if(H5Pset_libver_bounds(fapl, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST) < 0)
+        if (H5Pset_libver_bounds(fapl, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST) < 0)
             goto error;
     } /* end if */
     else {
@@ -1105,7 +908,6 @@ error:
     return -1;
 } /* end h5_get_libver_fapl() */
 
-
 /*-------------------------------------------------------------------------
  * Function:  h5_no_hwconv
  *
@@ -1126,7 +928,6 @@ h5_no_hwconv(void)
     H5Tunregister(H5T_PERS_HARD, NULL, (hid_t)-1, (hid_t)-1, NULL);
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:  h5_show_hostname
  *
@@ -1144,10 +945,10 @@ h5_no_hwconv(void)
 void
 h5_show_hostname(void)
 {
-    char  hostname[80];
+    char hostname[80];
 #ifdef H5_HAVE_WIN32_API
     WSADATA wsaData;
-    int err;
+    int     err;
 #endif
 
     /* try show the process or thread id in multiple processes cases*/
@@ -1158,22 +959,20 @@ h5_show_hostname(void)
         MPI_Initialized(&mpi_initialized);
         MPI_Finalized(&mpi_finalized);
 
-        if(mpi_initialized && !mpi_finalized) {
-            MPI_Comm_rank(MPI_COMM_WORLD,&mpi_rank);
+        if (mpi_initialized && !mpi_finalized) {
+            MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
             HDprintf("MPI-process %d.", mpi_rank);
         }
         else
             HDprintf("thread 0.");
     }
-#elif defined(H5_HAVE_THREADSAFE)
-    HDprintf("thread %lu.", HDpthread_self_ulong());
 #else
-    HDprintf("thread 0.");
+    HDprintf("thread %" PRIu64 ".", H5TS_thread_id());
 #endif
 #ifdef H5_HAVE_WIN32_API
 
-    err = WSAStartup( MAKEWORD(2,2), &wsaData );
-    if ( err != 0 ) {
+    err = WSAStartup(MAKEWORD(2, 2), &wsaData);
+    if (err != 0) {
         /* could not find a usable WinSock DLL */
         return;
     }
@@ -1184,10 +983,9 @@ h5_show_hostname(void)
     /* 2.2 in wVersion since that is the version we      */
     /* requested.                                        */
 
-    if ( LOBYTE( wsaData.wVersion ) != 2 ||
-         HIBYTE( wsaData.wVersion ) != 2 ) {
+    if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2) {
         /* could not find a usable WinSock DLL */
-        WSACleanup( );
+        WSACleanup();
         return;
     }
 
@@ -1205,7 +1003,6 @@ h5_show_hostname(void)
 #endif
 }
 
-
 #ifdef H5_HAVE_PARALLEL
 /*
  * Function:    h5_set_info_object
@@ -1223,16 +1020,17 @@ h5_show_hostname(void)
 int
 h5_set_info_object(void)
 {
-    char  *envp;      /* environment pointer */
-    int    ret_value=0;
+    char *envp; /* environment pointer */
+    int   ret_value = 0;
 
     /* handle any MPI INFO hints via $HDF5_MPI_INFO */
-    if ((envp = HDgetenv("HDF5_MPI_INFO")) != NULL){
+    if ((envp = HDgetenv("HDF5_MPI_INFO")) != NULL) {
         char *next, *valp;
 
         valp = envp = next = HDstrdup(envp);
 
-        if (!valp) return 0;
+        if (!valp)
+            return 0;
 
         /* create an INFO object if not created yet */
         if (h5_io_info_g == MPI_INFO_NULL)
@@ -1240,15 +1038,16 @@ h5_set_info_object(void)
 
         do {
             size_t len;
-            char *key_val, *endp, *namep;
+            char * key_val, *endp, *namep;
 
             if (*valp == ';')
                 valp++;
 
             /* copy key/value pair into temporary buffer */
-            len = strcspn(valp, ";");
+            len  = HDstrcspn(valp, ";");
             next = &valp[len];
-            key_val = (char *)HDcalloc(1, len + 1);
+            if (NULL == (key_val = (char *)HDcalloc(1, len + 1)))
+                return -1;
 
             /* increment the next pointer past the terminating semicolon */
             if (*next == ';')
@@ -1260,7 +1059,8 @@ h5_set_info_object(void)
             while (*namep && (*namep == ' ' || *namep == '\t'))
                 namep++;
 
-            if (!*namep) continue; /* was all white space, so move to next k/v pair */
+            if (!*namep)
+                continue; /* was all white space, so move to next k/v pair */
 
             /* eat up any ending white spaces */
             endp = &namep[HDstrlen(namep) - 1];
@@ -1271,7 +1071,7 @@ h5_set_info_object(void)
             /* find the '=' */
             valp = HDstrchr(namep, '=');
 
-            if (valp != NULL) {     /* it's a valid key/value pairing */
+            if (valp != NULL) { /* it's a valid key/value pairing */
                 char *tmp_val = valp + 1;
 
                 /* change '=' to \0, move valp down one */
@@ -1304,7 +1104,6 @@ h5_set_info_object(void)
     return ret_value;
 }
 
-
 /*
  * Function:    h5_dump_info_object
  * Purpose:     Display content of an MPI Info object
@@ -1315,29 +1114,26 @@ h5_set_info_object(void)
 void
 h5_dump_info_object(MPI_Info info)
 {
-    char  key[MPI_MAX_INFO_KEY+1];
-    char  value[MPI_MAX_INFO_VAL+1];
-    int    flag;
-    int    i, nkeys;
-
-    HDprintf("Dumping MPI Info Object(%d) (up to %d bytes per item):\n", (int)info,
-  MPI_MAX_INFO_VAL);
-    if (info==MPI_INFO_NULL){
-  HDprintf("object is MPI_INFO_NULL\n");
+    char key[MPI_MAX_INFO_KEY + 1];
+    char value[MPI_MAX_INFO_VAL + 1];
+    int  flag;
+    int  i, nkeys;
+
+    HDprintf("Dumping MPI Info Object (up to %d bytes per item):\n", MPI_MAX_INFO_VAL);
+    if (info == MPI_INFO_NULL) {
+        HDprintf("object is MPI_INFO_NULL\n");
     }
     else {
-  MPI_Info_get_nkeys(info, &nkeys);
-  HDprintf("object has %d items\n", nkeys);
-  for (i=0; i<nkeys; i++){
-      MPI_Info_get_nthkey(info, i, key);
-      MPI_Info_get(info, key, MPI_MAX_INFO_VAL, value, &flag);
-      HDprintf("%s=%s\n", key, value);
-  }
-
+        MPI_Info_get_nkeys(info, &nkeys);
+        HDprintf("object has %d items\n", nkeys);
+        for (i = 0; i < nkeys; i++) {
+            MPI_Info_get_nthkey(info, i, key);
+            MPI_Info_get(info, key, MPI_MAX_INFO_VAL, value, &flag);
+            HDprintf("%s=%s\n", key, value);
+        }
     }
 }
-#endif  /* H5_HAVE_PARALLEL */
-
+#endif /* H5_HAVE_PARALLEL */
 
 /*-------------------------------------------------------------------------
  * Function:  h5_get_file_size
@@ -1358,110 +1154,142 @@ h5_dump_info_object(MPI_Info info)
  *      temp in the code below, but early (4.4.7, at least) gcc only
  *      allows diagnostic pragmas to be toggled outside of functions.
  */
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wformat-nonliteral"
+H5_GCC_CLANG_DIAG_OFF("format-nonliteral")
 h5_stat_size_t
 h5_get_file_size(const char *filename, hid_t fapl)
 {
-    char temp[2048];    /* Temporary buffer for file names */
-    h5_stat_t  sb;     /* Structure for querying file info */
-    int j = 0;
+    char      temp[2048]; /* Temporary buffer for file names */
+    h5_stat_t sb;         /* Structure for querying file info */
+    int       j = 0;
 
-    if(fapl == H5P_DEFAULT) {
+    if (fapl == H5P_DEFAULT) {
         /* Get the file's statistics */
-        if(0 == HDstat(filename, &sb))
-            return((h5_stat_size_t)sb.st_size);
+        if (0 == HDstat(filename, &sb))
+            return ((h5_stat_size_t)sb.st_size);
     } /* end if */
     else {
-        hid_t  driver;         /* VFD used for file */
+        hid_t driver; /* VFD used for file */
 
         /* Get the driver used when creating the file */
-        if((driver = H5Pget_driver(fapl)) < 0)
-            return(-1);
+        if ((driver = H5Pget_driver(fapl)) < 0)
+            return (-1);
 
         /* Check for simple cases */
-        if(driver == H5FD_SEC2 || driver == H5FD_STDIO || driver == H5FD_CORE ||
+        if (driver == H5FD_SEC2 || driver == H5FD_STDIO || driver == H5FD_CORE ||
 #ifdef H5_HAVE_WINDOWS
-                driver == H5FD_WINDOWS ||
+            driver == H5FD_WINDOWS ||
 #endif /* H5_HAVE_WINDOWS */
 #ifdef H5_HAVE_DIRECT
-                driver == H5FD_DIRECT ||
+            driver == H5FD_DIRECT ||
 #endif /* H5_HAVE_DIRECT */
-                driver == H5FD_LOG) {
+            driver == H5FD_LOG || driver == H5FD_SPLITTER) {
             /* Get the file's statistics */
-            if(0 == HDstat(filename, &sb))
-                return((h5_stat_size_t)sb.st_size);
+            if (0 == HDstat(filename, &sb))
+                return ((h5_stat_size_t)sb.st_size);
         } /* end if */
-        else if(driver == H5FD_MULTI) {
-            H5FD_mem_t mt;
-            h5_stat_size_t tot_size = 0;
-
-            HDassert(HDstrlen(multi_letters) == H5FD_MEM_NTYPES);
-            for(mt = H5FD_MEM_DEFAULT; mt < H5FD_MEM_NTYPES; H5_INC_ENUM(H5FD_mem_t, mt)) {
-                /* Create the filename to query */
-                HDsnprintf(temp, sizeof temp, "%s-%c.h5", filename, multi_letters[mt]);
-
-                /* Check for existence of file */
-                if(0 == HDaccess(temp, F_OK)) {
-                    /* Get the file's statistics */
-                    if(0 != HDstat(temp, &sb))
-                        return(-1);
-
-                    /* Add to total size */
-                    tot_size += (h5_stat_size_t)sb.st_size;
-                } /* end if */
-            } /* end for */
+        else if (driver == H5FD_MULTI) {
+            H5FD_mem_t     mt;
+            h5_stat_size_t tot_size       = 0;
+            char *         driver_env_var = NULL;
+
+            driver_env_var = HDgetenv(HDF5_DRIVER);
+            if (driver_env_var && !HDstrcmp(driver_env_var, "split")) {
+                for (mt = H5FD_MEM_DEFAULT; mt < H5FD_MEM_NTYPES; mt++) {
+                    if (mt != H5FD_MEM_DRAW && mt != H5FD_MEM_SUPER)
+                        continue;
+
+                    /* Create the filename to query */
+                    if (mt == H5FD_MEM_DRAW) {
+                        HDsnprintf(temp, sizeof temp, "%s.raw", filename);
+                    }
+                    else {
+                        HDsnprintf(temp, sizeof temp, "%s.meta", filename);
+                    }
+
+                    /* Check for existence of file */
+                    if (0 == HDaccess(temp, F_OK)) {
+                        /* Get the file's statistics */
+                        if (0 != HDstat(temp, &sb))
+                            return (-1);
+
+                        /* Add to total size */
+                        tot_size += (h5_stat_size_t)sb.st_size;
+                    } /* end if */
+                }     /* end for */
+            }
+            else {
+                HDassert(HDstrlen(multi_letters) == H5FD_MEM_NTYPES);
+                for (mt = H5FD_MEM_DEFAULT; mt < H5FD_MEM_NTYPES; mt++) {
+                    /* Create the filename to query */
+                    HDsnprintf(temp, sizeof temp, "%s-%c.h5", filename, multi_letters[mt]);
+
+                    /* Check for existence of file */
+                    if (0 == HDaccess(temp, F_OK)) {
+                        /* Get the file's statistics */
+                        if (0 != HDstat(temp, &sb))
+                            return (-1);
+
+                        /* Add to total size */
+                        tot_size += (h5_stat_size_t)sb.st_size;
+                    } /* end if */
+                }     /* end for */
+            }
 
             /* Return total size */
-            return(tot_size);
+            return (tot_size);
         } /* end if */
 #ifdef H5_HAVE_PARALLEL
-        else if(driver == H5FD_MPIO) {
-            MPI_File fh;         /* MPI file handle used to open the file and verify its size */
-            int mpi_ret;
+        else if (driver == H5FD_MPIO) {
+            MPI_File   fh; /* MPI file handle used to open the file and verify its size */
+            int        mpi_ret;
             MPI_Offset file_size;
 
             mpi_ret = MPI_File_open(MPI_COMM_WORLD, filename, MPI_MODE_RDONLY, MPI_INFO_NULL, &fh);
-            if (mpi_ret != MPI_SUCCESS) return -1;
+            if (mpi_ret != MPI_SUCCESS)
+                return -1;
             mpi_ret = MPI_File_get_size(fh, &file_size);
-            if (mpi_ret != MPI_SUCCESS) return -1;
+            if (mpi_ret != MPI_SUCCESS)
+                return -1;
             mpi_ret = MPI_File_close(&fh);
-            if (mpi_ret != MPI_SUCCESS) return -1;
+            if (mpi_ret != MPI_SUCCESS)
+                return -1;
 
             return file_size;
         }
 #endif /* H5_HAVE_PARALLEL */
-        else if(driver == H5FD_FAMILY) {
+        else if (driver == H5FD_FAMILY) {
             h5_stat_size_t tot_size = 0;
 
             /* Try all filenames possible, until we find one that's missing */
-            for(j = 0; /*void*/; j++) {
+            for (j = 0; /*void*/; j++) {
                 /* Create the filename to query */
                 HDsnprintf(temp, sizeof temp, filename, j);
 
                 /* Check for existence of file */
-                if(HDaccess(temp, F_OK) < 0)
+                if (HDaccess(temp, F_OK) < 0)
                     break;
 
                 /* Get the file's statistics */
-                if(0 != HDstat(temp, &sb))
-                    return(-1);
+                if (0 != HDstat(temp, &sb))
+                    return (-1);
 
                 /* Add to total size */
                 tot_size += (h5_stat_size_t)sb.st_size;
             } /* end for */
 
             /* Return total size */
-            return(tot_size);
+            return (tot_size);
         } /* end if */
         else {
-            HDassert(0 && "Unknown VFD!");
+            /* Get the file's statistics */
+            if (0 == HDstat(filename, &sb))
+                return ((h5_stat_size_t)sb.st_size);
         } /* end else */
-    } /* end else */
+    }     /* end else */
 
-    return(-1);
+    return (-1);
 } /* end get_file_size() */
-#pragma GCC diagnostic pop
+H5_GCC_CLANG_DIAG_ON("format-nonliteral")
 
 /*
  * This routine is designed to provide equivalent functionality to 'printf'
@@ -1472,18 +1300,17 @@ H5_ATTR_FORMAT(printf, 1, 2)
 int
 print_func(const char *format, ...)
 {
-  va_list arglist;
-  int ret_value;
+    va_list arglist;
+    int     ret_value;
 
-  HDva_start(arglist, format);
-  ret_value = HDvprintf(format, arglist);
-  HDva_end(arglist);
-  return ret_value;
+    HDva_start(arglist, format);
+    ret_value = HDvprintf(format, arglist);
+    HDva_end(arglist);
+    return ret_value;
 }
 
 #ifdef H5_HAVE_FILTER_SZIP
 
-
 /*-------------------------------------------------------------------------
  * Function:  h5_szip_can_encode
  *
@@ -1500,31 +1327,31 @@ print_func(const char *format, ...)
  *
  *-------------------------------------------------------------------------
  */
-int h5_szip_can_encode(void )
+int
+h5_szip_can_encode(void)
 {
     unsigned int filter_config_flags;
 
     H5Zget_filter_info(H5Z_FILTER_SZIP, &filter_config_flags);
-    if ((filter_config_flags &
-            (H5Z_FILTER_CONFIG_ENCODE_ENABLED|H5Z_FILTER_CONFIG_DECODE_ENABLED)) == 0) {
+    if ((filter_config_flags & (H5Z_FILTER_CONFIG_ENCODE_ENABLED | H5Z_FILTER_CONFIG_DECODE_ENABLED)) == 0) {
         /* filter present but neither encode nor decode is supported (???) */
         return -1;
-    } else if ((filter_config_flags &
-            (H5Z_FILTER_CONFIG_ENCODE_ENABLED|H5Z_FILTER_CONFIG_DECODE_ENABLED)) ==
-            H5Z_FILTER_CONFIG_DECODE_ENABLED) {
+    }
+    else if ((filter_config_flags & (H5Z_FILTER_CONFIG_ENCODE_ENABLED | H5Z_FILTER_CONFIG_DECODE_ENABLED)) ==
+             H5Z_FILTER_CONFIG_DECODE_ENABLED) {
         /* decoder only: read but not write */
         return 0;
-    } else if ((filter_config_flags &
-            (H5Z_FILTER_CONFIG_ENCODE_ENABLED|H5Z_FILTER_CONFIG_DECODE_ENABLED)) ==
-            H5Z_FILTER_CONFIG_ENCODE_ENABLED) {
+    }
+    else if ((filter_config_flags & (H5Z_FILTER_CONFIG_ENCODE_ENABLED | H5Z_FILTER_CONFIG_DECODE_ENABLED)) ==
+             H5Z_FILTER_CONFIG_ENCODE_ENABLED) {
         /* encoder only: write but not read (???) */
         return -1;
-    } else if ((filter_config_flags &
-            (H5Z_FILTER_CONFIG_ENCODE_ENABLED|H5Z_FILTER_CONFIG_DECODE_ENABLED)) ==
-            (H5Z_FILTER_CONFIG_ENCODE_ENABLED|H5Z_FILTER_CONFIG_DECODE_ENABLED)) {
+    }
+    else if ((filter_config_flags & (H5Z_FILTER_CONFIG_ENCODE_ENABLED | H5Z_FILTER_CONFIG_DECODE_ENABLED)) ==
+             (H5Z_FILTER_CONFIG_ENCODE_ENABLED | H5Z_FILTER_CONFIG_DECODE_ENABLED)) {
         return 1;
     }
-   return(-1);
+    return (-1);
 }
 #endif /* H5_HAVE_FILTER_SZIP */
 
@@ -1556,27 +1383,27 @@ int h5_szip_can_encode(void )
  *-------------------------------------------------------------------------
  */
 char *
-getenv_all(MPI_Comm comm, int root, const char* name)
+getenv_all(MPI_Comm comm, int root, const char *name)
 {
-    int mpi_size, mpi_rank, mpi_initialized, mpi_finalized;
-    int len;
-    static char* env = NULL;
+    int          mpi_size, mpi_rank, mpi_initialized, mpi_finalized;
+    int          len;
+    static char *env = NULL;
 
     HDassert(name);
 
     MPI_Initialized(&mpi_initialized);
     MPI_Finalized(&mpi_finalized);
 
-    if(mpi_initialized && !mpi_finalized) {
+    if (mpi_initialized && !mpi_finalized) {
         MPI_Comm_rank(comm, &mpi_rank);
         MPI_Comm_size(comm, &mpi_size);
         HDassert(root < mpi_size);
 
         /* The root task does the getenv call
          * and sends the result to the other tasks */
-        if(mpi_rank == root) {
+        if (mpi_rank == root) {
             env = HDgetenv(name);
-            if(env) {
+            if (env) {
                 len = (int)HDstrlen(env);
                 MPI_Bcast(&len, 1, MPI_INT, root, comm);
                 MPI_Bcast(env, len, MPI_CHAR, root, comm);
@@ -1589,17 +1416,17 @@ getenv_all(MPI_Comm comm, int root, const char* name)
         }
         else {
             MPI_Bcast(&len, 1, MPI_INT, root, comm);
-            if(len >= 0) {
-                if(env == NULL)
-                    env = (char*) HDmalloc((size_t)len+1);
-                else if(HDstrlen(env) < (size_t)len)
-                    env = (char*) HDrealloc(env, (size_t)len+1);
+            if (len >= 0) {
+                if (env == NULL)
+                    env = (char *)HDmalloc((size_t)len + 1);
+                else if (HDstrlen(env) < (size_t)len)
+                    env = (char *)HDrealloc(env, (size_t)len + 1);
 
                 MPI_Bcast(env, len, MPI_CHAR, root, comm);
                 env[len] = '\0';
             }
             else {
-                if(env)
+                if (env)
                     HDfree(env);
                 env = NULL;
             }
@@ -1610,7 +1437,7 @@ getenv_all(MPI_Comm comm, int root, const char* name)
     }
     else {
         /* use original getenv */
-        if(env)
+        if (env)
             HDfree(env);
         env = HDgetenv(name);
     } /* end if */
@@ -1641,30 +1468,33 @@ getenv_all(MPI_Comm comm, int root, const char* name)
 int
 h5_make_local_copy(const char *origfilename, const char *local_copy_name)
 {
-    int fd_old = (-1), fd_new = (-1);   /* File descriptors for copying data */
-    ssize_t nread;                      /* Number of bytes read in */
-    void  *buf = NULL;                  /* Buffer for copying data */
-    const char *filename = H5_get_srcdir_filename(origfilename);       /* Get the test file name to copy */
+    int         fd_old = (-1), fd_new = (-1);                    /* File descriptors for copying data */
+    ssize_t     nread;                                           /* Number of bytes read in */
+    void *      buf      = NULL;                                 /* Buffer for copying data */
+    const char *filename = H5_get_srcdir_filename(origfilename); /* Get the test file name to copy */
+
+    if (!filename)
+        goto error;
 
     /* Allocate copy buffer */
-    if(NULL == (buf = HDcalloc((size_t)1, (size_t)READ_BUF_SIZE)))
+    if (NULL == (buf = HDcalloc((size_t)1, (size_t)READ_BUF_SIZE)))
         goto error;
 
     /* Copy old file into temporary file */
-    if((fd_old = HDopen(filename, O_RDONLY)) < 0)
+    if ((fd_old = HDopen(filename, O_RDONLY)) < 0)
         goto error;
-    if((fd_new = HDopen(local_copy_name, O_RDWR|O_CREAT|O_TRUNC, H5_POSIX_CREATE_MODE_RW)) < 0)
+    if ((fd_new = HDopen(local_copy_name, O_RDWR | O_CREAT | O_TRUNC, H5_POSIX_CREATE_MODE_RW)) < 0)
         goto error;
 
     /* Copy data */
-    while((nread = HDread(fd_old, buf, (size_t)READ_BUF_SIZE)) > 0)
-        if(HDwrite(fd_new, buf, (size_t)nread) < 0)
+    while ((nread = HDread(fd_old, buf, (size_t)READ_BUF_SIZE)) > 0)
+        if (HDwrite(fd_new, buf, (size_t)nread) < 0)
             goto error;
 
     /* Close files */
-    if(HDclose(fd_old) < 0)
+    if (HDclose(fd_old) < 0)
         goto error;
-    if(HDclose(fd_new) < 0)
+    if (HDclose(fd_new) < 0)
         goto error;
 
     /* Release memory */
@@ -1674,15 +1504,14 @@ h5_make_local_copy(const char *origfilename, const char *local_copy_name)
 
 error:
     /* ignore return values since we're already noted the problem */
-    if(fd_old > 0)
+    if (fd_old > 0)
         HDclose(fd_old);
-    if(fd_new > 0)
+    if (fd_new > 0)
         HDclose(fd_new);
     HDfree(buf);
     return -1;
 } /* end h5_make_local_copy() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    h5_verify_cached_stabs_cb
  *
@@ -1696,16 +1525,15 @@ error:
  *-------------------------------------------------------------------------
  */
 static herr_t
-h5_verify_cached_stabs_cb(hid_t oid, const char H5_ATTR_UNUSED *name,
-    const H5O_info_t *oinfo, void H5_ATTR_UNUSED *udata)
+h5_verify_cached_stabs_cb(hid_t oid, const char H5_ATTR_UNUSED *name, const H5O_info2_t *oinfo,
+                          void H5_ATTR_UNUSED *udata)
 {
-    if(oinfo->type == H5O_TYPE_GROUP)
+    if (oinfo->type == H5O_TYPE_GROUP)
         return H5G__verify_cached_stabs_test(oid);
     else
         return SUCCEED;
 } /* end h5_verify_cached_stabs_cb() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    h5_verify_cached_stabs
  *
@@ -1729,27 +1557,29 @@ h5_verify_cached_stabs_cb(hid_t oid, const char H5_ATTR_UNUSED *name,
 herr_t
 h5_verify_cached_stabs(const char *base_name[], hid_t fapl)
 {
-    hid_t       file = -1;
-    char        filename[1024];
-    int         i = 0;
+    hid_t file = -1;
+    char  filename[1024];
+    int   i = 0;
 
-    while(base_name[i]) {
+    while (base_name[i]) {
         if (h5_fixname(base_name[i], fapl, filename, sizeof(filename)) == NULL)
             continue;
 
-        H5E_BEGIN_TRY {
+        H5E_BEGIN_TRY
+        {
             file = H5Fopen(filename, H5F_ACC_RDONLY, fapl);
-        } H5E_END_TRY
-        if(file < 0) {
+        }
+        H5E_END_TRY
+        if (file < 0) {
             i++;
             continue;
         } /* end if */
 
-        if(H5Ovisit2(file, H5_INDEX_NAME, H5_ITER_NATIVE,
-                h5_verify_cached_stabs_cb, NULL, H5O_INFO_BASIC) < 0)
+        if (H5Ovisit3(file, H5_INDEX_NAME, H5_ITER_NATIVE, h5_verify_cached_stabs_cb, NULL, H5O_INFO_BASIC) <
+            0)
             goto error;
 
-        if(H5Fclose(file) < 0)
+        if (H5Fclose(file) < 0)
             goto error;
         file = -1;
 
@@ -1759,9 +1589,11 @@ h5_verify_cached_stabs(const char *base_name[], hid_t fapl)
     return 0;
 
 error:
-    H5E_BEGIN_TRY {
+    H5E_BEGIN_TRY
+    {
         H5Fclose(file);
-    } H5E_END_TRY;
+    }
+    H5E_END_TRY;
 
     return -1;
 }
@@ -1799,18 +1631,18 @@ h5_send_message(const char *send, const char *arg1, const char *arg2)
     signalfile = HDfopen(TMP_SIGNAL_FILE, "w+");
 
     /* Write messages to signal file, if provided */
-    if(arg2 != NULL) {
+    if (arg2 != NULL) {
         HDassert(arg1);
         HDfprintf(signalfile, "%s\n%s\n", arg1, arg2);
     } /* end if */
-    else if(arg1 != NULL) {
+    else if (arg1 != NULL) {
         HDassert(arg2 == NULL);
         HDfprintf(signalfile, "%s\n", arg1);
     } /* end if */
     else {
         HDassert(arg1 == NULL);
         HDassert(arg2 == NULL);
-    }/* end else */
+    } /* end else */
 
     HDfclose(signalfile);
 
@@ -1833,7 +1665,7 @@ h5_send_message(const char *send, const char *arg1, const char *arg2)
  *              signal file from disk, and only continues once it has
  *              successfully done so (i.e., only after another process has
  *              called the "h5_send_message" function to write the signal file).
- *              This functon will then immediately remove the file (i.e.,
+ *              This function will then immediately remove the file (i.e.,
  *              to indicate that it has been received and can be reused),
  *              and then exits, allowing the calling function to continue.
  *
@@ -1847,8 +1679,8 @@ h5_send_message(const char *send, const char *arg1, const char *arg2)
 herr_t
 h5_wait_message(const char *waitfor)
 {
-    FILE *returnfile;
-    time_t t0,t1;
+    FILE * returnfile;
+    time_t t0, t1;
 
     /* Start timer. If this function runs for too long (i.e.,
         expected signal is never received), it will
@@ -1864,11 +1696,11 @@ h5_wait_message(const char *waitfor)
         /* If we've been waiting for a signal for too long, then
             it was likely never sent and we should fail rather
             than loop infinitely */
-        if(HDdifftime(t1, t0) > MESSAGE_TIMEOUT) {
+        if (HDdifftime(t1, t0) > MESSAGE_TIMEOUT) {
             HDfprintf(stdout, "Error communicating between processes. Make sure test script is running.\n");
             TEST_ERROR;
         } /* end if */
-    } /* end while */
+    }     /* end while */
 
     HDfclose(returnfile);
     HDunlink(waitfor);
@@ -1885,63 +1717,104 @@ error:
  * real VFDs.
  */
 static H5FD_t *dummy_vfd_open(const char *name, unsigned flags, hid_t fapl_id, haddr_t maxaddr);
-static H5FD_t *dummy_vfd_open(const char H5_ATTR_UNUSED *name, unsigned H5_ATTR_UNUSED flags, hid_t H5_ATTR_UNUSED fapl_id, haddr_t H5_ATTR_UNUSED maxaddr) { return NULL; }
+static H5FD_t *
+dummy_vfd_open(const char H5_ATTR_UNUSED *name, unsigned H5_ATTR_UNUSED flags, hid_t H5_ATTR_UNUSED fapl_id,
+               haddr_t H5_ATTR_UNUSED maxaddr)
+{
+    return NULL;
+}
 
 static herr_t dummy_vfd_close(H5FD_t *_file);
-static herr_t dummy_vfd_close(H5FD_t H5_ATTR_UNUSED *_file) { return FAIL; }
+static herr_t
+dummy_vfd_close(H5FD_t H5_ATTR_UNUSED *_file)
+{
+    return FAIL;
+}
 
 static haddr_t dummy_vfd_get_eoa(const H5FD_t *file, H5FD_mem_t type);
-static haddr_t dummy_vfd_get_eoa(const H5FD_t H5_ATTR_UNUSED *file, H5FD_mem_t H5_ATTR_UNUSED type) { return HADDR_UNDEF; }
+static haddr_t
+dummy_vfd_get_eoa(const H5FD_t H5_ATTR_UNUSED *file, H5FD_mem_t H5_ATTR_UNUSED type)
+{
+    return HADDR_UNDEF;
+}
 
 static herr_t dummy_vfd_set_eoa(H5FD_t *_file, H5FD_mem_t type, haddr_t addr);
-static herr_t dummy_vfd_set_eoa(H5FD_t H5_ATTR_UNUSED *_file, H5FD_mem_t H5_ATTR_UNUSED type, haddr_t H5_ATTR_UNUSED addr) { return FAIL; }
+static herr_t
+dummy_vfd_set_eoa(H5FD_t H5_ATTR_UNUSED *_file, H5FD_mem_t H5_ATTR_UNUSED type, haddr_t H5_ATTR_UNUSED addr)
+{
+    return FAIL;
+}
 
 static haddr_t dummy_vfd_get_eof(const H5FD_t *file, H5FD_mem_t type);
-static haddr_t dummy_vfd_get_eof(const H5FD_t H5_ATTR_UNUSED *file, H5FD_mem_t H5_ATTR_UNUSED type) { return HADDR_UNDEF; }
+static haddr_t
+dummy_vfd_get_eof(const H5FD_t H5_ATTR_UNUSED *file, H5FD_mem_t H5_ATTR_UNUSED type)
+{
+    return HADDR_UNDEF;
+}
 
-static herr_t dummy_vfd_read(H5FD_t *_file, H5FD_mem_t type, hid_t fapl_id, haddr_t addr, size_t size, void *buf);
-static herr_t dummy_vfd_read(H5FD_t H5_ATTR_UNUSED *_file, H5FD_mem_t H5_ATTR_UNUSED type, hid_t H5_ATTR_UNUSED fapl_id, haddr_t H5_ATTR_UNUSED addr, size_t H5_ATTR_UNUSED size, void H5_ATTR_UNUSED *buf) { return FAIL; }
+static herr_t dummy_vfd_read(H5FD_t *_file, H5FD_mem_t type, hid_t fapl_id, haddr_t addr, size_t size,
+                             void *buf);
+static herr_t
+dummy_vfd_read(H5FD_t H5_ATTR_UNUSED *_file, H5FD_mem_t H5_ATTR_UNUSED type, hid_t H5_ATTR_UNUSED fapl_id,
+               haddr_t H5_ATTR_UNUSED addr, size_t H5_ATTR_UNUSED size, void H5_ATTR_UNUSED *buf)
+{
+    return FAIL;
+}
 
-static herr_t dummy_vfd_write(H5FD_t *_file, H5FD_mem_t type, hid_t fapl_id, haddr_t addr, size_t size, const void *buf);
-static herr_t dummy_vfd_write(H5FD_t H5_ATTR_UNUSED *_file, H5FD_mem_t H5_ATTR_UNUSED type, hid_t H5_ATTR_UNUSED fapl_id, haddr_t H5_ATTR_UNUSED addr, size_t H5_ATTR_UNUSED size, const void H5_ATTR_UNUSED *buf) { return FAIL; }
+static herr_t dummy_vfd_write(H5FD_t *_file, H5FD_mem_t type, hid_t fapl_id, haddr_t addr, size_t size,
+                              const void *buf);
+static herr_t
+dummy_vfd_write(H5FD_t H5_ATTR_UNUSED *_file, H5FD_mem_t H5_ATTR_UNUSED type, hid_t H5_ATTR_UNUSED fapl_id,
+                haddr_t H5_ATTR_UNUSED addr, size_t H5_ATTR_UNUSED size, const void H5_ATTR_UNUSED *buf)
+{
+    return FAIL;
+}
 
 /* Dummy VFD with the minimum parameters to make a VFD that can be registered */
+#define DUMMY_VFD_VALUE (H5FD_class_value_t)155
 static const H5FD_class_t H5FD_dummy_g = {
-    "dummy",                    /* name         */
-    1,                          /* maxaddr      */
-    H5F_CLOSE_WEAK,             /* fc_degree    */
-    NULL,                       /* terminate    */
-    NULL,                       /* sb_size      */
-    NULL,                       /* sb_encode    */
-    NULL,                       /* sb_decode    */
-    0,                          /* fapl_size    */
-    NULL,                       /* fapl_get     */
-    NULL,                       /* fapl_copy    */
-    NULL,                       /* fapl_free    */
-    0,                          /* dxpl_size    */
-    NULL,                       /* dxpl_copy    */
-    NULL,                       /* dxpl_free    */
-    dummy_vfd_open,             /* open         */
-    dummy_vfd_close,            /* close        */
-    NULL,                       /* cmp          */
-    NULL,                       /* query        */
-    NULL,                       /* get_type_map */
-    NULL,                       /* alloc        */
-    NULL,                       /* free         */
-    dummy_vfd_get_eoa,          /* get_eoa      */
-    dummy_vfd_set_eoa,          /* set_eoa      */
-    dummy_vfd_get_eof,          /* get_eof      */
-    NULL,                       /* get_handle   */
-    dummy_vfd_read,             /* read         */
-    dummy_vfd_write,            /* write        */
-    NULL,                       /* flush        */
-    NULL,                       /* truncate     */
-    NULL,                       /* lock         */
-    NULL,                       /* unlock       */
-    H5FD_FLMAP_DICHOTOMY    /* fl_map       */
+    H5FD_CLASS_VERSION,  /* struct version  */
+    DUMMY_VFD_VALUE,     /* value           */
+    "dummy",             /* name            */
+    1,                   /* maxaddr         */
+    H5F_CLOSE_WEAK,      /* fc_degree       */
+    NULL,                /* terminate       */
+    NULL,                /* sb_size         */
+    NULL,                /* sb_encode       */
+    NULL,                /* sb_decode       */
+    0,                   /* fapl_size       */
+    NULL,                /* fapl_get        */
+    NULL,                /* fapl_copy       */
+    NULL,                /* fapl_free       */
+    0,                   /* dxpl_size       */
+    NULL,                /* dxpl_copy       */
+    NULL,                /* dxpl_free       */
+    dummy_vfd_open,      /* open            */
+    dummy_vfd_close,     /* close           */
+    NULL,                /* cmp             */
+    NULL,                /* query           */
+    NULL,                /* get_type_map    */
+    NULL,                /* alloc           */
+    NULL,                /* free            */
+    dummy_vfd_get_eoa,   /* get_eoa         */
+    dummy_vfd_set_eoa,   /* set_eoa         */
+    dummy_vfd_get_eof,   /* get_eof         */
+    NULL,                /* get_handle      */
+    dummy_vfd_read,      /* read            */
+    dummy_vfd_write,     /* write           */
+    NULL,                /* read_vector     */
+    NULL,                /* write_vector    */
+    NULL,                /* read_selection  */
+    NULL,                /* write_selection */
+    NULL,                /* flush           */
+    NULL,                /* truncate        */
+    NULL,                /* lock            */
+    NULL,                /* unlock          */
+    NULL,                /* del             */
+    NULL,                /* ctl             */
+    H5FD_FLMAP_DICHOTOMY /* fl_map          */
 };
 
-
 /*-------------------------------------------------------------------------
  * Function:    h5_get_dummy_vfd_class()
  *
@@ -1965,10 +1838,10 @@ static const H5FD_class_t H5FD_dummy_g = {
 H5FD_class_t *
 h5_get_dummy_vfd_class(void)
 {
-    H5FD_class_t *vfd_class = NULL;     /* Dummy VFD that will be returned */
+    H5FD_class_t *vfd_class = NULL; /* Dummy VFD that will be returned */
 
     /* Create the class and initialize everything to zero/NULL */
-    if(NULL == (vfd_class = (H5FD_class_t *)HDmalloc(sizeof(H5FD_class_t))))
+    if (NULL == (vfd_class = (H5FD_class_t *)HDmalloc(sizeof(H5FD_class_t))))
         TEST_ERROR;
 
     /* Copy the dummy VFD */
@@ -1977,7 +1850,7 @@ h5_get_dummy_vfd_class(void)
     return vfd_class;
 
 error:
-    if(vfd_class)
+    if (vfd_class)
         HDfree(vfd_class);
     return NULL;
 } /* h5_get_dummy_vfd_class */
@@ -2005,21 +1878,22 @@ error:
 H5VL_class_t *
 h5_get_dummy_vol_class(void)
 {
-    H5VL_class_t *vol_class = NULL;     /* Dummy VOL class that will be returned */
+    H5VL_class_t *vol_class = NULL; /* Dummy VOL class that will be returned */
 
     /* Create the class and initialize everything to zero/NULL */
-    if(NULL == (vol_class = (H5VL_class_t *)HDcalloc((size_t)1, sizeof(H5VL_class_t))))
+    if (NULL == (vol_class = (H5VL_class_t *)HDcalloc((size_t)1, sizeof(H5VL_class_t))))
         TEST_ERROR;
 
     /* Fill in the minimum parameters to make a VOL connector class that
      * can be registered.
      */
-    vol_class->name = "dummy";
+    vol_class->version = H5VL_VERSION;
+    vol_class->name    = "dummy";
 
     return vol_class;
 
 error:
-    if(vol_class)
+    if (vol_class)
         HDfree(vol_class);
     return NULL;
 } /* h5_get_dummy_vol_class */
@@ -2036,5 +1910,401 @@ error:
 H5_ATTR_PURE const char *
 h5_get_version_string(H5F_libver_t libver)
 {
-    return(LIBVER_NAMES[libver]);
+    return (LIBVER_NAMES[libver]);
 } /* end of h5_get_version_string */
+
+/*-------------------------------------------------------------------------
+ * Function:    h5_compare_file_bytes()
+ *
+ * Purpose:     Helper function to compare two files byte-for-byte.
+ *
+ * Return:      Success:  0, if files are identical
+ *              Failure: -1, if files differ
+ *
+ * Programmer:  Binh-Minh Ribler
+ *              October, 2018
+ *-------------------------------------------------------------------------
+ */
+int
+h5_compare_file_bytes(char *f1name, char *f2name)
+{
+    FILE *f1ptr     = NULL; /* two file pointers */
+    FILE *f2ptr     = NULL;
+    off_t f1size    = 0; /* size of the files */
+    off_t f2size    = 0;
+    char  f1char    = 0; /* one char from each file */
+    char  f2char    = 0;
+    off_t ii        = 0;
+    int   ret_value = 0; /* for error handling */
+
+    /* Open files for reading */
+    f1ptr = HDfopen(f1name, "rb");
+    if (f1ptr == NULL) {
+        HDfprintf(stderr, "Unable to fopen() %s\n", f1name);
+        ret_value = -1;
+        goto done;
+    }
+    f2ptr = HDfopen(f2name, "rb");
+    if (f2ptr == NULL) {
+        HDfprintf(stderr, "Unable to fopen() %s\n", f2name);
+        ret_value = -1;
+        goto done;
+    }
+
+    /* Get the file sizes and verify that they equal */
+    HDfseek(f1ptr, 0, SEEK_END);
+    f1size = HDftell(f1ptr);
+
+    HDfseek(f2ptr, 0, SEEK_END);
+    f2size = HDftell(f2ptr);
+
+    if (f1size != f2size) {
+        HDfprintf(stderr, "Files differ in size, %" PRIuHSIZE " vs. %" PRIuHSIZE "\n", (hsize_t)f1size,
+                  (hsize_t)f2size);
+        ret_value = -1;
+        goto done;
+    }
+
+    /* Compare each byte and fail if a difference is found */
+    HDrewind(f1ptr);
+    HDrewind(f2ptr);
+    for (ii = 0; ii < f1size; ii++) {
+        if (HDfread(&f1char, 1, 1, f1ptr) != 1) {
+            ret_value = -1;
+            goto done;
+        }
+        if (HDfread(&f2char, 1, 1, f2ptr) != 1) {
+            ret_value = -1;
+            goto done;
+        }
+        if (f1char != f2char) {
+            HDfprintf(stderr, "Mismatch @ 0x%" PRIXHSIZE ": 0x%X != 0x%X\n", (hsize_t)ii, f1char, f2char);
+            ret_value = -1;
+            goto done;
+        }
+    }
+
+done:
+    if (f1ptr)
+        HDfclose(f1ptr);
+    if (f2ptr)
+        HDfclose(f2ptr);
+    return ret_value;
+} /* end h5_compare_file_bytes() */
+
+/*-------------------------------------------------------------------------
+ * Function:    H5_get_srcdir_filename
+ *
+ * Purpose:     Append the test file name to the srcdir path and return the whole string
+ *
+ * Return:      The string
+ *
+ *-------------------------------------------------------------------------
+ */
+const char *
+H5_get_srcdir_filename(const char *filename)
+{
+    const char *srcdir = H5_get_srcdir();
+
+    /* Check for error */
+    if (NULL == srcdir)
+        return (NULL);
+    else {
+        /* Build path to test file */
+        if ((HDstrlen(srcdir) + HDstrlen(filename) + 1) < sizeof(srcdir_testpath)) {
+            HDsnprintf(srcdir_testpath, sizeof(srcdir_testpath), "%s%s", srcdir, filename);
+            return (srcdir_testpath);
+        } /* end if */
+        else
+            return (NULL);
+    } /* end else */
+} /* end H5_get_srcdir_filename() */
+
+/*-------------------------------------------------------------------------
+ * Function:    H5_get_srcdir
+ *
+ * Purpose:     Just return the srcdir path
+ *
+ * Return:      The string
+ *
+ *-------------------------------------------------------------------------
+ */
+const char *
+H5_get_srcdir(void)
+{
+    const char *srcdir = HDgetenv("srcdir");
+
+    /* Check for using the srcdir from configure time */
+    if (NULL == srcdir)
+        srcdir = config_srcdir;
+
+    /* Build path to all test files */
+    if ((HDstrlen(srcdir) + 2) < sizeof(srcdir_path)) {
+        HDsnprintf(srcdir_path, sizeof(srcdir_path), "%s/", srcdir);
+        return (srcdir_path);
+    } /* end if */
+    else
+        return (NULL);
+} /* end H5_get_srcdir() */
+
+/*-------------------------------------------------------------------------
+ * Function:    h5_duplicate_file_by_bytes
+ *
+ * Purpose:     Duplicate a file byte-for-byte at filename/path 'orig'
+ *              to a new (or replaced) file at 'dest'.
+ *
+ * Return:      Success:  0, completed successfully
+ *              Failure: -1
+ *
+ * Programmer:  Jake Smith
+ *              24 June 2020
+ *
+ *-------------------------------------------------------------------------
+ */
+int
+h5_duplicate_file_by_bytes(const char *orig, const char *dest)
+{
+    FILE *  orig_ptr  = NULL;
+    FILE *  dest_ptr  = NULL;
+    hsize_t fsize     = 0;
+    hsize_t read_size = 0;
+    hsize_t max_buf   = 0;
+    void *  dup_buf   = NULL;
+    int     ret_value = 0;
+
+    max_buf = 4096 * sizeof(char);
+
+    orig_ptr = HDfopen(orig, "rb");
+    if (NULL == orig_ptr) {
+        ret_value = -1;
+        goto done;
+    }
+
+    HDfseek(orig_ptr, 0, SEEK_END);
+    fsize = (hsize_t)HDftell(orig_ptr);
+    HDrewind(orig_ptr);
+
+    dest_ptr = HDfopen(dest, "wb");
+    if (NULL == dest_ptr) {
+        ret_value = -1;
+        goto done;
+    }
+
+    read_size = MIN(fsize, max_buf);
+    dup_buf   = HDmalloc(read_size);
+    if (NULL == dup_buf) {
+        ret_value = -1;
+        goto done;
+    }
+
+    while (read_size > 0) {
+        if (HDfread(dup_buf, read_size, 1, orig_ptr) != 1) {
+            ret_value = -1;
+            goto done;
+        }
+        HDfwrite(dup_buf, read_size, 1, dest_ptr);
+        fsize -= read_size;
+        read_size = MIN(fsize, max_buf);
+    }
+
+done:
+    if (orig_ptr != NULL)
+        HDfclose(orig_ptr);
+    if (dest_ptr != NULL)
+        HDfclose(dest_ptr);
+    if (dup_buf != NULL)
+        HDfree(dup_buf);
+    return ret_value;
+} /* end h5_duplicate_file_by_bytes() */
+
+/*-------------------------------------------------------------------------
+ * Function:    h5_check_if_file_locking_enabled
+ *
+ * Purpose:     Checks if file locking is enabled on this file system.
+ *
+ * Return:      SUCCEED/FAIL
+ *              are_enabled will be FALSE if file locking is disabled on
+ *              the file system of if there were errors.
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+h5_check_if_file_locking_enabled(hbool_t *is_enabled)
+{
+    const char *filename = "locking_test_file";
+    int         pmode    = O_RDWR | O_CREAT | O_TRUNC;
+    int         fd       = -1;
+
+    *is_enabled = TRUE;
+
+    if ((fd = HDopen(filename, pmode, H5_POSIX_CREATE_MODE_RW)) < 0)
+        goto error;
+
+    /* Test HDflock() to see if it works */
+    if (HDflock(fd, LOCK_EX | LOCK_NB) < 0) {
+        if (ENOSYS == errno) {
+            /* When errno is set to ENOSYS, the file system does not support
+             * locking, so ignore it. This is most frequently used on
+             * Lustre. If we also want to check for disabled NFS locks
+             * we'll need to check for ENOLCK, too. That isn't done by
+             * default here since that could also represent an actual
+             * error condition.
+             */
+            errno       = 0;
+            *is_enabled = FALSE;
+        }
+        else
+            goto error;
+    }
+    if (HDflock(fd, LOCK_UN) < 0)
+        goto error;
+
+    if (HDclose(fd) < 0)
+        goto error;
+    if (HDremove(filename) < 0)
+        goto error;
+
+    return SUCCEED;
+
+error:
+    *is_enabled = FALSE;
+    if (fd > -1) {
+        HDclose(fd);
+        HDremove(filename);
+    }
+    return FAIL;
+} /* end h5_check_if_file_locking_enabled() */
+
+/*-------------------------------------------------------------------------
+ * Function:    h5_using_default_driver
+ *
+ * Purpose:     Checks if the specified VFD name matches the library's
+ *              default VFD. If `drv_name` is NULL, the HDF5_DRIVER
+ *              environment is checked instead (if it is set).
+ *
+ * Return:      TRUE/FALSE
+ *
+ *-------------------------------------------------------------------------
+ */
+hbool_t
+h5_using_default_driver(const char *drv_name)
+{
+    hbool_t ret_val = TRUE;
+
+    HDassert(H5_DEFAULT_VFD == H5FD_SEC2);
+
+    if (!drv_name)
+        drv_name = HDgetenv(HDF5_DRIVER);
+
+    if (drv_name)
+        return (!HDstrcmp(drv_name, "sec2") || !HDstrcmp(drv_name, "nomatch"));
+
+    return ret_val;
+}
+
+/*-------------------------------------------------------------------------
+ * Function:    h5_using_parallel_driver
+ *
+ * Purpose:     Checks if the specified VFD name matches a parallel-enabled
+ *              VFD (usually `mpio`). If `drv_name` is NULL, the
+ *              HDF5_DRIVER environment is checked instead (if it is set).
+ *
+ *              This is mostly useful for avoiding tests that use features
+ *              which are not currently supported for parallel HDF5, such
+ *              as writing of VL or region reference datatypes.
+ *
+ * Return:      TRUE/FALSE
+ *
+ *-------------------------------------------------------------------------
+ */
+hbool_t
+h5_using_parallel_driver(const char *drv_name)
+{
+    hbool_t ret_val = FALSE;
+
+    if (!drv_name)
+        drv_name = HDgetenv(HDF5_DRIVER);
+
+    if (drv_name)
+        return (!HDstrcmp(drv_name, "mpio"));
+
+    return ret_val;
+}
+
+/*-------------------------------------------------------------------------
+ * Function:    h5_driver_uses_modified_filename
+ *
+ * Purpose:     Checks if the current VFD set by use of the HDF5_DRIVER
+ *              environment variable uses a modified filename. Examples
+ *              are the multi and family drivers.
+ *
+ *              This routine is helpful for skipping tests that use
+ *              pre-generated files. VFDs that use a modified filename will
+ *              not be able to find these files and those tests will fail.
+ *              Eventually, HDF5's testing framework should be modified to
+ *              not run VFD testing against tests that use pre-generated
+ *              files.
+ *
+ * Return:      TRUE/FALSE
+ *
+ *-------------------------------------------------------------------------
+ */
+hbool_t
+h5_driver_uses_modified_filename(void)
+{
+    hbool_t ret_val = FALSE;
+    char *  driver  = HDgetenv(HDF5_DRIVER);
+
+    if (driver) {
+        ret_val = !HDstrcmp(driver, "multi") || !HDstrcmp(driver, "split") || !HDstrcmp(driver, "family") ||
+                  !HDstrcmp(driver, "splitter");
+    }
+
+    return ret_val;
+} /* end h5_driver_uses_modified_filename() */
+
+/*-------------------------------------------------------------------------
+ * Function:    h5_driver_uses_multiple_files
+ *
+ * Purpose:     Checks if the specified VFD name matches a driver that
+ *              stores data using multiple files.
+ *
+ *              The following flags can be used to control what types of
+ *              drivers are checked for by this routine:
+ *
+ *              H5_EXCLUDE_MULTIPART_DRIVERS - This flag excludes any
+ *                drivers which store data using multiple files which,
+ *                together, make up a single logical file. These are
+ *                drivers like the split, multi and family drivers.
+ *
+ *              H5_EXCLUDE_NON_MULTIPART_DRIVERS - This flag excludes any
+ *                drivers which store data using multiple files which are
+ *                separate logical files. The splitter driver is an example
+ *                of this type of driver.
+ *
+ * Return:      TRUE/FALSE
+ *
+ *-------------------------------------------------------------------------
+ */
+hbool_t
+h5_driver_uses_multiple_files(const char *drv_name, unsigned flags)
+{
+    hbool_t ret_val = FALSE;
+
+    if (!drv_name)
+        drv_name = HDgetenv(HDF5_DRIVER);
+
+    if (drv_name) {
+        if ((flags & H5_EXCLUDE_MULTIPART_DRIVERS) == 0) {
+            if (!HDstrcmp(drv_name, "split") || !HDstrcmp(drv_name, "multi") || !HDstrcmp(drv_name, "family"))
+                return TRUE;
+        }
+
+        if ((flags & H5_EXCLUDE_NON_MULTIPART_DRIVERS) == 0) {
+            if (!HDstrcmp(drv_name, "splitter"))
+                return TRUE;
+        }
+    }
+
+    return ret_val;
+}