Merge hdf5 1 10 8 (#1154)hdf5-1_10_8

 Merge HDF5 1.10.8 release files to 1.10/master

1 files changed, 560 insertions, 554 deletions

diff --git a/test/th5s.c b/test/th5s.c
index 9f9f99d..9e4547b 100644
--- a/test/th5s.c
+++ b/test/th5s.c
@@ -6,18 +6,18 @@
  * 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.                                                        *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 /***********************************************************
-*
-* Test program:     th5s
-*
-* Test the dataspace functionality
-*
-*************************************************************/
+ *
+ * Test program:     th5s
+ *
+ * Test the dataspace functionality
+ *
+ *************************************************************/
 
 #include "testhdf5.h"
 #include "H5srcdir.h"
@@ -29,69 +29,69 @@
  * This file needs to access private information from the H5S package.
  * This file also needs to access the dataspace testing code.
  */
-#define H5S_FRIEND      /*suppress error about including H5Spkg   */
-#define H5S_TESTING	/*suppress warning about H5S testing funcs*/
-#include "H5Spkg.h"     /* Dataspaces               */
+#define H5S_FRIEND  /*suppress error about including H5Spkg   */
+#define H5S_TESTING /*suppress warning about H5S testing funcs*/
+#include "H5Spkg.h" /* Dataspaces               */
 
 /*
  * This file needs to access private information from the H5O package.
  * This file also needs to access the dataspace testing code.
  */
-#define H5O_FRIEND      /*suppress error about including H5Opkg   */
+#define H5O_FRIEND /*suppress error about including H5Opkg   */
 #define H5O_TESTING
-#include "H5Opkg.h"     /* Object header            */
+#include "H5Opkg.h" /* Object header            */
 
-#define TESTFILE   "th5s.h5"
-#define DATAFILE   "th5s1.h5"
-#define NULLFILE   "th5s2.h5"
-#define BASICFILE  "th5s3.h5"
-#define ZEROFILE   "th5s4.h5"
+#define TESTFILE      "th5s.h5"
+#define DATAFILE      "th5s1.h5"
+#define NULLFILE      "th5s2.h5"
+#define BASICFILE     "th5s3.h5"
+#define ZEROFILE      "th5s4.h5"
 #define BASICDATASET  "basic_dataset"
 #define BASICDATASET1 "basic_dataset1"
 #define BASICDATASET2 "basic_dataset2"
 #define BASICDATASET3 "basic_dataset3"
 #define BASICDATASET4 "basic_dataset4"
-#define BASICATTR  "basic_attribute"
-#define NULLDATASET  "null_dataset"
-#define NULLATTR   "null_attribute"
-#define EXTFILE_NAME "ext_file"
+#define BASICATTR     "basic_attribute"
+#define NULLDATASET   "null_dataset"
+#define NULLATTR      "null_attribute"
+#define EXTFILE_NAME  "ext_file"
 
 /* 3-D dataset with fixed dimensions */
-#define SPACE1_RANK    3
-#define SPACE1_DIM1    3
-#define SPACE1_DIM2    15
-#define SPACE1_DIM3    13
+#define SPACE1_RANK 3
+#define SPACE1_DIM1 3
+#define SPACE1_DIM2 15
+#define SPACE1_DIM3 13
 
 /* 4-D dataset with one unlimited dimension */
-#define SPACE2_RANK    4
-#define SPACE2_DIM1    0
-#define SPACE2_DIM2    15
-#define SPACE2_DIM3    13
-#define SPACE2_DIM4    23
-#define SPACE2_MAX1    H5S_UNLIMITED
-#define SPACE2_MAX2    15
-#define SPACE2_MAX3    13
-#define SPACE2_MAX4    23
+#define SPACE2_RANK 4
+#define SPACE2_DIM1 0
+#define SPACE2_DIM2 15
+#define SPACE2_DIM3 13
+#define SPACE2_DIM4 23
+#define SPACE2_MAX1 H5S_UNLIMITED
+#define SPACE2_MAX2 15
+#define SPACE2_MAX3 13
+#define SPACE2_MAX4 23
 
 /* Scalar dataset with simple datatype */
-#define SPACE3_RANK    0
-unsigned space3_data=65;
+#define SPACE3_RANK 0
+unsigned space3_data = 65;
 
 /* Scalar dataset with compound datatype */
-#define SPACE4_FIELDNAME1    "c1"
-#define SPACE4_FIELDNAME2    "u"
-#define SPACE4_FIELDNAME3    "f"
-#define SPACE4_FIELDNAME4    "c2"
-size_t space4_field1_off=0;
-size_t space4_field2_off=0;
-size_t space4_field3_off=0;
-size_t space4_field4_off=0;
+#define SPACE4_FIELDNAME1 "c1"
+#define SPACE4_FIELDNAME2 "u"
+#define SPACE4_FIELDNAME3 "f"
+#define SPACE4_FIELDNAME4 "c2"
+size_t space4_field1_off = 0;
+size_t space4_field2_off = 0;
+size_t space4_field3_off = 0;
+size_t space4_field4_off = 0;
 struct space4_struct {
-    char c1;
+    char     c1;
     unsigned u;
-    float f;
-    char c2;
-} space4_data={'v',987123,-3.14F,'g'}; /* Test data for 4th dataspace */
+    float    f;
+    char     c2;
+} space4_data = {'v', 987123, -3.14F, 'g'}; /* Test data for 4th dataspace */
 
 /*
  *  Testing configuration defines used by:
@@ -99,13 +99,12 @@ struct space4_struct {
  *      test_h5s_encode_irregular_hyper()
  *      test_h5s_encode_points()
  */
-#define CONFIG_8    1
-#define CONFIG_16   2
-#define CONFIG_32   3
-#define POWER8      256             /* 2^8 */
-#define POWER16     65536           /* 2^16 */
-#define POWER32     4294967296      /* 2^32 */
-
+#define CONFIG_8  1
+#define CONFIG_16 2
+#define CONFIG_32 3
+#define POWER8    256        /* 2^8 */
+#define POWER16   65536      /* 2^16 */
+#define POWER32   4294967296 /* 2^32 */
 
 /****************************************************************
 **
@@ -115,21 +114,19 @@ struct space4_struct {
 static void
 test_h5s_basic(void)
 {
-    hid_t        fid1;        /* HDF5 File IDs        */
-    hid_t        sid1, sid2;    /* Dataspace ID            */
-    hid_t        dset1;        /* Dataset ID            */
-    hid_t               aid1;           /* Attribute ID                 */
-    int                rank;        /* Logical rank of dataspace    */
-    hsize_t        dims1[] = {SPACE1_DIM1, SPACE1_DIM2, SPACE1_DIM3};
-    hsize_t        dims2[] = {SPACE2_DIM1, SPACE2_DIM2, SPACE2_DIM3,
-                SPACE2_DIM4};
-    hsize_t        dims3[H5S_MAX_RANK+1];
-    hsize_t        max2[] = {SPACE2_MAX1, SPACE2_MAX2, SPACE2_MAX3,
-                SPACE2_MAX4};
-    hsize_t        tdims[4];    /* Dimension array to test with */
-    hsize_t        tmax[4];
-    hssize_t        n;         /* Number of dataspace elements */
-    herr_t        ret;        /* Generic return value        */
+    hid_t    fid1;       /* HDF5 File IDs        */
+    hid_t    sid1, sid2; /* Dataspace ID            */
+    hid_t    dset1;      /* Dataset ID            */
+    hid_t    aid1;       /* Attribute ID                 */
+    int      rank;       /* Logical rank of dataspace    */
+    hsize_t  dims1[] = {SPACE1_DIM1, SPACE1_DIM2, SPACE1_DIM3};
+    hsize_t  dims2[] = {SPACE2_DIM1, SPACE2_DIM2, SPACE2_DIM3, SPACE2_DIM4};
+    hsize_t  dims3[H5S_MAX_RANK + 1];
+    hsize_t  max2[] = {SPACE2_MAX1, SPACE2_MAX2, SPACE2_MAX3, SPACE2_MAX4};
+    hsize_t  tdims[4]; /* Dimension array to test with */
+    hsize_t  tmax[4];
+    hssize_t n;   /* Number of dataspace elements */
+    herr_t   ret; /* Generic return value        */
 
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Dataspace Manipulation\n"));
@@ -139,8 +136,7 @@ test_h5s_basic(void)
 
     n = H5Sget_simple_extent_npoints(sid1);
     CHECK(n, FAIL, "H5Sget_simple_extent_npoints");
-    VERIFY(n, SPACE1_DIM1 * SPACE1_DIM2 * SPACE1_DIM3,
-    "H5Sget_simple_extent_npoints");
+    VERIFY(n, SPACE1_DIM1 * SPACE1_DIM2 * SPACE1_DIM3, "H5Sget_simple_extent_npoints");
 
     rank = H5Sget_simple_extent_ndims(sid1);
     CHECK(rank, FAIL, "H5Sget_simple_extent_ndims");
@@ -148,16 +144,14 @@ test_h5s_basic(void)
 
     rank = H5Sget_simple_extent_dims(sid1, tdims, NULL);
     CHECK(rank, FAIL, "H5Sget_simple_extent_dims");
-    VERIFY(HDmemcmp(tdims, dims1, SPACE1_RANK * sizeof(hsize_t)), 0,
-    "H5Sget_simple_extent_dims");
+    VERIFY(HDmemcmp(tdims, dims1, SPACE1_RANK * sizeof(hsize_t)), 0, "H5Sget_simple_extent_dims");
 
     sid2 = H5Screate_simple(SPACE2_RANK, dims2, max2);
     CHECK(sid2, FAIL, "H5Screate_simple");
 
     n = H5Sget_simple_extent_npoints(sid2);
     CHECK(n, FAIL, "H5Sget_simple_extent_npoints");
-    VERIFY(n, SPACE2_DIM1 * SPACE2_DIM2 * SPACE2_DIM3 * SPACE2_DIM4,
-    "H5Sget_simple_extent_npoints");
+    VERIFY(n, SPACE2_DIM1 * SPACE2_DIM2 * SPACE2_DIM3 * SPACE2_DIM4, "H5Sget_simple_extent_npoints");
 
     rank = H5Sget_simple_extent_ndims(sid2);
     CHECK(rank, FAIL, "H5Sget_simple_extent_ndims");
@@ -165,20 +159,16 @@ test_h5s_basic(void)
 
     rank = H5Sget_simple_extent_dims(sid2, tdims, tmax);
     CHECK(rank, FAIL, "H5Sget_simple_extent_dims");
-    VERIFY(HDmemcmp(tdims, dims2, SPACE2_RANK * sizeof(hsize_t)), 0,
-    "H5Sget_simple_extent_dims");
-    VERIFY(HDmemcmp(tmax, max2, SPACE2_RANK * sizeof(hsize_t)), 0,
-    "H5Sget_simple_extent_dims");
+    VERIFY(HDmemcmp(tdims, dims2, SPACE2_RANK * sizeof(hsize_t)), 0, "H5Sget_simple_extent_dims");
+    VERIFY(HDmemcmp(tmax, max2, SPACE2_RANK * sizeof(hsize_t)), 0, "H5Sget_simple_extent_dims");
 
     /* Change max dims to be equal to the dimensions */
     ret = H5Sset_extent_simple(sid1, SPACE1_RANK, dims1, NULL);
     CHECK(ret, FAIL, "H5Sset_extent_simple");
     rank = H5Sget_simple_extent_dims(sid1, tdims, tmax);
     CHECK(rank, FAIL, "H5Sget_simple_extent_dims");
-    VERIFY(HDmemcmp(tdims, dims1, SPACE1_RANK * sizeof(hsize_t)), 0,
-    "H5Sget_simple_extent_dims");
-    VERIFY(HDmemcmp(tmax, dims1, SPACE1_RANK * sizeof(hsize_t)), 0,
-    "H5Sget_simple_extent_dims");
+    VERIFY(HDmemcmp(tdims, dims1, SPACE1_RANK * sizeof(hsize_t)), 0, "H5Sget_simple_extent_dims");
+    VERIFY(HDmemcmp(tmax, dims1, SPACE1_RANK * sizeof(hsize_t)), 0, "H5Sget_simple_extent_dims");
 
     ret = H5Sclose(sid1);
     CHECK(ret, FAIL, "H5Sclose");
@@ -190,9 +180,11 @@ test_h5s_basic(void)
      * Check to be sure we can't create a simple dataspace that has too many
      * dimensions.
      */
-    H5E_BEGIN_TRY {
-    sid1 = H5Screate_simple(H5S_MAX_RANK+1, dims3, NULL);
-    } H5E_END_TRY;
+    H5E_BEGIN_TRY
+    {
+        sid1 = H5Screate_simple(H5S_MAX_RANK + 1, dims3, NULL);
+    }
+    H5E_END_TRY;
     VERIFY(sid1, FAIL, "H5Screate_simple");
 
     /*
@@ -203,30 +195,30 @@ test_h5s_basic(void)
      * the instructions in space_overflow.c for regenerating the th5s.h5 file.
      */
     {
-    const char *testfile = H5_get_srcdir_filename(TESTFILE); /* Corrected test file name */
-
-    fid1 = H5Fopen(testfile, H5F_ACC_RDONLY, H5P_DEFAULT);
-    CHECK_I(fid1, "H5Fopen");
-    if (fid1 >= 0){
-        dset1 = H5Dopen2(fid1, "dset", H5P_DEFAULT);
-        VERIFY(dset1, FAIL, "H5Dopen2");
-        ret = H5Fclose(fid1);
-        CHECK_I(ret, "H5Fclose");
-    }
-    else
-        HDprintf("***cannot open the pre-created H5S_MAX_RANK test file (%s)\n", testfile);
+        const char *testfile = H5_get_srcdir_filename(TESTFILE); /* Corrected test file name */
+
+        fid1 = H5Fopen(testfile, H5F_ACC_RDONLY, H5P_DEFAULT);
+        CHECK_I(fid1, "H5Fopen");
+        if (fid1 >= 0) {
+            dset1 = H5Dopen2(fid1, "dset", H5P_DEFAULT);
+            VERIFY(dset1, FAIL, "H5Dopen2");
+            ret = H5Fclose(fid1);
+            CHECK_I(ret, "H5Fclose");
+        }
+        else
+            HDprintf("***cannot open the pre-created H5S_MAX_RANK test file (%s)\n", testfile);
     }
 
     /* Verify that incorrect dimensions don't work */
     dims1[0] = H5S_UNLIMITED;
-    sid1 = H5Screate_simple(SPACE1_RANK, dims1, NULL);
+    sid1     = H5Screate_simple(SPACE1_RANK, dims1, NULL);
     VERIFY(sid1, FAIL, "H5Screate_simple");
 
     dims1[0] = H5S_UNLIMITED;
-    sid1 = H5Screate(H5S_SIMPLE);
+    sid1     = H5Screate(H5S_SIMPLE);
     CHECK(sid1, FAIL, "H5Screate");
 
-    ret = H5Sset_extent_simple(sid1,SPACE1_RANK,dims1,NULL);
+    ret = H5Sset_extent_simple(sid1, SPACE1_RANK, dims1, NULL);
     VERIFY(ret, FAIL, "H5Sset_extent_simple");
 
     ret = H5Sclose(sid1);
@@ -239,7 +231,7 @@ test_h5s_basic(void)
     fid1 = H5Fcreate(BASICFILE, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
     CHECK(fid1, FAIL, "H5Fcreate");
 
-    dims1[0]=SPACE1_DIM1;
+    dims1[0] = SPACE1_DIM1;
 
     sid1 = H5Screate(H5S_SIMPLE);
     CHECK(sid1, FAIL, "H5Screate");
@@ -247,62 +239,82 @@ test_h5s_basic(void)
     CHECK(sid2, FAIL, "H5Screate");
 
     /* This dataset's space has no extent; it should not be created */
-    H5E_BEGIN_TRY {
-    dset1 = H5Dcreate2(fid1, BASICDATASET, H5T_NATIVE_INT, sid1, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
-    } H5E_END_TRY
+    H5E_BEGIN_TRY
+    {
+        dset1 = H5Dcreate2(fid1, BASICDATASET, H5T_NATIVE_INT, sid1, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+    }
+    H5E_END_TRY
     VERIFY(dset1, FAIL, "H5Dcreate2");
 
     dset1 = H5Dcreate2(fid1, BASICDATASET2, H5T_NATIVE_INT, sid2, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
     CHECK(dset1, FAIL, "H5Dcreate2");
 
     /* Try some writes with the bad dataspace (sid1) */
-    H5E_BEGIN_TRY {
-    ret = H5Dwrite(dset1, H5T_NATIVE_INT, sid1, H5S_ALL, H5P_DEFAULT, &n);
-    } H5E_END_TRY
+    H5E_BEGIN_TRY
+    {
+        ret = H5Dwrite(dset1, H5T_NATIVE_INT, sid1, H5S_ALL, H5P_DEFAULT, &n);
+    }
+    H5E_END_TRY
     VERIFY(ret, FAIL, "H5Dwrite");
 
-    H5E_BEGIN_TRY {
-    ret = H5Dwrite(dset1, H5T_NATIVE_INT, H5S_ALL, sid1, H5P_DEFAULT, &n);
-    } H5E_END_TRY
+    H5E_BEGIN_TRY
+    {
+        ret = H5Dwrite(dset1, H5T_NATIVE_INT, H5S_ALL, sid1, H5P_DEFAULT, &n);
+    }
+    H5E_END_TRY
     VERIFY(ret, FAIL, "H5Dwrite");
 
-    H5E_BEGIN_TRY {
-    ret = H5Dwrite(dset1, H5T_NATIVE_INT, sid1, sid1, H5P_DEFAULT, &n);
-    } H5E_END_TRY
+    H5E_BEGIN_TRY
+    {
+        ret = H5Dwrite(dset1, H5T_NATIVE_INT, sid1, sid1, H5P_DEFAULT, &n);
+    }
+    H5E_END_TRY
     VERIFY(ret, FAIL, "H5Dwrite");
 
     /* Try to iterate using the bad dataspace */
-    H5E_BEGIN_TRY {
-    ret = H5Diterate(&n, H5T_NATIVE_INT, sid1, NULL, NULL);
-    } H5E_END_TRY
+    H5E_BEGIN_TRY
+    {
+        ret = H5Diterate(&n, H5T_NATIVE_INT, sid1, NULL, NULL);
+    }
+    H5E_END_TRY
     VERIFY(ret, FAIL, "H5Diterate");
 
     /* Try to fill using the bad dataspace */
-    H5E_BEGIN_TRY {
-    ret = H5Dfill(NULL, H5T_NATIVE_INT, &n, H5T_NATIVE_INT, sid1);
-    } H5E_END_TRY
+    H5E_BEGIN_TRY
+    {
+        ret = H5Dfill(NULL, H5T_NATIVE_INT, &n, H5T_NATIVE_INT, sid1);
+    }
+    H5E_END_TRY
     VERIFY(ret, FAIL, "H5Dfill");
 
     /* Now use the bad dataspace as the space for an attribute */
-    H5E_BEGIN_TRY {
-    aid1 = H5Acreate2(dset1, BASICATTR, H5T_NATIVE_INT, sid1, H5P_DEFAULT, H5P_DEFAULT);
-    } H5E_END_TRY
+    H5E_BEGIN_TRY
+    {
+        aid1 = H5Acreate2(dset1, BASICATTR, H5T_NATIVE_INT, sid1, H5P_DEFAULT, H5P_DEFAULT);
+    }
+    H5E_END_TRY
     VERIFY(aid1, FAIL, "H5Acreate2");
 
     /* Make sure that dataspace reads using the bad dataspace fail */
-    H5E_BEGIN_TRY {
-    ret = H5Dread(dset1, H5T_NATIVE_INT, sid1, H5S_ALL, H5P_DEFAULT, &n);
-    } H5E_END_TRY
+    H5E_BEGIN_TRY
+    {
+        ret = H5Dread(dset1, H5T_NATIVE_INT, sid1, H5S_ALL, H5P_DEFAULT, &n);
+    }
+    H5E_END_TRY
     VERIFY(ret, FAIL, "H5Dread");
 
-    H5E_BEGIN_TRY {
-    ret = H5Dread(dset1, H5T_NATIVE_INT, H5S_ALL, sid1, H5P_DEFAULT, &n);
-    } H5E_END_TRY
+    H5E_BEGIN_TRY
+    {
+        ret = H5Dread(dset1, H5T_NATIVE_INT, H5S_ALL, sid1, H5P_DEFAULT, &n);
+    }
+    H5E_END_TRY
     VERIFY(ret, FAIL, "H5Dread");
 
-    H5E_BEGIN_TRY {
-    ret = H5Dread(dset1, H5T_NATIVE_INT, sid1, sid1, H5P_DEFAULT, &n);
-    } H5E_END_TRY
+    H5E_BEGIN_TRY
+    {
+        ret = H5Dread(dset1, H5T_NATIVE_INT, sid1, sid1, H5P_DEFAULT, &n);
+    }
+    H5E_END_TRY
     VERIFY(ret, FAIL, "H5Dread");
 
     /* Clean up */
@@ -314,7 +326,7 @@ test_h5s_basic(void)
     CHECK(ret, FAIL, "H5Sclose");
     ret = H5Fclose(fid1);
     CHECK(ret, FAIL, "H5Fclose");
-}                /* test_h5s_basic() */
+} /* test_h5s_basic() */
 
 /****************************************************************
 **
@@ -324,20 +336,20 @@ test_h5s_basic(void)
 static void
 test_h5s_null(void)
 {
-    hid_t fid;          /* File ID */
-    hid_t sid;          /* Dataspace IDs */
-    hid_t dset_sid, dset_sid2;    /* Dataspace IDs */
-    hid_t attr_sid;     /* Dataspace IDs */
-    hid_t did;          /* Dataset ID */
-    hid_t attr;         /*Attribute ID */
-    H5S_class_t stype;  /* dataspace type */
-    hssize_t nelem;     /* Number of elements */
-    unsigned uval=2;    /* Buffer for writing to dataset */
-    int val=1;          /* Buffer for writing to attribute */
-    H5S_sel_type sel_type;      /* Type of selection currently */
-    hsize_t dims[1]={10};       /* Dimensions for converting null dataspace to simple */
-    H5S_class_t space_type;     /* Type of dataspace */
-    herr_t ret;         /* Generic return value */
+    hid_t        fid;                 /* File ID */
+    hid_t        sid;                 /* Dataspace IDs */
+    hid_t        dset_sid, dset_sid2; /* Dataspace IDs */
+    hid_t        attr_sid;            /* Dataspace IDs */
+    hid_t        did;                 /* Dataset ID */
+    hid_t        attr;                /*Attribute ID */
+    H5S_class_t  stype;               /* dataspace type */
+    hssize_t     nelem;               /* Number of elements */
+    unsigned     uval = 2;            /* Buffer for writing to dataset */
+    int          val  = 1;            /* Buffer for writing to attribute */
+    H5S_sel_type sel_type;            /* Type of selection currently */
+    hsize_t      dims[1] = {10};      /* Dimensions for converting null dataspace to simple */
+    H5S_class_t  space_type;          /* Type of dataspace */
+    herr_t       ret;                 /* Generic return value */
 
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Null Dataspace\n"));
@@ -370,21 +382,25 @@ test_h5s_null(void)
     VERIFY(nelem, 0, "H5Sget_select_npoints");
 
     /* Check to be sure we can't set a hyperslab selection on a null dataspace */
-    H5E_BEGIN_TRY {
-        hsize_t start[1]={0};
-        hsize_t count[1]={0};
+    H5E_BEGIN_TRY
+    {
+        hsize_t start[1] = {0};
+        hsize_t count[1] = {0};
 
-    ret = H5Sselect_hyperslab(sid, H5S_SELECT_SET, start, NULL, count, NULL);
-    } H5E_END_TRY;
+        ret = H5Sselect_hyperslab(sid, H5S_SELECT_SET, start, NULL, count, NULL);
+    }
+    H5E_END_TRY;
     VERIFY(ret, FAIL, "H5Sselect_hyperslab");
 
     /* Check to be sure we can't set a point selection on a null dataspace */
-    H5E_BEGIN_TRY {
-        hsize_t    coord[1][1]; /* Coordinates for point selection */
+    H5E_BEGIN_TRY
+    {
+        hsize_t coord[1][1]; /* Coordinates for point selection */
 
-        coord[0][0]=0;
-    ret = H5Sselect_elements(sid, H5S_SELECT_SET, (size_t)1, (const hsize_t *)coord);
-    } H5E_END_TRY;
+        coord[0][0] = 0;
+        ret         = H5Sselect_elements(sid, H5S_SELECT_SET, (size_t)1, (const hsize_t *)coord);
+    }
+    H5E_END_TRY;
     VERIFY(ret, FAIL, "H5Sselect_elements");
 
     /* Create first dataset */
@@ -432,7 +448,7 @@ test_h5s_null(void)
     VERIFY(uval, 2, "H5Aread");
 
     /* Close attribute */
-    ret=H5Aclose(attr);
+    ret = H5Aclose(attr);
     CHECK(ret, FAIL, "H5Aclose");
 
     /* Close the dataset */
@@ -524,7 +540,7 @@ test_h5s_null(void)
     VERIFY(val, 1, "H5Aread");
 
     /* Close attribute */
-    ret=H5Aclose(attr);
+    ret = H5Aclose(attr);
     CHECK(ret, FAIL, "H5Aclose");
 
     /* Close the dataset */
@@ -544,61 +560,61 @@ test_h5s_null(void)
 static void
 test_h5s_zero_dim(void)
 {
-    hid_t        fid1;        /* HDF5 File IDs        */
-    hid_t        sid1, attr_sid;    /* Dataspace ID            */
-    hid_t        sid_chunk;    /* Dataspace ID for chunked dataset */
-    hid_t        dset1;        /* Dataset ID            */
-    hid_t               plist_id;       /* Dataset creation property list */
-    hid_t               attr;           /* Attribute ID                 */
-    int                rank;        /* Logical rank of dataspace    */
-    hsize_t        dims1[] = {0, SPACE1_DIM2, SPACE1_DIM3};
-    hsize_t        max_dims[] = {SPACE1_DIM1+1, SPACE1_DIM2, SPACE1_DIM3};
-    hsize_t        extend_dims[] = {SPACE1_DIM1, SPACE1_DIM2, SPACE1_DIM3};
-    hsize_t             chunk_dims[] = {SPACE1_DIM1, SPACE1_DIM2/3, SPACE1_DIM3};
-    hsize_t        tdims[SPACE1_RANK];    /* Dimension array to test with */
-    int                 wdata[SPACE1_DIM2][SPACE1_DIM3];
-    int                 rdata[SPACE1_DIM2][SPACE1_DIM3];
-    short               wdata_short[SPACE1_DIM2][SPACE1_DIM3];
-    short               rdata_short[SPACE1_DIM2][SPACE1_DIM3];
-    int                 wdata_real[SPACE1_DIM1][SPACE1_DIM2][SPACE1_DIM3];
-    int                 rdata_real[SPACE1_DIM1][SPACE1_DIM2][SPACE1_DIM3];
-    int                 val = 3;
-    hsize_t             start[] = {0, 0, 0};
-    hsize_t             count[] = {3, 15, 13};
-    hsize_t            coord[1][3];    /* Coordinates for point selection */
-    hssize_t            nelem;          /* Number of elements           */
-    H5S_sel_type        sel_type;       /* Type of selection currently  */
-    H5S_class_t         stype;          /* dataspace type               */
-    H5D_alloc_time_t    alloc_time;     /* Space allocation time        */
-    herr_t        ret;        /* Generic return value            */
-    unsigned int        i, j, k;
+    hid_t            fid1;           /* HDF5 File IDs        */
+    hid_t            sid1, attr_sid; /* Dataspace ID            */
+    hid_t            sid_chunk;      /* Dataspace ID for chunked dataset */
+    hid_t            dset1;          /* Dataset ID            */
+    hid_t            plist_id;       /* Dataset creation property list */
+    hid_t            attr;           /* Attribute ID                 */
+    int              rank;           /* Logical rank of dataspace    */
+    hsize_t          dims1[]       = {0, SPACE1_DIM2, SPACE1_DIM3};
+    hsize_t          max_dims[]    = {SPACE1_DIM1 + 1, SPACE1_DIM2, SPACE1_DIM3};
+    hsize_t          extend_dims[] = {SPACE1_DIM1, SPACE1_DIM2, SPACE1_DIM3};
+    hsize_t          chunk_dims[]  = {SPACE1_DIM1, SPACE1_DIM2 / 3, SPACE1_DIM3};
+    hsize_t          tdims[SPACE1_RANK]; /* Dimension array to test with */
+    int              wdata[SPACE1_DIM2][SPACE1_DIM3];
+    int              rdata[SPACE1_DIM2][SPACE1_DIM3];
+    short            wdata_short[SPACE1_DIM2][SPACE1_DIM3];
+    short            rdata_short[SPACE1_DIM2][SPACE1_DIM3];
+    int              wdata_real[SPACE1_DIM1][SPACE1_DIM2][SPACE1_DIM3];
+    int              rdata_real[SPACE1_DIM1][SPACE1_DIM2][SPACE1_DIM3];
+    int              val     = 3;
+    hsize_t          start[] = {0, 0, 0};
+    hsize_t          count[] = {3, 15, 13};
+    hsize_t          coord[1][3]; /* Coordinates for point selection */
+    hssize_t         nelem;       /* Number of elements           */
+    H5S_sel_type     sel_type;    /* Type of selection currently  */
+    H5S_class_t      stype;       /* dataspace type               */
+    H5D_alloc_time_t alloc_time;  /* Space allocation time        */
+    herr_t           ret;         /* Generic return value            */
+    unsigned int     i, j, k;
 
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Dataspace with zero dimension size\n"));
 
     /* Initialize the data */
-    for(i = 0; i < SPACE1_DIM2; i++)
-        for(j = 0; j < SPACE1_DIM3; j++) {
-            wdata[i][j] = (int)(i + j);
-            rdata[i][j] = 7;
+    for (i = 0; i < SPACE1_DIM2; i++)
+        for (j = 0; j < SPACE1_DIM3; j++) {
+            wdata[i][j]       = (int)(i + j);
+            rdata[i][j]       = 7;
             wdata_short[i][j] = (short)(i + j);
             rdata_short[i][j] = 7;
         }
 
-    for(i = 0; i < SPACE1_DIM1; i++)
-        for(j = 0; j < SPACE1_DIM2; j++)
-            for(k = 0; k < SPACE1_DIM3; k++)
+    for (i = 0; i < SPACE1_DIM1; i++)
+        for (j = 0; j < SPACE1_DIM2; j++)
+            for (k = 0; k < SPACE1_DIM3; k++)
                 wdata_real[i][j][k] = (int)(i + j + k);
 
     /* Test with different space allocation times */
-    for(alloc_time = H5D_ALLOC_TIME_EARLY; alloc_time <= H5D_ALLOC_TIME_INCR; alloc_time++) {
+    for (alloc_time = H5D_ALLOC_TIME_EARLY; alloc_time <= H5D_ALLOC_TIME_INCR; alloc_time++) {
 
         /* Make sure we can create the space with the dimension size 0 (starting from v1.8.7).
          * The dimension doesn't need to be unlimited. */
         dims1[0] = 0;
         dims1[1] = SPACE1_DIM2;
         dims1[2] = SPACE1_DIM3;
-        sid1 = H5Screate_simple(SPACE1_RANK, dims1, NULL);
+        sid1     = H5Screate_simple(SPACE1_RANK, dims1, NULL);
         CHECK(sid1, FAIL, "H5Screate_simple");
 
         ret = H5Sclose(sid1);
@@ -609,7 +625,7 @@ test_h5s_zero_dim(void)
 
         /* SID1 has the 1st dimension size as zero.  The maximal dimension will be
          * the same as the dimension because of the NULL passed in. */
-        ret = H5Sset_extent_simple(sid1,SPACE1_RANK,dims1,NULL);
+        ret = H5Sset_extent_simple(sid1, SPACE1_RANK, dims1, NULL);
         CHECK(ret, FAIL, "H5Sset_extent_simple");
 
         /* Check that the dataspace actually has 0 elements */
@@ -679,12 +695,11 @@ test_h5s_zero_dim(void)
         CHECK(ret, FAIL, "H5Dread");
 
         /* Check results */
-        for(i=0; i<SPACE1_DIM2; i++) {
-            for(j=0; j<SPACE1_DIM3; j++) {
-                if(rdata[i][j] != 7) {
+        for (i = 0; i < SPACE1_DIM2; i++) {
+            for (j = 0; j < SPACE1_DIM3; j++) {
+                if (rdata[i][j] != 7) {
                     H5_FAILED();
-                    HDprintf("element [%d][%d] is %d but should have been 7\n",
-                           i, j, rdata[i][j]);
+                    HDprintf("element [%d][%d] is %d but should have been 7\n", i, j, rdata[i][j]);
                 }
             }
         }
@@ -701,12 +716,11 @@ test_h5s_zero_dim(void)
         CHECK(ret, FAIL, "H5Dread");
 
         /* Check results */
-        for(i=0; i<SPACE1_DIM2; i++) {
-            for(j=0; j<SPACE1_DIM3; j++) {
-                if(rdata_short[i][j] != 7) {
+        for (i = 0; i < SPACE1_DIM2; i++) {
+            for (j = 0; j < SPACE1_DIM3; j++) {
+                if (rdata_short[i][j] != 7) {
                     H5_FAILED();
-                    HDprintf("element [%d][%d] is %d but should have been 7\n",
-                           i, j, rdata_short[i][j]);
+                    HDprintf("element [%d][%d] is %d but should have been 7\n", i, j, rdata_short[i][j]);
                 }
             }
         }
@@ -716,9 +730,11 @@ test_h5s_zero_dim(void)
         ret = H5Sselect_hyperslab(sid1, H5S_SELECT_SET, start, NULL, count, NULL);
         CHECK(ret, FAIL, "H5Sselect_hyperslab");
 
-        H5E_BEGIN_TRY {
+        H5E_BEGIN_TRY
+        {
             ret = H5Dwrite(dset1, H5T_NATIVE_INT, H5S_ALL, sid1, H5P_DEFAULT, wdata);
-        } H5E_END_TRY;
+        }
+        H5E_END_TRY;
         VERIFY(ret, FAIL, "H5Dwrite");
 
         /* Change to "none" selection */
@@ -727,13 +743,17 @@ test_h5s_zero_dim(void)
 
         /* Select a point beyond the dimension size, then try to write the data.
          * It should fail. */
-        coord[0][0]=2; coord[0][1]=5; coord[0][2]=3;
-        ret = H5Sselect_elements(sid1, H5S_SELECT_SET, (size_t)1, (const hsize_t *)coord);
+        coord[0][0] = 2;
+        coord[0][1] = 5;
+        coord[0][2] = 3;
+        ret         = H5Sselect_elements(sid1, H5S_SELECT_SET, (size_t)1, (const hsize_t *)coord);
         CHECK(ret, FAIL, "H5Sselect_elements");
 
-        H5E_BEGIN_TRY {
+        H5E_BEGIN_TRY
+        {
             ret = H5Dwrite(dset1, H5T_NATIVE_INT, H5S_ALL, sid1, H5P_DEFAULT, &val);
-        } H5E_END_TRY;
+        }
+        H5E_END_TRY;
         VERIFY(ret, FAIL, "H5Dwrite");
 
         /* Restore the selection to all */
@@ -753,7 +773,8 @@ test_h5s_zero_dim(void)
         /* ret = H5Pset_alloc_time(plist_id, alloc_time); */
         /* CHECK(ret, FAIL, "H5Pset_alloc_time"); */
 
-        dset1 = H5Dcreate2(fid1, BASICDATASET1, H5T_NATIVE_INT, sid_chunk, H5P_DEFAULT, plist_id, H5P_DEFAULT);
+        dset1 =
+            H5Dcreate2(fid1, BASICDATASET1, H5T_NATIVE_INT, sid_chunk, H5P_DEFAULT, plist_id, H5P_DEFAULT);
         CHECK(dset1, FAIL, "H5Dcreate2");
 
         /* Write "nothing" to the dataset */
@@ -768,19 +789,18 @@ test_h5s_zero_dim(void)
         CHECK(ret, FAIL, "H5Dread");
 
         /* Check results */
-        for(i=0; i<SPACE1_DIM2; i++)
-            for(j=0; j<SPACE1_DIM3; j++) {
-                if(rdata[i][j] != 7) {
+        for (i = 0; i < SPACE1_DIM2; i++)
+            for (j = 0; j < SPACE1_DIM3; j++) {
+                if (rdata[i][j] != 7) {
                     H5_FAILED();
-                    HDprintf("element [%d][%d] is %d but should have been 7\n",
-                           i, j, rdata[i][j]);
+                    HDprintf("element [%d][%d] is %d but should have been 7\n", i, j, rdata[i][j]);
                 }
-        }
+            }
 
         /* Now extend the dataset to SPACE1_DIM1*SPACE1_DIM2*SPACE1_DIM3 and make sure
          * we can write data to it */
         extend_dims[0] = SPACE1_DIM1;
-        ret = H5Dset_extent(dset1, extend_dims);
+        ret            = H5Dset_extent(dset1, extend_dims);
         CHECK(ret, FAIL, "H5Dset_extent");
 
         ret = H5Dwrite(dset1, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, wdata_real);
@@ -793,13 +813,13 @@ test_h5s_zero_dim(void)
         CHECK(ret, FAIL, "H5Dread");
 
         /* Check results */
-        for(i=0; i<SPACE1_DIM1; i++) {
-            for(j=0; j<SPACE1_DIM2; j++) {
-                for(k=0; k<SPACE1_DIM3; k++) {
-                    if(rdata_real[i][j][k] != wdata_real[i][j][k]) {
+        for (i = 0; i < SPACE1_DIM1; i++) {
+            for (j = 0; j < SPACE1_DIM2; j++) {
+                for (k = 0; k < SPACE1_DIM3; k++) {
+                    if (rdata_real[i][j][k] != wdata_real[i][j][k]) {
                         H5_FAILED();
-                        HDprintf("element [%d][%d][%d] is %d but should have been %d\n",
-                           i, j, k, rdata_real[i][j][k], wdata_real[i][j][k]);
+                        HDprintf("element [%d][%d][%d] is %d but should have been %d\n", i, j, k,
+                                 rdata_real[i][j][k], wdata_real[i][j][k]);
                     }
                 }
             }
@@ -807,7 +827,7 @@ test_h5s_zero_dim(void)
 
         /* Now shrink the first dimension size of the dataset to 0 and make sure no data is in it */
         extend_dims[0] = 0;
-        ret = H5Dset_extent(dset1, extend_dims);
+        ret            = H5Dset_extent(dset1, extend_dims);
         CHECK(ret, FAIL, "H5Dset_extent");
 
         ret = H5Fflush(fid1, H5F_SCOPE_GLOBAL);
@@ -818,21 +838,22 @@ test_h5s_zero_dim(void)
         CHECK(ret, FAIL, "H5Dread");
 
         /* Check results */
-        for(i=0; i<SPACE1_DIM2; i++)
-            for(j=0; j<SPACE1_DIM3; j++) {
-                if(rdata[i][j] != 7) {
+        for (i = 0; i < SPACE1_DIM2; i++)
+            for (j = 0; j < SPACE1_DIM3; j++) {
+                if (rdata[i][j] != 7) {
                     H5_FAILED();
-                    HDprintf("element [%d][%d] is %d but should have been 7\n",
-                           i, j, rdata[i][j]);
+                    HDprintf("element [%d][%d] is %d but should have been 7\n", i, j, rdata[i][j]);
                 }
-        }
+            }
 
         /* Now extend the first dimension size of the dataset to SPACE1_DIM1*3 past the maximal size.
          * It is supposed to fail. */
-        extend_dims[0] = SPACE1_DIM1*3;
-        H5E_BEGIN_TRY {
+        extend_dims[0] = SPACE1_DIM1 * 3;
+        H5E_BEGIN_TRY
+        {
             ret = H5Dset_extent(dset1, extend_dims);
-        } H5E_END_TRY;
+        }
+        H5E_END_TRY;
         VERIFY(ret, FAIL, "H5Dset_extent");
 
         ret = H5Pclose(plist_id);
@@ -865,14 +886,13 @@ test_h5s_zero_dim(void)
         CHECK(ret, FAIL, "H5Dread");
 
         /* Check results */
-        for(i=0; i<SPACE1_DIM2; i++)
-            for(j=0; j<SPACE1_DIM3; j++) {
-                if(rdata[i][j] != 7) {
+        for (i = 0; i < SPACE1_DIM2; i++)
+            for (j = 0; j < SPACE1_DIM3; j++) {
+                if (rdata[i][j] != 7) {
                     H5_FAILED();
-                    HDprintf("element [%d][%d] is %d but should have been 7\n",
-                           i, j, rdata[i][j]);
+                    HDprintf("element [%d][%d] is %d but should have been 7\n", i, j, rdata[i][j]);
                 }
-        }
+            }
 
         ret = H5Pclose(plist_id);
         CHECK(ret, FAIL, "H5Pclose");
@@ -909,12 +929,11 @@ test_h5s_zero_dim(void)
         CHECK(ret, FAIL, "H5Dread");
 
         /* Check results */
-        for(i=0; i<SPACE1_DIM2; i++) {
-            for(j=0; j<SPACE1_DIM3; j++) {
-                if(rdata[i][j] != 7) {
+        for (i = 0; i < SPACE1_DIM2; i++) {
+            for (j = 0; j < SPACE1_DIM3; j++) {
+                if (rdata[i][j] != 7) {
                     H5_FAILED();
-                    HDprintf("element [%d][%d] is %d but should have been 7\n",
-                           i, j, rdata[i][j]);
+                    HDprintf("element [%d][%d] is %d but should have been 7\n", i, j, rdata[i][j]);
                 }
             }
         }
@@ -941,12 +960,11 @@ test_h5s_zero_dim(void)
         CHECK(ret, FAIL, "H5Aread");
 
         /* Check results */
-        for(i=0; i<SPACE1_DIM2; i++) {
-            for(j=0; j<SPACE1_DIM3; j++) {
-                if(rdata[i][j] != 7) {
+        for (i = 0; i < SPACE1_DIM2; i++) {
+            for (j = 0; j < SPACE1_DIM3; j++) {
+                if (rdata[i][j] != 7) {
                     H5_FAILED();
-                    HDprintf("element [%d][%d] is %d but should have been 7\n",
-                           i, j, rdata[i][j]);
+                    HDprintf("element [%d][%d] is %d but should have been 7\n", i, j, rdata[i][j]);
                 }
             }
         }
@@ -963,12 +981,11 @@ test_h5s_zero_dim(void)
         CHECK(ret, FAIL, "H5Aread");
 
         /* Check results */
-        for(i=0; i<SPACE1_DIM2; i++) {
-            for(j=0; j<SPACE1_DIM3; j++) {
-                if(rdata_short[i][j] != 7) {
+        for (i = 0; i < SPACE1_DIM2; i++) {
+            for (j = 0; j < SPACE1_DIM3; j++) {
+                if (rdata_short[i][j] != 7) {
                     H5_FAILED();
-                    HDprintf("element [%d][%d] is %d but should have been 7\n",
-                           i, j, rdata_short[i][j]);
+                    HDprintf("element [%d][%d] is %d but should have been 7\n", i, j, rdata_short[i][j]);
                 }
             }
         }
@@ -983,14 +1000,13 @@ test_h5s_zero_dim(void)
          * dataset now.
          *===============================================================
          */
-        dims1[0]=SPACE1_DIM1;
-        ret = H5Sset_extent_simple(sid_chunk,SPACE1_RANK,dims1,max_dims);
+        dims1[0] = SPACE1_DIM1;
+        ret      = H5Sset_extent_simple(sid_chunk, SPACE1_RANK, dims1, max_dims);
         CHECK(ret, FAIL, "H5Sset_extent_simple");
 
         nelem = H5Sget_simple_extent_npoints(sid_chunk);
         CHECK(nelem, FAIL, "H5Sget_simple_extent_npoints");
-        VERIFY(nelem, SPACE1_DIM1 * SPACE1_DIM2 * SPACE1_DIM3,
-               "H5Sget_simple_extent_npoints");
+        VERIFY(nelem, SPACE1_DIM1 * SPACE1_DIM2 * SPACE1_DIM3, "H5Sget_simple_extent_npoints");
 
         rank = H5Sget_simple_extent_ndims(sid_chunk);
         CHECK(rank, FAIL, "H5Sget_simple_extent_ndims");
@@ -998,8 +1014,7 @@ test_h5s_zero_dim(void)
 
         rank = H5Sget_simple_extent_dims(sid_chunk, tdims, NULL);
         CHECK(rank, FAIL, "H5Sget_simple_extent_dims");
-        VERIFY(HDmemcmp(tdims, dims1, SPACE1_RANK * sizeof(hsize_t)), 0,
-               "H5Sget_simple_extent_dims");
+        VERIFY(HDmemcmp(tdims, dims1, SPACE1_RANK * sizeof(hsize_t)), 0, "H5Sget_simple_extent_dims");
 
         /* Set it to chunked dataset */
         plist_id = H5Pcreate(H5P_DATASET_CREATE);
@@ -1011,7 +1026,8 @@ test_h5s_zero_dim(void)
         ret = H5Pset_alloc_time(plist_id, alloc_time);
         CHECK(ret, FAIL, "H5Pset_alloc_time");
 
-        dset1 = H5Dcreate2(fid1, BASICDATASET4, H5T_NATIVE_INT, sid_chunk, H5P_DEFAULT, plist_id, H5P_DEFAULT);
+        dset1 =
+            H5Dcreate2(fid1, BASICDATASET4, H5T_NATIVE_INT, sid_chunk, H5P_DEFAULT, plist_id, H5P_DEFAULT);
         CHECK(dset1, FAIL, "H5Dcreate2");
 
         ret = H5Dwrite(dset1, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, wdata_real);
@@ -1024,13 +1040,13 @@ test_h5s_zero_dim(void)
         CHECK(ret, FAIL, "H5Dread");
 
         /* Check results */
-        for(i=0; i<SPACE1_DIM1; i++) {
-            for(j=0; j<SPACE1_DIM2; j++) {
-                for(k=0; k<SPACE1_DIM3; k++) {
-                    if(rdata_real[i][j][k] != wdata_real[i][j][k]) {
+        for (i = 0; i < SPACE1_DIM1; i++) {
+            for (j = 0; j < SPACE1_DIM2; j++) {
+                for (k = 0; k < SPACE1_DIM3; k++) {
+                    if (rdata_real[i][j][k] != wdata_real[i][j][k]) {
                         H5_FAILED();
-                        HDprintf("element [%d][%d][%d] is %d but should have been %d\n",
-                           i, j, k, rdata_real[i][j][k], wdata_real[i][j][k]);
+                        HDprintf("element [%d][%d][%d] is %d but should have been %d\n", i, j, k,
+                                 rdata_real[i][j][k], wdata_real[i][j][k]);
                     }
                 }
             }
@@ -1044,8 +1060,8 @@ test_h5s_zero_dim(void)
 
         /* Change the dimensions to make them zero size again (0x0x0).  Verify that
          * no element is in the dataspace. */
-        dims1[0]=dims1[1]=dims1[2]=0;
-        ret = H5Sset_extent_simple(sid_chunk,SPACE1_RANK,dims1,NULL);
+        dims1[0] = dims1[1] = dims1[2] = 0;
+        ret                            = H5Sset_extent_simple(sid_chunk, SPACE1_RANK, dims1, NULL);
         CHECK(ret, FAIL, "H5Sset_extent_simple");
 
         /* Check that the dataspace actually has 0 elements */
@@ -1112,12 +1128,11 @@ test_h5s_zero_dim(void)
         CHECK(ret, FAIL, "H5Dread");
 
         /* Check results */
-        for(i=0; i<SPACE1_DIM2; i++) {
-            for(j=0; j<SPACE1_DIM3; j++) {
-                if(rdata[i][j] != 7) {
+        for (i = 0; i < SPACE1_DIM2; i++) {
+            for (j = 0; j < SPACE1_DIM3; j++) {
+                if (rdata[i][j] != 7) {
                     H5_FAILED();
-                    HDprintf("element [%d][%d] is %d but should have been 7\n",
-                           i, j, rdata[i][j]);
+                    HDprintf("element [%d][%d] is %d but should have been 7\n", i, j, rdata[i][j]);
                 }
             }
         }
@@ -1150,18 +1165,17 @@ test_h5s_zero_dim(void)
         CHECK(ret, FAIL, "H5Aread");
 
         /* Check results */
-        for(i=0; i<SPACE1_DIM2; i++) {
-            for(j=0; j<SPACE1_DIM3; j++) {
-                if(rdata_short[i][j] != 7) {
+        for (i = 0; i < SPACE1_DIM2; i++) {
+            for (j = 0; j < SPACE1_DIM3; j++) {
+                if (rdata_short[i][j] != 7) {
                     H5_FAILED();
-                    HDprintf("element [%d][%d] is %d but should have been 7\n",
-                           i, j, rdata_short[i][j]);
+                    HDprintf("element [%d][%d] is %d but should have been 7\n", i, j, rdata_short[i][j]);
                 }
             }
         }
 
         /* Close attribute */
-        ret=H5Aclose(attr);
+        ret = H5Aclose(attr);
         CHECK(ret, FAIL, "H5Aclose");
 
         /* Close the dataspace */
@@ -1173,7 +1187,6 @@ test_h5s_zero_dim(void)
     } /* end for */
 } /* test_h5s_zero_dim() */
 
-
 /****************************************************************
 **
 **  test_h5s_encode(): Test H5S (dataspace) encoding and decoding.
@@ -1182,23 +1195,23 @@ test_h5s_zero_dim(void)
 static void
 test_h5s_encode(void)
 {
-    hid_t        sid1, sid2, sid3;    /* Dataspace ID        */
-    hid_t               decoded_sid1, decoded_sid2, decoded_sid3;
-    int                rank;        /* Logical rank of dataspace    */
-    hsize_t        dims1[] = {SPACE1_DIM1, SPACE1_DIM2, SPACE1_DIM3};
-    size_t              sbuf_size=0, null_size=0, scalar_size=0;
-    unsigned char       *sbuf=NULL, *null_sbuf=NULL, *scalar_buf=NULL;
-    hsize_t        tdims[4];    /* Dimension array to test with */
-    hssize_t        n;         /* Number of dataspace elements */
-    hsize_t             start[] = {0, 0, 0};
-    hsize_t             stride[] = {2, 5, 3};
-    hsize_t             count[] = {2, 2, 2};
-    hsize_t             block[] = {1, 3, 1};
-    H5S_sel_type        sel_type;
-    H5S_class_t         space_type;
-    hssize_t            nblocks;
-    hid_t        ret_id;        /* Generic hid_t return value    */
-    herr_t        ret;        /* Generic return value        */
+    hid_t          sid1, sid2, sid3; /* Dataspace ID        */
+    hid_t          decoded_sid1, decoded_sid2, decoded_sid3;
+    int            rank; /* Logical rank of dataspace    */
+    hsize_t        dims1[]   = {SPACE1_DIM1, SPACE1_DIM2, SPACE1_DIM3};
+    size_t         sbuf_size = 0, null_size = 0, scalar_size = 0;
+    unsigned char *sbuf = NULL, *null_sbuf = NULL, *scalar_buf = NULL;
+    hsize_t        tdims[4]; /* Dimension array to test with */
+    hssize_t       n;        /* Number of dataspace elements */
+    hsize_t        start[]  = {0, 0, 0};
+    hsize_t        stride[] = {2, 5, 3};
+    hsize_t        count[]  = {2, 2, 2};
+    hsize_t        block[]  = {1, 3, 1};
+    H5S_sel_type   sel_type;
+    H5S_class_t    space_type;
+    hssize_t       nblocks;
+    hid_t          ret_id; /* Generic hid_t return value    */
+    herr_t         ret;    /* Generic return value        */
 
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Dataspace Encoding and Decoding\n"));
@@ -1218,40 +1231,40 @@ test_h5s_encode(void)
     ret = H5Sencode(sid1, NULL, &sbuf_size);
     CHECK(ret, FAIL, "H5Sencode");
 
-    if(sbuf_size>0) {
-        sbuf = (unsigned char*)HDcalloc((size_t)1, sbuf_size);
-        CHECK(sbuf, NULL, "HDcalloc");
+    if (sbuf_size > 0) {
+        sbuf = (unsigned char *)HDcalloc((size_t)1, sbuf_size);
+        CHECK_PTR(sbuf, "HDcalloc");
     }
 
     /* Try decoding bogus buffer */
-    H5E_BEGIN_TRY {
+    H5E_BEGIN_TRY
+    {
         ret_id = H5Sdecode(sbuf);
-    } H5E_END_TRY;
+    }
+    H5E_END_TRY;
     VERIFY(ret_id, FAIL, "H5Sdecode");
 
     ret = H5Sencode(sid1, sbuf, &sbuf_size);
     CHECK(ret, FAIL, "H5Sencode");
 
     /* Decode from the dataspace buffer and return an object handle */
-    decoded_sid1=H5Sdecode(sbuf);
+    decoded_sid1 = H5Sdecode(sbuf);
     CHECK(decoded_sid1, FAIL, "H5Sdecode");
 
     /* Verify the decoded dataspace */
     n = H5Sget_simple_extent_npoints(decoded_sid1);
     CHECK(n, FAIL, "H5Sget_simple_extent_npoints");
-    VERIFY(n, SPACE1_DIM1 * SPACE1_DIM2 * SPACE1_DIM3,
-    "H5Sget_simple_extent_npoints");
+    VERIFY(n, SPACE1_DIM1 * SPACE1_DIM2 * SPACE1_DIM3, "H5Sget_simple_extent_npoints");
 
     /* Retrieve and verify the dataspace rank */
     rank = H5Sget_simple_extent_ndims(decoded_sid1);
     CHECK(rank, FAIL, "H5Sget_simple_extent_ndims");
     VERIFY(rank, SPACE1_RANK, "H5Sget_simple_extent_ndims");
 
-     /* Retrieve and verify the dataspace dimensions */
+    /* Retrieve and verify the dataspace dimensions */
     rank = H5Sget_simple_extent_dims(decoded_sid1, tdims, NULL);
     CHECK(rank, FAIL, "H5Sget_simple_extent_dims");
-    VERIFY(HDmemcmp(tdims, dims1, SPACE1_RANK * sizeof(hsize_t)), 0,
-    "H5Sget_simple_extent_dims");
+    VERIFY(HDmemcmp(tdims, dims1, SPACE1_RANK * sizeof(hsize_t)), 0, "H5Sget_simple_extent_dims");
 
     /* Verify the type of dataspace selection */
     sel_type = H5Sget_select_type(decoded_sid1);
@@ -1259,7 +1272,7 @@ test_h5s_encode(void)
 
     /* Verify the number of hyperslab blocks */
     nblocks = H5Sget_select_hyper_nblocks(decoded_sid1);
-    VERIFY(nblocks, 2*2*2, "H5Sget_select_hyper_nblocks");
+    VERIFY(nblocks, 2 * 2 * 2, "H5Sget_select_hyper_nblocks");
 
     /* Close the dataspaces */
     ret = H5Sclose(sid1);
@@ -1279,9 +1292,9 @@ test_h5s_encode(void)
     ret = H5Sencode(sid2, NULL, &null_size);
     CHECK(ret, FAIL, "H5Sencode");
 
-    if(null_size>0) {
-        null_sbuf = (unsigned char*)HDcalloc((size_t)1, null_size);
-        CHECK(null_sbuf, NULL, "HDcalloc");
+    if (null_size > 0) {
+        null_sbuf = (unsigned char *)HDcalloc((size_t)1, null_size);
+        CHECK_PTR(null_sbuf, "HDcalloc");
     }
 
     /* Encode the null dataspace in the buffer */
@@ -1289,7 +1302,7 @@ test_h5s_encode(void)
     CHECK(ret, FAIL, "H5Sencode");
 
     /* Decode from the dataspace buffer and return an object handle */
-    decoded_sid2=H5Sdecode(null_sbuf);
+    decoded_sid2 = H5Sdecode(null_sbuf);
     CHECK(decoded_sid2, FAIL, "H5Sdecode");
 
     /* Verify the decoded dataspace type */
@@ -1315,9 +1328,9 @@ test_h5s_encode(void)
     ret = H5Sencode(sid3, NULL, &scalar_size);
     CHECK(ret, FAIL, "H5Sencode");
 
-    if(scalar_size>0) {
-        scalar_buf = (unsigned char*)HDcalloc((size_t)1, scalar_size);
-        CHECK(scalar_buf, NULL, "HDcalloc");
+    if (scalar_size > 0) {
+        scalar_buf = (unsigned char *)HDcalloc((size_t)1, scalar_size);
+        CHECK_PTR(scalar_buf, "HDcalloc");
     }
 
     /* Encode the scalar dataspace in the buffer */
@@ -1325,7 +1338,7 @@ test_h5s_encode(void)
     CHECK(ret, FAIL, "H5Sencode");
 
     /* Decode from the dataspace buffer and return an object handle */
-    decoded_sid3=H5Sdecode(scalar_buf);
+    decoded_sid3 = H5Sdecode(scalar_buf);
     CHECK(decoded_sid3, FAIL, "H5Sdecode");
 
     /* Verify extent type */
@@ -1350,11 +1363,11 @@ test_h5s_encode(void)
     CHECK(ret, FAIL, "H5Sclose");
 
     /* Release resources */
-    if(sbuf)
+    if (sbuf)
         HDfree(sbuf);
-    if(null_sbuf)
+    if (null_sbuf)
         HDfree(null_sbuf);
-    if(scalar_buf)
+    if (scalar_buf)
         HDfree(scalar_buf);
 } /* test_h5s_encode() */
 
@@ -1366,14 +1379,14 @@ test_h5s_encode(void)
 static void
 test_h5s_scalar_write(void)
 {
-    hid_t        fid1;      /* HDF5 File IDs        */
-    hid_t        dataset;   /* Dataset ID            */
-    hid_t        sid1;      /* Dataspace ID            */
-    int          rank;      /* Logical rank of dataspace    */
-    hsize_t      tdims[4];  /* Dimension array to test with */
-    hssize_t     n;         /* Number of dataspace elements */
-    H5S_class_t  ext_type;  /* Extent type */
-    herr_t        ret;      /* Generic return value        */
+    hid_t       fid1;     /* HDF5 File IDs        */
+    hid_t       dataset;  /* Dataset ID            */
+    hid_t       sid1;     /* Dataspace ID            */
+    int         rank;     /* Logical rank of dataspace    */
+    hsize_t     tdims[4]; /* Dimension array to test with */
+    hssize_t    n;        /* Number of dataspace elements */
+    H5S_class_t ext_type; /* Extent type */
+    herr_t      ret;      /* Generic return value        */
 
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Scalar Dataspace Manipulation during Writing\n"));
@@ -1383,9 +1396,11 @@ test_h5s_scalar_write(void)
     CHECK(fid1, FAIL, "H5Fcreate");
 
     /* Verify a non-zero rank fails with a NULL dimension. */
-    H5E_BEGIN_TRY {
+    H5E_BEGIN_TRY
+    {
         sid1 = H5Screate_simple(SPACE1_RANK, NULL, NULL);
-    } H5E_END_TRY
+    }
+    H5E_END_TRY
     VERIFY(sid1, FAIL, "H5Screate_simple");
 
     /* Create scalar dataspace */
@@ -1429,7 +1444,7 @@ test_h5s_scalar_write(void)
     /* Close file */
     ret = H5Fclose(fid1);
     CHECK(ret, FAIL, "H5Fclose");
-}  /* test_h5s_scalar_write() */
+} /* test_h5s_scalar_write() */
 
 /****************************************************************
 **
@@ -1439,15 +1454,15 @@ test_h5s_scalar_write(void)
 static void
 test_h5s_scalar_read(void)
 {
-    hid_t        fid1;        /* HDF5 File IDs        */
-    hid_t        dataset;    /* Dataset ID            */
-    hid_t        sid1;            /* Dataspace ID            */
-    int                rank;        /* Logical rank of dataspace    */
-    hsize_t        tdims[4];    /* Dimension array to test with */
-    hssize_t        n;         /* Number of dataspace elements */
-    unsigned          rdata;          /* Scalar data read in         */
-    herr_t        ret;        /* Generic return value        */
-    H5S_class_t ext_type;               /* Extent type */
+    hid_t       fid1;     /* HDF5 File IDs        */
+    hid_t       dataset;  /* Dataset ID            */
+    hid_t       sid1;     /* Dataspace ID            */
+    int         rank;     /* Logical rank of dataspace    */
+    hsize_t     tdims[4]; /* Dimension array to test with */
+    hssize_t    n;        /* Number of dataspace elements */
+    unsigned    rdata;    /* Scalar data read in         */
+    herr_t      ret;      /* Generic return value        */
+    H5S_class_t ext_type; /* Extent type */
 
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Scalar Dataspace Manipulation during Reading\n"));
@@ -1493,7 +1508,7 @@ test_h5s_scalar_read(void)
     /* Close file */
     ret = H5Fclose(fid1);
     CHECK(ret, FAIL, "H5Fclose");
-}                /* test_h5s_scalar_read() */
+} /* test_h5s_scalar_read() */
 
 /****************************************************************
 **
@@ -1504,14 +1519,14 @@ test_h5s_scalar_read(void)
 static void
 test_h5s_compound_scalar_write(void)
 {
-    hid_t        fid1;        /* HDF5 File IDs        */
-    hid_t        dataset;    /* Dataset ID            */
-    hid_t           tid1;           /* Attribute datatype ID    */
-    hid_t        sid1;            /* Dataspace ID            */
-    int                rank;        /* Logical rank of dataspace    */
-    hsize_t        tdims[4];    /* Dimension array to test with */
-    hssize_t        n;         /* Number of dataspace elements */
-    herr_t        ret;        /* Generic return value        */
+    hid_t    fid1;     /* HDF5 File IDs        */
+    hid_t    dataset;  /* Dataset ID            */
+    hid_t    tid1;     /* Attribute datatype ID    */
+    hid_t    sid1;     /* Dataspace ID            */
+    int      rank;     /* Logical rank of dataspace    */
+    hsize_t  tdims[4]; /* Dimension array to test with */
+    hssize_t n;        /* Number of dataspace elements */
+    herr_t   ret;      /* Generic return value        */
 
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Scalar Dataspace Manipulation for Writing Compound Datatypes\n"));
@@ -1521,23 +1536,19 @@ test_h5s_compound_scalar_write(void)
     CHECK(fid1, FAIL, "H5Fcreate");
 
     /* Create the compound datatype.  */
-    tid1 = H5Tcreate (H5T_COMPOUND, sizeof(struct space4_struct));
+    tid1 = H5Tcreate(H5T_COMPOUND, sizeof(struct space4_struct));
     CHECK(tid1, FAIL, "H5Tcreate");
-    space4_field1_off=HOFFSET(struct space4_struct, c1);
-    ret = H5Tinsert(tid1, SPACE4_FIELDNAME1, space4_field1_off,
-            H5T_NATIVE_SCHAR);
+    space4_field1_off = HOFFSET(struct space4_struct, c1);
+    ret               = H5Tinsert(tid1, SPACE4_FIELDNAME1, space4_field1_off, H5T_NATIVE_SCHAR);
     CHECK(ret, FAIL, "H5Tinsert");
-    space4_field2_off=HOFFSET(struct space4_struct, u);
-    ret = H5Tinsert(tid1, SPACE4_FIELDNAME2, space4_field2_off,
-            H5T_NATIVE_UINT);
+    space4_field2_off = HOFFSET(struct space4_struct, u);
+    ret               = H5Tinsert(tid1, SPACE4_FIELDNAME2, space4_field2_off, H5T_NATIVE_UINT);
     CHECK(ret, FAIL, "H5Tinsert");
-    space4_field3_off=HOFFSET(struct space4_struct, f);
-    ret = H5Tinsert(tid1, SPACE4_FIELDNAME3, space4_field3_off,
-            H5T_NATIVE_FLOAT);
+    space4_field3_off = HOFFSET(struct space4_struct, f);
+    ret               = H5Tinsert(tid1, SPACE4_FIELDNAME3, space4_field3_off, H5T_NATIVE_FLOAT);
     CHECK(ret, FAIL, "H5Tinsert");
-    space4_field4_off=HOFFSET(struct space4_struct, c2);
-    ret = H5Tinsert(tid1, SPACE4_FIELDNAME4, space4_field4_off,
-            H5T_NATIVE_SCHAR);
+    space4_field4_off = HOFFSET(struct space4_struct, c2);
+    ret               = H5Tinsert(tid1, SPACE4_FIELDNAME4, space4_field4_off, H5T_NATIVE_SCHAR);
     CHECK(ret, FAIL, "H5Tinsert");
 
     /* Create scalar dataspace */
@@ -1577,7 +1588,7 @@ test_h5s_compound_scalar_write(void)
     /* Close file */
     ret = H5Fclose(fid1);
     CHECK(ret, FAIL, "H5Fclose");
-}                /* test_h5s_compound_scalar_write() */
+} /* test_h5s_compound_scalar_write() */
 
 /****************************************************************
 **
@@ -1588,15 +1599,15 @@ test_h5s_compound_scalar_write(void)
 static void
 test_h5s_compound_scalar_read(void)
 {
-    hid_t        fid1;        /* HDF5 File IDs        */
-    hid_t        dataset;    /* Dataset ID            */
-    hid_t        sid1;            /* Dataspace ID            */
-    hid_t           type;           /* Datatype                 */
-    int                rank;        /* Logical rank of dataspace    */
-    hsize_t        tdims[4];    /* Dimension array to test with */
-    hssize_t        n;         /* Number of dataspace elements */
-    struct space4_struct rdata;     /* Scalar data read in         */
-    herr_t        ret;        /* Generic return value        */
+    hid_t                fid1;     /* HDF5 File IDs        */
+    hid_t                dataset;  /* Dataset ID            */
+    hid_t                sid1;     /* Dataspace ID            */
+    hid_t                type;     /* Datatype                 */
+    int                  rank;     /* Logical rank of dataspace    */
+    hsize_t              tdims[4]; /* Dimension array to test with */
+    hssize_t             n;        /* Number of dataspace elements */
+    struct space4_struct rdata;    /* Scalar data read in         */
+    herr_t               ret;      /* Generic return value        */
 
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Scalar Dataspace Manipulation for Reading Compound Datatypes\n"));
@@ -1623,17 +1634,19 @@ test_h5s_compound_scalar_read(void)
     rank = H5Sget_simple_extent_dims(sid1, tdims, NULL);
     VERIFY(rank, 0, "H5Sget_simple_extent_dims");
 
-    type=H5Dget_type(dataset);
+    type = H5Dget_type(dataset);
     CHECK(type, FAIL, "H5Dget_type");
 
     ret = H5Dread(dataset, type, H5S_ALL, H5S_ALL, H5P_DEFAULT, &rdata);
     CHECK(ret, FAIL, "H5Dread");
-    if(HDmemcmp(&space4_data,&rdata,sizeof(struct space4_struct))) {
-        HDprintf("scalar data different: space4_data.c1=%c, read_data4.c1=%c\n",space4_data.c1,rdata.c1);
-        HDprintf("scalar data different: space4_data.u=%u, read_data4.u=%u\n",space4_data.u,rdata.u);
-        HDprintf("scalar data different: space4_data.f=%f, read_data4.f=%f\n",(double)space4_data.f,(double)rdata.f);
-        TestErrPrintf("scalar data different: space4_data.c1=%c, read_data4.c1=%c\n",space4_data.c1,rdata.c2);
-     } /* end if */
+    if (HDmemcmp(&space4_data, &rdata, sizeof(struct space4_struct)) != 0) {
+        HDprintf("scalar data different: space4_data.c1=%c, read_data4.c1=%c\n", space4_data.c1, rdata.c1);
+        HDprintf("scalar data different: space4_data.u=%u, read_data4.u=%u\n", space4_data.u, rdata.u);
+        HDprintf("scalar data different: space4_data.f=%f, read_data4.f=%f\n", (double)space4_data.f,
+                 (double)rdata.f);
+        TestErrPrintf("scalar data different: space4_data.c1=%c, read_data4.c1=%c\n", space4_data.c1,
+                      rdata.c2);
+    } /* end if */
 
     /* Close datatype */
     ret = H5Tclose(type);
@@ -1650,12 +1663,11 @@ test_h5s_compound_scalar_read(void)
     /* Close file */
     ret = H5Fclose(fid1);
     CHECK(ret, FAIL, "H5Fclose");
-}   /* end test_h5s_compound_scalar_read() */
-
+} /* end test_h5s_compound_scalar_read() */
 
 /* Data array sizes for chunk test */
-#define CHUNK_DATA_NX   50000
-#define CHUNK_DATA_NY   3
+#define CHUNK_DATA_NX 50000
+#define CHUNK_DATA_NY 3
 
 /****************************************************************
 **
@@ -1667,17 +1679,17 @@ test_h5s_compound_scalar_read(void)
 static void
 test_h5s_chunk(void)
 {
-    herr_t status;
-    hid_t fileID, dsetID;
-    hid_t plist_id;
-    hid_t space_id;
-    hsize_t dims[2];
-    hsize_t csize[2];
-    double  **chunk_data_dbl        = NULL;
-    double  *chunk_data_dbl_data    = NULL;
-    float   **chunk_data_flt        = NULL;
-    float   *chunk_data_flt_data    = NULL;
-    int i,j;
+    herr_t   status;
+    hid_t    fileID, dsetID;
+    hid_t    plist_id;
+    hid_t    space_id;
+    hsize_t  dims[2];
+    hsize_t  csize[2];
+    double **chunk_data_dbl      = NULL;
+    double * chunk_data_dbl_data = NULL;
+    float ** chunk_data_flt      = NULL;
+    float *  chunk_data_flt_data = NULL;
+    int      i, j;
 
     /* Allocate memory */
     chunk_data_dbl_data = (double *)HDcalloc(CHUNK_DATA_NX * CHUNK_DATA_NY, sizeof(double));
@@ -1702,12 +1714,12 @@ test_h5s_chunk(void)
 
     csize[0] = CHUNK_DATA_NX;
     csize[1] = CHUNK_DATA_NY;
-    status = H5Pset_chunk(plist_id, 2, csize);
+    status   = H5Pset_chunk(plist_id, 2, csize);
     CHECK(status, FAIL, "H5Pset_chunk");
 
     /* Create the dataspace */
-    dims[0] = CHUNK_DATA_NX;
-    dims[1] = CHUNK_DATA_NY;
+    dims[0]  = CHUNK_DATA_NX;
+    dims[1]  = CHUNK_DATA_NY;
     space_id = H5Screate_simple(2, dims, NULL);
     CHECK(space_id, FAIL, "H5Screate_simple");
 
@@ -1715,8 +1727,8 @@ test_h5s_chunk(void)
     CHECK(dsetID, FAIL, "H5Dcreate2");
 
     /* Initialize float array */
-    for(i = 0; i < CHUNK_DATA_NX; i++)
-        for(j = 0; j < CHUNK_DATA_NY; j++)
+    for (i = 0; i < CHUNK_DATA_NX; i++)
+        for (j = 0; j < CHUNK_DATA_NY; j++)
             chunk_data_flt[i][j] = (float)(i + 1) * 2.5F - (float)j * 100.3F;
 
     status = H5Dwrite(dsetID, H5T_NATIVE_FLOAT, H5S_ALL, H5S_ALL, H5P_DEFAULT, chunk_data_flt_data);
@@ -1740,9 +1752,9 @@ test_h5s_chunk(void)
     dsetID = H5Dopen2(fileID, "coords", H5P_DEFAULT);
     CHECK(dsetID, FAIL, "H5Dopen2");
 
-    status= H5Dread(dsetID, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT, chunk_data_dbl_data);
+    status = H5Dread(dsetID, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT, chunk_data_dbl_data);
     CHECK(status, FAIL, "H5Dread");
-    status= H5Dread(dsetID, H5T_NATIVE_FLOAT, H5S_ALL, H5S_ALL, H5P_DEFAULT, chunk_data_flt_data);
+    status = H5Dread(dsetID, H5T_NATIVE_FLOAT, H5S_ALL, H5S_ALL, H5P_DEFAULT, chunk_data_flt_data);
     CHECK(status, FAIL, "H5Dread");
 
     status = H5Dclose(dsetID);
@@ -1750,13 +1762,15 @@ test_h5s_chunk(void)
     status = H5Fclose(fileID);
     CHECK(status, FAIL, "H5Fclose");
 
-    for(i = 0; i < CHUNK_DATA_NX; i++) {
-        for(j = 0; j < CHUNK_DATA_NY; j++) {
+    for (i = 0; i < CHUNK_DATA_NX; i++) {
+        for (j = 0; j < CHUNK_DATA_NY; j++) {
             /* Check if the two values are within 0.001% range. */
-            if(!H5_DBL_REL_EQUAL(chunk_data_dbl[i][j], (double)chunk_data_flt[i][j], (double)0.00001F))
-                TestErrPrintf("%u: chunk_data_dbl[%d][%d]=%e, chunk_data_flt[%d][%d]=%e\n", (unsigned)__LINE__, i, j, chunk_data_dbl[i][j], i, j, (double)chunk_data_flt[i][j]);
+            if (!H5_DBL_REL_EQUAL(chunk_data_dbl[i][j], (double)chunk_data_flt[i][j], 0.00001))
+                TestErrPrintf("%u: chunk_data_dbl[%d][%d]=%e, chunk_data_flt[%d][%d]=%e\n",
+                              (unsigned)__LINE__, i, j, chunk_data_dbl[i][j], i, j,
+                              (double)chunk_data_flt[i][j]);
         } /* end for */
-    } /* end for */
+    }     /* end for */
 
     HDfree(chunk_data_dbl);
     HDfree(chunk_data_dbl_data);
@@ -1772,22 +1786,19 @@ test_h5s_chunk(void)
 static void
 test_h5s_extent_equal(void)
 {
-    hid_t null_space;           /* Null dataspace */
-    hid_t scalar_space;         /* Scalar dataspace */
-    hid_t d1_space1, d1_space2, d1_space3, d1_space4; /* 1-D dataspaces */
-    hid_t d2_space1, d2_space2, d2_space3, d2_space4; /* 2-D dataspaces */
-    hid_t d3_space1, d3_space2, d3_space3, d3_space4; /* 3-D dataspaces */
-    hsize_t d1_dims1[1] = {10}, /* 1-D dimensions */
-        d1_dims2[1] = {20},
-        d1_dims3[1] = {H5S_UNLIMITED};
-    hsize_t d2_dims1[2] = {10, 10},             /* 2-D dimensions */
-        d2_dims2[2] = {20, 20},
-        d2_dims3[2] = {H5S_UNLIMITED, H5S_UNLIMITED};
-    hsize_t d3_dims1[3] = {10, 10, 10},         /* 3-D dimensions */
-        d3_dims2[3] = {20, 20, 20},
-        d3_dims3[3] = {H5S_UNLIMITED, H5S_UNLIMITED, H5S_UNLIMITED};
-    htri_t ext_equal;           /* Whether two dataspace extents are equal */
-    herr_t ret;                 /* Generic error return */
+    hid_t   null_space;                                 /* Null dataspace */
+    hid_t   scalar_space;                               /* Scalar dataspace */
+    hid_t   d1_space1, d1_space2, d1_space3, d1_space4; /* 1-D dataspaces */
+    hid_t   d2_space1, d2_space2, d2_space3, d2_space4; /* 2-D dataspaces */
+    hid_t   d3_space1, d3_space2, d3_space3, d3_space4; /* 3-D dataspaces */
+    hsize_t d1_dims1[1] = {10},                         /* 1-D dimensions */
+        d1_dims2[1] = {20}, d1_dims3[1] = {H5S_UNLIMITED};
+    hsize_t d2_dims1[2] = {10, 10}, /* 2-D dimensions */
+        d2_dims2[2] = {20, 20}, d2_dims3[2] = {H5S_UNLIMITED, H5S_UNLIMITED};
+    hsize_t d3_dims1[3] = {10, 10, 10}, /* 3-D dimensions */
+        d3_dims2[3] = {20, 20, 20}, d3_dims3[3] = {H5S_UNLIMITED, H5S_UNLIMITED, H5S_UNLIMITED};
+    htri_t ext_equal; /* Whether two dataspace extents are equal */
+    herr_t ret;       /* Generic error return */
 
     /* Create dataspaces */
     null_space = H5Screate(H5S_NULL);
@@ -2289,22 +2300,19 @@ static void
 test_h5s_extent_copy(void)
 {
     hid_t spaces[14] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; /* Array of all dataspaces */
-    hid_t tmp_space = -1;
+    hid_t tmp_space  = -1;
     hsize_t d1_dims1[1] = {10}, /* 1-D dimensions */
-        d1_dims2[1] = {20},
-        d1_dims3[1] = {H5S_UNLIMITED};
-    hsize_t d2_dims1[2] = {10, 10},             /* 2-D dimensions */
-        d2_dims2[2] = {20, 20},
-        d2_dims3[2] = {H5S_UNLIMITED, H5S_UNLIMITED};
-    hsize_t d3_dims1[3] = {10, 10, 10},         /* 3-D dimensions */
-        d3_dims2[3] = {20, 20, 20},
-        d3_dims3[3] = {H5S_UNLIMITED, H5S_UNLIMITED, H5S_UNLIMITED};
-    hsize_t npoints[14];        /* Expected number of points in selection for each element in spaces */
-    hssize_t npoints_ret;       /* Number of points returned by H5Sget_select_npoints() */
-    htri_t ext_equal;           /* Whether two dataspace extents are equal */
+        d1_dims2[1] = {20}, d1_dims3[1] = {H5S_UNLIMITED};
+    hsize_t d2_dims1[2] = {10, 10}, /* 2-D dimensions */
+        d2_dims2[2] = {20, 20}, d2_dims3[2] = {H5S_UNLIMITED, H5S_UNLIMITED};
+    hsize_t d3_dims1[3] = {10, 10, 10}, /* 3-D dimensions */
+        d3_dims2[3] = {20, 20, 20}, d3_dims3[3] = {H5S_UNLIMITED, H5S_UNLIMITED, H5S_UNLIMITED};
+    hsize_t        npoints[14]; /* Expected number of points in selection for each element in spaces */
+    hssize_t       npoints_ret; /* Number of points returned by H5Sget_select_npoints() */
+    htri_t         ext_equal;   /* Whether two dataspace extents are equal */
     const unsigned num_spaces = sizeof(spaces) / sizeof(spaces[0]);
-    unsigned i, j;
-    herr_t ret;                 /* Generic error return */
+    unsigned       i, j;
+    herr_t         ret; /* Generic error return */
 
     /* Create dataspaces */
     spaces[0] = H5Screate(H5S_NULL);
@@ -2318,39 +2326,39 @@ test_h5s_extent_copy(void)
     spaces[2] = H5Screate_simple(1, d1_dims1, NULL);
     CHECK(spaces[2], FAIL, "H5Screate");
     npoints[2] = d1_dims1[0];
-    spaces[3] = H5Screate_simple(1, d1_dims2, NULL);
+    spaces[3]  = H5Screate_simple(1, d1_dims2, NULL);
     CHECK(spaces[3], FAIL, "H5Screate");
     npoints[3] = d1_dims2[0];
-    spaces[4] = H5Screate_simple(1, d1_dims1, d1_dims2);
+    spaces[4]  = H5Screate_simple(1, d1_dims1, d1_dims2);
     CHECK(spaces[4], FAIL, "H5Screate");
     npoints[4] = d1_dims1[0];
-    spaces[5] = H5Screate_simple(1, d1_dims1, d1_dims3);
+    spaces[5]  = H5Screate_simple(1, d1_dims1, d1_dims3);
     CHECK(spaces[5], FAIL, "H5Screate");
     npoints[5] = d1_dims1[0];
 
     spaces[6] = H5Screate_simple(2, d2_dims1, NULL);
     CHECK(spaces[6], FAIL, "H5Screate");
     npoints[6] = d2_dims1[0] * d2_dims1[1];
-    spaces[7] = H5Screate_simple(2, d2_dims2, NULL);
+    spaces[7]  = H5Screate_simple(2, d2_dims2, NULL);
     CHECK(spaces[7], FAIL, "H5Screate");
     npoints[7] = d2_dims2[0] * d2_dims2[1];
-    spaces[8] = H5Screate_simple(2, d2_dims1, d2_dims2);
+    spaces[8]  = H5Screate_simple(2, d2_dims1, d2_dims2);
     CHECK(spaces[8], FAIL, "H5Screate");
     npoints[8] = d2_dims1[0] * d2_dims1[1];
-    spaces[9] = H5Screate_simple(2, d2_dims1, d2_dims3);
+    spaces[9]  = H5Screate_simple(2, d2_dims1, d2_dims3);
     CHECK(spaces[9], FAIL, "H5Screate");
     npoints[9] = d2_dims1[0] * d2_dims1[1];
 
     spaces[10] = H5Screate_simple(3, d3_dims1, NULL);
     CHECK(spaces[10], FAIL, "H5Screate");
     npoints[10] = d3_dims1[0] * d3_dims1[1] * d3_dims1[2];
-    spaces[11] = H5Screate_simple(3, d3_dims2, NULL);
+    spaces[11]  = H5Screate_simple(3, d3_dims2, NULL);
     CHECK(spaces[11], FAIL, "H5Screate");
     npoints[11] = d3_dims2[0] * d3_dims2[1] * d3_dims2[2];
-    spaces[12] = H5Screate_simple(3, d3_dims1, d3_dims2);
+    spaces[12]  = H5Screate_simple(3, d3_dims1, d3_dims2);
     CHECK(spaces[12], FAIL, "H5Screate");
     npoints[12] = d3_dims1[0] * d3_dims1[1] * d3_dims1[2];
-    spaces[13] = H5Screate_simple(3, d3_dims1, d3_dims3);
+    spaces[13]  = H5Screate_simple(3, d3_dims1, d3_dims3);
     CHECK(spaces[13], FAIL, "H5Screate");
     npoints[13] = d3_dims1[0] * d3_dims1[1] * d3_dims1[2];
 
@@ -2359,8 +2367,8 @@ test_h5s_extent_copy(void)
 
     /* Copy between all dataspace combinations.  Note there are a few
      * duplicates. */
-    for(i = 0; i < num_spaces; i++)
-        for(j = i; j < num_spaces; j++) {
+    for (i = 0; i < num_spaces; i++)
+        for (j = i; j < num_spaces; j++) {
             /* Copy from i to j, unless the inner loop just restarted, in which
              * case i and j are the same, so the second call to H5Sextent_copy()
              * will test copying from i/j to i/j */
@@ -2389,7 +2397,7 @@ test_h5s_extent_copy(void)
         } /* end for */
 
     /* Close dataspaces */
-    for(i = 0; i < num_spaces; i++) {
+    for (i = 0; i < num_spaces; i++) {
         ret = H5Sclose(spaces[i]);
         CHECK(ret, FAIL, "H5Sclose");
         spaces[i] = -1;
@@ -2408,12 +2416,12 @@ test_h5s_extent_copy(void)
 static void
 test_h5s_bug1(void)
 {
-    hid_t space1;               /* Dataspace to copy extent to */
-    hid_t space2;               /* Scalar dataspace */
-    hsize_t dims[2] = {10, 10}; /* Dimensions */
-    hsize_t start[2] = {0, 0};  /* Hyperslab start */
-    htri_t select_valid;        /* Whether the dataspace selection is valid */
-    herr_t ret;                 /* Generic error return */
+    hid_t   space1;              /* Dataspace to copy extent to */
+    hid_t   space2;              /* Scalar dataspace */
+    hsize_t dims[2]  = {10, 10}; /* Dimensions */
+    hsize_t start[2] = {0, 0};   /* Hyperslab start */
+    htri_t  select_valid;        /* Whether the dataspace selection is valid */
+    herr_t  ret;                 /* Generic error return */
 
     /* Create dataspaces */
     space1 = H5Screate(H5S_SIMPLE);
@@ -2441,7 +2449,6 @@ test_h5s_bug1(void)
     CHECK(ret, FAIL, "H5Sclose");
 } /* test_h5s_bug1() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    test_versionbounds
  *
@@ -2457,21 +2464,21 @@ test_h5s_bug1(void)
  *
  *-------------------------------------------------------------------------
  */
-#define VERBFNAME       "tverbounds_dspace.h5"
-#define BASIC_DSET      "Basic Dataset"
-#define LATEST_DSET     "Latest Dataset"
+#define VERBFNAME   "tverbounds_dspace.h5"
+#define BASIC_DSET  "Basic Dataset"
+#define LATEST_DSET "Latest Dataset"
 static void
 test_versionbounds(void)
 {
-    hid_t file = -1;    /* File ID */
-    hid_t space = -1;   /* Dataspace ID */
-    hid_t dset = -1;    /* Dataset ID */
-    hid_t fapl = -1;    /* File access property list ID */
-    hid_t dset_space = -1;  /* Retrieved dataset's dataspace ID */
-    hsize_t dim[1];         /* Dataset dimensions */
-    H5F_libver_t low, high; /* File format bounds */
-    H5S_t *spacep = NULL;   /* Pointer to internal dataspace */
-    herr_t ret = 0;         /* Generic return value */
+    hid_t        file       = -1; /* File ID */
+    hid_t        space      = -1; /* Dataspace ID */
+    hid_t        dset       = -1; /* Dataset ID */
+    hid_t        fapl       = -1; /* File access property list ID */
+    hid_t        dset_space = -1; /* Retrieved dataset's dataspace ID */
+    hsize_t      dim[1];          /* Dataset dimensions */
+    H5F_libver_t low, high;       /* File format bounds */
+    H5S_t *      spacep = NULL;   /* Pointer to internal dataspace */
+    herr_t       ret    = 0;      /* Generic return value */
 
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Version Bounds\n"));
@@ -2482,18 +2489,18 @@ test_versionbounds(void)
 
     /* Create dataspace */
     dim[0] = 10;
-    space = H5Screate_simple(1, dim, NULL);
+    space  = H5Screate_simple(1, dim, NULL);
     CHECK(space, FAIL, "H5Screate");
 
     /* Its version should be H5O_SDSPACE_VERSION_1 */
     spacep = (H5S_t *)H5I_object(space);
-    CHECK(spacep, NULL, "H5I_object");
+    CHECK_PTR(spacep, "H5I_object");
     VERIFY(spacep->extent.version, H5O_SDSPACE_VERSION_1, "basic dataspace version bound");
 
     /* Set high bound to V18 */
-    low = H5F_LIBVER_EARLIEST;
+    low  = H5F_LIBVER_EARLIEST;
     high = H5F_LIBVER_V18;
-    ret = H5Pset_libver_bounds(fapl, low, high);
+    ret  = H5Pset_libver_bounds(fapl, low, high);
     CHECK(ret, FAIL, "H5Pset_libver_bounds");
 
     /* Create the file */
@@ -2508,7 +2515,7 @@ test_versionbounds(void)
         dset_space = H5Dget_space(dset);
         CHECK(dset_space, FAIL, "H5Dget_space");
         spacep = (H5S_t *)H5I_object(dset_space);
-        CHECK(spacep, NULL, "H5I_object");
+        CHECK_PTR(spacep, "H5I_object");
 
         /* Dataspace version should remain as H5O_SDSPACE_VERSION_1 */
         VERIFY(spacep->extent.version, H5O_SDSPACE_VERSION_1, "basic dataspace version bound");
@@ -2526,9 +2533,9 @@ test_versionbounds(void)
 
     /* Set low and high bounds to latest to trigger the increment of the
        dataspace version */
-    low = H5F_LIBVER_LATEST;
+    low  = H5F_LIBVER_LATEST;
     high = H5F_LIBVER_LATEST;
-    ret = H5Pset_libver_bounds(fapl, low, high);
+    ret  = H5Pset_libver_bounds(fapl, low, high);
     CHECK(ret, FAIL, "H5Pset_libver_bounds");
 
     /* Reopen the file with new version bounds, LATEST/LATEST */
@@ -2545,7 +2552,7 @@ test_versionbounds(void)
     dset_space = H5Dget_space(dset);
     CHECK(dset_space, FAIL, "H5Dget_space");
     spacep = (H5S_t *)H5I_object(dset_space);
-    CHECK(spacep, NULL, "H5I_object");
+    CHECK_PTR(spacep, "H5I_object");
 
     /* Verify the dataspace version */
     VERIFY(spacep->extent.version, H5O_sdspace_ver_bounds[low], "upgraded dataspace version");
@@ -2564,7 +2571,6 @@ test_versionbounds(void)
     CHECK(ret, FAIL, "H5Fclose");
 } /* end test_versionbounds() */
 
-
 /****************************************************************
 **
 **  test_h5s_encode_regular_exceed32():
@@ -2579,18 +2585,18 @@ test_versionbounds(void)
 static void
 test_h5s_encode_regular_exceed32(void)
 {
-    hid_t sid;                  /* Dataspace ID */
-    hid_t decoded_sid;          /* Dataspace ID from H5Sdecode */
-    size_t sbuf_size=0;         /* Buffer size for H5Sencode */
-    unsigned char *sbuf=NULL;   /* Buffer for H5Sencode */
-    hssize_t num;               /* Number of elements in the dataspace selection */
-    hssize_t decoded_num;       /* Number of elements in the dataspace selection from H5Sdeocde */
-    hsize_t numparticles = 8388608;
-    unsigned num_dsets = 513;
-    hsize_t total_particles = numparticles * num_dsets;
-    hsize_t vdsdims[1] = {total_particles};
-    hsize_t start, count, block;
-    herr_t ret;                 /* Generic return value */
+    hid_t          sid;              /* Dataspace ID */
+    hid_t          decoded_sid;      /* Dataspace ID from H5Sdecode */
+    size_t         sbuf_size = 0;    /* Buffer size for H5Sencode */
+    unsigned char *sbuf      = NULL; /* Buffer for H5Sencode */
+    hssize_t       num;              /* Number of elements in the dataspace selection */
+    hssize_t       decoded_num;      /* Number of elements in the dataspace selection from H5Sdeocde */
+    hsize_t        numparticles    = 8388608;
+    unsigned       num_dsets       = 513;
+    hsize_t        total_particles = numparticles * num_dsets;
+    hsize_t        vdsdims[1]      = {total_particles};
+    hsize_t        start, count, block;
+    herr_t         ret; /* Generic return value */
 
     MESSAGE(5, ("Testing Dataspace encoding regular hyperslabs that exceeds 32 bits\n"));
 
@@ -2612,8 +2618,8 @@ test_h5s_encode_regular_exceed32(void)
     ret = H5Sencode(sid, NULL, &sbuf_size);
     CHECK(ret, FAIL, "H5Sencode2");
 
-    if(sbuf_size > 0) {
-        sbuf = (unsigned char*)HDcalloc((size_t)1, sbuf_size);
+    if (sbuf_size > 0) {
+        sbuf = (unsigned char *)HDcalloc((size_t)1, sbuf_size);
         CHECK(sbuf, NULL, "H5Sencode");
     }
 
@@ -2638,7 +2644,7 @@ test_h5s_encode_regular_exceed32(void)
     ret = H5Sclose(decoded_sid);
     CHECK(ret, FAIL, "H5Sclose");
 
-    if(sbuf)
+    if (sbuf)
         HDfree(sbuf);
 
     ret = H5Sclose(sid);
@@ -2659,15 +2665,15 @@ test_h5s_encode_regular_exceed32(void)
 static void
 test_h5s_encode_irregular_exceed32(void)
 {
-    hid_t sid;           /* Dataspace ID */
-    hsize_t numparticles = 8388608;
-    unsigned num_dsets = 513;
-    hsize_t total_particles = numparticles * num_dsets;
-    hsize_t vdsdims[1] = {total_particles}; /* Dimension size */
-    hsize_t start, stride, count, block;    /* Selection info */
-    size_t sbuf_size=0; /* Buffer size for H5Sencode */
-    htri_t is_regular;  /* Is this a regular hyperslab */
-    herr_t ret;         /* Generic return value */
+    hid_t    sid; /* Dataspace ID */
+    hsize_t  numparticles    = 8388608;
+    unsigned num_dsets       = 513;
+    hsize_t  total_particles = numparticles * num_dsets;
+    hsize_t  vdsdims[1]      = {total_particles}; /* Dimension size */
+    hsize_t  start, stride, count, block;         /* Selection info */
+    size_t   sbuf_size = 0;                       /* Buffer size for H5Sencode */
+    htri_t   is_regular;                          /* Is this a regular hyperslab */
+    herr_t   ret;                                 /* Generic return value */
 
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Dataspace encoding irregular hyperslab that exceeds 32 bits\n"));
@@ -2682,9 +2688,9 @@ test_h5s_encode_irregular_exceed32(void)
     ret = H5Sselect_hyperslab(sid, H5S_SELECT_SET, &start, NULL, &count, &block);
     CHECK(ret, FAIL, "H5Sselect_hyperslab");
 
-    start = 8;
-    count = 5;
-    block = 2;
+    start  = 8;
+    count  = 5;
+    block  = 2;
     stride = POWER32;
 
     ret = H5Sselect_hyperslab(sid, H5S_SELECT_OR, &start, &stride, &count, &block);
@@ -2716,14 +2722,14 @@ test_h5s_encode_irregular_exceed32(void)
 static void
 test_h5s_encode_points_exceed32(void)
 {
-    hid_t sid;           /* Dataspace ID */
-    hsize_t numparticles = 8388608;
-    unsigned num_dsets = 513;
-    hsize_t total_particles = numparticles * num_dsets;
-    hsize_t vdsdims[1] = {total_particles}; /* Dimension size */
-    hsize_t coord[4];   /* The point coordinates */
-    size_t sbuf_size=0; /* Buffer size for H5Sencode */
-    herr_t ret;         /* Generic return value */
+    hid_t    sid; /* Dataspace ID */
+    hsize_t  numparticles    = 8388608;
+    unsigned num_dsets       = 513;
+    hsize_t  total_particles = numparticles * num_dsets;
+    hsize_t  vdsdims[1]      = {total_particles}; /* Dimension size */
+    hsize_t  coord[4];                            /* The point coordinates */
+    size_t   sbuf_size = 0;                       /* Buffer size for H5Sencode */
+    herr_t   ret;                                 /* Generic return value */
 
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Dataspace encoding points selection that exceeds 32 bits\n"));
@@ -2735,7 +2741,7 @@ test_h5s_encode_points_exceed32(void)
     coord[1] = 15;
     coord[2] = POWER32;
     coord[3] = 19;
-    ret = H5Sselect_elements(sid, H5S_SELECT_SET, (size_t)4, coord);
+    ret      = H5Sselect_elements(sid, H5S_SELECT_SET, (size_t)4, coord);
     CHECK(ret, FAIL, "H5Sselect_elements");
 
     /* Should fail because selection exceeds 32 bits */
@@ -2760,13 +2766,13 @@ test_h5s_encode_points_exceed32(void)
 static void
 test_h5s_encode_length(void)
 {
-    hid_t sid;                  /* Dataspace ID */
-    hid_t decoded_sid;          /* Dataspace ID from H5Sdecode2 */
-    size_t sbuf_size=0;         /* Buffer size for H5Sencode2/1 */
-    unsigned char *sbuf=NULL;   /* Buffer for H5Sencode2/1 */
-    hsize_t dims[1] = {500};    /* Dimension size */
-    hsize_t start, count, block, stride;    /* Hyperslab selection specifications */
-    herr_t ret;                 /* Generic return value */
+    hid_t          sid;                         /* Dataspace ID */
+    hid_t          decoded_sid;                 /* Dataspace ID from H5Sdecode2 */
+    size_t         sbuf_size = 0;               /* Buffer size for H5Sencode2/1 */
+    unsigned char *sbuf      = NULL;            /* Buffer for H5Sencode2/1 */
+    hsize_t        dims[1]   = {500};           /* Dimension size */
+    hsize_t        start, count, block, stride; /* Hyperslab selection specifications */
+    herr_t         ret;                         /* Generic return value */
 
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Version 2 Hyperslab Encoding Length is correct\n"));
@@ -2776,10 +2782,10 @@ test_h5s_encode_length(void)
     CHECK(sid, FAIL, "H5Screate_simple");
 
     /* Setting H5S_UNLIMITED in count will use version 2 for hyperslab encoding */
-    start = 0;
+    start  = 0;
     stride = 10;
-    block = 4;
-    count = H5S_UNLIMITED;
+    block  = 4;
+    count  = H5S_UNLIMITED;
 
     /* Set hyperslab selection */
     ret = H5Sselect_hyperslab(sid, H5S_SELECT_SET, &start, &stride, &count, &block);
@@ -2790,8 +2796,8 @@ test_h5s_encode_length(void)
     CHECK(ret, FAIL, "H5Sencode");
 
     /* Allocate the buffer */
-    if(sbuf_size > 0) {
-        sbuf = (unsigned char*)HDcalloc((size_t)1, sbuf_size);
+    if (sbuf_size > 0) {
+        sbuf = (unsigned char *)HDcalloc((size_t)1, sbuf_size);
         CHECK(sbuf, NULL, "H5Sencode2");
     }
 
@@ -2815,7 +2821,7 @@ test_h5s_encode_length(void)
     CHECK(ret, FAIL, "H5Sclose");
 
     /* Free the buffer */
-    if(sbuf)
+    if (sbuf)
         HDfree(sbuf);
 
     /* Close the original dataspace */
@@ -2835,32 +2841,32 @@ test_h5s(void)
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Dataspaces\n"));
 
-    test_h5s_basic();        /* Test basic H5S code */
-    test_h5s_null();        /* Test Null dataspace H5S code */
-    test_h5s_zero_dim();        /* Test dataspace with zero dimension size */
+    test_h5s_basic();    /* Test basic H5S code */
+    test_h5s_null();     /* Test Null dataspace H5S code */
+    test_h5s_zero_dim(); /* Test dataspace with zero dimension size */
 
-    test_h5s_encode();          /* Test encoding and decoding */
-    test_h5s_encode_regular_exceed32();     /* Test encoding regular hyperslab selection that exceeds 32 bits */
-    test_h5s_encode_irregular_exceed32();   /* Testing encoding irregular hyperslab selection that exceeds 32 bits */
-    test_h5s_encode_points_exceed32();      /* Testing encoding point selection that exceeds 32 bits */
-    test_h5s_encode_length();               /* Test version 2 hyperslab encoding length is correct */
+    test_h5s_encode();                    /* Test encoding and decoding */
+    test_h5s_encode_regular_exceed32();   /* Test encoding regular hyperslab selection that exceeds 32 bits */
+    test_h5s_encode_irregular_exceed32(); /* Testing encoding irregular hyperslab selection that exceeds 32
+                                             bits */
+    test_h5s_encode_points_exceed32();    /* Testing encoding point selection that exceeds 32 bits */
+    test_h5s_encode_length();             /* Test version 2 hyperslab encoding length is correct */
 
-    test_h5s_scalar_write();    /* Test scalar H5S writing code */
-    test_h5s_scalar_read();     /* Test scalar H5S reading code */
+    test_h5s_scalar_write(); /* Test scalar H5S writing code */
+    test_h5s_scalar_read();  /* Test scalar H5S reading code */
 
-    test_h5s_compound_scalar_write();    /* Test compound datatype scalar H5S writing code */
-    test_h5s_compound_scalar_read();    /* Test compound datatype scalar H5S reading code */
+    test_h5s_compound_scalar_write(); /* Test compound datatype scalar H5S writing code */
+    test_h5s_compound_scalar_read();  /* Test compound datatype scalar H5S reading code */
 
     /* This test was added later to exercise a bug in chunked I/O */
-    test_h5s_chunk();            /* Exercise bug fix for chunked I/O */
+    test_h5s_chunk(); /* Exercise bug fix for chunked I/O */
 
-    test_h5s_extent_equal();    /* Test extent comparison code */
-    test_h5s_extent_copy();     /* Test extent copy code */
-    test_h5s_bug1();            /* Test bug in offset initialization */
-    test_versionbounds();       /* Test version bounds with dataspace */
+    test_h5s_extent_equal(); /* Test extent comparison code */
+    test_h5s_extent_copy();  /* Test extent copy code */
+    test_h5s_bug1();         /* Test bug in offset initialization */
+    test_versionbounds();    /* Test version bounds with dataspace */
 } /* test_h5s() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    cleanup_h5s
  *
@@ -2878,9 +2884,9 @@ test_h5s(void)
 void
 cleanup_h5s(void)
 {
-    remove(DATAFILE);
-    remove(NULLFILE);
-    remove(BASICFILE);
-    remove(ZEROFILE);
-    remove(VERBFNAME);
+    HDremove(DATAFILE);
+    HDremove(NULLFILE);
+    HDremove(BASICFILE);
+    HDremove(ZEROFILE);
+    HDremove(VERBFNAME);
 }