Merge remote-tracking branch 'origin/hdf5_1_12_1' into 1.12/master forhdf5-1_12_1

HDF5 1.12.1 release.

1 files changed, 278 insertions, 18 deletions

diff --git a/test/h5test.c b/test/h5test.c
index 5b7b95d..b37409a 100644
--- a/test/h5test.c
+++ b/test/h5test.c
@@ -6,13 +6,13 @@
  * 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.
@@ -23,6 +23,7 @@
 
 #include "h5test.h"
 #include "H5srcdir.h"
+#include "H5srcdir_str.h"
 
 /* Necessary for h5_verify_cached_stabs() */
 #define H5G_FRIEND /*suppress error about including H5Gpkg      */
@@ -100,6 +101,12 @@ static const char *multi_letters = "msbrglo";
 /* The # of seconds to wait for the message file--used by h5_wait_message() */
 #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  */
@@ -163,8 +170,6 @@ h5_clean_files(const char *base_name[], hid_t fapl)
 
     /* Close the FAPL used to access the file */
     H5Pclose(fapl);
-
-    return;
 } /* end h5_clean_files() */
 
 /*-------------------------------------------------------------------------
@@ -190,7 +195,7 @@ h5_clean_files(const char *base_name[], hid_t fapl)
  *      sub_filename in the code below, but early (4.4.7, at least) gcc only
  *      allows diagnostic pragmas to be toggled outside of functions.
  */
-H5_GCC_DIAG_OFF(format - nonliteral)
+H5_GCC_DIAG_OFF("format-nonliteral")
 void
 h5_delete_test_file(const char *base_name, hid_t fapl)
 {
@@ -241,9 +246,8 @@ h5_delete_test_file(const char *base_name, hid_t fapl)
         HDremove(filename);
     } /* end driver selection tree */
 
-    return;
 } /* end h5_delete_test_file() */
-H5_GCC_DIAG_ON(format - nonliteral)
+H5_GCC_DIAG_ON("format-nonliteral")
 
 /*-------------------------------------------------------------------------
  * Function:    h5_delete_all_test_files
@@ -274,7 +278,6 @@ h5_delete_all_test_files(const char *base_name[], hid_t fapl)
         h5_delete_test_file(base_name[i], fapl);
     } /* end for */
 
-    return;
 } /* end h5_delete_all_test_files() */
 
 /*-------------------------------------------------------------------------
@@ -333,8 +336,6 @@ h5_test_shutdown(void)
 
     /* Restore the original error reporting routine */
     h5_restore_err();
-
-    return;
 } /* end h5_test_shutdown() */
 
 /*-------------------------------------------------------------------------
@@ -441,8 +442,6 @@ 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() */
 
 /*-------------------------------------------------------------------------
@@ -1160,10 +1159,8 @@ h5_show_hostname(void)
         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
 
@@ -1349,7 +1346,7 @@ 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.
  */
-H5_GCC_DIAG_OFF(format - nonliteral)
+H5_GCC_DIAG_OFF("format-nonliteral")
 h5_stat_size_t
 h5_get_file_size(const char *filename, hid_t fapl)
 {
@@ -1454,7 +1451,7 @@ h5_get_file_size(const char *filename, hid_t fapl)
 
     return (-1);
 } /* end get_file_size() */
-H5_GCC_DIAG_ON(format - nonliteral)
+H5_GCC_DIAG_ON("format-nonliteral")
 
 /*
  * This routine is designed to provide equivalent functionality to 'printf'
@@ -2040,7 +2037,8 @@ h5_get_dummy_vol_class(void)
     /* 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;
 
@@ -2064,3 +2062,265 @@ h5_get_version_string(H5F_libver_t 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() */