Merge branch 'develop' into feature/coding_standardsfeature/coding_standards

1 files changed, 530 insertions, 474 deletions

diff --git a/c++/test/tattr.cpp b/c++/test/tattr.cpp
index 4734755..dc968f9 100644
--- a/c++/test/tattr.cpp
+++ b/c++/test/tattr.cpp
@@ -6,7 +6,7 @@
  * 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.                                                        *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -17,20 +17,18 @@
         C attribute interface (H5A)
 
  ***************************************************************************/
-#ifdef OLD_HEADER_FILENAME
-#include <iostream.h>
-#else
+#include <cfloat>
+#include <cmath>
 #include <iostream>
-#endif
 using std::cerr;
 using std::endl;
 
 #include <string>
-#include "H5Cpp.h"      // C++ API header file
+#include "H5Cpp.h" // C++ API header file
 using namespace H5;
 
 #include "h5test.h"
-#include "h5cpputil.h"  // C++ utilility header file
+#include "h5cpputil.h" // C++ utilility header file
 
 const H5std_string FILE_BASIC("tattr_basic.h5");
 const H5std_string FILE_COMPOUND("tattr_compound.h5");
@@ -39,10 +37,10 @@ const H5std_string FILE_MULTI("tattr_multi.h5");
 const H5std_string FILE_DTYPE("tattr_dtype.h5");
 const H5std_string ATTR_TMP_NAME("temp_attr_name");
 const H5std_string FATTR_TMP_NAME("temp_fattr_name");
-const size_t ATTR_MAX_DIMS = 7;
+const size_t       ATTR_MAX_DIMS = 7;
 
 /* 3-D dataset with fixed dimensions */
-const int SPACE1_RANK = 3;
+const int     SPACE1_RANK = 3;
 const hsize_t SPACE1_DIM1 = 3;
 const hsize_t SPACE1_DIM2 = 15;
 const hsize_t SPACE1_DIM3 = 13;
@@ -54,54 +52,55 @@ const H5std_string TYPE1_NAME("/Type");
 
 /* Attribute Rank & Dimensions */
 const H5std_string ATTR1_NAME("Attr1");
-const int ATTR1_RANK = 1;
-const hsize_t ATTR1_DIM1 = 3;
-int attr_data1[ATTR1_DIM1]={512,-234,98123}; /* Test data for 1st attribute */
+const int          ATTR1_RANK             = 1;
+const hsize_t      ATTR1_DIM1             = 3;
+int                attr_data1[ATTR1_DIM1] = {512, -234, 98123}; /* Test data for 1st attribute */
 
 // File attribute, using the same rank and dimensions as ATTR1_NAME's
 const H5std_string FATTR1_NAME("File Attr1");
 const H5std_string FATTR2_NAME("File Attr2");
 
 const H5std_string ATTR2_NAME("Attr2");
-const int ATTR2_RANK = 2;
-const hsize_t ATTR2_DIM1 = 2;
-const hsize_t ATTR2_DIM2 = 2;
-int attr_data2[ATTR2_DIM1][ATTR2_DIM2]={{7614,-416},{197814,-3}}; /* Test data for 2nd attribute */
+const int          ATTR2_RANK          = 2;
+const hsize_t      ATTR2_DIM1          = 2;
+const hsize_t      ATTR2_DIM2          = 2;
+int attr_data2[ATTR2_DIM1][ATTR2_DIM2] = {{7614, -416}, {197814, -3}}; /* Test data for 2nd attribute */
 
 const H5std_string ATTR3_NAME("Attr3");
-const int ATTR3_RANK = 3;
-const hsize_t ATTR3_DIM1 = 2;
-const hsize_t ATTR3_DIM2 = 2;
-const hsize_t ATTR3_DIM3 = 2;
-double attr_data3[ATTR3_DIM1][ATTR3_DIM2][ATTR3_DIM3]={{{2.3,-26.1},{0.123,-10.0}},{{981724.2,-0.91827},{2.0,23.0}}}; /* Test data for 3rd attribute */
+const int          ATTR3_RANK                                     = 3;
+const hsize_t      ATTR3_DIM1                                     = 2;
+const hsize_t      ATTR3_DIM2                                     = 2;
+const hsize_t      ATTR3_DIM3                                     = 2;
+double             attr_data3[ATTR3_DIM1][ATTR3_DIM2][ATTR3_DIM3] = {
+    {{2.3, -26.1}, {0.123, -10.0}}, {{981724.2, -0.91827}, {2.0, 23.0}}}; /* Test data for 3rd attribute */
 
 const H5std_string ATTR4_NAME("Attr4");
-const int ATTR4_RANK = 2;
-const hsize_t ATTR4_DIM1 = 2;
-const hsize_t ATTR4_DIM2 = 2;
+const int          ATTR4_RANK = 2;
+const hsize_t      ATTR4_DIM1 = 2;
+const hsize_t      ATTR4_DIM2 = 2;
 
 const H5std_string ATTR4_FIELDNAME1("i");
 const H5std_string ATTR4_FIELDNAME2("d");
 const H5std_string ATTR4_FIELDNAME3("c");
-size_t attr4_field1_off=0;
-size_t attr4_field2_off=0;
-size_t attr4_field3_off=0;
+size_t             attr4_field1_off = 0;
+size_t             attr4_field2_off = 0;
+size_t             attr4_field3_off = 0;
 struct attr4_struct {
-    int i;
+    int    i;
     double d;
-    char c;
- } attr_data4[ATTR4_DIM1][ATTR4_DIM2]={{{3,-26.1,'d'},{-100000, 0.123,'3'}},
-    {{-23,981724.2,'Q'},{0,2.0,'\n'}}}; // Test data for 4th attribute
+    char   c;
+} attr_data4[ATTR4_DIM1][ATTR4_DIM2] = {
+    {{3, -26.1, 'd'}, {-100000, 0.123, '3'}},
+    {{-23, 981724.2, 'Q'}, {0, 2.0, '\n'}}}; // Test data for 4th attribute
 
 const H5std_string ATTR5_NAME("Attr5");
-const int ATTR5_RANK = 0;
-float attr_data5 = (float)-5.123;     // Test data for 5th attribute
+const int          ATTR5_RANK = 0;
+float              attr_data5 = -5.123F; // Test data for 5th attribute
 
 /* Info for another attribute */
 const H5std_string ATTR1A_NAME("Attr1_a");
-int attr_data1a[ATTR1_DIM1]={256,11945,-22107};
+int                attr_data1a[ATTR1_DIM1] = {256, 11945, -22107};
 
-
 /*-------------------------------------------------------------------------
  * Function:    test_attr_basic_write
  *
@@ -110,12 +109,13 @@ int attr_data1a[ATTR1_DIM1]={256,11945,-22107};
  * Return       None
  *-------------------------------------------------------------------------
  */
-static void test_attr_basic_write()
+static void
+test_attr_basic_write()
 {
-    hsize_t dims1[] = {SPACE1_DIM1, SPACE1_DIM2, SPACE1_DIM3};
-    hsize_t dims2[] = {ATTR1_DIM1};
-    hsize_t dims3[] = {ATTR2_DIM1,ATTR2_DIM2};
-    int     read_data1[ATTR1_DIM1]={0}; // Buffer for reading 1st attribute
+    hsize_t dims1[]                = {SPACE1_DIM1, SPACE1_DIM2, SPACE1_DIM3};
+    hsize_t dims2[]                = {ATTR1_DIM1};
+    hsize_t dims3[]                = {ATTR2_DIM1, ATTR2_DIM2};
+    int     read_data1[ATTR1_DIM1] = {0}; // Buffer for reading 1st attribute
     hsize_t i;
 
     // Output message about test being performed
@@ -123,10 +123,10 @@ static void test_attr_basic_write()
 
     try {
         // Create file
-        H5File fid1 (FILE_BASIC, H5F_ACC_TRUNC);
+        H5File fid1(FILE_BASIC, H5F_ACC_TRUNC);
 
         // Create dataspace for dataset
-        DataSpace ds_space (SPACE1_RANK, dims1);
+        DataSpace ds_space(SPACE1_RANK, dims1);
 
         /*
          *                Test attribute with dataset
@@ -136,55 +136,61 @@ static void test_attr_basic_write()
         DataSet dataset = fid1.createDataSet(DSET1_NAME, PredType::NATIVE_UCHAR, ds_space);
 
         // Create dataspace for attribute
-        DataSpace att_space (ATTR1_RANK, dims2);
+        DataSpace att_space(ATTR1_RANK, dims2);
 
         // Create a file attribute
-        Attribute file_attr2 = fid1.createAttribute (FATTR1_NAME, PredType::NATIVE_INT, att_space);
+        Attribute file_attr2 = fid1.createAttribute(FATTR1_NAME, PredType::NATIVE_INT, att_space);
 
         // Create a file attribute
-        Attribute file_attr1 = fid1.createAttribute (FATTR2_NAME, PredType::NATIVE_INT, att_space);
+        Attribute file_attr1 = fid1.createAttribute(FATTR2_NAME, PredType::NATIVE_INT, att_space);
 
         // Create an attribute for the dataset
-        Attribute ds_attr1 = dataset.createAttribute (ATTR1_NAME, PredType::NATIVE_INT, att_space);
+        Attribute ds_attr1 = dataset.createAttribute(ATTR1_NAME, PredType::NATIVE_INT, att_space);
 
         // Try creating an attribute that already exists.  This should fail
         // since two attributes cannot have the same name.  If an exception
         // is not thrown for this action by createAttribute, then throw an
         // invalid action exception.
         try {
-            Attribute invalid_attr = dataset.createAttribute (ATTR1_NAME, PredType::NATIVE_INT, att_space);
+            Attribute invalid_attr = dataset.createAttribute(ATTR1_NAME, PredType::NATIVE_INT, att_space);
 
             // continuation here, that means no exception has been thrown
-            throw InvalidActionException("H5File::createDataSet", "Library allowed overwrite of existing dataset");
+            throw InvalidActionException("H5File::createDataSet",
+                                         "Library allowed overwrite of existing dataset");
         }
-        catch (AttributeIException& E) // catching invalid creating attribute
-        {} // do nothing, exception expected
+        catch (AttributeIException &E) // catching invalid creating attribute
+        {
+        } // do nothing, exception expected
 
         // Write attribute information
-        ds_attr1.write (PredType::NATIVE_INT, attr_data1);
+        ds_attr1.write(PredType::NATIVE_INT, attr_data1);
 
         // Read attribute information immediately, without closing attribute
-        ds_attr1.read (PredType::NATIVE_INT, read_data1);
+        ds_attr1.read(PredType::NATIVE_INT, read_data1);
 
         // Verify values read in
-        for(i=0; i<ATTR1_DIM1; i++)
-            if(attr_data1[i]!=read_data1[i])
-                TestErrPrintf("%d: attribute data different: attr_data1[%d]=%d,read_data1[%d]=%d\n",__LINE__,i,attr_data1[i],i,read_data1[i]);
+        for (i = 0; i < ATTR1_DIM1; i++)
+            if (attr_data1[i] != read_data1[i])
+                TestErrPrintf("%d: attribute data different: attr_data1[%" PRIuHSIZE
+                              "]=%d,read_data1[%" PRIuHSIZE "]=%d\n",
+                              __LINE__, i, attr_data1[i], i, read_data1[i]);
 
         // Create two more attributes for this dataset, but only write to one.
-        Attribute ds_attr2 = dataset.createAttribute (ATTR2_NAME, PredType::NATIVE_INT, att_space);
-        Attribute ds_attr3 = dataset.createAttribute (ATTR3_NAME, PredType::NATIVE_INT, att_space);
+        Attribute ds_attr2 = dataset.createAttribute(ATTR2_NAME, PredType::NATIVE_INT, att_space);
+        Attribute ds_attr3 = dataset.createAttribute(ATTR3_NAME, PredType::NATIVE_INT, att_space);
 
         // Write attribute information
-        ds_attr2.write (PredType::NATIVE_INT, attr_data1a);
+        ds_attr2.write(PredType::NATIVE_INT, attr_data1a);
 
         // Read attribute information immediately, without closing attribute
-        ds_attr2.read (PredType::NATIVE_INT, read_data1);
+        ds_attr2.read(PredType::NATIVE_INT, read_data1);
 
         // Verify values read in
-        for(i=0; i<ATTR1_DIM1; i++)
-            if(attr_data1a[i]!=read_data1[i])
-                TestErrPrintf("%d: attribute data different: attr_data1a[%d]=%d,read_data1[%d]=%d\n",__LINE__,i,attr_data1a[i],i,read_data1[i]);
+        for (i = 0; i < ATTR1_DIM1; i++)
+            if (attr_data1a[i] != read_data1[i])
+                TestErrPrintf("%d: attribute data different: attr_data1a[%" PRIuHSIZE
+                              "]=%d,read_data1[%" PRIuHSIZE "]=%d\n",
+                              __LINE__, i, attr_data1a[i], i, read_data1[i]);
 
         // Close both attributes
         ds_attr1.close();
@@ -196,47 +202,46 @@ static void test_attr_basic_write()
          */
 
         // Create group in file fid1
-        Group group = fid1.createGroup (GROUP1_NAME);
+        Group group = fid1.createGroup(GROUP1_NAME);
 
         // Create dataspace for attribute
         DataSpace sid3(ATTR2_RANK, dims3);
 
         // Create an attribute for the group
-        Attribute gr_attr = group.createAttribute (ATTR2_NAME, PredType::NATIVE_INT, sid3);
+        Attribute gr_attr = group.createAttribute(ATTR2_NAME, PredType::NATIVE_INT, sid3);
 
         // Check storage size for attribute
         hsize_t attr_size = gr_attr.getStorageSize();
-        verify_val((long)attr_size, (long)(ATTR2_DIM1*ATTR2_DIM2*sizeof(int)),
-                "Attribute::getStorageSize",__LINE__,__FILE__);
+        verify_val(static_cast<long>(attr_size), static_cast<long>(ATTR2_DIM1 * ATTR2_DIM2 * sizeof(int)),
+                   "Attribute::getStorageSize", __LINE__, __FILE__);
 
         // Try to create the same attribute again (should fail)
         try {
-            Attribute invalid_attr = group.createAttribute (ATTR2_NAME, PredType::NATIVE_INT, sid3);
+            Attribute invalid_attr = group.createAttribute(ATTR2_NAME, PredType::NATIVE_INT, sid3);
             // continuation here, that means no exception has been thrown
             throw InvalidActionException("H5Group::createAttribute",
-                "Attempting to create an existing attribute");
+                                         "Attempting to create an existing attribute");
         }
-        catch (AttributeIException& E) // catching invalid creating attribute
-        {} // do nothing, exception expected
+        catch (AttributeIException &E) // catching invalid creating attribute
+        {
+        } // do nothing, exception expected
 
         // Write attribute information
-        gr_attr.write (PredType::NATIVE_INT, attr_data2);
+        gr_attr.write(PredType::NATIVE_INT, attr_data2);
 
         // Check storage size for attribute
         attr_size = gr_attr.getStorageSize();
-        verify_val((long)attr_size, (long)(ATTR2_DIM1*ATTR2_DIM2*sizeof(int)),
-                "Attribute::getStorageSize",  __LINE__, __FILE__);
+        verify_val(static_cast<long>(attr_size), static_cast<long>(ATTR2_DIM1 * ATTR2_DIM2 * sizeof(int)),
+                   "Attribute::getStorageSize", __LINE__, __FILE__);
 
         PASSED();
     } // end try block
 
-    catch (Exception& E)
-    {
+    catch (Exception &E) {
         issue_fail_msg("test_attr_basic_write()", __LINE__, __FILE__, E.getCDetailMsg());
     }
-}   // test_attr_basic_write()
+} // test_attr_basic_write()
 
-
 /*-------------------------------------------------------------------------
  * Function:    test_attr_getname
  *
@@ -264,7 +269,8 @@ static void test_attr_basic_write()
  * Return       None
  *-------------------------------------------------------------------------
  */
-static void test_attr_getname()
+static void
+test_attr_getname()
 {
     // Output message about test being performed
     SUBTEST("Testing all overloads of Attribute::getName");
@@ -279,10 +285,10 @@ static void test_attr_getname()
 
         // Check for existence of attribute FATTR1_NAME
         bool attr_exists = fid1.attrExists(FATTR1_NAME);
-        if (attr_exists == false)
+        if (!attr_exists)
             throw InvalidActionException("H5File::attrExists", "Attribute should exist but does not");
 
-        // Open attribute 
+        // Open attribute
         Attribute fattr1(fid1.openAttribute(FATTR1_NAME));
 
         // A. Get attribute name with
@@ -290,36 +296,40 @@ static void test_attr_getname()
         // using different buffer sizes and verify against FATTR1_NAME (3 cases)
 
         // 1. With arbitrary buf_size that is larger than the name size
-        size_t buf_size = FATTR1_NAME.length() + 10;
-        char* fattr1_name = new char[buf_size+1];
-        HDmemset(fattr1_name, 0, buf_size+1);
+        size_t buf_size    = FATTR1_NAME.length() + 10;
+        char * fattr1_name = new char[buf_size + 1];
+        HDmemset(fattr1_name, 0, buf_size + 1);
         ssize_t name_size = 0; // actual length of attribute name
-        name_size = fattr1.getName(fattr1_name, buf_size+1);
+        name_size         = fattr1.getName(fattr1_name, buf_size + 1);
         CHECK(name_size, FAIL, "Attribute::getName", __LINE__, __FILE__);
-        verify_val((size_t)name_size, FATTR1_NAME.length(), "Attribute::getName", __LINE__, __FILE__);
-        verify_val((const char*)fattr1_name, FATTR1_NAME, "Attribute::getName", __LINE__, __FILE__);
-        delete []fattr1_name;
+        verify_val(static_cast<size_t>(name_size), FATTR1_NAME.length(), "Attribute::getName", __LINE__,
+                   __FILE__);
+        verify_val(const_cast<const char *>(fattr1_name), FATTR1_NAME, "Attribute::getName", __LINE__,
+                   __FILE__);
+        delete[] fattr1_name;
 
         // 2. With arbitrary buf_size that is smaller than the name's length.
         // Let's try 4 first characters in the name.
-        buf_size = 4;
+        buf_size           = 4;
         char short_name[5] = "File"; // to verify the read name
-        fattr1_name = new char[buf_size+1];
-        HDmemset(fattr1_name, 0, buf_size+1);
-        name_size = fattr1.getName(fattr1_name, buf_size+1);
+        fattr1_name        = new char[buf_size + 1];
+        HDmemset(fattr1_name, 0, buf_size + 1);
+        name_size = fattr1.getName(fattr1_name, buf_size + 1);
         CHECK(name_size, FAIL, "Attribute::getName", __LINE__, __FILE__);
-        verify_val((size_t)name_size, FATTR1_NAME.size(), "Attribute::getName", __LINE__, __FILE__);
-        verify_val((const char*)fattr1_name, (const char*)short_name, "Attribute::getName", __LINE__, __FILE__);
-        delete []fattr1_name;
+        verify_val(static_cast<size_t>(name_size), FATTR1_NAME.size(), "Attribute::getName", __LINE__,
+                   __FILE__);
+        verify_val(const_cast<const char *>(fattr1_name), const_cast<const char *>(short_name),
+                   "Attribute::getName", __LINE__, __FILE__);
+        delete[] fattr1_name;
 
         // 3. With a buf_size that equals the name's length.
-        buf_size = FATTR1_NAME.length();
-        fattr1_name = new char[buf_size+1];
-        HDmemset(fattr1_name, 0, buf_size+1);
-        name_size = fattr1.getName(fattr1_name, buf_size+1);
+        buf_size    = FATTR1_NAME.length();
+        fattr1_name = new char[buf_size + 1];
+        HDmemset(fattr1_name, 0, buf_size + 1);
+        name_size = fattr1.getName(fattr1_name, buf_size + 1);
         CHECK(name_size, FAIL, "Attribute::getName", __LINE__, __FILE__);
         verify_val(fattr1_name, FATTR1_NAME, "Attribute::getName", __LINE__, __FILE__);
-        delete []fattr1_name;
+        delete[] fattr1_name;
 
         // B. Get attribute name with
         // ssize_t Attribute::getName(H5std_string& attr_name, size_t buf_size)
@@ -351,13 +361,13 @@ static void test_attr_getname()
 
         // Check for existence of attribute
         attr_exists = dataset.attrExists(ATTR1_NAME);
-        if (attr_exists == false)
+        if (!attr_exists)
             throw InvalidActionException("H5File::attrExists", "Attribute should exist but does not");
 
         // Open attribute
         Attribute attr1(dataset.openAttribute(ATTR1_NAME));
 
-        size_t len = 4;
+        size_t       len         = 4;
         H5std_string dattr_name1 = attr1.getName(len);
         verify_val(dattr_name1, "Attr", "Attribute::getName", __LINE__, __FILE__);
 
@@ -370,13 +380,11 @@ static void test_attr_getname()
         PASSED();
     } // end try block
 
-    catch (Exception& E)
-    {
+    catch (Exception &E) {
         issue_fail_msg("test_attr_getname()", __LINE__, __FILE__, E.getCDetailMsg());
     }
-}   // test_attr_getname()
+} // test_attr_getname()
 
-
 /*-------------------------------------------------------------------------
  * Function:    test_attr_rename
  *
@@ -385,9 +393,10 @@ static void test_attr_getname()
  * Return       None
  *-------------------------------------------------------------------------
  */
-static void test_attr_rename()
+static void
+test_attr_rename()
 {
-    int read_data1[ATTR1_DIM1]={0}; // Buffer for reading the attribute
+    int     read_data1[ATTR1_DIM1] = {0}; // Buffer for reading the attribute
     hsize_t i;
 
     // Output message about test being performed
@@ -401,7 +410,7 @@ static void test_attr_rename()
 
         // Check for existence of attribute
         bool attr_exists = fid1.attrExists(FATTR1_NAME);
-        if (attr_exists == false)
+        if (!attr_exists)
             throw InvalidActionException("H5File::attrExists", "Attribute should exist but does not");
 
         // Change attribute name
@@ -427,7 +436,7 @@ static void test_attr_rename()
 
         // Check for existence of attribute
         attr_exists = dataset.attrExists(ATTR1_NAME);
-        if (attr_exists == false)
+        if (!attr_exists)
             throw InvalidActionException("H5File::attrExists", "Attribute should exist but does not");
 
         // Change attribute name
@@ -441,19 +450,21 @@ static void test_attr_rename()
         verify_val(attr_name, ATTR_TMP_NAME, "Attribute::getName", __LINE__, __FILE__);
 
         // Read attribute information immediately, without closing attribute
-        attr1.read (PredType::NATIVE_INT, read_data1);
+        attr1.read(PredType::NATIVE_INT, read_data1);
 
         // Verify values read in
-        for(i=0; i<ATTR1_DIM1; i++)
-            if(attr_data1[i]!=read_data1[i])
-                TestErrPrintf("%d: attribute data different: attr_data1[%d]=%d,read_data1[%d]=%d\n",__LINE__,i,attr_data1[i],i,read_data1[i]);
+        for (i = 0; i < ATTR1_DIM1; i++)
+            if (attr_data1[i] != read_data1[i])
+                TestErrPrintf("%d: attribute data different: attr_data1[%" PRIuHSIZE
+                              "]=%d,read_data1[%" PRIuHSIZE "]=%d\n",
+                              __LINE__, i, attr_data1[i], i, read_data1[i]);
 
         // Close attribute
-            attr1.close();
+        attr1.close();
 
         // Check for existence of second attribute
         attr_exists = dataset.attrExists(ATTR2_NAME);
-        if (attr_exists == false)
+        if (!attr_exists)
             throw InvalidActionException("H5File::attrExists", "Attribute should exist but does not");
 
         // Open the second attribute
@@ -464,12 +475,14 @@ static void test_attr_rename()
         verify_val(attr2_name, ATTR2_NAME, "Attribute::getName", __LINE__, __FILE__);
 
         // Read attribute information immediately, without closing attribute
-        attr2.read (PredType::NATIVE_INT, read_data1);
+        attr2.read(PredType::NATIVE_INT, read_data1);
 
         // Verify values read in
-        for(i=0; i<ATTR1_DIM1; i++)
-            if(attr_data1a[i]!=read_data1[i])
-                TestErrPrintf("%d: attribute data different: attr_data1a[%d]=%d,read_data1[%d]=%d\n",__LINE__,i,attr_data1a[i],i,read_data1[i]);
+        for (i = 0; i < ATTR1_DIM1; i++)
+            if (attr_data1a[i] != read_data1[i])
+                TestErrPrintf("%d: attribute data different: attr_data1a[%" PRIuHSIZE
+                              "]=%d,read_data1[%" PRIuHSIZE "]=%d\n",
+                              __LINE__, i, attr_data1a[i], i, read_data1[i]);
 
         // Close attribute
         attr2.close();
@@ -479,19 +492,17 @@ static void test_attr_rename()
 
         // Check for existence of attribute after renaming
         attr_exists = dataset.attrExists(ATTR1_NAME);
-        if (attr_exists == false)
+        if (!attr_exists)
             throw InvalidActionException("H5File::attrExists", "Attribute should exist but does not");
 
         PASSED();
     } // end try block
 
-    catch (Exception& E)
-    {
+    catch (Exception &E) {
         issue_fail_msg("test_attr_rename()", __LINE__, __FILE__, E.getCDetailMsg());
     }
-}   // test_attr_rename()
+} // test_attr_rename()
 
-
 /*-------------------------------------------------------------------------
  * Function:    test_attr_basic_read
  *
@@ -500,7 +511,8 @@ static void test_attr_rename()
  * Return       None
  *-------------------------------------------------------------------------
  */
-static void test_attr_basic_read()
+static void
+test_attr_basic_read()
 {
     hsize_t i, j;
 
@@ -519,22 +531,24 @@ static void test_attr_basic_read()
         verify_val(num_attrs, 3, "DataSet::getNumAttrs", __LINE__, __FILE__);
 
         // Verify the correct number of attributes another way
-        H5O_info_t oinfo;
+        H5O_info2_t oinfo;
         HDmemset(&oinfo, 0, sizeof(oinfo));
         dataset.getObjinfo(oinfo, H5O_INFO_NUM_ATTRS);
-        verify_val(oinfo.num_attrs, 3, "DataSet::getObjinfo", __LINE__, __FILE__);
+        verify_val(static_cast<long>(oinfo.num_attrs), 3, "DataSet::getObjinfo", __LINE__, __FILE__);
 
         // Open an attribute for the dataset
-        Attribute ds_attr=dataset.openAttribute(ATTR1_NAME);
+        Attribute ds_attr = dataset.openAttribute(ATTR1_NAME);
 
         // Read attribute information
-        int read_data1[ATTR1_DIM1]={0}; // Buffer for reading 1st attribute
+        int read_data1[ATTR1_DIM1] = {0}; // Buffer for reading 1st attribute
         ds_attr.read(PredType::NATIVE_INT, &read_data1);
 
         // Verify values read in
-        for(i=0; i<ATTR1_DIM1; i++)
-            if(attr_data1[i]!=read_data1[i])
-                TestErrPrintf("%d: attribute data different: attr_data1[%d]=%d, read_data1[%d]=%d\n",__LINE__,i,attr_data1[i],i,read_data1[i]);
+        for (i = 0; i < ATTR1_DIM1; i++)
+            if (attr_data1[i] != read_data1[i])
+                TestErrPrintf("%d: attribute data different: attr_data1[%" PRIuHSIZE
+                              "]=%d, read_data1[%" PRIuHSIZE "]=%d\n",
+                              __LINE__, i, attr_data1[i], i, read_data1[i]);
 
         /*
          *                Test attribute with group
@@ -549,33 +563,34 @@ static void test_attr_basic_read()
         // Verify the correct number of attributes another way
         HDmemset(&oinfo, 0, sizeof(oinfo));
         group.getObjinfo(oinfo, H5O_INFO_NUM_ATTRS);
-        verify_val(oinfo.num_attrs, 1, "Group::getObjinfo", __LINE__, __FILE__);
+        verify_val(static_cast<long>(oinfo.num_attrs), 1, "Group::getObjinfo", __LINE__, __FILE__);
 
         // Open an attribute for the group
         Attribute gr_attr = group.openAttribute(ATTR2_NAME);
 
         // Buffer for reading 2nd attribute
-        int read_data2[ATTR2_DIM1][ATTR2_DIM2]={{0}};
+        int read_data2[ATTR2_DIM1][ATTR2_DIM2] = {{0}};
 
         // Read attribute information
         gr_attr.read(PredType::NATIVE_INT, read_data2);
 
         // Verify values read in
-        for(i=0; i<ATTR2_DIM1; i++)
-            for(j=0; j<ATTR2_DIM2; j++)
-                if(attr_data2[i][j]!=read_data2[i][j]) {
-                    TestErrPrintf("%d: attribute data different: attr_data2[%d][%d]=%d, read_data2[%d][%d]=%d\n",__LINE__, i,j,attr_data2[i][j],i,j,read_data2[i][j]);
+        for (i = 0; i < ATTR2_DIM1; i++)
+            for (j = 0; j < ATTR2_DIM2; j++)
+                if (attr_data2[i][j] != read_data2[i][j]) {
+                    TestErrPrintf("%d: attribute data different: attr_data2[%" PRIuHSIZE "][%" PRIuHSIZE
+                                  "]=%d, "
+                                  "read_data2[%" PRIuHSIZE "][%" PRIuHSIZE "]=%d\n",
+                                  __LINE__, i, j, attr_data2[i][j], i, j, read_data2[i][j]);
                 }
         PASSED();
     } // end try block
 
-    catch (Exception& E)
-    {
+    catch (Exception &E) {
         issue_fail_msg("test_attr_basic_read()", __LINE__, __FILE__, E.getCDetailMsg());
     }
-}   // test_attr_basic_read()
+} // test_attr_basic_read()
 
-
 /*-------------------------------------------------------------------------
  * Function:    test_attr_compound_write
  *
@@ -584,10 +599,11 @@ static void test_attr_basic_read()
  * Return       None
  *-------------------------------------------------------------------------
  */
-static void test_attr_compound_write()
+static void
+test_attr_compound_write()
 {
 
-        // Output message about test being performed
+    // Output message about test being performed
     SUBTEST("Multiple Attribute Functions");
 
     try {
@@ -595,11 +611,11 @@ static void test_attr_compound_write()
         H5File fid1(FILE_COMPOUND.c_str(), H5F_ACC_TRUNC);
 
         // Create dataspace for dataset
-        hsize_t dims1[] = {SPACE1_DIM1, SPACE1_DIM2, SPACE1_DIM3};
+        hsize_t   dims1[] = {SPACE1_DIM1, SPACE1_DIM2, SPACE1_DIM3};
         DataSpace sid1(SPACE1_RANK, dims1);
 
         // Create a dataset
-        DataSet dataset = fid1.createDataSet(DSET1_NAME, PredType::NATIVE_UCHAR,sid1);
+        DataSet dataset = fid1.createDataSet(DSET1_NAME, PredType::NATIVE_UCHAR, sid1);
 
         // Create the attribute datatype.
         CompType comp_type(sizeof(struct attr4_struct));
@@ -614,7 +630,7 @@ static void test_attr_compound_write()
         comp_type.insertMember(ATTR4_FIELDNAME3, attr4_field3_off, PredType::NATIVE_SCHAR);
 
         // Create dataspace for 1st attribute
-        hsize_t dims2[] = {ATTR4_DIM1,ATTR4_DIM2};
+        hsize_t   dims2[] = {ATTR4_DIM1, ATTR4_DIM2};
         DataSpace sid2(ATTR4_RANK, dims2);
 
         // Create complex attribute for the dataset
@@ -622,10 +638,11 @@ static void test_attr_compound_write()
 
         // Try to create the same attribute again (should fail)
         try {
-            Attribute invalid_attr = dataset.createAttribute (ATTR4_NAME, comp_type, sid2);
+            Attribute invalid_attr = dataset.createAttribute(ATTR4_NAME, comp_type, sid2);
         }
-        catch (AttributeIException& E) // catching invalid creating attribute
-        {} // do nothing, exception expected
+        catch (AttributeIException &E) // catching invalid creating attribute
+        {
+        } // do nothing, exception expected
 
         // Write complex attribute data
         attr.write(comp_type, attr_data4);
@@ -633,13 +650,11 @@ static void test_attr_compound_write()
         PASSED();
     } // end try block
 
-    catch (Exception& E)
-    {
+    catch (Exception &E) {
         issue_fail_msg("test_attr_compound_write()", __LINE__, __FILE__, E.getCDetailMsg());
     }
-}   // test_attr_compound_write()
+} // test_attr_compound_write()
 
-
 /*-------------------------------------------------------------------------
  * Function:    test_attr_compound_read
  *
@@ -648,11 +663,12 @@ static void test_attr_compound_write()
  * Return       None
  *-------------------------------------------------------------------------
  */
-static void test_attr_compound_read()
+static void
+test_attr_compound_read()
 {
-    hsize_t dims[ATTR_MAX_DIMS];        // Attribute dimensions
-    size_t      size;   // Attribute datatype size as stored in file
-    size_t      offset; // Attribute datatype field offset
+    hsize_t             dims[ATTR_MAX_DIMS];                // Attribute dimensions
+    size_t              size;                               // Attribute datatype size as stored in file
+    size_t              offset;                             // Attribute datatype field offset
     struct attr4_struct read_data4[ATTR4_DIM1][ATTR4_DIM2]; // Buffer for reading 4th attribute
 
     // Output message about test being performed
@@ -670,13 +686,13 @@ static void test_attr_compound_read()
         verify_val(num_attrs, 1, "DataSet::getNumAttrs", __LINE__, __FILE__);
 
         // Verify the correct number of attributes another way
-        H5O_info_t oinfo;
+        H5O_info2_t oinfo;
         HDmemset(&oinfo, 0, sizeof(oinfo));
         dataset.getObjinfo(oinfo, H5O_INFO_NUM_ATTRS);
-        verify_val(oinfo.num_attrs, 1, "DataSet::getObjinfo", __LINE__, __FILE__);
+        verify_val(static_cast<long>(oinfo.num_attrs), 1, "DataSet::getObjinfo", __LINE__, __FILE__);
 
         // Open 1st attribute for the dataset
-        Attribute attr = dataset.openAttribute((unsigned)0);
+        Attribute attr = dataset.openAttribute(static_cast<unsigned>(0));
 
         /* Verify Dataspace */
 
@@ -690,14 +706,17 @@ static void test_attr_compound_read()
         // Get the dims of the dataspace and verify them
         int ndims = space.getSimpleExtentDims(dims);
         verify_val(ndims, ATTR4_RANK, "DataSpace::getSimpleExtentDims", __LINE__, __FILE__);
-        verify_val((long)dims[0], (long)ATTR4_DIM1, "DataSpace::getSimpleExtentDims",__LINE__, __FILE__);
-        verify_val((long)dims[1], (long)ATTR4_DIM2, "DataSpace::getSimpleExtentDims",__LINE__, __FILE__);
+        verify_val(static_cast<long>(dims[0]), static_cast<long>(ATTR4_DIM1),
+                   "DataSpace::getSimpleExtentDims", __LINE__, __FILE__);
+        verify_val(static_cast<long>(dims[1]), static_cast<long>(ATTR4_DIM2),
+                   "DataSpace::getSimpleExtentDims", __LINE__, __FILE__);
 
         // Get the class of the datatype that is used by attr
         H5T_class_t type_class = attr.getTypeClass();
 
         // Verify that the type is of compound datatype
-        verify_val(type_class, H5T_COMPOUND, "Attribute::getTypeClass", __LINE__, __FILE__);
+        verify_val(static_cast<long>(type_class), static_cast<long>(H5T_COMPOUND), "Attribute::getTypeClass",
+                   __LINE__, __FILE__);
 
         // Get the compound datatype
         CompType datatype = attr.getCompType();
@@ -709,13 +728,11 @@ static void test_attr_compound_read()
         // Verify that the fields have the same names as when the type
         // was created
         int j;
-        for(j=0; j<fields; j++)
-        {
+        for (j = 0; j < fields; j++) {
             H5std_string fieldname = datatype.getMemberName(j);
-            if(!((fieldname == ATTR4_FIELDNAME1) ||
-                 (fieldname == ATTR4_FIELDNAME2) ||
-                 (fieldname == ATTR4_FIELDNAME3)))
-            TestErrPrintf("%d:invalid field name for field #%d: %s\n",__LINE__,j,fieldname.c_str());
+            if (!((fieldname == ATTR4_FIELDNAME1) || (fieldname == ATTR4_FIELDNAME2) ||
+                  (fieldname == ATTR4_FIELDNAME3)))
+                TestErrPrintf("%d:invalid field name for field #%d: %s\n", __LINE__, j, fieldname.c_str());
         } /* end for */
 
         offset = datatype.getMemberOffset(0);
@@ -731,11 +748,13 @@ static void test_attr_compound_read()
 
         // Get and verify the type class of the first member
         type_class = datatype.getMemberClass(0);
-        verify_val(type_class, H5T_INTEGER, "DataType::getMemberClass", __LINE__, __FILE__);
+        verify_val(static_cast<long>(type_class), static_cast<long>(H5T_INTEGER), "DataType::getMemberClass",
+                   __LINE__, __FILE__);
         // Get and verify the order of this member's type
-        IntType i_type = datatype.getMemberIntType(0);
-        H5T_order_t order = i_type.getOrder();
-        verify_val(order, PredType::NATIVE_INT.getOrder(), "DataType::getOrder", __LINE__, __FILE__);
+        IntType     i_type = datatype.getMemberIntType(0);
+        H5T_order_t order  = i_type.getOrder();
+        verify_val(static_cast<long>(order), static_cast<long>(PredType::NATIVE_INT.getOrder()),
+                   "DataType::getOrder", __LINE__, __FILE__);
 
         // Get and verify the size of this member's type
         size = i_type.getSize();
@@ -743,21 +762,25 @@ static void test_attr_compound_read()
 
         // Get and verify class, order, and size of the second member's type
         type_class = datatype.getMemberClass(1);
-        verify_val(type_class, H5T_FLOAT, "DataType::getMemberClass", __LINE__, __FILE__);
+        verify_val(static_cast<long>(type_class), static_cast<long>(H5T_FLOAT), "DataType::getMemberClass",
+                   __LINE__, __FILE__);
         FloatType f_type = datatype.getMemberFloatType(1);
-        order = f_type.getOrder();
-        verify_val(order, PredType::NATIVE_DOUBLE.getOrder(), "DataType::getOrder", __LINE__, __FILE__);
+        order            = f_type.getOrder();
+        verify_val(static_cast<long>(order), static_cast<long>(PredType::NATIVE_DOUBLE.getOrder()),
+                   "DataType::getOrder", __LINE__, __FILE__);
         size = f_type.getSize();
         verify_val(size, PredType::NATIVE_DOUBLE.getSize(), "DataType::getSize", __LINE__, __FILE__);
 
         // Get and verify class, order, and size of the third member's type
         type_class = datatype.getMemberClass(2);
-        verify_val(type_class, H5T_INTEGER, "DataType::getMemberClass", __LINE__, __FILE__);
+        verify_val(static_cast<long>(type_class), static_cast<long>(H5T_INTEGER), "DataType::getMemberClass",
+                   __LINE__, __FILE__);
         // Note: H5T_INTEGER is correct here!
 
         StrType s_type = datatype.getMemberStrType(2);
-        order = s_type.getOrder();
-        verify_val(order, PredType::NATIVE_SCHAR.getOrder(), "DataType::getOrder", __LINE__, __FILE__);
+        order          = s_type.getOrder();
+        verify_val(static_cast<long>(order), static_cast<long>(PredType::NATIVE_SCHAR.getOrder()),
+                   "DataType::getOrder", __LINE__, __FILE__);
         size = s_type.getSize();
         verify_val(size, PredType::NATIVE_SCHAR.getSize(), "DataType::getSize", __LINE__, __FILE__);
 
@@ -766,26 +789,33 @@ static void test_attr_compound_read()
 
         // Verify values read in
         hsize_t ii, jj;
-        for(ii=0; ii<ATTR4_DIM1; ii++)
-            for(jj=0; jj<ATTR4_DIM2; jj++)
-                if(HDmemcmp(&attr_data4[ii][jj],&read_data4[ii][jj],sizeof(struct attr4_struct))) {
-                    TestErrPrintf("%d:attribute data different: attr_data4[%d][%d].i=%d, read_data4[%d][%d].i=%d\n",__LINE__,ii,jj,attr_data4[ii][jj].i,ii,jj,read_data4[ii][jj].i);
-                    TestErrPrintf("%d:attribute data different: attr_data4[%d][%d].d=%f, read_data4[%d][%d].d=%f\n",__LINE__,ii,jj,attr_data4[ii][jj].d,ii,jj,read_data4[ii][jj].d);
-                    TestErrPrintf("%d:attribute data different: attr_data4[%d][%d].c=%c, read_data4[%d][%d].c=%c\n",__LINE__,ii,jj,attr_data4[ii][jj].c,ii,jj,read_data4[ii][jj].c);
-             } /* end if */
+        for (ii = 0; ii < ATTR4_DIM1; ii++)
+            for (jj = 0; jj < ATTR4_DIM2; jj++)
+                if (HDmemcmp(&attr_data4[ii][jj], &read_data4[ii][jj], sizeof(struct attr4_struct)) != 0) {
+                    TestErrPrintf("%d:attribute data different: attr_data4[%" PRIuHSIZE "][%" PRIuHSIZE
+                                  "].i=%d, "
+                                  "read_data4[%" PRIuHSIZE "][%" PRIuHSIZE "].i=%d\n",
+                                  __LINE__, ii, jj, attr_data4[ii][jj].i, ii, jj, read_data4[ii][jj].i);
+                    TestErrPrintf("%d:attribute data different: attr_data4[%" PRIuHSIZE "][%" PRIuHSIZE
+                                  "].d=%f, "
+                                  "read_data4[%" PRIuHSIZE "][%" PRIuHSIZE "].d=%f\n",
+                                  __LINE__, ii, jj, attr_data4[ii][jj].d, ii, jj, read_data4[ii][jj].d);
+                    TestErrPrintf("%d:attribute data different: attr_data4[%" PRIuHSIZE "][%" PRIuHSIZE
+                                  "].c=%c, "
+                                  "read_data4[%" PRIuHSIZE "][%" PRIuHSIZE "].c=%c\n",
+                                  __LINE__, ii, jj, attr_data4[ii][jj].c, ii, jj, read_data4[ii][jj].c);
+                } /* end if */
 
         // Verify name
         H5std_string attr_name = attr.getName();
         verify_val(attr_name, ATTR4_NAME, "Attribute::getName", __LINE__, __FILE__);
     } // end try block
 
-    catch (Exception& E)
-    {
+    catch (Exception &E) {
         issue_fail_msg("test_attr_compound_read()", __LINE__, __FILE__, E.getCDetailMsg());
     }
 
-    try
-    {
+    try {
         // Now, try truncating the file to make sure reference counting is good.
         // If any references to ids in the previous block are left unterminated,
         // the truncating will fail, because the file will not be closed in
@@ -795,13 +825,12 @@ static void test_attr_compound_read()
         PASSED();
     } // end try block
 
-    catch (FileIException& E)
-    {
-        issue_fail_msg("test_attr_compound_read()", __LINE__, __FILE__, "Unable to truncate file, possibly because some objects are left opened");
+    catch (FileIException &E) {
+        issue_fail_msg("test_attr_compound_read()", __LINE__, __FILE__,
+                       "Unable to truncate file, possibly because some objects are left opened");
     }
-}   // test_attr_compound_read()
+} // test_attr_compound_read()
 
-
 /*-------------------------------------------------------------------------
  * Function:    test_attr_scalar_write
  *
@@ -810,7 +839,8 @@ static void test_attr_compound_read()
  * Return       None
  *-------------------------------------------------------------------------
  */
-static void test_attr_scalar_write()
+static void
+test_attr_scalar_write()
 {
     // Output message about test being performed
     SUBTEST("Basic Scalar Attribute Writing Functions");
@@ -820,11 +850,11 @@ static void test_attr_scalar_write()
         H5File fid1(FILE_SCALAR, H5F_ACC_TRUNC);
 
         // Create dataspace for dataset
-        hsize_t dims1[] = {SPACE1_DIM1, SPACE1_DIM2, SPACE1_DIM3};
+        hsize_t   dims1[] = {SPACE1_DIM1, SPACE1_DIM2, SPACE1_DIM3};
         DataSpace sid1(SPACE1_RANK, dims1);
 
         // Create a dataset
-        DataSet dataset = fid1.createDataSet(DSET1_NAME, PredType::NATIVE_UCHAR,sid1);
+        DataSet dataset = fid1.createDataSet(DSET1_NAME, PredType::NATIVE_UCHAR, sid1);
 
         // Close dataset's dataspace
         sid1.close();
@@ -833,34 +863,34 @@ static void test_attr_scalar_write()
         DataSpace att_space(ATTR5_RANK, NULL);
 
         // Create an attribute for the dataset
-        Attribute ds_attr = dataset.createAttribute (ATTR5_NAME, PredType::NATIVE_FLOAT, att_space);
+        Attribute ds_attr = dataset.createAttribute(ATTR5_NAME, PredType::NATIVE_FLOAT, att_space);
 
         // Try creating an attribute that already exists.  This should fail
         // since two attributes cannot have the same name.  If an exception
         // is not thrown for this action by createAttribute, then throw an
         // invalid action exception.
         try {
-            Attribute invalid_attr = dataset.createAttribute (ATTR5_NAME, PredType::NATIVE_FLOAT, att_space);
+            Attribute invalid_attr = dataset.createAttribute(ATTR5_NAME, PredType::NATIVE_FLOAT, att_space);
 
             // continuation here, that means no exception has been thrown
-            throw InvalidActionException("H5File::createDataSet", "Library allowed overwrite of existing dataset");
+            throw InvalidActionException("H5File::createDataSet",
+                                         "Library allowed overwrite of existing dataset");
         }
-        catch (AttributeIException& E) // catching invalid creating attribute
-        {} // do nothing, exception expected
+        catch (AttributeIException &E) // catching invalid creating attribute
+        {
+        } // do nothing, exception expected
 
         // Write attribute information
-        ds_attr.write (PredType::NATIVE_FLOAT, &attr_data5);
+        ds_attr.write(PredType::NATIVE_FLOAT, &attr_data5);
 
         PASSED();
     } // end try block
 
-    catch (Exception& E)
-    {
+    catch (Exception &E) {
         issue_fail_msg("test_attr_scalar_write()", __LINE__, __FILE__, E.getCDetailMsg());
     }
-}   // test_attr_scalar_write()
+} // test_attr_scalar_write()
 
-
 /*-------------------------------------------------------------------------
  * Function:    test_attr_scalar_read
  *
@@ -872,7 +902,8 @@ static void test_attr_scalar_write()
 /* Epsilon for floating-point comparisons */
 #define FP_EPSILON 0.000001F
 
-static void test_attr_scalar_read()
+static void
+test_attr_scalar_read()
 {
     // Output message about test being performed
     SUBTEST("Basic Scalar Attribute Reading Functions");
@@ -889,31 +920,32 @@ static void test_attr_scalar_read()
         verify_val(num_attrs, 1, "DataSet::getNumAttrs", __LINE__, __FILE__);
 
         // Open an attribute for the dataset
-        Attribute ds_attr=dataset.openAttribute(ATTR5_NAME);
+        Attribute ds_attr = dataset.openAttribute(ATTR5_NAME);
 
         // Read attribute information
-        float read_data2=0.0;  // Buffer for reading 1st attribute
-        ds_attr.read(PredType::NATIVE_FLOAT,&read_data2);
-        if (HDfabs(read_data2 - attr_data5) > FP_EPSILON)
-            verify_val(read_data2, attr_data5, FP_EPSILON, "Attribute::read", __LINE__, __FILE__);
+        float read_data2 = 0.0; // Buffer for reading 1st attribute
+        ds_attr.read(PredType::NATIVE_FLOAT, &read_data2);
+        if (abs(read_data2 - attr_data5) > FLT_EPSILON)
+            TestErrPrintf("%d: attribute data different: read_data2=%f, "
+                          "attr_data5=%f\n",
+                          __LINE__, static_cast<double>(read_data2), static_cast<double>(attr_data5));
 
         // Get the dataspace of the attribute
         DataSpace att_space = ds_attr.getSpace();
 
         // Make certain the dataspace is scalar
         H5S_class_t space_type = att_space.getSimpleExtentType();
-        verify_val(space_type, H5S_SCALAR, "DataSpace::getSimpleExtentType", __LINE__, __FILE__);
+        verify_val(static_cast<long>(space_type), static_cast<long>(H5S_SCALAR),
+                   "DataSpace::getSimpleExtentType", __LINE__, __FILE__);
 
         PASSED();
     } // end try block
 
-    catch (Exception& E)
-    {
+    catch (Exception &E) {
         issue_fail_msg("test_attr_scalar_read()", __LINE__, __FILE__, E.getCDetailMsg());
     }
-}   // test_attr_scalar_read()
+} // test_attr_scalar_read()
 
-
 /*-------------------------------------------------------------------------
  * Function:    test_attr_mult_write
  *
@@ -922,75 +954,76 @@ static void test_attr_scalar_read()
  * Return       None
  *-------------------------------------------------------------------------
  */
-static void test_attr_mult_write()
+static void
+test_attr_mult_write()
 {
     // Output message about test being performed
     SUBTEST("Multiple Attribute Writing Functions");
 
     try {
         // Create file
-        H5File fid1 (FILE_MULTI, H5F_ACC_TRUNC);
+        H5File fid1(FILE_MULTI, H5F_ACC_TRUNC);
 
         // Create dataspace for dataset
-        hsize_t dims1[] = {SPACE1_DIM1, SPACE1_DIM2, SPACE1_DIM3};
-        DataSpace ds_space (SPACE1_RANK, dims1);
+        hsize_t   dims1[] = {SPACE1_DIM1, SPACE1_DIM2, SPACE1_DIM3};
+        DataSpace ds_space(SPACE1_RANK, dims1);
 
         // Create a dataset
         DataSet dataset = fid1.createDataSet(DSET1_NAME, PredType::NATIVE_UCHAR, ds_space);
 
         // Create dataspace for 1st attribute
-        hsize_t dims2[] = {ATTR1_DIM1};
-        DataSpace att_space (ATTR1_RANK, dims2);
+        hsize_t   dims2[] = {ATTR1_DIM1};
+        DataSpace att_space(ATTR1_RANK, dims2);
 
         // Create 1st attribute for the dataset
-        Attribute ds_attr = dataset.createAttribute (ATTR1_NAME, PredType::NATIVE_INT, att_space);
+        Attribute ds_attr = dataset.createAttribute(ATTR1_NAME, PredType::NATIVE_INT, att_space);
 
         // Write attribute information
-        ds_attr.write (PredType::NATIVE_INT, attr_data1);
+        ds_attr.write(PredType::NATIVE_INT, attr_data1);
 
         // Create dataspace for 2nd attribute
-        hsize_t dims3[] = {ATTR2_DIM1,ATTR2_DIM2};
-        DataSpace att2_space (ATTR2_RANK, dims3);
+        hsize_t   dims3[] = {ATTR2_DIM1, ATTR2_DIM2};
+        DataSpace att2_space(ATTR2_RANK, dims3);
 
         // Create 2nd attribute for the dataset
-        Attribute ds_attr2 = dataset.createAttribute (ATTR2_NAME, PredType::NATIVE_INT, att2_space);
+        Attribute ds_attr2 = dataset.createAttribute(ATTR2_NAME, PredType::NATIVE_INT, att2_space);
 
         // Write 2nd attribute information
-        ds_attr2.write (PredType::NATIVE_INT, attr_data2);
+        ds_attr2.write(PredType::NATIVE_INT, attr_data2);
 
         // Create dataspace for 3rd attribute
-        hsize_t dims4[] = {ATTR3_DIM1,ATTR3_DIM2,ATTR3_DIM3};
-        DataSpace att3_space (ATTR3_RANK, dims4);
+        hsize_t   dims4[] = {ATTR3_DIM1, ATTR3_DIM2, ATTR3_DIM3};
+        DataSpace att3_space(ATTR3_RANK, dims4);
 
         // Create 3rd attribute for the dataset
-        Attribute ds_attr3 = dataset.createAttribute (ATTR3_NAME, PredType::NATIVE_DOUBLE, att3_space);
+        Attribute ds_attr3 = dataset.createAttribute(ATTR3_NAME, PredType::NATIVE_DOUBLE, att3_space);
 
         // Try creating an attribute that already exists.  This should fail
         // since two attributes cannot have the same name.  If an exception
         // is not thrown for this action by createAttribute, then throw an
         // invalid action exception.
         try {
-            Attribute invalid_attr = dataset.createAttribute (ATTR3_NAME, PredType::NATIVE_DOUBLE, att3_space);
+            Attribute invalid_attr = dataset.createAttribute(ATTR3_NAME, PredType::NATIVE_DOUBLE, att3_space);
 
             // continuation here, that means no exception has been thrown
-            throw InvalidActionException("DataSet::createAttribute", "Attempting to create a duplicate attribute");
+            throw InvalidActionException("DataSet::createAttribute",
+                                         "Attempting to create a duplicate attribute");
         }
-        catch (AttributeIException& E) // catching invalid creating attribute
-        {} // do nothing, exception expected
+        catch (AttributeIException &E) // catching invalid creating attribute
+        {
+        } // do nothing, exception expected
 
         // Write 3rd attribute information
-        ds_attr3.write (PredType::NATIVE_DOUBLE, attr_data3);
+        ds_attr3.write(PredType::NATIVE_DOUBLE, attr_data3);
 
         PASSED();
     } // end try block
 
-    catch (Exception& E)
-    {
+    catch (Exception &E) {
         issue_fail_msg("test_attr_mult_write()", __LINE__, __FILE__, E.getCDetailMsg());
     }
-}   // test_attr_mult_write()
+} // test_attr_mult_write()
 
-
 /*-------------------------------------------------------------------------
  * Function:    test_attr_mult_read
  *
@@ -999,14 +1032,15 @@ static void test_attr_mult_write()
  * Return       None
  *-------------------------------------------------------------------------
  */
-static void test_attr_mult_read()
+static void
+test_attr_mult_read()
 {
-    int     read_data1[ATTR1_DIM1]={0}; // Buffer for reading 1st attribute
-    int     read_data2[ATTR2_DIM1][ATTR2_DIM2]={{0}}; // Buffer for reading 2nd attribute
-    double  read_data3[ATTR3_DIM1][ATTR3_DIM2][ATTR3_DIM3]={{{0}}}; // Buffer for reading 3rd attribute
-    hsize_t i,j,k;
+    int     read_data1[ATTR1_DIM1]                         = {0};     // Buffer for reading 1st attribute
+    int     read_data2[ATTR2_DIM1][ATTR2_DIM2]             = {{0}};   // Buffer for reading 2nd attribute
+    double  read_data3[ATTR3_DIM1][ATTR3_DIM2][ATTR3_DIM3] = {{{0}}}; // Buffer for reading 3rd attribute
+    hsize_t i, j, k;
 
-        // Output message about test being performed
+    // Output message about test being performed
     SUBTEST("Multiple Attribute Reading Functions");
 
     try {
@@ -1021,7 +1055,7 @@ static void test_attr_mult_read()
         verify_val(num_attrs, 3, "DataSet::getNumAttrs", __LINE__, __FILE__);
 
         // Open 1st attribute for the dataset
-        Attribute attr = dataset.openAttribute((unsigned)0);
+        Attribute attr = dataset.openAttribute(static_cast<unsigned>(0));
 
         /* Verify Dataspace */
 
@@ -1033,10 +1067,11 @@ static void test_attr_mult_read()
         verify_val(rank, ATTR1_RANK, "DataSpace::getSimpleExtentNdims", __LINE__, __FILE__);
 
         // Get the dims of the dataspace and verify them
-        hsize_t dims[ATTR_MAX_DIMS];    // Attribute dimensions
-        int ndims = space.getSimpleExtentDims(dims);
-        if ((long)dims[0] != (long)ATTR1_DIM1)
-            TestErrPrintf("%d:attribute dimensions different: dims[0]=%d, should be %d\n",__LINE__,(int)dims[0],ATTR1_DIM1);
+        hsize_t dims[ATTR_MAX_DIMS]; // Attribute dimensions
+        (void)space.getSimpleExtentDims(dims);
+        if (dims[0] != ATTR1_DIM1)
+            TestErrPrintf("%d:attribute dimensions different: dims[0]=%d, should be %" PRIuHSIZE "\n",
+                          __LINE__, static_cast<int>(dims[0]), ATTR1_DIM1);
 
         /* Verify Datatype */
 
@@ -1044,14 +1079,16 @@ static void test_attr_mult_read()
         H5T_class_t type_class = attr.getTypeClass();
 
         // Verify that the type is of integer datatype
-        verify_val(type_class, H5T_INTEGER, "Attribute::getTypeClass", __LINE__, __FILE__);
+        verify_val(static_cast<long>(type_class), static_cast<long>(H5T_INTEGER), "Attribute::getTypeClass",
+                   __LINE__, __FILE__);
 
-            // Get the integer datatype
+        // Get the integer datatype
         IntType i_type1 = attr.getIntType();
 
         // Get and verify the order of this type
         H5T_order_t order = i_type1.getOrder();
-        verify_val(order, PredType::NATIVE_INT.getOrder(), "DataType::getOrder", __LINE__, __FILE__);
+        verify_val(static_cast<long>(order), static_cast<long>(PredType::NATIVE_INT.getOrder()),
+                   "DataType::getOrder", __LINE__, __FILE__);
 
         // Get and verify the size of this type
         size_t size = i_type1.getSize();
@@ -1061,9 +1098,11 @@ static void test_attr_mult_read()
         attr.read(PredType::NATIVE_INT, read_data1);
 
         // Verify values read in
-        for(i=0; i<ATTR1_DIM1; i++)
-            if(attr_data1[i]!=read_data1[i])
-                TestErrPrintf("%d: attribute data different: attr_data1[%d]=%d,read_data1[%d]=%d\n",__LINE__,i,attr_data1[i],i,read_data1[i]);
+        for (i = 0; i < ATTR1_DIM1; i++)
+            if (attr_data1[i] != read_data1[i])
+                TestErrPrintf("%d: attribute data different: attr_data1[%" PRIuHSIZE
+                              "]=%d,read_data1[%" PRIuHSIZE "]=%d\n",
+                              __LINE__, i, attr_data1[i], i, read_data1[i]);
 
         // Verify Name
         H5std_string attr_name = attr.getName();
@@ -1073,7 +1112,7 @@ static void test_attr_mult_read()
         space.close();
 
         // Open 2nd attribute for the dataset
-        attr = dataset.openAttribute((unsigned)1);
+        attr = dataset.openAttribute(static_cast<unsigned>(1));
 
         /* Verify Dataspace */
 
@@ -1085,10 +1124,12 @@ static void test_attr_mult_read()
         verify_val(rank, ATTR2_RANK, "DataSpace::getSimpleExtentNdims", __LINE__, __FILE__);
 
         // Get the dims of the dataspace and verify them
-        ndims = space.getSimpleExtentDims(dims);
+        (void)space.getSimpleExtentDims(dims);
 
-        verify_val((long)dims[0], (long)ATTR2_DIM1, "DataSpace::getSimpleExtentDims",__LINE__, __FILE__);
-        verify_val((long)dims[1], (long)ATTR2_DIM2, "DataSpace::getSimpleExtentDims",__LINE__, __FILE__);
+        verify_val(static_cast<long>(dims[0]), static_cast<long>(ATTR2_DIM1),
+                   "DataSpace::getSimpleExtentDims", __LINE__, __FILE__);
+        verify_val(static_cast<long>(dims[1]), static_cast<long>(ATTR2_DIM2),
+                   "DataSpace::getSimpleExtentDims", __LINE__, __FILE__);
 
         /* Verify Datatype */
 
@@ -1096,14 +1137,16 @@ static void test_attr_mult_read()
         type_class = attr.getTypeClass();
 
         // Verify that the type is of integer datatype
-        verify_val(type_class, H5T_INTEGER, "Attribute::getTypeClass", __LINE__, __FILE__);
+        verify_val(static_cast<long>(type_class), static_cast<long>(H5T_INTEGER), "Attribute::getTypeClass",
+                   __LINE__, __FILE__);
 
-            // Get the integer datatype
+        // Get the integer datatype
         IntType i_type2 = attr.getIntType();
 
         // Get and verify the order of this type
         order = i_type2.getOrder();
-        verify_val(order, PredType::NATIVE_INT.getOrder(), "DataType::getOrder", __LINE__, __FILE__);
+        verify_val(static_cast<long>(order), static_cast<long>(PredType::NATIVE_INT.getOrder()),
+                   "DataType::getOrder", __LINE__, __FILE__);
 
         // Get and verify the size of this type
         size = i_type2.getSize();
@@ -1111,13 +1154,16 @@ static void test_attr_mult_read()
 
         // Read attribute information
         attr.read(PredType::NATIVE_INT, read_data2);
-        //attr.read(i_type, read_data2);
+        // attr.read(i_type, read_data2);
 
         // Verify values read in
-        for(i=0; i<ATTR2_DIM1; i++)
-          for(j=0; j<ATTR2_DIM2; j++)
-            if(attr_data2[i][j]!=read_data2[i][j])
-                TestErrPrintf("%d: attribute data different: attr_data2[%d][%d]=%d, read_data2[%d][%d]=%d\n",__LINE__,i,j,attr_data2[i][j],i,j,read_data2[i][j]);
+        for (i = 0; i < ATTR2_DIM1; i++)
+            for (j = 0; j < ATTR2_DIM2; j++)
+                if (attr_data2[i][j] != read_data2[i][j])
+                    TestErrPrintf("%d: attribute data different: attr_data2[%" PRIuHSIZE "][%" PRIuHSIZE
+                                  "]=%d, "
+                                  "read_data2[%" PRIuHSIZE "][%" PRIuHSIZE "]=%d\n",
+                                  __LINE__, i, j, attr_data2[i][j], i, j, read_data2[i][j]);
 
         // Verify Name
         attr_name = attr.getName();
@@ -1126,7 +1172,7 @@ static void test_attr_mult_read()
         space.close();
 
         // Open 3rd attribute for the dataset
-        attr = dataset.openAttribute((unsigned)2);
+        attr = dataset.openAttribute(static_cast<unsigned>(2));
 
         /* Verify Dataspace */
 
@@ -1138,10 +1184,13 @@ static void test_attr_mult_read()
         verify_val(rank, ATTR3_RANK, "DataSpace::getSimpleExtentNdims", __LINE__, __FILE__);
 
         // Get the dims of the dataspace and verify them
-        ndims = space.getSimpleExtentDims(dims);
-        verify_val((long)dims[0],(long)ATTR3_DIM1,"attribute dimensions",__FILE__,__LINE__);
-        verify_val((long)dims[1],(long)ATTR3_DIM2,"attribute dimensions",__FILE__,__LINE__);
-        verify_val((long)dims[2],(long)ATTR3_DIM3,"attribute dimensions",__FILE__,__LINE__);
+        (void)space.getSimpleExtentDims(dims);
+        verify_val(static_cast<long>(dims[0]), static_cast<long>(ATTR3_DIM1), "attribute dimensions",
+                   __FILE__, __LINE__);
+        verify_val(static_cast<long>(dims[1]), static_cast<long>(ATTR3_DIM2), "attribute dimensions",
+                   __FILE__, __LINE__);
+        verify_val(static_cast<long>(dims[2]), static_cast<long>(ATTR3_DIM3), "attribute dimensions",
+                   __FILE__, __LINE__);
 
         /* Verify Datatype */
 
@@ -1149,14 +1198,16 @@ static void test_attr_mult_read()
         type_class = attr.getTypeClass();
 
         // Verify that the type is of compound datatype
-        verify_val(type_class, H5T_FLOAT, "Attribute::getTypeClass", __LINE__, __FILE__);
+        verify_val(static_cast<long>(type_class), static_cast<long>(H5T_FLOAT), "Attribute::getTypeClass",
+                   __LINE__, __FILE__);
 
-            // Get the double datatype
+        // Get the double datatype
         FloatType f_type = attr.getFloatType();
 
         // Get and verify the order of this type
         order = f_type.getOrder();
-        verify_val(order, PredType::NATIVE_DOUBLE.getOrder(), "DataType::getOrder", __LINE__, __FILE__);
+        verify_val(static_cast<long>(order), static_cast<long>(PredType::NATIVE_DOUBLE.getOrder()),
+                   "DataType::getOrder", __LINE__, __FILE__);
 
         // Get and verify the size of this type
         size = f_type.getSize();
@@ -1166,11 +1217,14 @@ static void test_attr_mult_read()
         attr.read(PredType::NATIVE_DOUBLE, read_data3);
 
         // Verify values read in
-        for(i=0; i<ATTR3_DIM1; i++)
-            for(j=0; j<ATTR3_DIM2; j++)
-                for(k=0; k<ATTR3_DIM3; k++)
-                    if(attr_data3[i][j][k]!=read_data3[i][j][k])
-                        TestErrPrintf("%d: attribute data different: attr_data3[%d][%d][%d]=%f, read_data3[%d][%d][%d]=%f\n",__LINE__,i,j,k,attr_data3[i][j][k],i,j,k,read_data3[i][j][k]);
+        for (i = 0; i < ATTR3_DIM1; i++)
+            for (j = 0; j < ATTR3_DIM2; j++)
+                for (k = 0; k < ATTR3_DIM3; k++)
+                    if (abs(attr_data3[i][j][k] - read_data3[i][j][k]) > DBL_EPSILON)
+                        TestErrPrintf("%d: attribute data different: attr_data3[%" PRIuHSIZE "][%" PRIuHSIZE
+                                      "][%" PRIuHSIZE "]=%f, "
+                                      "read_data3[%" PRIuHSIZE "][%" PRIuHSIZE "][%" PRIuHSIZE "]=%f\n",
+                                      __LINE__, i, j, k, attr_data3[i][j][k], i, j, k, read_data3[i][j][k]);
 
         // Verify Name
         attr_name = attr.getName();
@@ -1179,13 +1233,11 @@ static void test_attr_mult_read()
         PASSED();
     } // end try block
 
-    catch (Exception& E)
-    {
+    catch (Exception &E) {
         issue_fail_msg("test_attr_mult_read()", __LINE__, __FILE__, E.getCDetailMsg());
     }
-}   // test_attr_mult_read()
+} // test_attr_mult_read()
 
-
 /*-------------------------------------------------------------------------
  * Function:    test_attr_delete
  *
@@ -1194,9 +1246,10 @@ static void test_attr_mult_read()
  * Return       None
  *-------------------------------------------------------------------------
  */
-static void test_attr_delete()
+static void
+test_attr_delete()
 {
-    H5std_string  attr_name; // Buffer for attribute names
+    H5std_string attr_name; // Buffer for attribute names
 
     // Output message about test being performed
     SUBTEST("Removing Attribute Function");
@@ -1217,11 +1270,11 @@ static void test_attr_delete()
         verify_val(num_attrs, 1, "H5File::getNumAttrs", __LINE__, __FILE__);
 
         // Verify the name of the only file attribute left
-        Attribute fattr = fid1.openAttribute((unsigned)0);
-        attr_name = fattr.getName();
+        Attribute fattr = fid1.openAttribute(static_cast<unsigned>(0));
+        attr_name       = fattr.getName();
         verify_val(attr_name, FATTR1_NAME, "Attribute::getName", __LINE__, __FILE__);
         fattr.close();
-        
+
         // Test deleting non-existing attribute
 
         // Open the dataset
@@ -1236,10 +1289,12 @@ static void test_attr_delete()
             dataset.removeAttr("Bogus");
 
             // continuation here, that means no exception has been thrown
-            throw InvalidActionException("DataSet::removeAttr", "Attempting to remove non-existing attribute");
+            throw InvalidActionException("DataSet::removeAttr",
+                                         "Attempting to remove non-existing attribute");
         }
-        catch (AttributeIException& E) // catching invalid removing attribute
-        {} // do nothing, exception expected
+        catch (AttributeIException &E) // catching invalid removing attribute
+        {
+        } // do nothing, exception expected
 
         // Test deleting dataset's attributes
 
@@ -1255,7 +1310,7 @@ static void test_attr_delete()
         verify_val(num_attrs, 2, "DataSet::getNumAttrs", __LINE__, __FILE__);
 
         // Open 1st attribute for the dataset
-        Attribute attr = dataset.openAttribute((unsigned)0);
+        Attribute attr = dataset.openAttribute(static_cast<unsigned>(0));
 
         // Verify Name
         attr_name = attr.getName();
@@ -1265,7 +1320,7 @@ static void test_attr_delete()
         attr.close();
 
         // Open last (formally 3rd) attribute for the dataset
-        attr = dataset.openAttribute((unsigned)1);
+        attr = dataset.openAttribute(static_cast<unsigned>(1));
 
         // Verify Name
         attr_name = attr.getName();
@@ -1281,7 +1336,7 @@ static void test_attr_delete()
         verify_val(num_attrs, 1, "DataSet::getNumAttrs", __LINE__, __FILE__);
 
         // Open the only attribute for the dataset (formally 3rd)
-        attr = dataset.openAttribute((unsigned)0);
+        attr = dataset.openAttribute(static_cast<unsigned>(0));
 
         // Verify Name
         attr_name = attr.getName();
@@ -1299,13 +1354,11 @@ static void test_attr_delete()
         PASSED();
     } // end try block
 
-    catch (Exception& E)
-    {
+    catch (Exception &E) {
         issue_fail_msg("test_attr_delete()", __LINE__, __FILE__, E.getCDetailMsg());
     }
-}   // test_attr_delete()
+} // test_attr_delete()
 
-
 /*-------------------------------------------------------------------------
  * Function:    test_attr_dtype_shared
  *
@@ -1314,14 +1367,15 @@ static void test_attr_delete()
  * Return       None
  *-------------------------------------------------------------------------
  */
-static void test_attr_dtype_shared()
+static void
+test_attr_dtype_shared()
 {
-    int data=8;                 // Data to write
-    int rdata=0;                // Data read in
+    int data  = 8; // Data to write
+    int rdata = 0; // Data read in
 #ifndef H5_NO_DEPRECATED_SYMBOLS
-    H5G_stat_t statbuf;         // Object's information
+    H5G_stat_t statbuf; // Object's information
 #endif
-    h5_stat_size_t filesize;    // Size of file after modifications
+    h5_stat_size_t filesize; // Size of file after modifications
 
     // Output message about test being performed
     SUBTEST("Shared Datatypes with Attributes");
@@ -1334,7 +1388,7 @@ static void test_attr_dtype_shared()
         fid1.close();
 
         // Get size of file
-        h5_stat_size_t empty_filesize;       // Size of empty file
+        h5_stat_size_t empty_filesize; // Size of empty file
         empty_filesize = h5_get_file_size(FILE_DTYPE.c_str(), H5P_DEFAULT);
         if (empty_filesize < 0)
             TestErrPrintf("Line %d: file size wrong!\n", __LINE__);
@@ -1347,67 +1401,68 @@ static void test_attr_dtype_shared()
         // scope, causing incorrect number of ref counts.
         { // First enclosed block
 
-        // Create a datatype to commit and use
-        IntType dtype(PredType::NATIVE_INT);
+            // Create a datatype to commit and use
+            IntType dtype(PredType::NATIVE_INT);
 
-        // Commit datatype to file
-        dtype.commit(fid1, TYPE1_NAME);
+            // Commit datatype to file
+            dtype.commit(fid1, TYPE1_NAME);
 
 #ifndef H5_NO_DEPRECATED_SYMBOLS
-        // Check reference count on named datatype
-        fid1.getObjinfo(TYPE1_NAME, statbuf);
-        verify_val((int)statbuf.nlink, 1, "DataType::getObjinfo", __LINE__, __FILE__);
+            // Check reference count on named datatype
+            fid1.getObjinfo(TYPE1_NAME, statbuf);
+            verify_val(static_cast<int>(statbuf.nlink), 1, "DataType::getObjinfo", __LINE__, __FILE__);
 #endif
 
-        // Create dataspace for dataset
-        DataSpace dspace;
+            // Create dataspace for dataset
+            DataSpace dspace;
 
-        DataSet dset = fid1.createDataSet(DSET1_NAME, dtype, dspace);
+            DataSet dset = fid1.createDataSet(DSET1_NAME, dtype, dspace);
 
 #ifndef H5_NO_DEPRECATED_SYMBOLS
-        // Check reference count on named datatype
-        fid1.getObjinfo(TYPE1_NAME, statbuf);
-        verify_val((int)statbuf.nlink, 2, "H5File::getObjinfo", __LINE__, __FILE__);
+            // Check reference count on named datatype
+            fid1.getObjinfo(TYPE1_NAME, statbuf);
+            verify_val(static_cast<int>(statbuf.nlink), 2, "H5File::getObjinfo", __LINE__, __FILE__);
 #endif
 
-        // Create attribute on dataset
-        Attribute attr = dset.createAttribute(ATTR1_NAME,dtype,dspace);
+            // Create attribute on dataset
+            Attribute attr = dset.createAttribute(ATTR1_NAME, dtype, dspace);
 
 #ifndef H5_NO_DEPRECATED_SYMBOLS
-        // Check reference count on named datatype
-        fid1.getObjinfo(TYPE1_NAME, statbuf);
-        verify_val((int)statbuf.nlink, 3, "DataSet::getObjinfo", __LINE__, __FILE__);
+            // Check reference count on named datatype
+            fid1.getObjinfo(TYPE1_NAME, statbuf);
+            verify_val(static_cast<int>(statbuf.nlink), 3, "DataSet::getObjinfo", __LINE__, __FILE__);
 #endif
 
-        // Close attribute
-        attr.close();
+            // Close attribute
+            attr.close();
 
-        // Delete attribute
-        dset.removeAttr(ATTR1_NAME);
+            // Delete attribute
+            dset.removeAttr(ATTR1_NAME);
 
 #ifndef H5_NO_DEPRECATED_SYMBOLS
-        // Check reference count on named datatype
-        fid1.getObjinfo(TYPE1_NAME, statbuf);
-        verify_val((int)statbuf.nlink, 2, "DataSet::getObjinfo after DataSet::removeAttr", __LINE__, __FILE__);
+            // Check reference count on named datatype
+            fid1.getObjinfo(TYPE1_NAME, statbuf);
+            verify_val(static_cast<int>(statbuf.nlink), 2, "DataSet::getObjinfo after DataSet::removeAttr",
+                       __LINE__, __FILE__);
 #endif
 
-        // Create attribute on dataset
-        attr = dset.createAttribute(ATTR1_NAME,dtype,dspace);
+            // Create attribute on dataset
+            attr = dset.createAttribute(ATTR1_NAME, dtype, dspace);
 
 #ifndef H5_NO_DEPRECATED_SYMBOLS
-        // Check reference count on named datatype
-        fid1.getObjinfo(TYPE1_NAME, statbuf);
-        verify_val((int)statbuf.nlink, 3, "DataSet::createAttribute", __LINE__, __FILE__);
+            // Check reference count on named datatype
+            fid1.getObjinfo(TYPE1_NAME, statbuf);
+            verify_val(static_cast<int>(statbuf.nlink), 3, "DataSet::createAttribute", __LINE__, __FILE__);
 #endif
 
-        // Write data into the attribute
-        attr.write(PredType::NATIVE_INT,&data);
+            // Write data into the attribute
+            attr.write(PredType::NATIVE_INT, &data);
 
-        // Close attribute, dataset, dataspace, datatype, and file
-        attr.close();
-        dset.close();
-        dspace.close();
-        dtype.close();
+            // Close attribute, dataset, dataspace, datatype, and file
+            attr.close();
+            dset.close();
+            dspace.close();
+            dtype.close();
         } // end of first enclosing
 
         fid1.close();
@@ -1417,24 +1472,24 @@ static void test_attr_dtype_shared()
 
         { // Second enclosed block...
 
-        // Open dataset
-        DataSet *dset2 = new DataSet (fid1.openDataSet(DSET1_NAME));
+            // Open dataset
+            DataSet *dset2 = new DataSet(fid1.openDataSet(DSET1_NAME));
 
-        // Open attribute
-        Attribute *attr2 = new Attribute (dset2->openAttribute(ATTR1_NAME));
+            // Open attribute
+            Attribute *attr2 = new Attribute(dset2->openAttribute(ATTR1_NAME));
 
-        // Read data from the attribute
-        attr2->read(PredType::NATIVE_INT, &rdata);
-        verify_val(data, rdata, "Attribute::read", __LINE__, __FILE__);
+            // Read data from the attribute
+            attr2->read(PredType::NATIVE_INT, &rdata);
+            verify_val(data, rdata, "Attribute::read", __LINE__, __FILE__);
 
-        // Close attribute and dataset
-        delete attr2;
-        delete dset2;
+            // Close attribute and dataset
+            delete attr2;
+            delete dset2;
 
 #ifndef H5_NO_DEPRECATED_SYMBOLS
-        // Check reference count on named datatype
-        fid1.getObjinfo(TYPE1_NAME, statbuf);
-        verify_val((int)statbuf.nlink, 3, "DataSet::openAttribute", __LINE__, __FILE__);
+            // Check reference count on named datatype
+            fid1.getObjinfo(TYPE1_NAME, statbuf);
+            verify_val(static_cast<int>(statbuf.nlink), 3, "DataSet::openAttribute", __LINE__, __FILE__);
 #endif
         } // end of second enclosing
 
@@ -1444,7 +1499,7 @@ static void test_attr_dtype_shared()
 #ifndef H5_NO_DEPRECATED_SYMBOLS
         // Check reference count on named datatype
         fid1.getObjinfo(TYPE1_NAME, statbuf);
-        verify_val((int)statbuf.nlink, 1, "H5File::unlink", __LINE__, __FILE__);
+        verify_val(static_cast<int>(statbuf.nlink), 1, "H5File::unlink", __LINE__, __FILE__);
 #endif
 
         // Unlink the named datatype
@@ -1455,18 +1510,17 @@ static void test_attr_dtype_shared()
 
         // Check size of file
         filesize = h5_get_file_size(FILE_DTYPE.c_str(), H5P_DEFAULT);
-        verify_val((long)filesize, (long)empty_filesize, "Checking file size", __LINE__, __FILE__);
+        verify_val(static_cast<long>(filesize), static_cast<long>(empty_filesize), "Checking file size",
+                   __LINE__, __FILE__);
 
         PASSED();
-    }   // end try block
+    } // end try block
 
-    catch (Exception& E)
-    {
+    catch (Exception &E) {
         issue_fail_msg("test_attr_dtype_shared()", __LINE__, __FILE__, E.getCDetailMsg());
     }
-}   // test_attr_dtype_shared()
+} // test_attr_dtype_shared()
 
-
 /*-------------------------------------------------------------------------
  * Function:    test_string_attr
  *
@@ -1480,9 +1534,10 @@ const H5std_string ATTR1_FL_STR_NAME("String_attr 1");
 const H5std_string ATTR2_FL_STR_NAME("String_attr 2");
 const H5std_string ATTR_VL_STR_NAME("String_attr");
 const H5std_string ATTRSTR_DATA("String Attribute");
-const int ATTR_LEN = 17;
+const int          ATTR_LEN = 17;
 
-static void test_string_attr()
+static void
+test_string_attr()
 {
     // Output message about test being performed
     SUBTEST("I/O on FL and VL String Attributes");
@@ -1501,7 +1556,7 @@ static void test_string_attr()
         Group root = fid1.openGroup("/");
 
         // Create dataspace for the attribute.
-        DataSpace att_space (H5S_SCALAR);
+        DataSpace att_space(H5S_SCALAR);
 
         /* Test Attribute::write(...,const void *buf) with Fixed len string */
 
@@ -1524,18 +1579,20 @@ static void test_string_attr()
         // Read and verify the attribute string as a string of chars.
         char flstring_att_check[ATTR_LEN];
         gr_flattr1.read(fls_type, flstring_att_check);
-        if(HDstrcmp(flstring_att_check, ATTRSTR_DATA.c_str())!=0)
-            TestErrPrintf("Line %d: Attribute data different: ATTRSTR_DATA=%s,flstring_att_check=%s\n",__LINE__, ATTRSTR_DATA.c_str(), flstring_att_check);
+        if (HDstrcmp(flstring_att_check, ATTRSTR_DATA.c_str()) != 0)
+            TestErrPrintf("Line %d: Attribute data different: ATTRSTR_DATA=%s,flstring_att_check=%s\n",
+                          __LINE__, ATTRSTR_DATA.c_str(), flstring_att_check);
 
         // Read and verify the attribute string as a string of chars; buffer
         // is dynamically allocated.
         size_t attr_size = gr_flattr1.getInMemDataSize();
-        char *fl_dyn_string_att_check;
-        fl_dyn_string_att_check = new char[attr_size+1];
+        char * fl_dyn_string_att_check;
+        fl_dyn_string_att_check = new char[attr_size + 1];
         gr_flattr1.read(fls_type, fl_dyn_string_att_check);
-        if(HDstrcmp(fl_dyn_string_att_check, ATTRSTR_DATA.c_str())!=0)
-            TestErrPrintf("Line %d: Attribute data different: ATTRSTR_DATA=%s,flstring_att_check=%s\n",__LINE__, ATTRSTR_DATA.c_str(), fl_dyn_string_att_check);
-        delete []fl_dyn_string_att_check;
+        if (HDstrcmp(fl_dyn_string_att_check, ATTRSTR_DATA.c_str()) != 0)
+            TestErrPrintf("Line %d: Attribute data different: ATTRSTR_DATA=%s,flstring_att_check=%s\n",
+                          __LINE__, ATTRSTR_DATA.c_str(), fl_dyn_string_att_check);
+        delete[] fl_dyn_string_att_check;
 
         /* Test Attribute::read(...,H5std_string& strg) with FL string */
 
@@ -1543,13 +1600,15 @@ static void test_string_attr()
         H5std_string read_flstr1;
         gr_flattr1.read(fls_type, read_flstr1);
         if (read_flstr1 != ATTRSTR_DATA)
-            TestErrPrintf("Line %d: Attribute data different: ATTRSTR_DATA=%s,read_flstr1=%s\n",__LINE__, ATTRSTR_DATA.c_str(), read_flstr1.c_str());
+            TestErrPrintf("Line %d: Attribute data different: ATTRSTR_DATA=%s,read_flstr1=%s\n", __LINE__,
+                          ATTRSTR_DATA.c_str(), read_flstr1.c_str());
 
         // Read and verify the attribute string as a string of chars.
         HDstrcpy(flstring_att_check, "");
         gr_flattr2.read(fls_type, flstring_att_check);
-        if(HDstrcmp(flstring_att_check, ATTRSTR_DATA.c_str())!=0)
-            TestErrPrintf("Line %d: Attribute data different: ATTRSTR_DATA=%s,flstring_att_check=%s\n",__LINE__, ATTRSTR_DATA.c_str(), flstring_att_check);
+        if (HDstrcmp(flstring_att_check, ATTRSTR_DATA.c_str()) != 0)
+            TestErrPrintf("Line %d: Attribute data different: ATTRSTR_DATA=%s,flstring_att_check=%s\n",
+                          __LINE__, ATTRSTR_DATA.c_str(), flstring_att_check);
 
         /* Test Attribute::read(...,H5std_string& strg) with FL string */
 
@@ -1557,7 +1616,8 @@ static void test_string_attr()
         H5std_string read_flstr2;
         gr_flattr2.read(fls_type, read_flstr2);
         if (read_flstr2 != ATTRSTR_DATA)
-            TestErrPrintf("Line %d: Attribute data different: ATTRSTR_DATA=%s,read_flstr2=%s\n",__LINE__, ATTRSTR_DATA.c_str(), read_flstr2.c_str());
+            TestErrPrintf("Line %d: Attribute data different: ATTRSTR_DATA=%s,read_flstr2=%s\n", __LINE__,
+                          ATTRSTR_DATA.c_str(), read_flstr2.c_str());
 
         //
         // Variable-lenth string attributes
@@ -1575,8 +1635,9 @@ static void test_string_attr()
         // Read and verify the attribute string as a string of chars.
         char *string_att_check;
         gr_vlattr.read(vls_type, &string_att_check);
-        if(HDstrcmp(string_att_check, ATTRSTR_DATA.c_str())!=0)
-            TestErrPrintf("Line %d: Attribute data different: ATTRSTR_DATA=%s,string_att_check=%s\n",__LINE__, ATTRSTR_DATA.c_str(), string_att_check);
+        if (HDstrcmp(string_att_check, ATTRSTR_DATA.c_str()) != 0)
+            TestErrPrintf("Line %d: Attribute data different: ATTRSTR_DATA=%s,string_att_check=%s\n",
+                          __LINE__, ATTRSTR_DATA.c_str(), string_att_check);
         HDfree(string_att_check);
 
         /* Test Attribute::read(...,H5std_string& strg) with VL string */
@@ -1584,17 +1645,16 @@ static void test_string_attr()
         H5std_string read_str;
         gr_vlattr.read(vls_type, read_str);
         if (read_str != ATTRSTR_DATA)
-            TestErrPrintf("Line %d: Attribute data different: ATTRSTR_DATA=%s,read_str=%s\n",__LINE__, ATTRSTR_DATA.c_str(), read_str.c_str());
+            TestErrPrintf("Line %d: Attribute data different: ATTRSTR_DATA=%s,read_str=%s\n", __LINE__,
+                          ATTRSTR_DATA.c_str(), read_str.c_str());
         PASSED();
     } // end try block
 
-    catch (Exception& E)
-    {
+    catch (Exception &E) {
         issue_fail_msg("test_string_attr()", __LINE__, __FILE__, E.getCDetailMsg());
     }
-}   // test_string_attr()
+} // test_string_attr()
 
-
 /*-------------------------------------------------------------------------
  * Function:    test_attr_exists
  *
@@ -1606,7 +1666,8 @@ static void test_string_attr()
  *              Additional attrExists tests are in test_attr_rename().
  *-------------------------------------------------------------------------
  */
-static void test_attr_exists()
+static void
+test_attr_exists()
 {
     // Output message about test being performed
     SUBTEST("Check Attribute Existence");
@@ -1620,36 +1681,36 @@ static void test_attr_exists()
 
         // Check for existence of attribute
         bool attr_exists = fid1.attrExists(ATTR1_FL_STR_NAME);
-        if (attr_exists == false)
-            throw InvalidActionException("H5File::attrExists", "fid1, ATTR1_FL_STR_NAMEAttribute should exist but does not");
+        if (!attr_exists)
+            throw InvalidActionException("H5File::attrExists",
+                                         "fid1, ATTR1_FL_STR_NAMEAttribute should exist but does not");
 
         // Check for existence of attribute
         attr_exists = fid1.attrExists(FATTR1_NAME);
-        if (attr_exists == false)
-            throw InvalidActionException("H5File::attrExists", "fid1,FATTR2_NAMEAttribute should exist but does not");
+        if (!attr_exists)
+            throw InvalidActionException("H5File::attrExists",
+                                         "fid1,FATTR2_NAMEAttribute should exist but does not");
 
         // Open a group.
         Group group = fid1.openGroup(GROUP1_NAME);
 
         // Check for existence of attribute
         attr_exists = group.attrExists(ATTR2_NAME);
-        if (attr_exists == false)
-            throw InvalidActionException("H5File::attrExists", "group, ATTR2_NAMEAttribute should exist but does not");
+        if (!attr_exists)
+            throw InvalidActionException("H5File::attrExists",
+                                         "group, ATTR2_NAMEAttribute should exist but does not");
 
         PASSED();
     } // end try block
 
-    catch (InvalidActionException& E)
-    {
+    catch (InvalidActionException &E) {
         issue_fail_msg("test_attr_exists()", __LINE__, __FILE__, E.getCDetailMsg());
     }
-    catch (Exception& E)
-    {
+    catch (Exception &E) {
         issue_fail_msg("test_attr_exists()", __LINE__, __FILE__, E.getCDetailMsg());
     }
-}   // test_attr_exists()
+} // test_attr_exists()
 
-
 /*-------------------------------------------------------------------------
  * Function:    test_attr_dense_create
  *
@@ -1659,25 +1720,25 @@ static void test_attr_exists()
  *-------------------------------------------------------------------------
  */
 const H5std_string FILE_CRTPROPS("tattr_crt_properties.h5");
-const int NAME_BUF_SIZE = 1024;
-const unsigned MAX_COMPACT_DEF = 8;
-const unsigned MIN_DENSE_DEF = 6;
+const int          NAME_BUF_SIZE   = 1024;
+const unsigned     MAX_COMPACT_DEF = 8;
+const unsigned     MIN_DENSE_DEF   = 6;
 
-static void test_attr_dense_create(FileCreatPropList& fcpl,
-                                   FileAccPropList& fapl)
+static void
+test_attr_dense_create(FileCreatPropList &fcpl, FileAccPropList &fapl)
 {
     // Output message about test being performed
     SUBTEST("Dense Attribute Storage Creation");
 
     try {
         // Create file
-        H5File fid1 (FILE_CRTPROPS, H5F_ACC_TRUNC, fcpl, fapl);
+        H5File fid1(FILE_CRTPROPS, H5F_ACC_TRUNC, fcpl, fapl);
 
         // Close file
         fid1.close();
 
         // Get size of file
-        h5_stat_size_t empty_filesize;       // Size of empty file
+        h5_stat_size_t empty_filesize; // Size of empty file
         empty_filesize = h5_get_file_size(FILE_CRTPROPS.c_str(), fapl.getId());
         if (empty_filesize < 0)
             TestErrPrintf("Line %d: file size wrong!\n", __LINE__);
@@ -1698,16 +1759,18 @@ static void test_attr_dense_create(FileCreatPropList& fcpl,
 
         // Retrieve limits for compact/dense attribute storage
         dcpl.getAttrPhaseChange(max_compact, min_dense);
-        verify_val(max_compact, MAX_COMPACT_DEF, "DSetCreatPropList::getAttrPhaseChange",__LINE__,__FILE__);
-        verify_val(min_dense, MIN_DENSE_DEF, "DSetCreatPropList::getAttrPhaseChange",__LINE__,__FILE__);
+        verify_val(max_compact, MAX_COMPACT_DEF, "DSetCreatPropList::getAttrPhaseChange", __LINE__, __FILE__);
+        verify_val(min_dense, MIN_DENSE_DEF, "DSetCreatPropList::getAttrPhaseChange", __LINE__, __FILE__);
 
         // Set new compact/dense attribute storage limits to some random numbers
         dcpl.setAttrPhaseChange(7, 5);
 
         // Retrieve limits for compact/dense attribute storage and verify them
         dcpl.getAttrPhaseChange(max_compact, min_dense);
-        verify_val(max_compact, static_cast<unsigned>(7), "DSetCreatPropList::getAttrPhaseChange",__LINE__,__FILE__);
-        verify_val(min_dense, static_cast<unsigned>(5), "DSetCreatPropList::getAttrPhaseChange",__LINE__,__FILE__);
+        verify_val(max_compact, static_cast<unsigned>(7), "DSetCreatPropList::getAttrPhaseChange", __LINE__,
+                   __FILE__);
+        verify_val(min_dense, static_cast<unsigned>(5), "DSetCreatPropList::getAttrPhaseChange", __LINE__,
+                   __FILE__);
 
         // Close property list
         dcpl.close();
@@ -1715,12 +1778,11 @@ static void test_attr_dense_create(FileCreatPropList& fcpl,
         // H5O__is_attr_dense_test - un-usable
 
         // Add attributes, until just before converting to dense storage
-        char attr_name[NAME_BUF_SIZE];
+        char     attr_name[NAME_BUF_SIZE];
         unsigned attr_num;
-        for (attr_num = 0; attr_num < max_compact; attr_num++)
-        {
+        for (attr_num = 0; attr_num < max_compact; attr_num++) {
             // Create attribute
-            sprintf(attr_name, "attr %02u", attr_num);
+            snprintf(attr_name, sizeof(attr_name), "attr %02u", attr_num);
             Attribute attr = dataset.createAttribute(attr_name, PredType::NATIVE_UINT, ds_space);
 
             // Write data to the attribute
@@ -1732,7 +1794,7 @@ static void test_attr_dense_create(FileCreatPropList& fcpl,
         { // Add one more attribute, to push into "dense" storage
 
             // Create another attribute
-            sprintf(attr_name, "attr %02u", attr_num);
+            snprintf(attr_name, sizeof(attr_name), "attr %02u", attr_num);
             Attribute attr = dataset.createAttribute(attr_name, PredType::NATIVE_UINT, ds_space);
 
             // Write data to the attribute
@@ -1740,28 +1802,27 @@ static void test_attr_dense_create(FileCreatPropList& fcpl,
         }
 
         // Attempt to add attribute again, which should fail
-        try
-        {
+        try {
             // Create another attribute
-            sprintf(attr_name, "attr %02u", attr_num);
+            snprintf(attr_name, sizeof(attr_name), "attr %02u", attr_num);
             Attribute attr = dataset.createAttribute(attr_name, PredType::NATIVE_UINT, ds_space);
 
             // continuation here, that means no exception has been thrown
-            throw InvalidActionException("DataSet::createAttribute", "Maximum number of attributes has been reached");
+            throw InvalidActionException("DataSet::createAttribute",
+                                         "Maximum number of attributes has been reached");
         }
-        catch (AttributeIException& E) // catching invalid action
-        {} // do nothing, exception expected
+        catch (AttributeIException &E) // catching invalid action
+        {
+        } // do nothing, exception expected
 
         PASSED();
     } // end try block
 
-    catch (Exception& E)
-    {
+    catch (Exception &E) {
         issue_fail_msg("test_attr_dense_create()", __LINE__, __FILE__, E.getCDetailMsg());
     }
-}   // test_attr_dense_create()
+} // test_attr_dense_create()
 
-
 /*-------------------------------------------------------------------------
  * Function:    test_attr_corder_create_basic
  *
@@ -1770,23 +1831,24 @@ static void test_attr_dense_create(FileCreatPropList& fcpl,
  * Return       None
  *-------------------------------------------------------------------------
  */
-static void test_attr_corder_create_basic(FileCreatPropList& fcpl,
-                                   FileAccPropList& fapl)
+static void
+test_attr_corder_create_basic(FileCreatPropList &fcpl, FileAccPropList &fapl)
 {
     // Output message about test being performed
     SUBTEST("Basic Code for Attributes with Creation Order Info");
 
     try {
         // Create file
-        H5File fid1 (FILE_CRTPROPS, H5F_ACC_TRUNC, fcpl, fapl);
+        H5File fid1(FILE_CRTPROPS, H5F_ACC_TRUNC, fcpl, fapl);
 
         //  Create dataset creation property list.
         DSetCreatPropList dcpl;
 
         // Get creation order indexing on object
         unsigned crt_order_flags = 0;
-        crt_order_flags = dcpl.getAttrCrtOrder();
-        verify_val(crt_order_flags, (unsigned)0, "DSetCreatPropList::getAttrCrtOrder",__LINE__,__FILE__);
+        crt_order_flags          = dcpl.getAttrCrtOrder();
+        verify_val(static_cast<long>(crt_order_flags), 0, "DSetCreatPropList::getAttrCrtOrder", __LINE__,
+                   __FILE__);
 
         // Setting invalid combination of a attribute order creation order
         // indexing on should fail
@@ -1794,16 +1856,19 @@ static void test_attr_corder_create_basic(FileCreatPropList& fcpl,
             dcpl.setAttrCrtOrder(H5P_CRT_ORDER_INDEXED);
 
             // continuation here, that means no exception has been thrown
-            throw InvalidActionException("DSetCreatPropList::getAttrCrtOrder", "Indexing cannot be set alone, order tracking is required");
+            throw InvalidActionException("DSetCreatPropList::getAttrCrtOrder",
+                                         "Indexing cannot be set alone, order tracking is required");
         }
-        catch (PropListIException& E) // catching invalid action
-        {} // do nothing, exception expected
+        catch (PropListIException &E) // catching invalid action
+        {
+        } // do nothing, exception expected
 
         // Set attribute creation order tracking & indexing for object then
         // verify them
         dcpl.setAttrCrtOrder(H5P_CRT_ORDER_TRACKED | H5P_CRT_ORDER_INDEXED);
         crt_order_flags = dcpl.getAttrCrtOrder();
-        verify_val(crt_order_flags, (unsigned)(H5P_CRT_ORDER_TRACKED | H5P_CRT_ORDER_INDEXED), "DSetCreatPropList::getAttrCrtOrder",__LINE__,__FILE__);
+        verify_val(crt_order_flags, static_cast<unsigned>(H5P_CRT_ORDER_TRACKED | H5P_CRT_ORDER_INDEXED),
+                   "DSetCreatPropList::getAttrCrtOrder", __LINE__, __FILE__);
 
         // Create dataspace for dataset
         DataSpace ds_space(H5S_SCALAR);
@@ -1838,18 +1903,17 @@ static void test_attr_corder_create_basic(FileCreatPropList& fcpl,
 
         // Query the attribute creation properties
         crt_order_flags = dcpl.getAttrCrtOrder();
-        verify_val(crt_order_flags, (unsigned)(H5P_CRT_ORDER_TRACKED | H5P_CRT_ORDER_INDEXED), "DSetCreatPropList::getAttrCrtOrder",__LINE__,__FILE__);
+        verify_val(crt_order_flags, static_cast<unsigned>(H5P_CRT_ORDER_TRACKED | H5P_CRT_ORDER_INDEXED),
+                   "DSetCreatPropList::getAttrCrtOrder", __LINE__, __FILE__);
 
         PASSED();
     } // end try block
 
-    catch (Exception& E)
-    {
+    catch (Exception &E) {
         issue_fail_msg("test_attr_corder_create_basic()", __LINE__, __FILE__, E.getCDetailMsg());
     }
-}   // test_attr_corder_create_basic()
+} // test_attr_corder_create_basic()
 
-
 /*-------------------------------------------------------------------------
  * Function:    test_attr
  *
@@ -1858,14 +1922,13 @@ static void test_attr_corder_create_basic(FileCreatPropList& fcpl,
  * Return       None
  *-------------------------------------------------------------------------
  */
-extern "C"
-void test_attr()
+extern "C" void
+test_attr()
 {
     // Output message about test being performed
     MESSAGE(5, ("Testing Attributes\n"));
 
-    try
-    {
+    try {
         // Create a default file access property list
         FileAccPropList fapl;
 
@@ -1887,45 +1950,41 @@ void test_attr()
 
         // Loop over using new group format
         unsigned new_format;
-        for (new_format = FALSE; new_format <= TRUE; new_format++)
-        {
+        for (new_format = FALSE; new_format <= TRUE; new_format++) {
             FileAccPropList curr_fapl;
 
             // Set the file access proplist for the type of format
-            if (new_format)
-            {
+            if (new_format) {
                 MESSAGE(7, ("testing with new file format\n"));
                 curr_fapl = fapl_new;
             }
-            else
-            {
+            else {
                 MESSAGE(7, ("testing with old file format\n"));
                 curr_fapl = fapl;
             }
 
-            test_attr_basic_write();    // Test basic H5A writing code
-            test_attr_getname();        // Test overloads of Attribute::getName
-            test_attr_rename();         // Test renaming attribute
-            test_attr_basic_read();     // Test basic H5A reading code
+            test_attr_basic_write(); // Test basic H5A writing code
+            test_attr_getname();     // Test overloads of Attribute::getName
+            test_attr_rename();      // Test renaming attribute
+            test_attr_basic_read();  // Test basic H5A reading code
 
             test_attr_compound_write(); // Test complex datatype H5A writing code
             test_attr_compound_read();  // Test complex datatype H5A reading code
 
-            test_attr_scalar_write();   // Test scalar dataspace H5A writing code
-            test_attr_scalar_read();    // Test scalar dataspace H5A reading code
+            test_attr_scalar_write(); // Test scalar dataspace H5A writing code
+            test_attr_scalar_read();  // Test scalar dataspace H5A reading code
 
-            test_attr_mult_write();     // Test writing multiple attributes
-            test_attr_mult_read();      // Test reading multiple attributes
-            test_attr_delete();         // Test deleting attributes
+            test_attr_mult_write(); // Test writing multiple attributes
+            test_attr_mult_read();  // Test reading multiple attributes
+            test_attr_delete();     // Test deleting attributes
 
-            test_attr_dtype_shared();   // Test using shared datatypes in attributes
+            test_attr_dtype_shared(); // Test using shared datatypes in attributes
 
-            test_string_attr();         // Test read/write string attribute
-            test_attr_exists();         // Test H5Location::attrExists
+            test_string_attr(); // Test read/write string attribute
+            test_attr_exists(); // Test H5Location::attrExists
 
             // Test with new format
-            if (new_format)
-            {
+            if (new_format) {
                 // Test dense attribute storage creation
                 test_attr_dense_create(fcpl, curr_fapl);
 
@@ -1933,15 +1992,13 @@ void test_attr()
                 test_attr_corder_create_basic(fcpl, curr_fapl);
             }
         } // end for
-    } // end try block
+    }     // end try block
 
-    catch (Exception& E)
-    {
+    catch (Exception &E) {
         issue_fail_msg("test_attr()", __LINE__, __FILE__, E.getCDetailMsg());
     }
-}   // test_attr()
+} // test_attr()
 
-
 /*-------------------------------------------------------------------------
  * Function:    cleanup_attr
  *
@@ -1950,8 +2007,8 @@ void test_attr()
  * Return       None
  *-------------------------------------------------------------------------
  */
-extern "C"
-void cleanup_attr()
+extern "C" void
+cleanup_attr()
 {
     HDremove(FILE_BASIC.c_str());
     HDremove(FILE_COMPOUND.c_str());
@@ -1960,4 +2017,3 @@ void cleanup_attr()
     HDremove(FILE_DTYPE.c_str());
     HDremove(FILE_CRTPROPS.c_str());
 }
-