Clang-format of source files

1 files changed, 243 insertions, 231 deletions

diff --git a/testpar/t_file.c b/testpar/t_file.c
index 19a75c8..4e652bf 100644
--- a/testpar/t_file.c
+++ b/testpar/t_file.c
@@ -17,30 +17,30 @@
 
 #include "testphdf5.h"
 
-#include "H5CXprivate.h"        /* API Contexts                         */
+#include "H5CXprivate.h" /* API Contexts                         */
 #include "H5Iprivate.h"
 #include "H5PBprivate.h"
 
 /*
  * This file needs to access private information from the H5F package.
  */
-#define H5AC_FRIEND        /*suppress error about including H5ACpkg      */
+#define H5AC_FRIEND /*suppress error about including H5ACpkg      */
 #include "H5ACpkg.h"
-#define H5C_FRIEND        /*suppress error about including H5Cpkg      */
+#define H5C_FRIEND /*suppress error about including H5Cpkg      */
 #include "H5Cpkg.h"
-#define H5F_FRIEND        /*suppress error about including H5Fpkg      */
+#define H5F_FRIEND /*suppress error about including H5Fpkg      */
 #define H5F_TESTING
 #include "H5Fpkg.h"
-#define H5MF_FRIEND        /*suppress error about including H5MFpkg      */
+#define H5MF_FRIEND /*suppress error about including H5MFpkg      */
 #include "H5MFpkg.h"
 
-#define NUM_DSETS               5
+#define NUM_DSETS 5
 
 int mpi_size, mpi_rank;
 
 static int create_file(const char *filename, hid_t fcpl, hid_t fapl, int metadata_write_strategy);
-static int open_file(const char *filename, hid_t fapl, int metadata_write_strategy,
-                     hsize_t page_size, size_t page_buffer_size);
+static int open_file(const char *filename, hid_t fapl, int metadata_write_strategy, hsize_t page_size,
+                     size_t page_buffer_size);
 
 /*
  * test file access by communicator besides COMM_WORLD.
@@ -56,79 +56,79 @@ static int open_file(const char *filename, hid_t fapl, int metadata_write_strate
 void
 test_split_comm_access(void)
 {
-    MPI_Comm comm;
-    MPI_Info info = MPI_INFO_NULL;
-    int is_old, mrc;
-    int newrank, newprocs;
-    hid_t fid;            /* file IDs */
-    hid_t acc_tpl;        /* File access properties */
-    herr_t ret;            /* generic return value */
+    MPI_Comm    comm;
+    MPI_Info    info = MPI_INFO_NULL;
+    int         is_old, mrc;
+    int         newrank, newprocs;
+    hid_t       fid;     /* file IDs */
+    hid_t       acc_tpl; /* File access properties */
+    herr_t      ret;     /* generic return value */
     const char *filename;
 
     filename = (const char *)GetTestParameters();
     if (VERBOSE_MED)
-    HDprintf("Split Communicator access test on file %s\n",
-        filename);
+        HDprintf("Split Communicator access test on file %s\n", filename);
 
     /* set up MPI parameters */
-    MPI_Comm_size(MPI_COMM_WORLD,&mpi_size);
-    MPI_Comm_rank(MPI_COMM_WORLD,&mpi_rank);
-    is_old = mpi_rank%2;
-    mrc = MPI_Comm_split(MPI_COMM_WORLD, is_old, mpi_rank, &comm);
-    VRFY((mrc==MPI_SUCCESS), "");
-    MPI_Comm_size(comm,&newprocs);
-    MPI_Comm_rank(comm,&newrank);
-
-    if (is_old){
-    /* odd-rank processes */
-    mrc = MPI_Barrier(comm);
-    VRFY((mrc==MPI_SUCCESS), "");
-    }else{
-    /* even-rank processes */
-    int sub_mpi_rank;    /* rank in the sub-comm */
-    MPI_Comm_rank(comm,&sub_mpi_rank);
-
-    /* setup file access template */
-    acc_tpl = create_faccess_plist(comm, info, facc_type);
-    VRFY((acc_tpl >= 0), "");
-
-    /* create the file collectively */
-    fid=H5Fcreate(filename,H5F_ACC_TRUNC,H5P_DEFAULT,acc_tpl);
-    VRFY((fid >= 0), "H5Fcreate succeeded");
-
-    /* Release file-access template */
-    ret=H5Pclose(acc_tpl);
-    VRFY((ret >= 0), "");
+    MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
+    MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
+    is_old = mpi_rank % 2;
+    mrc    = MPI_Comm_split(MPI_COMM_WORLD, is_old, mpi_rank, &comm);
+    VRFY((mrc == MPI_SUCCESS), "");
+    MPI_Comm_size(comm, &newprocs);
+    MPI_Comm_rank(comm, &newrank);
+
+    if (is_old) {
+        /* odd-rank processes */
+        mrc = MPI_Barrier(comm);
+        VRFY((mrc == MPI_SUCCESS), "");
+    }
+    else {
+        /* even-rank processes */
+        int sub_mpi_rank; /* rank in the sub-comm */
+        MPI_Comm_rank(comm, &sub_mpi_rank);
 
-    /* close the file */
-    ret=H5Fclose(fid);
-    VRFY((ret >= 0), "");
+        /* setup file access template */
+        acc_tpl = create_faccess_plist(comm, info, facc_type);
+        VRFY((acc_tpl >= 0), "");
 
-    /* delete the test file */
-    if (sub_mpi_rank == 0){
-        mrc = MPI_File_delete((char *)filename, info);
-        /*VRFY((mrc==MPI_SUCCESS), ""); */
-    }
+        /* create the file collectively */
+        fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, acc_tpl);
+        VRFY((fid >= 0), "H5Fcreate succeeded");
+
+        /* Release file-access template */
+        ret = H5Pclose(acc_tpl);
+        VRFY((ret >= 0), "");
+
+        /* close the file */
+        ret = H5Fclose(fid);
+        VRFY((ret >= 0), "");
+
+        /* delete the test file */
+        if (sub_mpi_rank == 0) {
+            mrc = MPI_File_delete((char *)filename, info);
+            /*VRFY((mrc==MPI_SUCCESS), ""); */
+        }
     }
     mrc = MPI_Comm_free(&comm);
-    VRFY((mrc==MPI_SUCCESS), "MPI_Comm_free succeeded");
+    VRFY((mrc == MPI_SUCCESS), "MPI_Comm_free succeeded");
     mrc = MPI_Barrier(MPI_COMM_WORLD);
-    VRFY((mrc==MPI_SUCCESS), "final MPI_Barrier succeeded");
+    VRFY((mrc == MPI_SUCCESS), "final MPI_Barrier succeeded");
 }
 
 void
 test_page_buffer_access(void)
 {
-    hid_t file_id = -1;          /* File ID */
-    hid_t fcpl, fapl;
-    size_t page_count = 0;
-    int i, num_elements = 200;
-    haddr_t raw_addr, meta_addr;
-    int *data;
-    H5F_t *f = NULL;
-    herr_t ret;            /* generic return value */
+    hid_t       file_id = -1; /* File ID */
+    hid_t       fcpl, fapl;
+    size_t      page_count = 0;
+    int         i, num_elements = 200;
+    haddr_t     raw_addr, meta_addr;
+    int *       data;
+    H5F_t *     f = NULL;
+    herr_t      ret; /* generic return value */
     const char *filename;
-    hbool_t     api_ctx_pushed = FALSE;             /* Whether API context pushed */
+    hbool_t     api_ctx_pushed = FALSE; /* Whether API context pushed */
 
     MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
     MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
@@ -136,7 +136,7 @@ test_page_buffer_access(void)
     filename = (const char *)GetTestParameters();
 
     if (VERBOSE_MED)
-    HDprintf("Page Buffer Usage in Parallel %s\n", filename);
+        HDprintf("Page Buffer Usage in Parallel %s\n", filename);
 
     fapl = create_faccess_plist(MPI_COMM_WORLD, MPI_INFO_NULL, facc_type);
     VRFY((fapl >= 0), "create_faccess_plist succeeded");
@@ -145,15 +145,14 @@ test_page_buffer_access(void)
 
     ret = H5Pset_file_space_strategy(fcpl, H5F_FSPACE_STRATEGY_PAGE, 1, (hsize_t)0);
     VRFY((ret == 0), "");
-    ret = H5Pset_file_space_page_size(fcpl, sizeof(int)*128);
+    ret = H5Pset_file_space_page_size(fcpl, sizeof(int) * 128);
     VRFY((ret == 0), "");
-    ret = H5Pset_page_buffer_size(fapl, sizeof(int)*100000, 0, 0);
+    ret = H5Pset_page_buffer_size(fapl, sizeof(int) * 100000, 0, 0);
     VRFY((ret == 0), "");
 
     /* This should fail because collective metadata writes are not supported with page buffering */
-    H5E_BEGIN_TRY {
-        file_id = H5Fcreate(filename, H5F_ACC_TRUNC, fcpl, fapl);
-    } H5E_END_TRY;
+    H5E_BEGIN_TRY { file_id = H5Fcreate(filename, H5F_ACC_TRUNC, fcpl, fapl); }
+    H5E_END_TRY;
     VRFY((file_id < 0), "H5Fcreate failed");
 
     /* disable collective metadata writes for page buffering to work */
@@ -162,27 +161,29 @@ test_page_buffer_access(void)
 
     ret = create_file(filename, fcpl, fapl, H5AC_METADATA_WRITE_STRATEGY__DISTRIBUTED);
     VRFY((ret == 0), "");
-    ret = open_file(filename, fapl, H5AC_METADATA_WRITE_STRATEGY__DISTRIBUTED, sizeof(int)*100, sizeof(int)*100000);
+    ret = open_file(filename, fapl, H5AC_METADATA_WRITE_STRATEGY__DISTRIBUTED, sizeof(int) * 100,
+                    sizeof(int) * 100000);
     VRFY((ret == 0), "");
 
     ret = create_file(filename, fcpl, fapl, H5AC_METADATA_WRITE_STRATEGY__PROCESS_0_ONLY);
     VRFY((ret == 0), "");
-    ret = open_file(filename, fapl, H5AC_METADATA_WRITE_STRATEGY__PROCESS_0_ONLY, sizeof(int)*100, sizeof(int)*100000);
+    ret = open_file(filename, fapl, H5AC_METADATA_WRITE_STRATEGY__PROCESS_0_ONLY, sizeof(int) * 100,
+                    sizeof(int) * 100000);
     VRFY((ret == 0), "");
 
-    ret = H5Pset_file_space_page_size(fcpl, sizeof(int)*100);
+    ret = H5Pset_file_space_page_size(fcpl, sizeof(int) * 100);
     VRFY((ret == 0), "");
 
-    data = (int *) HDmalloc(sizeof(int)*(size_t)num_elements);
+    data = (int *)HDmalloc(sizeof(int) * (size_t)num_elements);
 
     /* intialize all the elements to have a value of -1 */
-    for(i=0 ; i<num_elements ; i++)
+    for (i = 0; i < num_elements; i++)
         data[i] = -1;
-    if(MAINPROCESS) {
+    if (MAINPROCESS) {
         hid_t fapl_self = H5I_INVALID_HID;
-        fapl_self = create_faccess_plist(MPI_COMM_SELF, MPI_INFO_NULL, facc_type);
+        fapl_self       = create_faccess_plist(MPI_COMM_SELF, MPI_INFO_NULL, facc_type);
 
-        ret = H5Pset_page_buffer_size(fapl_self, sizeof(int)*1000, 0, 0);
+        ret = H5Pset_page_buffer_size(fapl_self, sizeof(int) * 1000, 0, 0);
         VRFY((ret == 0), "");
         /* collective metadata writes do not work with page buffering */
         ret = H5Pset_coll_metadata_write(fapl_self, FALSE);
@@ -202,49 +203,49 @@ test_page_buffer_access(void)
         VRFY((f->shared->page_buf != NULL), "Page Buffer created with 1 process");
 
         /* allocate space for 200 raw elements */
-        raw_addr = H5MF_alloc(f, H5FD_MEM_DRAW, sizeof(int)*(size_t)num_elements);
+        raw_addr = H5MF_alloc(f, H5FD_MEM_DRAW, sizeof(int) * (size_t)num_elements);
         VRFY((raw_addr != HADDR_UNDEF), "");
 
         /* allocate space for 200 metadata elements */
-        meta_addr = H5MF_alloc(f, H5FD_MEM_SUPER, sizeof(int)*(size_t)num_elements);
+        meta_addr = H5MF_alloc(f, H5FD_MEM_SUPER, sizeof(int) * (size_t)num_elements);
         VRFY((meta_addr != HADDR_UNDEF), "");
 
         page_count = 0;
 
-        ret = H5F_block_write(f, H5FD_MEM_SUPER, meta_addr, sizeof(int)*(size_t)num_elements, data);
+        ret = H5F_block_write(f, H5FD_MEM_SUPER, meta_addr, sizeof(int) * (size_t)num_elements, data);
         VRFY((ret == 0), "");
-        ret = H5F_block_write(f, H5FD_MEM_SUPER, meta_addr, sizeof(int)*(size_t)num_elements, data);
-        ret = H5F_block_write(f, H5FD_MEM_DRAW, raw_addr, sizeof(int)*(size_t)num_elements, data);
+        ret = H5F_block_write(f, H5FD_MEM_SUPER, meta_addr, sizeof(int) * (size_t)num_elements, data);
+        ret = H5F_block_write(f, H5FD_MEM_DRAW, raw_addr, sizeof(int) * (size_t)num_elements, data);
         VRFY((ret == 0), "");
 
         VRFY((H5SL_count(f->shared->page_buf->slist_ptr) == page_count), "Wrong number of pages in PB");
 
         /* update the first 50 elements */
-        for(i=0 ; i<50 ; i++)
+        for (i = 0; i < 50; i++)
             data[i] = i;
-        ret = H5F_block_write(f, H5FD_MEM_DRAW, raw_addr, sizeof(int)*50, data);
+        ret = H5F_block_write(f, H5FD_MEM_DRAW, raw_addr, sizeof(int) * 50, data);
         H5Eprint2(H5E_DEFAULT, stderr);
         VRFY((ret == 0), "");
-        ret = H5F_block_write(f, H5FD_MEM_SUPER, meta_addr, sizeof(int)*50, data);
+        ret = H5F_block_write(f, H5FD_MEM_SUPER, meta_addr, sizeof(int) * 50, data);
         VRFY((ret == 0), "");
         page_count += 2;
         VRFY((H5SL_count(f->shared->page_buf->slist_ptr) == page_count), "Wrong number of pages in PB");
 
         /* update the second 50 elements */
-        for(i=0 ; i<50 ; i++)
-            data[i] = i+50;
-        ret = H5F_block_write(f, H5FD_MEM_DRAW, raw_addr+(sizeof(int)*50), sizeof(int)*50, data);
+        for (i = 0; i < 50; i++)
+            data[i] = i + 50;
+        ret = H5F_block_write(f, H5FD_MEM_DRAW, raw_addr + (sizeof(int) * 50), sizeof(int) * 50, data);
         VRFY((ret == 0), "");
-        ret = H5F_block_write(f, H5FD_MEM_SUPER, meta_addr+(sizeof(int)*50), sizeof(int)*50, data);
+        ret = H5F_block_write(f, H5FD_MEM_SUPER, meta_addr + (sizeof(int) * 50), sizeof(int) * 50, data);
         VRFY((ret == 0), "");
         VRFY((H5SL_count(f->shared->page_buf->slist_ptr) == page_count), "Wrong number of pages in PB");
 
         /* update 100 - 200 */
-        for(i=0 ; i<100 ; i++)
-            data[i] = i+100;
-        ret = H5F_block_write(f, H5FD_MEM_DRAW, raw_addr+(sizeof(int)*100), sizeof(int)*100, data);
+        for (i = 0; i < 100; i++)
+            data[i] = i + 100;
+        ret = H5F_block_write(f, H5FD_MEM_DRAW, raw_addr + (sizeof(int) * 100), sizeof(int) * 100, data);
         VRFY((ret == 0), "");
-        ret = H5F_block_write(f, H5FD_MEM_SUPER, meta_addr+(sizeof(int)*100), sizeof(int)*100, data);
+        ret = H5F_block_write(f, H5FD_MEM_SUPER, meta_addr + (sizeof(int) * 100), sizeof(int) * 100, data);
         VRFY((ret == 0), "");
         VRFY((H5SL_count(f->shared->page_buf->slist_ptr) == page_count), "Wrong number of pages in PB");
 
@@ -252,43 +253,47 @@ test_page_buffer_access(void)
         VRFY((ret == 0), "");
 
         /* read elements 0 - 200 */
-        ret = H5F_block_read(f, H5FD_MEM_DRAW, raw_addr, sizeof(int)*200, data);
+        ret = H5F_block_read(f, H5FD_MEM_DRAW, raw_addr, sizeof(int) * 200, data);
         VRFY((ret == 0), "");
         VRFY((H5SL_count(f->shared->page_buf->slist_ptr) == page_count), "Wrong number of pages in PB");
-        for (i=0; i < 200; i++)
+        for (i = 0; i < 200; i++)
             VRFY((data[i] == i), "Read different values than written");
-        ret = H5F_block_read(f, H5FD_MEM_SUPER, meta_addr, sizeof(int)*200, data);
+        ret = H5F_block_read(f, H5FD_MEM_SUPER, meta_addr, sizeof(int) * 200, data);
         VRFY((ret == 0), "");
         VRFY((H5SL_count(f->shared->page_buf->slist_ptr) == page_count), "Wrong number of pages in PB");
-        for (i=0; i < 200; i++)
+        for (i = 0; i < 200; i++)
             VRFY((data[i] == i), "Read different values than written");
 
         /* read elements 0 - 50 */
-        ret = H5F_block_read(f, H5FD_MEM_DRAW, raw_addr, sizeof(int)*50, data);
+        ret = H5F_block_read(f, H5FD_MEM_DRAW, raw_addr, sizeof(int) * 50, data);
         VRFY((ret == 0), "");
         VRFY((H5SL_count(f->shared->page_buf->slist_ptr) == page_count), "Wrong number of pages in PB");
-        for (i=0; i < 50; i++)
+        for (i = 0; i < 50; i++)
             VRFY((data[i] == i), "Read different values than written");
-        ret = H5F_block_read(f, H5FD_MEM_SUPER, meta_addr, sizeof(int)*50, data);
+        ret = H5F_block_read(f, H5FD_MEM_SUPER, meta_addr, sizeof(int) * 50, data);
         VRFY((ret == 0), "");
         VRFY((H5SL_count(f->shared->page_buf->slist_ptr) == page_count), "Wrong number of pages in PB");
-        for (i=0; i < 50; i++)
+        for (i = 0; i < 50; i++)
             VRFY((data[i] == i), "Read different values than written");
 
         /* close the file */
         ret = H5Fclose(file_id);
         VRFY((ret >= 0), "H5Fclose succeeded");
         ret = H5Pclose(fapl_self);
-        VRFY((ret>=0), "H5Pclose succeeded");
+        VRFY((ret >= 0), "H5Pclose succeeded");
 
         /* Pop API context */
-        if(api_ctx_pushed) { ret = H5CX_pop(); VRFY((ret == 0), "H5CX_pop()"); api_ctx_pushed = FALSE; }
+        if (api_ctx_pushed) {
+            ret = H5CX_pop();
+            VRFY((ret == 0), "H5CX_pop()");
+            api_ctx_pushed = FALSE;
+        }
     }
 
     MPI_Barrier(MPI_COMM_WORLD);
 
-    if(mpi_size > 1) {
-        ret = H5Pset_page_buffer_size(fapl, sizeof(int)*1000, 0, 0);
+    if (mpi_size > 1) {
+        ret = H5Pset_page_buffer_size(fapl, sizeof(int) * 1000, 0, 0);
         VRFY((ret == 0), "");
         /* collective metadata writes do not work with page buffering */
         ret = H5Pset_coll_metadata_write(fapl, FALSE);
@@ -308,45 +313,45 @@ test_page_buffer_access(void)
         VRFY((f->shared->page_buf != NULL), "Page Buffer created with 1 process");
 
         /* allocate space for 200 raw elements */
-        raw_addr = H5MF_alloc(f, H5FD_MEM_DRAW, sizeof(int)*(size_t)num_elements);
+        raw_addr = H5MF_alloc(f, H5FD_MEM_DRAW, sizeof(int) * (size_t)num_elements);
         VRFY((raw_addr != HADDR_UNDEF), "");
         /* allocate space for 200 metadata elements */
-        meta_addr = H5MF_alloc(f, H5FD_MEM_SUPER, sizeof(int)*(size_t)num_elements);
+        meta_addr = H5MF_alloc(f, H5FD_MEM_SUPER, sizeof(int) * (size_t)num_elements);
         VRFY((meta_addr != HADDR_UNDEF), "");
 
         page_count = 0;
 
-        ret = H5F_block_write(f, H5FD_MEM_SUPER, meta_addr, sizeof(int)*(size_t)num_elements, data);
+        ret = H5F_block_write(f, H5FD_MEM_SUPER, meta_addr, sizeof(int) * (size_t)num_elements, data);
         VRFY((ret == 0), "");
-        ret = H5F_block_write(f, H5FD_MEM_DRAW, raw_addr, sizeof(int)*(size_t)num_elements, data);
+        ret = H5F_block_write(f, H5FD_MEM_DRAW, raw_addr, sizeof(int) * (size_t)num_elements, data);
         VRFY((ret == 0), "");
 
         VRFY((H5SL_count(f->shared->page_buf->slist_ptr) == page_count), "Wrong number of pages in PB");
 
         /* update the first 50 elements */
-        for(i=0 ; i<50 ; i++)
+        for (i = 0; i < 50; i++)
             data[i] = i;
-        ret = H5F_block_write(f, H5FD_MEM_DRAW, raw_addr, sizeof(int)*50, data);
+        ret = H5F_block_write(f, H5FD_MEM_DRAW, raw_addr, sizeof(int) * 50, data);
         VRFY((ret == 0), "");
-        ret = H5F_block_write(f, H5FD_MEM_SUPER, meta_addr, sizeof(int)*50, data);
+        ret = H5F_block_write(f, H5FD_MEM_SUPER, meta_addr, sizeof(int) * 50, data);
         VRFY((ret == 0), "");
         VRFY((H5SL_count(f->shared->page_buf->slist_ptr) == page_count), "Wrong number of pages in PB");
 
         /* update the second 50 elements */
-        for(i=0 ; i<50 ; i++)
-            data[i] = i+50;
-        ret = H5F_block_write(f, H5FD_MEM_DRAW, raw_addr+(sizeof(int)*50), sizeof(int)*50, data);
+        for (i = 0; i < 50; i++)
+            data[i] = i + 50;
+        ret = H5F_block_write(f, H5FD_MEM_DRAW, raw_addr + (sizeof(int) * 50), sizeof(int) * 50, data);
         VRFY((ret == 0), "");
-        ret = H5F_block_write(f, H5FD_MEM_SUPER, meta_addr+(sizeof(int)*50), sizeof(int)*50, data);
+        ret = H5F_block_write(f, H5FD_MEM_SUPER, meta_addr + (sizeof(int) * 50), sizeof(int) * 50, data);
         VRFY((ret == 0), "");
         VRFY((H5SL_count(f->shared->page_buf->slist_ptr) == page_count), "Wrong number of pages in PB");
 
         /* update 100 - 200 */
-        for(i=0 ; i<100 ; i++)
-            data[i] = i+100;
-        ret = H5F_block_write(f, H5FD_MEM_DRAW, raw_addr+(sizeof(int)*100), sizeof(int)*100, data);
+        for (i = 0; i < 100; i++)
+            data[i] = i + 100;
+        ret = H5F_block_write(f, H5FD_MEM_DRAW, raw_addr + (sizeof(int) * 100), sizeof(int) * 100, data);
         VRFY((ret == 0), "");
-        ret = H5F_block_write(f, H5FD_MEM_SUPER, meta_addr+(sizeof(int)*100), sizeof(int)*100, data);
+        ret = H5F_block_write(f, H5FD_MEM_SUPER, meta_addr + (sizeof(int) * 100), sizeof(int) * 100, data);
         VRFY((ret == 0), "");
         VRFY((H5SL_count(f->shared->page_buf->slist_ptr) == page_count), "Wrong number of pages in PB");
 
@@ -354,51 +359,51 @@ test_page_buffer_access(void)
         VRFY((ret == 0), "");
 
         /* read elements 0 - 200 */
-        ret = H5F_block_read(f, H5FD_MEM_DRAW, raw_addr, sizeof(int)*200, data);
+        ret = H5F_block_read(f, H5FD_MEM_DRAW, raw_addr, sizeof(int) * 200, data);
         VRFY((ret == 0), "");
         VRFY((H5SL_count(f->shared->page_buf->slist_ptr) == page_count), "Wrong number of pages in PB");
-        for (i=0; i < 200; i++)
+        for (i = 0; i < 200; i++)
             VRFY((data[i] == i), "Read different values than written");
-        ret = H5F_block_read(f, H5FD_MEM_SUPER, meta_addr, sizeof(int)*200, data);
+        ret = H5F_block_read(f, H5FD_MEM_SUPER, meta_addr, sizeof(int) * 200, data);
         VRFY((ret == 0), "");
         VRFY((H5SL_count(f->shared->page_buf->slist_ptr) == page_count), "Wrong number of pages in PB");
-        for (i=0; i < 200; i++)
+        for (i = 0; i < 200; i++)
             VRFY((data[i] == i), "Read different values than written");
 
         /* read elements 0 - 50 */
-        ret = H5F_block_read(f, H5FD_MEM_DRAW, raw_addr, sizeof(int)*50, data);
+        ret = H5F_block_read(f, H5FD_MEM_DRAW, raw_addr, sizeof(int) * 50, data);
         VRFY((ret == 0), "");
         VRFY((H5SL_count(f->shared->page_buf->slist_ptr) == page_count), "Wrong number of pages in PB");
-        for (i=0; i < 50; i++)
+        for (i = 0; i < 50; i++)
             VRFY((data[i] == i), "Read different values than written");
-        ret = H5F_block_read(f, H5FD_MEM_SUPER, meta_addr, sizeof(int)*50, data);
+        ret = H5F_block_read(f, H5FD_MEM_SUPER, meta_addr, sizeof(int) * 50, data);
         VRFY((ret == 0), "");
         page_count += 1;
         VRFY((H5SL_count(f->shared->page_buf->slist_ptr) == page_count), "Wrong number of pages in PB");
-        for (i=0; i < 50; i++)
+        for (i = 0; i < 50; i++)
             VRFY((data[i] == i), "Read different values than written");
 
         MPI_Barrier(MPI_COMM_WORLD);
         /* reset the first 50 elements to -1*/
-        for(i=0 ; i<50 ; i++)
+        for (i = 0; i < 50; i++)
             data[i] = -1;
-        ret = H5F_block_write(f, H5FD_MEM_DRAW, raw_addr, sizeof(int)*50, data);
+        ret = H5F_block_write(f, H5FD_MEM_DRAW, raw_addr, sizeof(int) * 50, data);
         VRFY((ret == 0), "");
         VRFY((H5SL_count(f->shared->page_buf->slist_ptr) == page_count), "Wrong number of pages in PB");
-        ret = H5F_block_write(f, H5FD_MEM_SUPER, meta_addr, sizeof(int)*50, data);
+        ret = H5F_block_write(f, H5FD_MEM_SUPER, meta_addr, sizeof(int) * 50, data);
         VRFY((ret == 0), "");
         VRFY((H5SL_count(f->shared->page_buf->slist_ptr) == page_count), "Wrong number of pages in PB");
 
         /* read elements 0 - 50 */
-        ret = H5F_block_read(f, H5FD_MEM_DRAW, raw_addr, sizeof(int)*50, data);
+        ret = H5F_block_read(f, H5FD_MEM_DRAW, raw_addr, sizeof(int) * 50, data);
         VRFY((ret == 0), "");
         VRFY((H5SL_count(f->shared->page_buf->slist_ptr) == page_count), "Wrong number of pages in PB");
-        for (i=0; i < 50; i++)
+        for (i = 0; i < 50; i++)
             VRFY((data[i] == -1), "Read different values than written");
-        ret = H5F_block_read(f, H5FD_MEM_SUPER, meta_addr, sizeof(int)*50, data);
+        ret = H5F_block_read(f, H5FD_MEM_SUPER, meta_addr, sizeof(int) * 50, data);
         VRFY((ret == 0), "");
         VRFY((H5SL_count(f->shared->page_buf->slist_ptr) == page_count), "Wrong number of pages in PB");
-        for (i=0; i < 50; i++)
+        for (i = 0; i < 50; i++)
             VRFY((data[i] == -1), "Read different values than written");
 
         /* close the file */
@@ -407,12 +412,16 @@ test_page_buffer_access(void)
     }
 
     ret = H5Pclose(fapl);
-    VRFY((ret>=0), "H5Pclose succeeded");
+    VRFY((ret >= 0), "H5Pclose succeeded");
     ret = H5Pclose(fcpl);
-    VRFY((ret>=0), "H5Pclose succeeded");
+    VRFY((ret >= 0), "H5Pclose succeeded");
 
     /* Pop API context */
-    if(api_ctx_pushed) { ret = H5CX_pop(); VRFY((ret == 0), "H5CX_pop()"); api_ctx_pushed = FALSE; }
+    if (api_ctx_pushed) {
+        ret = H5CX_pop();
+        VRFY((ret == 0), "H5CX_pop()");
+        api_ctx_pushed = FALSE;
+    }
 
     HDfree(data);
     data = NULL;
@@ -422,22 +431,22 @@ test_page_buffer_access(void)
 static int
 create_file(const char *filename, hid_t fcpl, hid_t fapl, int metadata_write_strategy)
 {
-    hid_t       file_id, dset_id, grp_id;
-    hid_t       sid, mem_dataspace;
-    hsize_t     start[RANK];
-    hsize_t     count[RANK];
-    hsize_t     stride[RANK];
-    hsize_t     block[RANK];
-    DATATYPE   *data_array = NULL;
-    hsize_t     dims[RANK], i;
-    hsize_t     num_elements;
-    int         k;
-    char        dset_name[20];
-    H5F_t       *f = NULL;
-    H5C_t       *cache_ptr = NULL;
+    hid_t               file_id, dset_id, grp_id;
+    hid_t               sid, mem_dataspace;
+    hsize_t             start[RANK];
+    hsize_t             count[RANK];
+    hsize_t             stride[RANK];
+    hsize_t             block[RANK];
+    DATATYPE *          data_array = NULL;
+    hsize_t             dims[RANK], i;
+    hsize_t             num_elements;
+    int                 k;
+    char                dset_name[20];
+    H5F_t *             f         = NULL;
+    H5C_t *             cache_ptr = NULL;
     H5AC_cache_config_t config;
-    hbool_t     api_ctx_pushed = FALSE;             /* Whether API context pushed */
-    herr_t      ret;
+    hbool_t             api_ctx_pushed = FALSE; /* Whether API context pushed */
+    herr_t              ret;
 
     file_id = H5Fcreate(filename, H5F_ACC_TRUNC, fcpl, fapl);
     VRFY((file_id >= 0), "");
@@ -471,61 +480,57 @@ create_file(const char *filename, hid_t fcpl, hid_t fapl, int metadata_write_str
     grp_id = H5Gcreate2(file_id, "GROUP", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
     VRFY((grp_id >= 0), "");
 
-    dims[0] = (hsize_t)(ROW_FACTOR*mpi_size);
-    dims[1] = (hsize_t)(COL_FACTOR*mpi_size);
-    sid = H5Screate_simple (RANK, dims, NULL);
+    dims[0] = (hsize_t)(ROW_FACTOR * mpi_size);
+    dims[1] = (hsize_t)(COL_FACTOR * mpi_size);
+    sid     = H5Screate_simple(RANK, dims, NULL);
     VRFY((sid >= 0), "H5Screate_simple succeeded");
 
     /* Each process takes a slabs of rows. */
-    block[0] = dims[0]/(hsize_t)mpi_size;
-    block[1] = dims[1];
+    block[0]  = dims[0] / (hsize_t)mpi_size;
+    block[1]  = dims[1];
     stride[0] = block[0];
     stride[1] = block[1];
-    count[0] = 1;
-    count[1] = 1;
-    start[0] = (hsize_t)mpi_rank*block[0];
-    start[1] = 0;
+    count[0]  = 1;
+    count[1]  = 1;
+    start[0]  = (hsize_t)mpi_rank * block[0];
+    start[1]  = 0;
 
     num_elements = block[0] * block[1];
     /* allocate memory for data buffer */
-    data_array = (DATATYPE *)HDmalloc(num_elements*sizeof(DATATYPE));
+    data_array = (DATATYPE *)HDmalloc(num_elements * sizeof(DATATYPE));
     VRFY((data_array != NULL), "data_array HDmalloc succeeded");
     /* put some trivial data in the data_array */
-    for(i=0 ; i<num_elements; i++)
+    for (i = 0; i < num_elements; i++)
         data_array[i] = mpi_rank + 1;
 
     ret = H5Sselect_hyperslab(sid, H5S_SELECT_SET, start, stride, count, block);
     VRFY((ret >= 0), "H5Sset_hyperslab succeeded");
 
     /* create a memory dataspace independently */
-    mem_dataspace = H5Screate_simple (1, &num_elements, NULL);
+    mem_dataspace = H5Screate_simple(1, &num_elements, NULL);
     VRFY((mem_dataspace >= 0), "");
 
-    for(k=0 ; k<NUM_DSETS; k++) {
+    for (k = 0; k < NUM_DSETS; k++) {
         HDsprintf(dset_name, "D1dset%d", k);
-        dset_id = H5Dcreate2(grp_id, dset_name, H5T_NATIVE_INT, sid,
-                             H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+        dset_id = H5Dcreate2(grp_id, dset_name, H5T_NATIVE_INT, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
         VRFY((dset_id >= 0), "");
         ret = H5Dclose(dset_id);
         VRFY((ret == 0), "");
 
         HDsprintf(dset_name, "D2dset%d", k);
-        dset_id = H5Dcreate2(grp_id, dset_name, H5T_NATIVE_INT, sid,
-                             H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+        dset_id = H5Dcreate2(grp_id, dset_name, H5T_NATIVE_INT, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
         VRFY((dset_id >= 0), "");
         ret = H5Dclose(dset_id);
         VRFY((ret == 0), "");
 
         HDsprintf(dset_name, "D3dset%d", k);
-        dset_id = H5Dcreate2(grp_id, dset_name, H5T_NATIVE_INT, sid,
-                             H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+        dset_id = H5Dcreate2(grp_id, dset_name, H5T_NATIVE_INT, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
         VRFY((dset_id >= 0), "");
         ret = H5Dclose(dset_id);
         VRFY((ret == 0), "");
 
         HDsprintf(dset_name, "dset%d", k);
-        dset_id = H5Dcreate2(grp_id, dset_name, H5T_NATIVE_INT, sid,
-                             H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+        dset_id = H5Dcreate2(grp_id, dset_name, H5T_NATIVE_INT, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
         VRFY((dset_id >= 0), "");
 
         ret = H5Dwrite(dset_id, H5T_NATIVE_INT, mem_dataspace, sid, H5P_DEFAULT, data_array);
@@ -534,7 +539,7 @@ create_file(const char *filename, hid_t fcpl, hid_t fapl, int metadata_write_str
         ret = H5Dclose(dset_id);
         VRFY((ret == 0), "");
 
-        HDmemset(data_array, 0, num_elements*sizeof(DATATYPE));
+        HDmemset(data_array, 0, num_elements * sizeof(DATATYPE));
         dset_id = H5Dopen2(grp_id, dset_name, H5P_DEFAULT);
         VRFY((dset_id >= 0), "");
 
@@ -544,8 +549,8 @@ create_file(const char *filename, hid_t fcpl, hid_t fapl, int metadata_write_str
         ret = H5Dclose(dset_id);
         VRFY((ret == 0), "");
 
-        for (i=0; i < num_elements; i++)
-            VRFY((data_array[i] == mpi_rank+1), "Dataset Verify failed");
+        for (i = 0; i < num_elements; i++)
+            VRFY((data_array[i] == mpi_rank + 1), "Dataset Verify failed");
 
         HDsprintf(dset_name, "D1dset%d", k);
         ret = H5Ldelete(grp_id, dset_name, H5P_DEFAULT);
@@ -568,7 +573,11 @@ create_file(const char *filename, hid_t fcpl, hid_t fapl, int metadata_write_str
     VRFY((ret == 0), "");
 
     /* Pop API context */
-    if(api_ctx_pushed) { ret = H5CX_pop(); VRFY((ret == 0), "H5CX_pop()"); api_ctx_pushed = FALSE; }
+    if (api_ctx_pushed) {
+        ret = H5CX_pop();
+        VRFY((ret == 0), "H5CX_pop()");
+        api_ctx_pushed = FALSE;
+    }
 
     MPI_Barrier(MPI_COMM_WORLD);
     HDfree(data_array);
@@ -576,28 +585,28 @@ create_file(const char *filename, hid_t fcpl, hid_t fapl, int metadata_write_str
 } /* create_file */
 
 static int
-open_file(const char *filename, hid_t fapl, int metadata_write_strategy,
-          hsize_t page_size, size_t page_buffer_size)
+open_file(const char *filename, hid_t fapl, int metadata_write_strategy, hsize_t page_size,
+          size_t page_buffer_size)
 {
-    hid_t       file_id, dset_id, grp_id, grp_id2;
-    hid_t       sid, mem_dataspace;
-    DATATYPE   *data_array = NULL;
-    hsize_t     dims[RANK];
-    hsize_t     start[RANK];
-    hsize_t     count[RANK];
-    hsize_t     stride[RANK];
-    hsize_t     block[RANK];
-    int         i, k, ndims;
-    hsize_t     num_elements;
-    char        dset_name[20];
-    H5F_t       *f = NULL;
-    H5C_t       *cache_ptr = NULL;
+    hid_t               file_id, dset_id, grp_id, grp_id2;
+    hid_t               sid, mem_dataspace;
+    DATATYPE *          data_array = NULL;
+    hsize_t             dims[RANK];
+    hsize_t             start[RANK];
+    hsize_t             count[RANK];
+    hsize_t             stride[RANK];
+    hsize_t             block[RANK];
+    int                 i, k, ndims;
+    hsize_t             num_elements;
+    char                dset_name[20];
+    H5F_t *             f         = NULL;
+    H5C_t *             cache_ptr = NULL;
     H5AC_cache_config_t config;
-    hbool_t     api_ctx_pushed = FALSE;             /* Whether API context pushed */
-    herr_t      ret;
+    hbool_t             api_ctx_pushed = FALSE; /* Whether API context pushed */
+    herr_t              ret;
 
     config.version = H5AC__CURR_CACHE_CONFIG_VERSION;
-    ret = H5Pget_mdc_config(fapl, &config);
+    ret            = H5Pget_mdc_config(fapl, &config);
     VRFY((ret == 0), "");
 
     config.metadata_write_strategy = metadata_write_strategy;
@@ -632,29 +641,29 @@ open_file(const char *filename, hid_t fapl, int metadata_write_strategy,
     grp_id = H5Gopen2(file_id, "GROUP", H5P_DEFAULT);
     VRFY((grp_id >= 0), "");
 
-    dims[0] = (hsize_t)(ROW_FACTOR*mpi_size);
-    dims[1] = (hsize_t)(COL_FACTOR*mpi_size);
+    dims[0] = (hsize_t)(ROW_FACTOR * mpi_size);
+    dims[1] = (hsize_t)(COL_FACTOR * mpi_size);
 
     /* Each process takes a slabs of rows. */
-    block[0] = dims[0]/(hsize_t)mpi_size;
-    block[1] = dims[1];
+    block[0]  = dims[0] / (hsize_t)mpi_size;
+    block[1]  = dims[1];
     stride[0] = block[0];
     stride[1] = block[1];
-    count[0] = 1;
-    count[1] = 1;
-    start[0] = (hsize_t)mpi_rank*block[0];
-    start[1] = 0;
+    count[0]  = 1;
+    count[1]  = 1;
+    start[0]  = (hsize_t)mpi_rank * block[0];
+    start[1]  = 0;
 
     num_elements = block[0] * block[1];
     /* allocate memory for data buffer */
-    data_array = (DATATYPE *)HDmalloc(num_elements*sizeof(DATATYPE));
+    data_array = (DATATYPE *)HDmalloc(num_elements * sizeof(DATATYPE));
     VRFY((data_array != NULL), "data_array HDmalloc succeeded");
 
     /* create a memory dataspace independently */
-    mem_dataspace = H5Screate_simple (1, &num_elements, NULL);
+    mem_dataspace = H5Screate_simple(1, &num_elements, NULL);
     VRFY((mem_dataspace >= 0), "");
 
-    for(k=0 ; k<NUM_DSETS; k++) {
+    for (k = 0; k < NUM_DSETS; k++) {
         HDsprintf(dset_name, "dset%d", k);
         dset_id = H5Dopen2(grp_id, dset_name, H5P_DEFAULT);
         VRFY((dset_id >= 0), "");
@@ -664,8 +673,8 @@ open_file(const char *filename, hid_t fapl, int metadata_write_strategy,
 
         ndims = H5Sget_simple_extent_dims(sid, dims, NULL);
         VRFY((ndims == 2), "H5Sget_simple_extent_dims succeeded");
-        VRFY(dims[0] == (hsize_t)(ROW_FACTOR*mpi_size), "Wrong dataset dimensions");
-        VRFY(dims[1] == (hsize_t)(COL_FACTOR*mpi_size), "Wrong dataset dimensions");
+        VRFY(dims[0] == (hsize_t)(ROW_FACTOR * mpi_size), "Wrong dataset dimensions");
+        VRFY(dims[1] == (hsize_t)(COL_FACTOR * mpi_size), "Wrong dataset dimensions");
 
         ret = H5Sselect_hyperslab(sid, H5S_SELECT_SET, start, stride, count, block);
         VRFY((ret >= 0), "H5Sset_hyperslab succeeded");
@@ -678,8 +687,8 @@ open_file(const char *filename, hid_t fapl, int metadata_write_strategy,
         ret = H5Sclose(sid);
         VRFY((ret == 0), "");
 
-        for (i=0; i < (int)num_elements; i++)
-            VRFY((data_array[i] == mpi_rank+1), "Dataset Verify failed");
+        for (i = 0; i < (int)num_elements; i++)
+            VRFY((data_array[i] == mpi_rank + 1), "Dataset Verify failed");
     }
 
     grp_id2 = H5Gcreate2(file_id, "GROUP/GROUP2", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
@@ -694,16 +703,16 @@ open_file(const char *filename, hid_t fapl, int metadata_write_strategy,
     /* flush invalidate each ring, starting from the outermost ring and
      * working inward.
      */
-    for ( i = 0; i < H5C__HASH_TABLE_LEN; i++ ) {
-        H5C_cache_entry_t * entry_ptr = NULL;
+    for (i = 0; i < H5C__HASH_TABLE_LEN; i++) {
+        H5C_cache_entry_t *entry_ptr = NULL;
 
         entry_ptr = cache_ptr->index[i];
 
-        while ( entry_ptr != NULL ) {
+        while (entry_ptr != NULL) {
             HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
             HDassert(entry_ptr->is_dirty == FALSE);
 
-            if(!entry_ptr->is_pinned && !entry_ptr->is_protected) {
+            if (!entry_ptr->is_pinned && !entry_ptr->is_protected) {
                 ret = H5AC_expunge_entry(f, entry_ptr->type, entry_ptr->addr, 0);
                 VRFY((ret == 0), "");
             }
@@ -728,7 +737,11 @@ open_file(const char *filename, hid_t fapl, int metadata_write_strategy,
     VRFY((ret == 0), "");
 
     /* Pop API context */
-    if(api_ctx_pushed) { ret = H5CX_pop(); VRFY((ret == 0), "H5CX_pop()"); api_ctx_pushed = FALSE; }
+    if (api_ctx_pushed) {
+        ret = H5CX_pop();
+        VRFY((ret == 0), "H5CX_pop()");
+        api_ctx_pushed = FALSE;
+    }
 
     HDfree(data_array);
 
@@ -743,19 +756,19 @@ open_file(const char *filename, hid_t fapl, int metadata_write_strategy,
 void
 test_file_properties(void)
 {
-    hid_t fid = H5I_INVALID_HID;            /* HDF5 file ID */
-    hid_t fapl_id = H5I_INVALID_HID;        /* File access plist */
-    hid_t fapl_copy_id = H5I_INVALID_HID;   /* File access plist */
-    hbool_t is_coll;
-    htri_t are_equal;
+    hid_t       fid          = H5I_INVALID_HID; /* HDF5 file ID */
+    hid_t       fapl_id      = H5I_INVALID_HID; /* File access plist */
+    hid_t       fapl_copy_id = H5I_INVALID_HID; /* File access plist */
+    hbool_t     is_coll;
+    htri_t      are_equal;
     const char *filename;
-    MPI_Comm comm = MPI_COMM_WORLD;
-    MPI_Info info = MPI_INFO_NULL;
-    MPI_Comm comm_out = MPI_COMM_NULL;
-    MPI_Info info_out = MPI_INFO_NULL;
-    herr_t ret;                 /* Generic return value */
-    int mpi_ret;                /* MPI return value */
-    int cmp;                    /* Compare value */
+    MPI_Comm    comm     = MPI_COMM_WORLD;
+    MPI_Info    info     = MPI_INFO_NULL;
+    MPI_Comm    comm_out = MPI_COMM_NULL;
+    MPI_Info    info_out = MPI_INFO_NULL;
+    herr_t      ret;     /* Generic return value */
+    int         mpi_ret; /* MPI return value */
+    int         cmp;     /* Compare value */
 
     filename = (const char *)GetTestParameters();
 
@@ -785,7 +798,7 @@ test_file_properties(void)
 
     /* Check the communicator */
     VRFY((comm != comm_out), "Communicators should not be bitwise identical");
-    cmp = MPI_UNEQUAL;
+    cmp     = MPI_UNEQUAL;
     mpi_ret = MPI_Comm_compare(comm, comm_out, &cmp);
     VRFY((ret >= 0), "MPI_Comm_compare succeeded");
     VRFY((cmp == MPI_CONGRUENT), "Communicators should be congruent via MPI_Comm_compare");
@@ -932,4 +945,3 @@ test_file_properties(void)
     VRFY((mpi_ret >= 0), "MPI_Info_free succeeded");
 
 } /* end test_file_properties() */
-