Source formatted

1 files changed, 345 insertions, 383 deletions

diff --git a/c++/test/dsets.cpp b/c++/test/dsets.cpp
index 76e4424..0116d6c 100644
--- a/c++/test/dsets.cpp
+++ b/c++/test/dsets.cpp
@@ -32,29 +32,28 @@ 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    FILE1("dataset.h5");
-const H5std_string    DSET_DEFAULT_NAME("default");
-const H5std_string    DSET_DEFAULT_NAME_PATH("/default");
-const H5std_string    DSET_CHUNKED_NAME("chunked");
-const H5std_string    DSET_SIMPLE_IO_NAME("simple_io");
-const H5std_string    DSET_TCONV_NAME("tconv");
-const H5std_string    DSET_COMPRESS_NAME("compressed");
-const H5std_string    DSET_BOGUS_NAME("bogus");
+const H5std_string FILE1("dataset.h5");
+const H5std_string DSET_DEFAULT_NAME("default");
+const H5std_string DSET_DEFAULT_NAME_PATH("/default");
+const H5std_string DSET_CHUNKED_NAME("chunked");
+const H5std_string DSET_SIMPLE_IO_NAME("simple_io");
+const H5std_string DSET_TCONV_NAME("tconv");
+const H5std_string DSET_COMPRESS_NAME("compressed");
+const H5std_string DSET_BOGUS_NAME("bogus");
 
 /* Temporary filter IDs used for testing */
 const int H5Z_FILTER_BOGUS = 305;
 
-static size_t filter_bogus(unsigned int flags, size_t cd_nelmts,
-    const unsigned int *cd_values, size_t nbytes, size_t *buf_size, void **buf);
+static size_t filter_bogus(unsigned int flags, size_t cd_nelmts, const unsigned int *cd_values, size_t nbytes,
+                           size_t *buf_size, void **buf);
 // H5_ATTR_UNUSED variables caused warning, but taking them out caused failure.
 
-
 /*-------------------------------------------------------------------------
  * Function:    test_create
  *
@@ -68,7 +67,8 @@ static size_t filter_bogus(unsigned int flags, size_t cd_nelmts,
  *              Friday, January 5, 2001
  *-------------------------------------------------------------------------
  */
-static herr_t test_create( H5File& file)
+static herr_t
+test_create(H5File &file)
 {
     SUBTEST("Create, open, close");
 
@@ -76,19 +76,17 @@ static herr_t test_create( H5File& file)
     DataSet *dataset = NULL;
     try {
         // Create a data space
-        hsize_t     dims[2];
+        hsize_t dims[2];
         dims[0] = 256;
         dims[1] = 512;
-        DataSpace space (2, dims, NULL);
+        DataSpace space(2, dims, NULL);
 
         // Create a dataset using the default dataset creation properties.
         // We're not sure what they are, so we won't check.
-        dataset = new DataSet (file.createDataSet
-                (DSET_DEFAULT_NAME, PredType::NATIVE_DOUBLE, space));
-
+        dataset = new DataSet(file.createDataSet(DSET_DEFAULT_NAME, PredType::NATIVE_DOUBLE, space));
 
         // Add a comment to the dataset
-        file.setComment (DSET_DEFAULT_NAME, "This is a dataset");
+        file.setComment(DSET_DEFAULT_NAME, "This is a dataset");
 
         // Close the dataset
         delete dataset;
@@ -98,18 +96,19 @@ static herr_t test_create( H5File& file)
         // dataset can only be created once.  If an exception is not thrown for
         // this action by createDataSet, then throw an invalid action exception.
         try {
-            dataset = new DataSet (file.createDataSet
-                          (DSET_DEFAULT_NAME, PredType::NATIVE_DOUBLE, space));
+            dataset = new DataSet(file.createDataSet(DSET_DEFAULT_NAME, PredType::NATIVE_DOUBLE, 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 (FileIException& E)        // catching invalid creating dataset
-        {} // do nothing, exception expected
+        catch (FileIException &E) // catching invalid creating dataset
+        {
+        } // do nothing, exception expected
 
         // Open the dataset we created above and then close it.  This is one
         // way to open an existing dataset for accessing.
-        dataset = new DataSet (file.openDataSet (DSET_DEFAULT_NAME));
+        dataset = new DataSet(file.openDataSet(DSET_DEFAULT_NAME));
 
         // Get and verify the name of this dataset, using
         // H5std_string getObjName()
@@ -125,30 +124,31 @@ static herr_t test_create( H5File& file)
         delete dataset;
 
         // This is another way to open an existing dataset for accessing.
-        DataSet another_dataset(file.openDataSet (DSET_DEFAULT_NAME));
+        DataSet another_dataset(file.openDataSet(DSET_DEFAULT_NAME));
 
         // Try opening a non-existent dataset.  This should fail so if an
         // exception is not thrown for this action by openDataSet, then
         // display failure information and throw an exception.
         try {
-            dataset = new DataSet (file.openDataSet( "does_not_exist" ));
+            dataset = new DataSet(file.openDataSet("does_not_exist"));
 
             // continuation here, that means no exception has been thrown
             throw InvalidActionException("H5File::openDataSet", "Attempted to open a non-existent dataset");
         }
-        catch (FileIException& E ) // catching creating non-existent dataset
-        {} // do nothing, exception expected
+        catch (FileIException &E) // catching creating non-existent dataset
+        {
+        } // do nothing, exception expected
 
         // Create a new dataset that uses chunked storage instead of the default
         // layout.
         DSetCreatPropList create_parms;
-        hsize_t     csize[2];
+        hsize_t           csize[2];
         csize[0] = 5;
         csize[1] = 100;
-        create_parms.setChunk( 2, csize );
+        create_parms.setChunk(2, csize);
 
-        dataset = new DataSet (file.createDataSet(DSET_CHUNKED_NAME,
-                               PredType::NATIVE_DOUBLE, space, create_parms));
+        dataset =
+            new DataSet(file.createDataSet(DSET_CHUNKED_NAME, PredType::NATIVE_DOUBLE, space, create_parms));
         // Note: this one has no error message in C when failure occurs?
 
         // clean up and return with success
@@ -156,10 +156,9 @@ static herr_t test_create( H5File& file)
 
         PASSED();
         return 0;
-    }        // outer most try block
+    } // outer most try block
 
-    catch (InvalidActionException& E)
-    {
+    catch (InvalidActionException &E) {
         cerr << " FAILED" << endl;
         cerr << "    <<<  " << E.getDetailMsg() << "  >>>" << endl << endl;
 
@@ -169,8 +168,7 @@ static herr_t test_create( H5File& file)
         return -1;
     }
     // catch all other exceptions
-    catch (Exception& E)
-    {
+    catch (Exception &E) {
         issue_fail_msg("test_create", __LINE__, __FILE__);
 
         // clean up and return with failure
@@ -178,9 +176,8 @@ static herr_t test_create( H5File& file)
             delete dataset;
         return -1;
     }
-}   // test_create
+} // test_create
 
-
 /*-------------------------------------------------------------------------
  * Function:    test_simple_io
  *
@@ -196,75 +193,72 @@ static herr_t test_create( H5File& file)
  *              Friday, January 5, 2001
  *-------------------------------------------------------------------------
  */
-static herr_t test_simple_io( H5File& file)
+static herr_t
+test_simple_io(H5File &file)
 {
 
     SUBTEST("Simple I/O");
 
-    int        points[100][200];
-    int        check[100][200];
+    int points[100][200];
+    int check[100][200];
     int i, j, n;
 
     // Initialize the dataset
-    for (i = n = 0; i < 100; i++)
-    {
+    for (i = n = 0; i < 100; i++) {
         for (j = 0; j < 200; j++) {
             points[i][j] = n++;
         }
     }
 
-    char* tconv_buf = new char [1000];
-    try
-    {
+    char *tconv_buf = new char[1000];
+    try {
         // Create the data space
         hsize_t dims[2];
         dims[0] = 100;
         dims[1] = 200;
-        DataSpace space (2, dims, NULL);
+        DataSpace space(2, dims, NULL);
 
         // Create a small conversion buffer to test strip mining
         DSetMemXferPropList xfer;
 
-        xfer.setBuffer (1000, tconv_buf, NULL);
+        xfer.setBuffer(1000, tconv_buf, NULL);
 
         // Create the dataset
-        DataSet dataset (file.createDataSet (DSET_SIMPLE_IO_NAME, PredType::NATIVE_INT, space));
+        DataSet dataset(file.createDataSet(DSET_SIMPLE_IO_NAME, PredType::NATIVE_INT, space));
 
         // Write the data to the dataset
-        dataset.write(static_cast<void*>(points), PredType::NATIVE_INT, DataSpace::ALL, DataSpace::ALL, xfer);
+        dataset.write(static_cast<void *>(points), PredType::NATIVE_INT, DataSpace::ALL, DataSpace::ALL,
+                      xfer);
 
         // Read the dataset back
-        dataset.read (static_cast<void*>(check), PredType::NATIVE_INT, DataSpace::ALL, DataSpace::ALL, xfer);
+        dataset.read(static_cast<void *>(check), PredType::NATIVE_INT, DataSpace::ALL, DataSpace::ALL, xfer);
 
         // Check that the values read are the same as the values written
         for (i = 0; i < 100; i++)
-            for (j = 0; j < 200; j++)
-            {
-                int status = check_values (i, j, points[i][j], check[i][j]);
+            for (j = 0; j < 200; j++) {
+                int status = check_values(i, j, points[i][j], check[i][j]);
                 if (status == -1)
                     throw Exception("DataSet::read");
             }
 
         // clean up and return with success
-        delete [] tconv_buf;
+        delete[] tconv_buf;
         PASSED();
         return 0;
-    }  // end try
+    } // end try
 
     // catch all dataset, space, plist exceptions
-    catch (Exception& E)
-    {
+    catch (Exception &E) {
         cerr << " FAILED" << endl;
         cerr << "    <<<  " << E.getDetailMsg() << "  >>>" << endl << endl;
 
         // clean up and return with failure
         if (tconv_buf)
-            delete [] tconv_buf;
+            delete[] tconv_buf;
         return -1;
     }
-}   // test_simple_io
+} // test_simple_io
 
-
 /*-------------------------------------------------------------------------
  * Function:    test_datasize
  *
@@ -278,25 +272,24 @@ static herr_t test_simple_io( H5File& file)
  *              Thursday, March 22, 2012
  *-------------------------------------------------------------------------
  */
-static herr_t test_datasize(FileAccPropList &fapl)
+static herr_t
+test_datasize(FileAccPropList &fapl)
 {
     SUBTEST("DataSet::getInMemDataSize()");
-    try
-    {
+    try {
         // Open FILE1.
         H5File file(FILE1, H5F_ACC_RDWR, FileCreatPropList::DEFAULT, fapl);
 
         // Open dataset DSET_SIMPLE_IO_NAME.
-        DataSet dset = file.openDataSet (DSET_SIMPLE_IO_NAME);
+        DataSet dset = file.openDataSet(DSET_SIMPLE_IO_NAME);
 
         // Get the dataset's dataspace to calculate the size for verification.
         DataSpace space(dset.getSpace());
 
         // Get the dimension sizes.
         hsize_t dims[2];
-        int n_dims = space.getSimpleExtentDims(dims);
-        if (n_dims < 0)
-        {
+        int     n_dims = space.getSimpleExtentDims(dims);
+        if (n_dims < 0) {
             throw Exception("test_compression", "DataSpace::getSimpleExtentDims() failed");
         }
 
@@ -308,8 +301,7 @@ static herr_t test_datasize(FileAccPropList &fapl)
         size_t ds_size = dset.getInMemDataSize();
 
         // Verify the data size.
-        if (ds_size != expected_size)
-        {
+        if (ds_size != expected_size) {
             H5_FAILED();
             cerr << " Expected data size = " << expected_size;
             cerr << " but dset.getInMemDataSize() returned " << ds_size << endl;
@@ -318,19 +310,17 @@ static herr_t test_datasize(FileAccPropList &fapl)
 
         PASSED();
         return 0;
-    }  // end try
+    } // end try
 
     // catch all dataset, space, plist exceptions
-    catch (Exception& E)
-    {
+    catch (Exception &E) {
         cerr << " FAILED" << endl;
         cerr << "    <<<  " << E.getDetailMsg() << "  >>>" << endl << endl;
 
         return -1;
     }
-}   // test_datasize
+} // test_datasize
 
-
 /*-------------------------------------------------------------------------
  * Function:    test_tconv
  *
@@ -344,84 +334,79 @@ static herr_t test_datasize(FileAccPropList &fapl)
  *              Friday, January 5, 2001
  *-------------------------------------------------------------------------
  */
-static herr_t test_tconv(H5File& file)
+static herr_t
+test_tconv(H5File &file)
 {
     // Prepare buffers for input/output
-    char        *out=NULL, *in=NULL;
-    out = new char [4*1000000];
+    char *out = NULL, *in = NULL;
+    out = new char[4 * 1000000];
     // assert (out); - should use exception handler for new - BMR
-    in = new char [4*1000000];
-    //assert (in);
+    in = new char[4 * 1000000];
+    // assert (in);
 
     SUBTEST("Data type conversion");
 
     // Initialize the dataset
     for (int i = 0; i < 1000000; i++) {
-        out[i*4+0] = 0x11;
-        out[i*4+1] = 0x22;
-        out[i*4+2] = 0x33;
-        out[i*4+3] = 0x44;
+        out[i * 4 + 0] = 0x11;
+        out[i * 4 + 1] = 0x22;
+        out[i * 4 + 2] = 0x33;
+        out[i * 4 + 3] = 0x44;
     }
 
-    try
-    {
+    try {
         // Create the data space
         hsize_t dims[1];
         dims[0] = 1000000;
-        DataSpace space (1, dims, NULL);
+        DataSpace space(1, dims, NULL);
 
         // Create the data set
-        DataSet dataset (file.createDataSet (DSET_TCONV_NAME, PredType::STD_I32LE, space));
+        DataSet dataset(file.createDataSet(DSET_TCONV_NAME, PredType::STD_I32LE, space));
 
         // Write the data to the dataset
-        dataset.write (static_cast<void*>(out), PredType::STD_I32LE);
+        dataset.write(static_cast<void *>(out), PredType::STD_I32LE);
 
         // Read data with byte order conversion
-        dataset.read (static_cast<void*>(in), PredType::STD_I32BE);
+        dataset.read(static_cast<void *>(in), PredType::STD_I32BE);
 
         // Check
         for (int i = 0; i < 1000000; i++) {
-            if (in[4*i+0]!=out[4*i+3] ||
-                in[4*i+1]!=out[4*i+2] ||
-                in[4*i+2]!=out[4*i+1] ||
-                in[4*i+3]!=out[4*i+0])
-            {
+            if (in[4 * i + 0] != out[4 * i + 3] || in[4 * i + 1] != out[4 * i + 2] ||
+                in[4 * i + 2] != out[4 * i + 1] || in[4 * i + 3] != out[4 * i + 0]) {
                 throw Exception("DataSet::read", "Read with byte order conversion failed");
             }
         }
 
         // clean up and return with success
-        delete [] out;
-        delete [] in;
+        delete[] out;
+        delete[] in;
         PASSED();
         return 0;
-    }  // end try
+    } // end try
 
     // catch all dataset and space exceptions
-    catch (Exception& E)
-    {
+    catch (Exception &E) {
         cerr << " FAILED" << endl;
         cerr << "    <<<  " << E.getDetailMsg() << "  >>>" << endl << endl;
 
         // clean up and return with failure
-        delete [] out;
-        delete [] in;
+        delete[] out;
+        delete[] in;
         return -1;
     }
-}   // test_tconv
+} // test_tconv
 
 /* This message derives from H5Z */
 const H5Z_class2_t H5Z_BOGUS[1] = {{
-    H5Z_CLASS_T_VERS,           /* H5Z_class_t version number   */
-    H5Z_FILTER_BOGUS,           /* Filter id number             */
-    1, 1,                       /* Encode and decode enabled    */
-    "bogus",                    /* Filter name for debugging        */
-    NULL,                       /* The "can apply" callback     */
-    NULL,                       /* The "set local" callback     */
-    (H5Z_func_t)filter_bogus,   /* The actual filter function        */
+    H5Z_CLASS_T_VERS,         /* H5Z_class_t version number   */
+    H5Z_FILTER_BOGUS,         /* Filter id number             */
+    1, 1,                     /* Encode and decode enabled    */
+    "bogus",                  /* Filter name for debugging        */
+    NULL,                     /* The "can apply" callback     */
+    NULL,                     /* The "set local" callback     */
+    (H5Z_func_t)filter_bogus, /* The actual filter function        */
 }};
 
-
 /*-------------------------------------------------------------------------
  * Function:    bogus
  *
@@ -435,15 +420,14 @@ const H5Z_class2_t H5Z_BOGUS[1] = {{
  *              Tuesday, April 21, 1998
  *-------------------------------------------------------------------------
  */
-static size_t filter_bogus(unsigned int flags, size_t cd_nelmts,
-      const unsigned int cd_values[], size_t nbytes,
-      size_t *buf_size, void **buf)
+static size_t
+filter_bogus(unsigned int flags, size_t cd_nelmts, const unsigned int cd_values[], size_t nbytes,
+             size_t *buf_size, void **buf)
 // H5_ATTR_UNUSED variables caused warning, but taking them out caused failure.
 {
     return nbytes;
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:    test_compression
  *
@@ -460,28 +444,27 @@ static size_t filter_bogus(unsigned int flags, size_t cd_nelmts,
  *              Friday, January 5, 2001
  *-------------------------------------------------------------------------
  */
-static herr_t test_compression(H5File& file)
+static herr_t
+test_compression(H5File &file)
 {
 #ifndef H5_HAVE_FILTER_DEFLATE
     const char *not_supported;
     not_supported = "    Deflate compression is not enabled.";
 #endif /* H5_HAVE_FILTER_DEFLATE */
-    int points[100][200];
-    int check[100][200];
-    hsize_t        i, j, n;
+    int     points[100][200];
+    int     check[100][200];
+    hsize_t i, j, n;
 
     // Initialize the dataset
-    for (i = n = 0; i < 100; i++)
-    {
+    for (i = n = 0; i < 100; i++) {
         for (j = 0; j < 200; j++) {
             points[i][j] = static_cast<int>(n++);
         }
     }
 
-    char* tconv_buf = new char [1000];
-    DataSet* dataset = NULL;
-    try
-    {
+    char *   tconv_buf = new char[1000];
+    DataSet *dataset   = NULL;
+    try {
         const hsize_t size[2] = {100, 200};
         // Create the data space
         DataSpace space1(2, size, NULL);
@@ -489,39 +472,39 @@ static herr_t test_compression(H5File& file)
         // Create a small conversion buffer to test strip mining
         DSetMemXferPropList xfer;
 
-        xfer.setBuffer (1000, tconv_buf, NULL);
+        xfer.setBuffer(1000, tconv_buf, NULL);
 
         // Use chunked storage with compression
         DSetCreatPropList dscreatplist;
 
         const hsize_t chunk_size[2] = {2, 25};
-        dscreatplist.setChunk (2, chunk_size);
-        dscreatplist.setDeflate (6);
+        dscreatplist.setChunk(2, chunk_size);
+        dscreatplist.setDeflate(6);
 
 #ifdef H5_HAVE_FILTER_DEFLATE
         SUBTEST("Compression (setup)");
 
         // Create the dataset
-        dataset = new DataSet (file.createDataSet
-            (DSET_COMPRESS_NAME, PredType::NATIVE_INT, space1, dscreatplist));
+        dataset =
+            new DataSet(file.createDataSet(DSET_COMPRESS_NAME, PredType::NATIVE_INT, space1, dscreatplist));
 
         PASSED();
 
         /*----------------------------------------------------------------------
-        * STEP 1: Read uninitialized data.  It should be zero.
-        *----------------------------------------------------------------------
-        */
+         * STEP 1: Read uninitialized data.  It should be zero.
+         *----------------------------------------------------------------------
+         */
         SUBTEST("Compression (uninitialized read)");
 
-        dataset->read (static_cast<void*>(check), PredType::NATIVE_INT, DataSpace::ALL, DataSpace::ALL, xfer);
+        dataset->read(static_cast<void *>(check), PredType::NATIVE_INT, DataSpace::ALL, DataSpace::ALL, xfer);
 
-        for (i=0; i<size[0]; i++) {
-            for (j=0; j<size[1]; j++) {
-                if (0!=check[i][j]) {
+        for (i = 0; i < size[0]; i++) {
+            for (j = 0; j < size[1]; j++) {
+                if (0 != check[i][j]) {
                     H5_FAILED();
                     cerr << "    Read a non-zero value." << endl;
-                    cerr << "    At index " << static_cast<unsigned long>(i)
-                         << "," << static_cast<unsigned long>(j) << endl;
+                    cerr << "    At index " << static_cast<unsigned long>(i) << ","
+                         << static_cast<unsigned long>(j) << endl;
                     throw Exception("test_compression", "Failed in uninitialized read");
                 }
             }
@@ -529,38 +512,36 @@ static herr_t test_compression(H5File& file)
         PASSED();
 
         /*----------------------------------------------------------------------
-        * STEP 2: Test compression by setting up a chunked dataset and writing
-        * to it.
-        *----------------------------------------------------------------------
-        */
+         * STEP 2: Test compression by setting up a chunked dataset and writing
+         * to it.
+         *----------------------------------------------------------------------
+         */
         SUBTEST("Compression (write)");
 
-        for (i=n=0; i<size[0]; i++)
-        {
-            for (j=0; j<size[1]; j++)
-            {
+        for (i = n = 0; i < size[0]; i++) {
+            for (j = 0; j < size[1]; j++) {
                 points[i][j] = static_cast<int>(n++);
             }
         }
 
-        dataset->write (static_cast<void*>(points), PredType::NATIVE_INT, DataSpace::ALL, DataSpace::ALL, xfer);
+        dataset->write(static_cast<void *>(points), PredType::NATIVE_INT, DataSpace::ALL, DataSpace::ALL,
+                       xfer);
 
         PASSED();
 
         /*----------------------------------------------------------------------
-        * STEP 3: Try to read the data we just wrote.
-        *----------------------------------------------------------------------
-        */
+         * STEP 3: Try to read the data we just wrote.
+         *----------------------------------------------------------------------
+         */
         SUBTEST("Compression (read)");
 
         // Read the dataset back
-        dataset->read (static_cast<void*>(check), PredType::NATIVE_INT, DataSpace::ALL, DataSpace::ALL, xfer);
+        dataset->read(static_cast<void *>(check), PredType::NATIVE_INT, DataSpace::ALL, DataSpace::ALL, xfer);
 
         // Check that the values read are the same as the values written
         for (i = 0; i < size[0]; i++)
-            for (j = 0; j < size[1]; j++)
-            {
-                int status = check_values (i, j, points[i][j], check[i][j]);
+            for (j = 0; j < size[1]; j++) {
+                int status = check_values(i, j, points[i][j], check[i][j]);
                 if (status == -1)
                     throw Exception("test_compression", "Failed in read");
             }
@@ -568,31 +549,29 @@ static herr_t test_compression(H5File& file)
         PASSED();
 
         /*----------------------------------------------------------------------
-        * STEP 4: Write new data over the top of the old data.  The new data is
-        * random thus not very compressible, and will cause the chunks to move
-        * around as they grow.  We only change values for the left half of the
-        * dataset although we rewrite the whole thing.
-        *----------------------------------------------------------------------
-        */
+         * STEP 4: Write new data over the top of the old data.  The new data is
+         * random thus not very compressible, and will cause the chunks to move
+         * around as they grow.  We only change values for the left half of the
+         * dataset although we rewrite the whole thing.
+         *----------------------------------------------------------------------
+         */
         SUBTEST("Compression (modify)");
 
-        for (i=0; i<size[0]; i++)
-        {
-            for (j=0; j<size[1]/2; j++)
-            {
-                    points[i][j] = rand ();
+        for (i = 0; i < size[0]; i++) {
+            for (j = 0; j < size[1] / 2; j++) {
+                points[i][j] = rand();
             }
         }
-        dataset->write (static_cast<void*>(points), PredType::NATIVE_INT, DataSpace::ALL, DataSpace::ALL, xfer);
+        dataset->write(static_cast<void *>(points), PredType::NATIVE_INT, DataSpace::ALL, DataSpace::ALL,
+                       xfer);
 
         // Read the dataset back and check it
-        dataset->read (static_cast<void*>(check), PredType::NATIVE_INT, DataSpace::ALL, DataSpace::ALL, xfer);
+        dataset->read(static_cast<void *>(check), PredType::NATIVE_INT, DataSpace::ALL, DataSpace::ALL, xfer);
 
         // Check that the values read are the same as the values written
         for (i = 0; i < size[0]; i++)
-            for (j = 0; j < size[1]; j++)
-            {
-                int status = check_values (i, j, points[i][j], check[i][j]);
+            for (j = 0; j < size[1]; j++) {
+                int status = check_values(i, j, points[i][j], check[i][j]);
                 if (status == -1)
                     throw Exception("test_compression", "Failed in modify");
             }
@@ -600,66 +579,65 @@ static herr_t test_compression(H5File& file)
         PASSED();
 
         /*----------------------------------------------------------------------
-        * STEP 5: Close the dataset and then open it and read it again.  This
-        * insures that the compression message is picked up properly from the
-        * object header.
-        *----------------------------------------------------------------------
-        */
+         * STEP 5: Close the dataset and then open it and read it again.  This
+         * insures that the compression message is picked up properly from the
+         * object header.
+         *----------------------------------------------------------------------
+         */
         SUBTEST("Compression (re-open)");
 
         // close this dataset to reuse the var
         delete dataset;
 
-        dataset = new DataSet (file.openDataSet (DSET_COMPRESS_NAME));
-        dataset->read (static_cast<void*>(check), PredType::NATIVE_INT, DataSpace::ALL, DataSpace::ALL, xfer);
+        dataset = new DataSet(file.openDataSet(DSET_COMPRESS_NAME));
+        dataset->read(static_cast<void *>(check), PredType::NATIVE_INT, DataSpace::ALL, DataSpace::ALL, xfer);
 
         // Check that the values read are the same as the values written
         for (i = 0; i < size[0]; i++)
-            for (j = 0; j < size[1]; j++)
-            {
-                int status = check_values (i, j, points[i][j], check[i][j]);
+            for (j = 0; j < size[1]; j++) {
+                int status = check_values(i, j, points[i][j], check[i][j]);
                 if (status == -1)
                     throw Exception("test_compression", "Failed in re-open");
             }
 
         PASSED();
 
-
         /*----------------------------------------------------------------------
-        * STEP 6: Test partial I/O by writing to and then reading from a
-        * hyperslab of the dataset.  The hyperslab does not line up on chunk
-        * boundaries (we know that case already works from above tests).
-        *----------------------------------------------------------------------
-        */
+         * STEP 6: Test partial I/O by writing to and then reading from a
+         * hyperslab of the dataset.  The hyperslab does not line up on chunk
+         * boundaries (we know that case already works from above tests).
+         *----------------------------------------------------------------------
+         */
         SUBTEST("Compression (partial I/O)");
 
-        const hsize_t hs_size[2] = {4, 50};
+        const hsize_t hs_size[2]   = {4, 50};
         const hsize_t hs_offset[2] = {7, 30};
         for (i = 0; i < hs_size[0]; i++) {
             for (j = 0; j < hs_size[1]; j++) {
-                points[hs_offset[0]+i][hs_offset[1]+j] = rand ();
+                points[hs_offset[0] + i][hs_offset[1] + j] = rand();
             }
         }
-        space1.selectHyperslab( H5S_SELECT_SET, hs_size, hs_offset );
-        dataset->write (static_cast<void*>(points), PredType::NATIVE_INT, space1, space1, xfer);
-        dataset->read (static_cast<void*>(check), PredType::NATIVE_INT, space1, space1, xfer);
+        space1.selectHyperslab(H5S_SELECT_SET, hs_size, hs_offset);
+        dataset->write(static_cast<void *>(points), PredType::NATIVE_INT, space1, space1, xfer);
+        dataset->read(static_cast<void *>(check), PredType::NATIVE_INT, space1, space1, xfer);
 
         // Check that the values read are the same as the values written
-        for (i=0; i<hs_size[0]; i++) {
-        for (j=0; j<hs_size[1]; j++) {
-            if (points[hs_offset[0]+i][hs_offset[1]+j] !=
-                check[hs_offset[0]+i][hs_offset[1]+j]) {
-                H5_FAILED();
-                cerr << "    Read different values than written.\n" << endl;
-                cerr << "    At index " << static_cast<unsigned long>((hs_offset[0]+i)) <<
-                    "," << static_cast<unsigned long>((hs_offset[1]+j)) << endl;
-
-                cerr << "    At original: " << static_cast<int>(points[hs_offset[0]+i][hs_offset[1]+j]) << endl;
-                cerr << "    At returned: " << static_cast<int>(check[hs_offset[0]+i][hs_offset[1]+j]) << endl;
-                throw Exception("test_compression", "Failed in partial I/O");
-            }
-        } // for j
-        } // for i
+        for (i = 0; i < hs_size[0]; i++) {
+            for (j = 0; j < hs_size[1]; j++) {
+                if (points[hs_offset[0] + i][hs_offset[1] + j] != check[hs_offset[0] + i][hs_offset[1] + j]) {
+                    H5_FAILED();
+                    cerr << "    Read different values than written.\n" << endl;
+                    cerr << "    At index " << static_cast<unsigned long>((hs_offset[0] + i)) << ","
+                         << static_cast<unsigned long>((hs_offset[1] + j)) << endl;
+
+                    cerr << "    At original: "
+                         << static_cast<int>(points[hs_offset[0] + i][hs_offset[1] + j]) << endl;
+                    cerr << "    At returned: " << static_cast<int>(check[hs_offset[0] + i][hs_offset[1] + j])
+                         << endl;
+                    throw Exception("test_compression", "Failed in partial I/O");
+                }
+            } // for j
+        }     // for i
 
         delete dataset;
         dataset = NULL;
@@ -673,29 +651,30 @@ static herr_t test_compression(H5File& file)
 #endif
 
         /*----------------------------------------------------------------------
-        * STEP 7: Register an application-defined compression method and use it
-        * to write and then read the dataset.
-        *----------------------------------------------------------------------
-        */
+         * STEP 7: Register an application-defined compression method and use it
+         * to write and then read the dataset.
+         *----------------------------------------------------------------------
+         */
         SUBTEST("Compression (app-defined method)");
 
-        if (H5Zregister (H5Z_BOGUS)<0)
-                throw Exception("test_compression", "Failed in app-defined method");
-        if (H5Pset_filter (dscreatplist.getId(), H5Z_FILTER_BOGUS, 0, 0, NULL)<0)
+        if (H5Zregister(H5Z_BOGUS) < 0)
+            throw Exception("test_compression", "Failed in app-defined method");
+        if (H5Pset_filter(dscreatplist.getId(), H5Z_FILTER_BOGUS, 0, 0, NULL) < 0)
             throw Exception("test_compression", "Failed in app-defined method");
-        dscreatplist.setFilter (H5Z_FILTER_BOGUS, 0, 0, NULL);
+        dscreatplist.setFilter(H5Z_FILTER_BOGUS, 0, 0, NULL);
 
-        DataSpace space2 (2, size, NULL);
-        dataset = new DataSet (file.createDataSet (DSET_BOGUS_NAME, PredType::NATIVE_INT, space2, dscreatplist));
+        DataSpace space2(2, size, NULL);
+        dataset =
+            new DataSet(file.createDataSet(DSET_BOGUS_NAME, PredType::NATIVE_INT, space2, dscreatplist));
 
-        dataset->write (static_cast<void*>(points), PredType::NATIVE_INT, DataSpace::ALL, DataSpace::ALL, xfer);
-        dataset->read (static_cast<void*>(check), PredType::NATIVE_INT, DataSpace::ALL, DataSpace::ALL, xfer);
+        dataset->write(static_cast<void *>(points), PredType::NATIVE_INT, DataSpace::ALL, DataSpace::ALL,
+                       xfer);
+        dataset->read(static_cast<void *>(check), PredType::NATIVE_INT, DataSpace::ALL, DataSpace::ALL, xfer);
 
         // Check that the values read are the same as the values written
         for (i = 0; i < size[0]; i++)
-            for (j = 0; j < size[1]; j++)
-            {
-                int status = check_values (i, j, points[i][j], check[i][j]);
+            for (j = 0; j < size[1]; j++) {
+                int status = check_values(i, j, points[i][j], check[i][j]);
                 if (status == -1)
                     throw Exception("test_compression", "Failed in app-defined method");
             }
@@ -703,17 +682,16 @@ static herr_t test_compression(H5File& file)
         PASSED();
 
         /*----------------------------------------------------------------------
-        * Cleanup
-        *----------------------------------------------------------------------
-        */
+         * Cleanup
+         *----------------------------------------------------------------------
+         */
         delete dataset;
-        delete [] tconv_buf;
+        delete[] tconv_buf;
         return 0;
     } // end try
 
     // catch all dataset, file, space, and plist exceptions
-    catch (Exception& E)
-    {
+    catch (Exception &E) {
         cerr << " FAILED" << endl;
         cerr << "    <<<  " << E.getDetailMsg() << "  >>>" << endl << endl;
 
@@ -721,12 +699,11 @@ static herr_t test_compression(H5File& file)
         if (dataset != NULL)
             delete dataset;
         if (tconv_buf)
-            delete [] tconv_buf;
+            delete[] tconv_buf;
         return -1;
     }
-}   // test_compression
+} // test_compression
 
-
 /*-------------------------------------------------------------------------
  * Function:    test_nbit_methods
  *
@@ -742,18 +719,19 @@ static herr_t test_compression(H5File& file)
  *-------------------------------------------------------------------------
  */
 const H5std_string DSET_NBIT_NAME("nbit_dataset");
-const hsize_t DIM1 = 2;
-const hsize_t DIM2 = 5;
+const hsize_t      DIM1 = 2;
+const hsize_t      DIM2 = 5;
 
-static herr_t test_nbit_compression(H5File& file)
+static herr_t
+test_nbit_compression(H5File &file)
 {
     typedef struct {
-        int i;
-        char c;
+        int   i;
+        char  c;
         short s;
     } s1_t;
 
-    const hsize_t size[2] = {DIM1, DIM2};
+    const hsize_t size[2]       = {DIM1, DIM2};
     const hsize_t chunk_size[2] = {DIM1, DIM2};
     s1_t          orig_data[DIM1][DIM2];
     s1_t          new_data[DIM1][DIM2];
@@ -761,8 +739,7 @@ static herr_t test_nbit_compression(H5File& file)
 
     SUBTEST("N-bit compression (setup)");
 
-    try
-    {
+    try {
         // Define datatypes of members of compound datatype
         IntType i_type(PredType::NATIVE_INT);
         IntType c_type(PredType::NATIVE_CHAR);
@@ -781,7 +758,7 @@ static herr_t test_nbit_compression(H5File& file)
         mem_cmpd.insertMember("s", HOFFSET(s1_t, s), s_type);
 
         // Set order of dataset compound datatype
-        //cmpd.setOrder(H5T_ORDER_BE); only for atomic type?
+        // cmpd.setOrder(H5T_ORDER_BE); only for atomic type?
 
         // Create the data space
         DataSpace space(2, size);
@@ -796,36 +773,33 @@ static herr_t test_nbit_compression(H5File& file)
 
         // Initialize data, assuming size of long long >= size of member datatypes
         for (i = 0; i < size[0]; i++)
-            for (j = 0; j < size[1]; j++)
-            {
+            for (j = 0; j < size[1]; j++) {
                 orig_data[i][j].i = static_cast<int>(i * j);
                 orig_data[i][j].c = static_cast<char>('a' + i);
                 orig_data[i][j].s = static_cast<short>(i + j);
 
                 // Some even-numbered integer values are negative
-                if ((i*size[1]+j+1)%2 == 0) {
+                if ((i * size[1] + j + 1) % 2 == 0) {
                     orig_data[i][j].i = -orig_data[i][j].i;
                     orig_data[i][j].s = static_cast<short>(-orig_data[i][j].s);
                 }
             }
 
         // Write to the dataset
-        dataset.write(static_cast<void*>(orig_data), mem_cmpd);
+        dataset.write(static_cast<void *>(orig_data), mem_cmpd);
 
         // Read the dataset back */
-        dataset.read(static_cast<void*>(new_data), mem_cmpd);
+        dataset.read(static_cast<void *>(new_data), mem_cmpd);
 
         // Check that the values read are the same as the values written.
         for (i = 0; i < size[0]; i++)
-            for (j = 0; j < size[1]; j++)
-            {
-                if((new_data[i][j].i != orig_data[i][j].i) ||
-                   (new_data[i][j].c != orig_data[i][j].c) ||
-                   (new_data[i][j].s != orig_data[i][j].s))
-                {
+            for (j = 0; j < size[1]; j++) {
+                if ((new_data[i][j].i != orig_data[i][j].i) || (new_data[i][j].c != orig_data[i][j].c) ||
+                    (new_data[i][j].s != orig_data[i][j].s)) {
                     H5_FAILED();
                     printf("    Read different values than written.\n");
-                    printf("    At index %lu,%lu\n", static_cast<unsigned long>(i), static_cast<unsigned long>(j));
+                    printf("    At index %lu,%lu\n", static_cast<unsigned long>(i),
+                           static_cast<unsigned long>(j));
                 }
             }
 
@@ -834,8 +808,7 @@ static herr_t test_nbit_compression(H5File& file)
     } // end try block
 
     // catch all dataset, file, space, and plist exceptions
-    catch (Exception& E)
-    {
+    catch (Exception &E) {
         cerr << " FAILED" << endl;
         cerr << "    <<<  " << E.getDetailMsg() << "  >>>" << endl << endl;
 
@@ -843,7 +816,6 @@ static herr_t test_nbit_compression(H5File& file)
     }
 } // test_nbit_compression
 
-
 /*-------------------------------------------------------------------------
  * Function:    test_multiopen
  *
@@ -860,12 +832,13 @@ static herr_t test_nbit_compression(H5File& file)
  *              Saturday, February 17, 2001
  *-------------------------------------------------------------------------
  */
-static herr_t test_multiopen (H5File& file)
+static herr_t
+test_multiopen(H5File &file)
 {
 
     SUBTEST("Multi-open with extending");
 
-    DataSpace* space = NULL;
+    DataSpace *space = NULL;
     try {
 
         // Create a dataset creation property list
@@ -873,17 +846,17 @@ static herr_t test_multiopen (H5File& file)
 
         // Set chunk size to given size
         hsize_t cur_size[1] = {10};
-        dcpl.setChunk (1, cur_size);
+        dcpl.setChunk(1, cur_size);
 
         // Create a simple data space with unlimited size
         hsize_t max_size[1] = {H5S_UNLIMITED};
-        space = new DataSpace (1, cur_size, max_size);
+        space               = new DataSpace(1, cur_size, max_size);
 
         // Create first dataset
-        DataSet dset1 = file.createDataSet ("multiopen", PredType::NATIVE_INT, *space, dcpl);
+        DataSet dset1 = file.createDataSet("multiopen", PredType::NATIVE_INT, *space, dcpl);
 
         // Open again the first dataset from the file to another DataSet object.
-        DataSet dset2 = file.openDataSet ("multiopen");
+        DataSet dset2 = file.openDataSet("multiopen");
 
         // Relieve the dataspace
         delete space;
@@ -891,18 +864,16 @@ static herr_t test_multiopen (H5File& file)
 
         // Extend the dimensionality of the first dataset
         cur_size[0] = 20;
-        dset1.extend (cur_size);
+        dset1.extend(cur_size);
 
         // Get the size from the second handle
-        space = new DataSpace (dset2.getSpace());
+        space = new DataSpace(dset2.getSpace());
 
         hsize_t tmp_size[1];
-        space->getSimpleExtentDims (tmp_size);
-        if (cur_size[0]!=tmp_size[0])
-        {
-            cerr << "    Got " << static_cast<int>(tmp_size[0])
-                 << " instead of " << static_cast<int>(cur_size[0])
-                 << "!" << endl;
+        space->getSimpleExtentDims(tmp_size);
+        if (cur_size[0] != tmp_size[0]) {
+            cerr << "    Got " << static_cast<int>(tmp_size[0]) << " instead of "
+                 << static_cast<int>(cur_size[0]) << "!" << endl;
             throw Exception("test_multiopen", "Failed in multi-open with extending");
         }
 
@@ -913,8 +884,7 @@ static herr_t test_multiopen (H5File& file)
     } // end try block
 
     // catch all dataset, file, space, and plist exceptions
-    catch (Exception& E)
-    {
+    catch (Exception &E) {
         cerr << " FAILED" << endl;
         cerr << "    <<<  " << E.getDetailMsg() << "  >>>" << endl << endl;
 
@@ -923,9 +893,8 @@ static herr_t test_multiopen (H5File& file)
             delete space;
         return -1;
     }
-}   // test_multiopen
+} // test_multiopen
 
-
 /*-------------------------------------------------------------------------
  * Function:    test_types
  *
@@ -939,24 +908,25 @@ static herr_t test_multiopen (H5File& file)
  *              February 17, 2001
  *-------------------------------------------------------------------------
  */
-static herr_t test_types(H5File& file)
+static herr_t
+test_types(H5File &file)
 {
     SUBTEST("Various datatypes");
 
-    size_t i;
-    DataSet* dset = NULL;
+    size_t   i;
+    DataSet *dset = NULL;
     try {
 
         // Create a group in the file that was passed in from the caller
-        Group grp = file.createGroup ("typetests");
+        Group grp = file.createGroup("typetests");
 
         /* bitfield_1 */
         unsigned char buf[32];
-        hsize_t nelmts = sizeof(buf);
-        DataType type;
+        hsize_t       nelmts = sizeof(buf);
+        DataType      type;
         try { // block of bitfield_1
             // test copying a predefined type
-            type.copy (PredType::STD_B8LE);
+            type.copy(PredType::STD_B8LE);
 
             // Test copying a user-defined type using DataType::copy
             DataType copied_type;
@@ -967,7 +937,7 @@ static herr_t test_types(H5File& file)
             another_copied_type = type;
 
             // Test copying a user-defined int type using DataType::operator=
-            IntType orig_int(PredType::STD_B8LE);
+            IntType  orig_int(PredType::STD_B8LE);
             DataType generic_type;
             generic_type = orig_int;
 
@@ -978,45 +948,45 @@ static herr_t test_types(H5File& file)
             IntType another_int_type;
             another_int_type = new_int_type;
 
-            DataSpace space (1, &nelmts);
+            DataSpace space(1, &nelmts);
             dset = new DataSet(grp.createDataSet("bitfield_1", type, space));
 
             // Fill buffer
-            for (i=0; i<sizeof buf; i++)
-                    buf[i] = static_cast<unsigned char>(0xff) ^ static_cast<unsigned char>(i);
+            for (i = 0; i < sizeof buf; i++)
+                buf[i] = static_cast<unsigned char>(0xff) ^ static_cast<unsigned char>(i);
 
             // Write data from buf using all default dataspaces and property list
-            dset->write (buf, type);
+            dset->write(buf, type);
 
             // no failure in bitfield_1, close this dataset
             delete dset;
         } // end try block of bitfield_1
 
         // catch exceptions thrown in try block of bitfield_1
-        catch (Exception& E)
-        {
+        catch (Exception &E) {
             cerr << " FAILED" << endl;
-            cerr << "    <<<  " << "bitfield_1: " << E.getFuncName()
-                 << " - " << E.getDetailMsg() << "  >>>" << endl << endl;
+            cerr << "    <<<  "
+                 << "bitfield_1: " << E.getFuncName() << " - " << E.getDetailMsg() << "  >>>" << endl
+                 << endl;
             if (dset != NULL)
                 delete dset;
             return -1;
         }
 
         /* bitfield_2 */
-        nelmts = sizeof(buf)/2;
+        nelmts = sizeof(buf) / 2;
         try { // bitfield_2 block
-            type.copy (PredType::STD_B16LE);
-            DataSpace space (1, &nelmts);
+            type.copy(PredType::STD_B16LE);
+            DataSpace space(1, &nelmts);
             dset = new DataSet(grp.createDataSet("bitfield_2", type, space));
 
             // Fill buffer
-            for (i=0; i<sizeof(buf); i++)
+            for (i = 0; i < sizeof(buf); i++)
                 buf[i] = static_cast<unsigned char>(0xff) ^ static_cast<unsigned char>(i);
 
             // Write data from buf using all default dataspaces and property
             // list; if writing fails, deallocate dset and return.
-            dset->write (buf, type);
+            dset->write(buf, type);
 
             // no failure in bitfield_2, close this dataset and reset for
             // variable reuse
@@ -1025,44 +995,46 @@ static herr_t test_types(H5File& file)
         } // end try block of bitfield_2
 
         // catch exceptions thrown in try block of bitfield_2
-        catch (Exception& E)
-        {
+        catch (Exception &E) {
             cerr << " FAILED" << endl;
-            cerr << "    <<<  " << "bitfield_2: " << E.getFuncName()
-                 << " - " << E.getDetailMsg() << "  >>>" << endl << endl;
+            cerr << "    <<<  "
+                 << "bitfield_2: " << E.getFuncName() << " - " << E.getDetailMsg() << "  >>>" << endl
+                 << endl;
             if (dset != NULL)
                 delete dset;
             throw E; // propagate the exception
         }
 
         /* opaque_1 */
-        DataType* optype = NULL;
+        DataType *optype = NULL;
         try { // opaque_1 block
             optype = new DataType(H5T_OPAQUE, 1);
             nelmts = sizeof(buf);
-            DataSpace space (1, &nelmts);
-            optype->setTag ("testing 1-byte opaque type");
+            DataSpace space(1, &nelmts);
+            optype->setTag("testing 1-byte opaque type");
             dset = new DataSet(grp.createDataSet("opaque_1", *optype, space));
 
             // Fill buffer
-            for (i=0; i<sizeof buf; i++)
+            for (i = 0; i < sizeof buf; i++)
                 buf[i] = static_cast<unsigned char>(0xff) ^ static_cast<unsigned char>(i);
 
             // Write data from buf using all default dataspaces and property
             // list; if writing fails, deallocate dset and return.
-            dset->write (buf, *optype);
+            dset->write(buf, *optype);
 
             // no failure in opaque_1
-            delete dset; dset = NULL;
-            delete optype; optype = NULL;
+            delete dset;
+            dset = NULL;
+            delete optype;
+            optype = NULL;
         } // end try block of opaque_1
 
         // catch exceptions thrown in try block of opaque_1
-        catch (Exception& E)
-        {
+        catch (Exception &E) {
             cerr << " FAILED" << endl;
-            cerr << "    <<<  " << "opaque_1: " << E.getFuncName()
-                 << " - " << E.getDetailMsg() << "  >>>" << endl << endl;
+            cerr << "    <<<  "
+                 << "opaque_1: " << E.getFuncName() << " - " << E.getDetailMsg() << "  >>>" << endl
+                 << endl;
             if (dset != NULL)
                 delete dset;
             if (optype != NULL)
@@ -1072,31 +1044,33 @@ static herr_t test_types(H5File& file)
 
         /* opaque_2 */
         try { // block opaque_2
-            nelmts = sizeof(buf)/4;
-            DataSpace space (1, &nelmts);
+            nelmts = sizeof(buf) / 4;
+            DataSpace space(1, &nelmts);
             optype = new DataType(H5T_OPAQUE, 4);
-            optype->setTag ("testing 4-byte opaque type");
+            optype->setTag("testing 4-byte opaque type");
             dset = new DataSet(grp.createDataSet("opaque_2", *optype, space));
 
             // Fill buffer
-            for (i=0; i<sizeof(buf); i++)
+            for (i = 0; i < sizeof(buf); i++)
                 buf[i] = static_cast<unsigned char>(0xff) ^ static_cast<unsigned char>(i);
 
             // Write data from buf using all default dataspaces and property
             // list; if writing fails, deallocate dset and return.
-            dset->write (buf, *optype);
+            dset->write(buf, *optype);
 
             // no failure in opaque_1
-            delete dset; dset = NULL;
-            delete optype; optype = NULL;
-        } //end try block of opaque_2
+            delete dset;
+            dset = NULL;
+            delete optype;
+            optype = NULL;
+        } // end try block of opaque_2
 
         // catch exceptions thrown in try block of opaque_2
-        catch (Exception& E)
-        {
+        catch (Exception &E) {
             cerr << " FAILED" << endl;
-            cerr << "    <<<  " << "opaque_2: " << E.getFuncName()
-                 << " - " << E.getDetailMsg() << "  >>>" << endl << endl;
+            cerr << "    <<<  "
+                 << "opaque_2: " << E.getFuncName() << " - " << E.getDetailMsg() << "  >>>" << endl
+                 << endl;
             if (dset != NULL)
                 delete dset;
             if (optype != NULL)
@@ -1108,13 +1082,11 @@ static herr_t test_types(H5File& file)
         return 0;
     } // end top try block
 
-    catch (Exception& E)
-    {
+    catch (Exception &E) {
         return -1;
     }
-}   // test_types
+} // test_types
 
-
 /*-------------------------------------------------------------------------
  * Function:    test_getNativeObjinfo
  *
@@ -1126,16 +1098,17 @@ static herr_t test_types(H5File& file)
  * July, 2018
  *-------------------------------------------------------------------------
  */
-static herr_t test_getnativeinfo(H5File& file)
+static herr_t
+test_getnativeinfo(H5File &file)
 {
     SUBTEST("Getting object information");
 
     try {
         // Create a data space
-        hsize_t     dims[2];
+        hsize_t dims[2];
         dims[0] = 256;
         dims[1] = 512;
-        DataSpace space (2, dims, NULL);
+        DataSpace space(2, dims, NULL);
 
         // Create a dataset using the default dataset creation properties.
         // We're not sure what they are, so we won't check.
@@ -1158,23 +1131,20 @@ static herr_t test_getnativeinfo(H5File& file)
 
         PASSED();
         return 0;
-    }   // outer most try block
+    } // outer most try block
 
-    catch (InvalidActionException& E)
-    {
+    catch (InvalidActionException &E) {
         cerr << " FAILED" << endl;
         cerr << "    <<<  " << E.getDetailMsg() << "  >>>" << endl << endl;
         return -1;
     }
     // catch all other exceptions
-    catch (Exception& E)
-    {
+    catch (Exception &E) {
         issue_fail_msg("test_getnativeinfo", __LINE__, __FILE__);
         return -1;
     }
-}   // test_getnativeinfo
+} // test_getnativeinfo
 
-
 /*-------------------------------------------------------------------------
  * Function:    test_chunk_cache
  *
@@ -1187,10 +1157,11 @@ static herr_t test_getnativeinfo(H5File& file)
  * July 2018
  *-------------------------------------------------------------------------
  */
-const int RANK1 = 1;
+const int          RANK1 = 1;
 const H5std_string FILE_ACCPLIST("test_accplist.h5");
 
-static herr_t test_chunk_cache(FileAccPropList fapl)
+static herr_t
+test_chunk_cache(FileAccPropList fapl)
 {
     SUBTEST("DSetAccPropList::set/getChunkCache");
 
@@ -1200,14 +1171,14 @@ static herr_t test_chunk_cache(FileAccPropList fapl)
         DSetAccPropList dapl;
 
         // Verify that chunk cache parameters are the same
-        int mdc_nelmts = 0;
+        int    mdc_nelmts = 0;
         size_t nslots_1 = 0, nslots_4 = 0, nbytes_1 = 0, nbytes_4 = 0;
         double w0_1 = 0.0F, w0_4 = 0.0F;
         fapl_def.getCache(mdc_nelmts, nslots_1, nbytes_1, w0_1);
         dapl.getChunkCache(nslots_4, nbytes_4, w0_4);
-        verify_val(nslots_1, nslots_4, "DSetAccPropList::getChunkCache",  __LINE__, __FILE__);
-        verify_val(nbytes_1, nbytes_4, "DSetAccPropList::getChunkCache",  __LINE__, __FILE__);
-        verify_val(w0_1, w0_4, "DSetAccPropList::getChunkCache",  __LINE__, __FILE__);
+        verify_val(nslots_1, nslots_4, "DSetAccPropList::getChunkCache", __LINE__, __FILE__);
+        verify_val(nbytes_1, nbytes_4, "DSetAccPropList::getChunkCache", __LINE__, __FILE__);
+        verify_val(w0_1, w0_4, "DSetAccPropList::getChunkCache", __LINE__, __FILE__);
 
         // Set a link access property on dapl to verify property list inheritance
         dapl.setNumLinks((size_t)134);
@@ -1220,7 +1191,7 @@ static herr_t test_chunk_cache(FileAccPropList fapl)
         // Set new rdcc settings on fapl local
         size_t nslots_2 = nslots_1 * 2;
         size_t nbytes_2 = nbytes_1 * 2;
-        double w0_2 = w0_1 / (double)2.0F;
+        double w0_2     = w0_1 / (double)2.0F;
         fapl_local.getCache(mdc_nelmts, nslots_2, nbytes_2, w0_2);
 
         // Create a new file using default fcpl and the passed-in fapl
@@ -1247,17 +1218,16 @@ static herr_t test_chunk_cache(FileAccPropList fapl)
 
         // Retrieve and verify the raw data chunk cache parameters
         nslots_4 = nbytes_4 = 0;
-        w0_4 = 0.0F;
+        w0_4                = 0.0F;
         dapl2.getChunkCache(nslots_4, nbytes_4, w0_4);
         verify_val(nslots_2, nslots_4, "DSetCreatPropList::getChunkCache", __LINE__, __FILE__);
         verify_val(nbytes_2, nbytes_4, "DSetCreatPropList::getChunkCache", __LINE__, __FILE__);
         verify_val(H5_DBL_ABS_EQUAL(w0_2, w0_4), 1, "DSetCreatPropList::getChunkCache", __LINE__, __FILE__);
 
-
         // Set new values on original dapl
         size_t nslots_3 = nslots_1 * 2;
         size_t nbytes_3 = H5D_CHUNK_CACHE_NBYTES_DEFAULT;
-        double w0_3 = w0_2 / 2;
+        double w0_3     = w0_2 / 2;
         dapl.getChunkCache(nslots_3, nbytes_3, w0_3);
 
         // Close dataset
@@ -1275,18 +1245,15 @@ static herr_t test_chunk_cache(FileAccPropList fapl)
         verify_val(nbytes_3, nbytes_4, "DSetCreatPropList::getLayout", __LINE__, __FILE__);
         verify_val(H5_DBL_ABS_EQUAL(w0_3, w0_4), 1, "DSetCreatPropList::getLayout", __LINE__, __FILE__);
 
-
         PASSED();
         return 0;
     } // end top try block
 
-    catch (Exception& E)
-    {
+    catch (Exception &E) {
         return -1;
     }
 } // test_chunk_cache
 
-
 /*-------------------------------------------------------------------------
  * Function:    test_virtual
  *
@@ -1303,7 +1270,8 @@ static herr_t test_chunk_cache(FileAccPropList fapl)
  */
 const int RANK = 2;
 
-static herr_t test_virtual()
+static herr_t
+test_virtual()
 {
     SUBTEST("DSetCreatPropList::setVirtual");
 
@@ -1338,8 +1306,8 @@ static herr_t test_virtual()
         dims[1] = 6;
         DataSpace vspace(RANK, dims, mdims);
 
-        hsize_t start[RANK];       // Hyperslab start
-        hsize_t count[RANK];       // Hyperslab count
+        hsize_t start[RANK]; // Hyperslab start
+        hsize_t count[RANK]; // Hyperslab count
         start[0] = start[1] = 3;
         count[0] = count[1] = 3;
         vspace.selectHyperslab(H5S_SELECT_SET, count, start);
@@ -1358,13 +1326,11 @@ static herr_t test_virtual()
         return 0;
     } // end top try block
 
-    catch (Exception& E)
-    {
+    catch (Exception &E) {
         return -1;
     }
 } // test_virtual
 
-
 /*-------------------------------------------------------------------------
  * Function:    test_dset
  *
@@ -1387,15 +1353,14 @@ static herr_t test_virtual()
  *
  *-------------------------------------------------------------------------
  */
-extern "C"
-void test_dset()
+extern "C" void
+test_dset()
 {
     hid_t fapl_id;
-    fapl_id = h5_fileaccess(); // in h5test.c, returns a file access template
-    int nerrors=0; // keep track of number of failures occur
+    fapl_id     = h5_fileaccess(); // in h5test.c, returns a file access template
+    int nerrors = 0;               // keep track of number of failures occur
 
-    try
-    {
+    try {
         // Use the file access template id to create a file access prop.
         // list object to pass in H5File::H5File
         FileAccPropList fapl(fapl_id);
@@ -1403,19 +1368,19 @@ void test_dset()
         H5File file(FILE1, H5F_ACC_TRUNC, FileCreatPropList::DEFAULT, fapl);
 
         // Cause the library to emit initial messages
-        Group grp = file.createGroup( "emit diagnostics", 0);
+        Group grp = file.createGroup("emit diagnostics", 0);
         grp.setComment("Causes diagnostic messages to be emitted");
 
-        nerrors += test_create(file) < 0 ? 1:0;
-        nerrors += test_simple_io(file) < 0 ? 1:0;
-        nerrors += test_getnativeinfo(file) < 0 ? 1:0;
-        nerrors += test_tconv(file) < 0 ? 1:0;
-        nerrors += test_compression(file) < 0 ? 1:0;
-        nerrors += test_nbit_compression(file) < 0 ? 1:0;
-        nerrors += test_multiopen (file) < 0 ? 1:0;
-        nerrors += test_types(file) < 0 ? 1:0;
-        nerrors += test_virtual() < 0 ? 1:0;
-        nerrors += test_chunk_cache(fapl) < 0 ? 1:0;
+        nerrors += test_create(file) < 0 ? 1 : 0;
+        nerrors += test_simple_io(file) < 0 ? 1 : 0;
+        nerrors += test_getnativeinfo(file) < 0 ? 1 : 0;
+        nerrors += test_tconv(file) < 0 ? 1 : 0;
+        nerrors += test_compression(file) < 0 ? 1 : 0;
+        nerrors += test_nbit_compression(file) < 0 ? 1 : 0;
+        nerrors += test_multiopen(file) < 0 ? 1 : 0;
+        nerrors += test_types(file) < 0 ? 1 : 0;
+        nerrors += test_virtual() < 0 ? 1 : 0;
+        nerrors += test_chunk_cache(fapl) < 0 ? 1 : 0;
 
         // Close group "emit diagnostics".
         grp.close();
@@ -1423,18 +1388,16 @@ void test_dset()
         // Close the file before testing data size.
         file.close();
 
-        nerrors += test_datasize(fapl) <0 ? 1:0;
+        nerrors += test_datasize(fapl) < 0 ? 1 : 0;
     }
-    catch (Exception& E)
-    {
+    catch (Exception &E) {
         test_report(nerrors, H5std_string(" Dataset"));
     }
 
     // Clean up data file
     cleanup_dsets();
-}   // test_dset
+} // test_dset
 
-
 /*-------------------------------------------------------------------------
  * Function:    cleanup_dsets
  *
@@ -1445,9 +1408,8 @@ void test_dset()
  * Programmer   (use C version)
  *-------------------------------------------------------------------------
  */
-extern "C"
-void cleanup_dsets()
+extern "C" void
+cleanup_dsets()
 {
     HDremove(FILE1.c_str());
 } // cleanup_dsets
-