Clang-format of source files

1 files changed, 1168 insertions, 1493 deletions

diff --git a/testpar/t_span_tree.c b/testpar/t_span_tree.c
index 8d2b61c..cb5c01a 100644
--- a/testpar/t_span_tree.c
+++ b/testpar/t_span_tree.c
@@ -35,11 +35,9 @@
 #include "H5private.h"
 #include "testphdf5.h"
 
-
 static void coll_write_test(int chunk_factor);
 static void coll_read_test(void);
 
-
 /*-------------------------------------------------------------------------
  * Function:    coll_irregular_cont_write
  *
@@ -59,12 +57,9 @@ void
 coll_irregular_cont_write(void)
 {
 
-  coll_write_test(0);
-
+    coll_write_test(0);
 }
 
-
-
 /*-------------------------------------------------------------------------
  * Function:    coll_irregular_cont_read
  *
@@ -84,11 +79,9 @@ void
 coll_irregular_cont_read(void)
 {
 
-  coll_read_test();
-
+    coll_read_test();
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:    coll_irregular_simple_chunk_write
  *
@@ -108,12 +101,9 @@ void
 coll_irregular_simple_chunk_write(void)
 {
 
-  coll_write_test(1);
-
+    coll_write_test(1);
 }
 
-
-
 /*-------------------------------------------------------------------------
  * Function:    coll_irregular_simple_chunk_read
  *
@@ -133,8 +123,7 @@ void
 coll_irregular_simple_chunk_read(void)
 {
 
-  coll_read_test();
-
+    coll_read_test();
 }
 
 /*-------------------------------------------------------------------------
@@ -156,12 +145,9 @@ void
 coll_irregular_complex_chunk_write(void)
 {
 
-  coll_write_test(4);
-
+    coll_write_test(4);
 }
 
-
-
 /*-------------------------------------------------------------------------
  * Function:    coll_irregular_complex_chunk_read
  *
@@ -181,11 +167,9 @@ void
 coll_irregular_complex_chunk_read(void)
 {
 
-  coll_read_test();
-
+    coll_read_test();
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:    coll_write_test
  *
@@ -202,447 +186,445 @@ coll_irregular_complex_chunk_read(void)
  *
  *-------------------------------------------------------------------------
  */
-void coll_write_test(int chunk_factor)
+void
+coll_write_test(int chunk_factor)
 {
 
-  const    char *filename;
-  hid_t    facc_plist,dxfer_plist,dcrt_plist;
-  hid_t    file, datasetc,dataseti;      /* File and dataset identifiers */
-  hid_t    mspaceid1, mspaceid, fspaceid,fspaceid1; /* Dataspace identifiers */
-
-  hsize_t  mdim1[1];    /* Dimension size of the first dataset (in memory) */
-  hsize_t  fsdim[2];    /* Dimension sizes of the dataset (on disk) */
-  hsize_t  mdim[2];     /* Dimension sizes of the dataset in memory when we
-                         * read selection from the dataset on the disk
-                         */
-
-  hsize_t  start[2];  /* Start of hyperslab */
-  hsize_t  stride[2]; /* Stride of hyperslab */
-  hsize_t  count[2];  /* Block count */
-  hsize_t  block[2];  /* Block sizes */
-  hsize_t  chunk_dims[2];
-
-  herr_t   ret;
-  int      i;
-  int      fillvalue = 0;   /* Fill value for the dataset */
-
-  int      *matrix_out = NULL;
-  int      *matrix_out1 = NULL;     /* Buffer to read from the dataset */
-  int      *vector = NULL;
-
-  int      mpi_size,mpi_rank;
-
-  MPI_Comm comm = MPI_COMM_WORLD;
-  MPI_Info info = MPI_INFO_NULL;
-
-  /*set up MPI parameters */
-  MPI_Comm_size(comm,&mpi_size);
-  MPI_Comm_rank(comm,&mpi_rank);
-
-  /* Obtain file name */
-  filename = GetTestParameters();
-
-  /*
-   * Buffers' initialization.
-   */
-
-  mdim1[0] = (hsize_t)(MSPACE1_DIM*mpi_size);
-  mdim[0]  = MSPACE_DIM1;
-  mdim[1]  = (hsize_t)(MSPACE_DIM2*mpi_size);
-  fsdim[0] = FSPACE_DIM1;
-  fsdim[1] = (hsize_t)(FSPACE_DIM2*mpi_size);
-
-  vector = (int*)HDmalloc(sizeof(int)*(size_t)mdim1[0]*(size_t)mpi_size);
-  matrix_out  = (int*)HDmalloc(sizeof(int)*(size_t)mdim[0]*(size_t)mdim[1]*(size_t)mpi_size);
-  matrix_out1 = (int*)HDmalloc(sizeof(int)*(size_t)mdim[0]*(size_t)mdim[1]*(size_t)mpi_size);
-
-  HDmemset(vector,0,sizeof(int)*(size_t)mdim1[0]*(size_t)mpi_size);
-  vector[0] = vector[MSPACE1_DIM*mpi_size - 1] = -1;
-  for (i = 1; i < MSPACE1_DIM*mpi_size - 1; i++) H5_CHECKED_ASSIGN(vector[i], int, i, unsigned);
-
-  /* Grab file access property list */
-  facc_plist = create_faccess_plist(comm, info, facc_type);
-  VRFY((facc_plist >= 0),"");
-
-  /*
-   * Create a file.
-   */
-  file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, facc_plist);
-  VRFY((file >= 0),"H5Fcreate succeeded");
-
-  /*
-   * Create property list for a dataset and set up fill values.
-   */
-  dcrt_plist = H5Pcreate(H5P_DATASET_CREATE);
-  VRFY((dcrt_plist >= 0),"");
-
-  ret   = H5Pset_fill_value(dcrt_plist, H5T_NATIVE_INT, &fillvalue);
-  VRFY((ret >= 0),"Fill value creation property list succeeded");
-
-  if(chunk_factor != 0) {
-    chunk_dims[0] = fsdim[0] / (hsize_t)chunk_factor;
-    chunk_dims[1] = fsdim[1] / (hsize_t)chunk_factor;
-    ret = H5Pset_chunk(dcrt_plist, 2, chunk_dims);
-    VRFY((ret >= 0),"chunk creation property list succeeded");
-  }
-
-  /*
-   *
-   * Create dataspace for the first dataset in the disk.
-   * dim1 = 9
-   * dim2 = 3600
-   *
-   *
-   */
-  fspaceid = H5Screate_simple(FSPACE_RANK, fsdim, NULL);
-  VRFY((fspaceid >= 0),"file dataspace created succeeded");
-
-  /*
-   * Create dataset in the file. Notice that creation
-   * property list dcrt_plist is used.
-   */
-  datasetc = H5Dcreate2(file, "collect_write", H5T_NATIVE_INT, fspaceid, H5P_DEFAULT, dcrt_plist, H5P_DEFAULT);
-  VRFY((datasetc >= 0),"dataset created succeeded");
-
-  dataseti = H5Dcreate2(file, "independ_write", H5T_NATIVE_INT, fspaceid, H5P_DEFAULT, dcrt_plist, H5P_DEFAULT);
-  VRFY((dataseti >= 0),"dataset created succeeded");
-
-  /* The First selection for FILE
-   *
-   *  block (3,2)
-   *  stride(4,3)
-   *  count (1,768/mpi_size)
-   *  start (0,1+768*3*mpi_rank/mpi_size)
-   *
-   */
-
-  start[0]  = FHSTART0;
-  start[1]  = (hsize_t)(FHSTART1 + mpi_rank * FHSTRIDE1 * FHCOUNT1);
-  stride[0] = FHSTRIDE0;
-  stride[1] = FHSTRIDE1;
-  count[0]  = FHCOUNT0;
-  count[1]  = FHCOUNT1;
-  block[0]  = FHBLOCK0;
-  block[1]  = FHBLOCK1;
-
-  ret = H5Sselect_hyperslab(fspaceid, H5S_SELECT_SET, start, stride, count, block);
-  VRFY((ret >= 0),"hyperslab selection succeeded");
-
-  /* The Second selection for FILE
-   *
-   *  block  (3,768)
-   *  stride (1,1)
-   *  count  (1,1)
-   *  start  (4,768*mpi_rank/mpi_size)
-   *
-   */
-
-  start[0]  = SHSTART0;
-  start[1]  = (hsize_t)(SHSTART1+SHCOUNT1*SHBLOCK1*mpi_rank);
-  stride[0] = SHSTRIDE0;
-  stride[1] = SHSTRIDE1;
-  count[0]  = SHCOUNT0;
-  count[1]  = SHCOUNT1;
-  block[0]  = SHBLOCK0;
-  block[1]  = SHBLOCK1;
-
-  ret = H5Sselect_hyperslab(fspaceid, H5S_SELECT_OR, start, stride, count, block);
-  VRFY((ret >= 0),"hyperslab selection succeeded");
-
-  /*
-   * Create dataspace for the first dataset in the memory
-   * dim1 = 27000
-   *
-   */
-  mspaceid1 = H5Screate_simple(MSPACE1_RANK, mdim1, NULL);
-  VRFY((mspaceid1 >= 0),"memory dataspace created succeeded");
-
-  /*
-   * Memory space is 1-D, this is a good test to check
-   * whether a span-tree derived datatype needs to be built.
-   * block  1
-   * stride 1
-   * count  6912/mpi_size
-   * start  1
-   *
-   */
-  start[0]  = MHSTART0;
-  stride[0] = MHSTRIDE0;
-  count[0]  = MHCOUNT0;
-  block[0]  = MHBLOCK0;
-
-  ret = H5Sselect_hyperslab(mspaceid1, H5S_SELECT_SET, start, stride, count, block);
-  VRFY((ret >= 0),"hyperslab selection succeeded");
-
-  /* independent write */
-  ret = H5Dwrite(dataseti, H5T_NATIVE_INT, mspaceid1, fspaceid, H5P_DEFAULT, vector);
-  VRFY((ret >= 0),"dataset independent write succeed");
-
-  dxfer_plist = H5Pcreate(H5P_DATASET_XFER);
-  VRFY((dxfer_plist >= 0),"");
-
-  ret = H5Pset_dxpl_mpio(dxfer_plist, H5FD_MPIO_COLLECTIVE);
-  VRFY((ret >= 0),"MPIO data transfer property list succeed");
-  if(dxfer_coll_type == DXFER_INDEPENDENT_IO) {
-     ret = H5Pset_dxpl_mpio_collective_opt(dxfer_plist,H5FD_MPIO_INDIVIDUAL_IO);
-     VRFY((ret>= 0),"set independent IO collectively succeeded");
-  }
-
-
-  /* collective write */
-  ret = H5Dwrite(datasetc, H5T_NATIVE_INT, mspaceid1, fspaceid, dxfer_plist, vector);
-  VRFY((ret >= 0),"dataset collective write succeed");
-
-  ret = H5Sclose(mspaceid1);
-  VRFY((ret >= 0),"");
-
-  ret = H5Sclose(fspaceid);
-  VRFY((ret >= 0),"");
-
-  /*
-   * Close dataset.
-   */
-  ret = H5Dclose(datasetc);
-  VRFY((ret >= 0),"");
-
-  ret = H5Dclose(dataseti);
-  VRFY((ret >= 0),"");
-
-  /*
-   * Close the file.
-   */
-  ret = H5Fclose(file);
-  VRFY((ret >= 0),"");
-  /*
-   * Close property list
-   */
-
-  ret = H5Pclose(facc_plist);
-  VRFY((ret >= 0),"");
-  ret = H5Pclose(dxfer_plist);
-  VRFY((ret >= 0),"");
-  ret = H5Pclose(dcrt_plist);
-  VRFY((ret >= 0),"");
-
-  /*
-   * Open the file.
-   */
-
-  /***
-
-       For testing collective hyperslab selection write
-       In this test, we are using independent read to check
-       the correctedness of collective write compared with
-       independent write,
-
-       In order to throughly test this feature, we choose
-       a different selection set for reading the data out.
-
-
-  ***/
-
-  /* Obtain file access property list with MPI-IO driver */
-  facc_plist = create_faccess_plist(comm, info, facc_type);
-  VRFY((facc_plist >= 0),"");
-
-  file = H5Fopen(filename, H5F_ACC_RDONLY, facc_plist);
-  VRFY((file >= 0),"H5Fopen succeeded");
-
-  /*
-   * Open the dataset.
-   */
-  datasetc = H5Dopen2(file,"collect_write", H5P_DEFAULT);
-  VRFY((datasetc >= 0),"H5Dopen2 succeeded");
-
-  dataseti = H5Dopen2(file,"independ_write", H5P_DEFAULT);
-  VRFY((dataseti >= 0),"H5Dopen2 succeeded");
-
-  /*
-   * Get dataspace of the open dataset.
-   */
-  fspaceid  = H5Dget_space(datasetc);
-  VRFY((fspaceid >= 0),"file dataspace obtained succeeded");
-
-  fspaceid1 = H5Dget_space(dataseti);
-  VRFY((fspaceid1 >= 0),"file dataspace obtained succeeded");
-
-
-  /* The First selection for FILE to read
-   *
-   *  block (1,1)
-   *  stride(1.1)
-   *  count (3,768/mpi_size)
-   *  start (1,2+768*mpi_rank/mpi_size)
-   *
-   */
-  start[0]  = RFFHSTART0;
-  start[1]  = (hsize_t)(RFFHSTART1+mpi_rank*RFFHCOUNT1);
-  block[0]  = RFFHBLOCK0;
-  block[1]  = RFFHBLOCK1;
-  stride[0] = RFFHSTRIDE0;
-  stride[1] = RFFHSTRIDE1;
-  count[0]  = RFFHCOUNT0;
-  count[1]  = RFFHCOUNT1;
-
-
-  /* The first selection of the dataset generated by collective write */
-  ret = H5Sselect_hyperslab(fspaceid, H5S_SELECT_SET, start, stride, count, block);
-  VRFY((ret >= 0),"hyperslab selection succeeded");
-
-  /* The first selection of the dataset generated by independent write */
-  ret = H5Sselect_hyperslab(fspaceid1, H5S_SELECT_SET, start, stride, count, block);
-  VRFY((ret >= 0),"hyperslab selection succeeded");
-
-  /* The Second selection for FILE to read
-   *
-   *  block (1,1)
-   *  stride(1.1)
-   *  count (3,1536/mpi_size)
-   *  start (2,4+1536*mpi_rank/mpi_size)
-   *
-   */
-
-  start[0] = RFSHSTART0;
-  start[1] = (hsize_t)(RFSHSTART1+RFSHCOUNT1*mpi_rank);
-  block[0] = RFSHBLOCK0;
-  block[1] = RFSHBLOCK1;
-  stride[0] = RFSHSTRIDE0;
-  stride[1] = RFSHSTRIDE0;
-  count[0]  = RFSHCOUNT0;
-  count[1]  = RFSHCOUNT1;
-
-  /* The second selection of the dataset generated by collective write */
-  ret = H5Sselect_hyperslab(fspaceid, H5S_SELECT_OR, start, stride, count, block);
-  VRFY((ret >= 0),"hyperslab selection succeeded");
-
-  /* The second selection of the dataset generated by independent write */
-  ret = H5Sselect_hyperslab(fspaceid1, H5S_SELECT_OR, start, stride, count, block);
-  VRFY((ret >= 0),"hyperslab selection succeeded");
-
-  /*
-   * Create memory dataspace.
-   * rank  = 2
-   * mdim1 = 9
-   * mdim2 = 3600
-   *
-   */
-  mspaceid = H5Screate_simple(MSPACE_RANK, mdim, NULL);
-
-  /*
-   * Select two hyperslabs in memory. Hyperslabs has the same
-   * size and shape as the selected hyperslabs for the file dataspace
-   * Only the starting point is different.
-   * The first selection
-   *  block (1,1)
-   *  stride(1.1)
-   *  count (3,768/mpi_size)
-   *  start (0,768*mpi_rank/mpi_size)
-   *
-   */
-
-
-  start[0]  = RMFHSTART0;
-  start[1]  = (hsize_t)(RMFHSTART1+mpi_rank*RMFHCOUNT1);
-  block[0]  = RMFHBLOCK0;
-  block[1]  = RMFHBLOCK1;
-  stride[0] = RMFHSTRIDE0;
-  stride[1] = RMFHSTRIDE1;
-  count[0]  = RMFHCOUNT0;
-  count[1]  = RMFHCOUNT1;
-
-  ret = H5Sselect_hyperslab(mspaceid, H5S_SELECT_SET, start, stride, count, block);
-  VRFY((ret >= 0),"hyperslab selection succeeded");
-
-  /*
-   * Select two hyperslabs in memory. Hyperslabs has the same
-   * size and shape as the selected hyperslabs for the file dataspace
-   * Only the starting point is different.
-   * The second selection
-   *  block (1,1)
-   *  stride(1,1)
-   *  count (3,1536/mpi_size)
-   *  start (1,2+1536*mpi_rank/mpi_size)
-   *
-   */
-  start[0]  = RMSHSTART0;
-  start[1]  = (hsize_t)(RMSHSTART1+mpi_rank*RMSHCOUNT1);
-  block[0]  = RMSHBLOCK0;
-  block[1]  = RMSHBLOCK1;
-  stride[0] = RMSHSTRIDE0;
-  stride[1] = RMSHSTRIDE1;
-  count[0]  = RMSHCOUNT0;
-  count[1]  = RMSHCOUNT1;
-
-  ret = H5Sselect_hyperslab(mspaceid, H5S_SELECT_OR, start, stride, count, block);
-  VRFY((ret >= 0),"hyperslab selection succeeded");
-
-  /*
-   * Initialize data buffer.
-   */
-
-  HDmemset(matrix_out,0,sizeof(int)*(size_t)MSPACE_DIM1*(size_t)MSPACE_DIM2*(size_t)mpi_size);
-  HDmemset(matrix_out1,0,sizeof(int)*(size_t)MSPACE_DIM1*(size_t)MSPACE_DIM2*(size_t)mpi_size);
-  /*
-   * Read data back to the buffer matrix_out.
-   */
-
-  ret = H5Dread(datasetc, H5T_NATIVE_INT, mspaceid, fspaceid,
-        H5P_DEFAULT, matrix_out);
-  VRFY((ret >= 0),"H5D independent read succeed");
-
-
-  ret = H5Dread(dataseti, H5T_NATIVE_INT, mspaceid, fspaceid,
-        H5P_DEFAULT, matrix_out1);
-  VRFY((ret >= 0),"H5D independent read succeed");
-
-  ret = 0;
-
-  for (i = 0; i < MSPACE_DIM1*MSPACE_DIM2*mpi_size; i++){
-         if(matrix_out[i]!=matrix_out1[i]) ret = -1;
-      if(ret < 0) break;
+    const char *filename;
+    hid_t       facc_plist, dxfer_plist, dcrt_plist;
+    hid_t       file, datasetc, dataseti;                 /* File and dataset identifiers */
+    hid_t       mspaceid1, mspaceid, fspaceid, fspaceid1; /* Dataspace identifiers */
+
+    hsize_t mdim1[1]; /* Dimension size of the first dataset (in memory) */
+    hsize_t fsdim[2]; /* Dimension sizes of the dataset (on disk) */
+    hsize_t mdim[2];  /* Dimension sizes of the dataset in memory when we
+                       * read selection from the dataset on the disk
+                       */
+
+    hsize_t start[2];  /* Start of hyperslab */
+    hsize_t stride[2]; /* Stride of hyperslab */
+    hsize_t count[2];  /* Block count */
+    hsize_t block[2];  /* Block sizes */
+    hsize_t chunk_dims[2];
+
+    herr_t ret;
+    int    i;
+    int    fillvalue = 0; /* Fill value for the dataset */
+
+    int *matrix_out  = NULL;
+    int *matrix_out1 = NULL; /* Buffer to read from the dataset */
+    int *vector      = NULL;
+
+    int mpi_size, mpi_rank;
+
+    MPI_Comm comm = MPI_COMM_WORLD;
+    MPI_Info info = MPI_INFO_NULL;
+
+    /*set up MPI parameters */
+    MPI_Comm_size(comm, &mpi_size);
+    MPI_Comm_rank(comm, &mpi_rank);
+
+    /* Obtain file name */
+    filename = GetTestParameters();
+
+    /*
+     * Buffers' initialization.
+     */
+
+    mdim1[0] = (hsize_t)(MSPACE1_DIM * mpi_size);
+    mdim[0]  = MSPACE_DIM1;
+    mdim[1]  = (hsize_t)(MSPACE_DIM2 * mpi_size);
+    fsdim[0] = FSPACE_DIM1;
+    fsdim[1] = (hsize_t)(FSPACE_DIM2 * mpi_size);
+
+    vector      = (int *)HDmalloc(sizeof(int) * (size_t)mdim1[0] * (size_t)mpi_size);
+    matrix_out  = (int *)HDmalloc(sizeof(int) * (size_t)mdim[0] * (size_t)mdim[1] * (size_t)mpi_size);
+    matrix_out1 = (int *)HDmalloc(sizeof(int) * (size_t)mdim[0] * (size_t)mdim[1] * (size_t)mpi_size);
+
+    HDmemset(vector, 0, sizeof(int) * (size_t)mdim1[0] * (size_t)mpi_size);
+    vector[0] = vector[MSPACE1_DIM * mpi_size - 1] = -1;
+    for (i = 1; i < MSPACE1_DIM * mpi_size - 1; i++)
+        H5_CHECKED_ASSIGN(vector[i], int, i, unsigned);
+
+    /* Grab file access property list */
+    facc_plist = create_faccess_plist(comm, info, facc_type);
+    VRFY((facc_plist >= 0), "");
+
+    /*
+     * Create a file.
+     */
+    file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, facc_plist);
+    VRFY((file >= 0), "H5Fcreate succeeded");
+
+    /*
+     * Create property list for a dataset and set up fill values.
+     */
+    dcrt_plist = H5Pcreate(H5P_DATASET_CREATE);
+    VRFY((dcrt_plist >= 0), "");
+
+    ret = H5Pset_fill_value(dcrt_plist, H5T_NATIVE_INT, &fillvalue);
+    VRFY((ret >= 0), "Fill value creation property list succeeded");
+
+    if (chunk_factor != 0) {
+        chunk_dims[0] = fsdim[0] / (hsize_t)chunk_factor;
+        chunk_dims[1] = fsdim[1] / (hsize_t)chunk_factor;
+        ret           = H5Pset_chunk(dcrt_plist, 2, chunk_dims);
+        VRFY((ret >= 0), "chunk creation property list succeeded");
     }
 
-  VRFY((ret >= 0),"H5D irregular collective write succeed");
+    /*
+     *
+     * Create dataspace for the first dataset in the disk.
+     * dim1 = 9
+     * dim2 = 3600
+     *
+     *
+     */
+    fspaceid = H5Screate_simple(FSPACE_RANK, fsdim, NULL);
+    VRFY((fspaceid >= 0), "file dataspace created succeeded");
 
-  /*
-   * Close memory file and memory dataspaces.
-   */
-  ret = H5Sclose(mspaceid);
-  VRFY((ret >= 0),"");
-  ret = H5Sclose(fspaceid);
-  VRFY((ret >= 0),"");
+    /*
+     * Create dataset in the file. Notice that creation
+     * property list dcrt_plist is used.
+     */
+    datasetc =
+        H5Dcreate2(file, "collect_write", H5T_NATIVE_INT, fspaceid, H5P_DEFAULT, dcrt_plist, H5P_DEFAULT);
+    VRFY((datasetc >= 0), "dataset created succeeded");
 
-  /*
-   * Close dataset.
-   */
-  ret = H5Dclose(dataseti);
-  VRFY((ret >= 0),"");
+    dataseti =
+        H5Dcreate2(file, "independ_write", H5T_NATIVE_INT, fspaceid, H5P_DEFAULT, dcrt_plist, H5P_DEFAULT);
+    VRFY((dataseti >= 0), "dataset created succeeded");
 
-  ret = H5Dclose(datasetc);
-  VRFY((ret >= 0),"");
+    /* The First selection for FILE
+     *
+     *  block (3,2)
+     *  stride(4,3)
+     *  count (1,768/mpi_size)
+     *  start (0,1+768*3*mpi_rank/mpi_size)
+     *
+     */
+
+    start[0]  = FHSTART0;
+    start[1]  = (hsize_t)(FHSTART1 + mpi_rank * FHSTRIDE1 * FHCOUNT1);
+    stride[0] = FHSTRIDE0;
+    stride[1] = FHSTRIDE1;
+    count[0]  = FHCOUNT0;
+    count[1]  = FHCOUNT1;
+    block[0]  = FHBLOCK0;
+    block[1]  = FHBLOCK1;
 
-  /*
-   * Close property list
-   */
+    ret = H5Sselect_hyperslab(fspaceid, H5S_SELECT_SET, start, stride, count, block);
+    VRFY((ret >= 0), "hyperslab selection succeeded");
 
-  ret = H5Pclose(facc_plist);
-  VRFY((ret >= 0),"");
+    /* The Second selection for FILE
+     *
+     *  block  (3,768)
+     *  stride (1,1)
+     *  count  (1,1)
+     *  start  (4,768*mpi_rank/mpi_size)
+     *
+     */
 
+    start[0]  = SHSTART0;
+    start[1]  = (hsize_t)(SHSTART1 + SHCOUNT1 * SHBLOCK1 * mpi_rank);
+    stride[0] = SHSTRIDE0;
+    stride[1] = SHSTRIDE1;
+    count[0]  = SHCOUNT0;
+    count[1]  = SHCOUNT1;
+    block[0]  = SHBLOCK0;
+    block[1]  = SHBLOCK1;
+
+    ret = H5Sselect_hyperslab(fspaceid, H5S_SELECT_OR, start, stride, count, block);
+    VRFY((ret >= 0), "hyperslab selection succeeded");
+
+    /*
+     * Create dataspace for the first dataset in the memory
+     * dim1 = 27000
+     *
+     */
+    mspaceid1 = H5Screate_simple(MSPACE1_RANK, mdim1, NULL);
+    VRFY((mspaceid1 >= 0), "memory dataspace created succeeded");
+
+    /*
+     * Memory space is 1-D, this is a good test to check
+     * whether a span-tree derived datatype needs to be built.
+     * block  1
+     * stride 1
+     * count  6912/mpi_size
+     * start  1
+     *
+     */
+    start[0]  = MHSTART0;
+    stride[0] = MHSTRIDE0;
+    count[0]  = MHCOUNT0;
+    block[0]  = MHBLOCK0;
+
+    ret = H5Sselect_hyperslab(mspaceid1, H5S_SELECT_SET, start, stride, count, block);
+    VRFY((ret >= 0), "hyperslab selection succeeded");
+
+    /* independent write */
+    ret = H5Dwrite(dataseti, H5T_NATIVE_INT, mspaceid1, fspaceid, H5P_DEFAULT, vector);
+    VRFY((ret >= 0), "dataset independent write succeed");
+
+    dxfer_plist = H5Pcreate(H5P_DATASET_XFER);
+    VRFY((dxfer_plist >= 0), "");
+
+    ret = H5Pset_dxpl_mpio(dxfer_plist, H5FD_MPIO_COLLECTIVE);
+    VRFY((ret >= 0), "MPIO data transfer property list succeed");
+    if (dxfer_coll_type == DXFER_INDEPENDENT_IO) {
+        ret = H5Pset_dxpl_mpio_collective_opt(dxfer_plist, H5FD_MPIO_INDIVIDUAL_IO);
+        VRFY((ret >= 0), "set independent IO collectively succeeded");
+    }
+
+    /* collective write */
+    ret = H5Dwrite(datasetc, H5T_NATIVE_INT, mspaceid1, fspaceid, dxfer_plist, vector);
+    VRFY((ret >= 0), "dataset collective write succeed");
+
+    ret = H5Sclose(mspaceid1);
+    VRFY((ret >= 0), "");
+
+    ret = H5Sclose(fspaceid);
+    VRFY((ret >= 0), "");
+
+    /*
+     * Close dataset.
+     */
+    ret = H5Dclose(datasetc);
+    VRFY((ret >= 0), "");
+
+    ret = H5Dclose(dataseti);
+    VRFY((ret >= 0), "");
+
+    /*
+     * Close the file.
+     */
+    ret = H5Fclose(file);
+    VRFY((ret >= 0), "");
+    /*
+     * Close property list
+     */
+
+    ret = H5Pclose(facc_plist);
+    VRFY((ret >= 0), "");
+    ret = H5Pclose(dxfer_plist);
+    VRFY((ret >= 0), "");
+    ret = H5Pclose(dcrt_plist);
+    VRFY((ret >= 0), "");
+
+    /*
+     * Open the file.
+     */
 
-  /*
-   * Close the file.
-   */
-  ret = H5Fclose(file);
-  VRFY((ret >= 0),"");
+    /***
 
-  if (vector)
-      HDfree(vector);
-  if (matrix_out)
-      HDfree(matrix_out);
-  if (matrix_out1)
-      HDfree(matrix_out1);
+         For testing collective hyperslab selection write
+         In this test, we are using independent read to check
+         the correctedness of collective write compared with
+         independent write,
 
-  return ;
+         In order to throughly test this feature, we choose
+         a different selection set for reading the data out.
+
+
+    ***/
+
+    /* Obtain file access property list with MPI-IO driver */
+    facc_plist = create_faccess_plist(comm, info, facc_type);
+    VRFY((facc_plist >= 0), "");
+
+    file = H5Fopen(filename, H5F_ACC_RDONLY, facc_plist);
+    VRFY((file >= 0), "H5Fopen succeeded");
+
+    /*
+     * Open the dataset.
+     */
+    datasetc = H5Dopen2(file, "collect_write", H5P_DEFAULT);
+    VRFY((datasetc >= 0), "H5Dopen2 succeeded");
+
+    dataseti = H5Dopen2(file, "independ_write", H5P_DEFAULT);
+    VRFY((dataseti >= 0), "H5Dopen2 succeeded");
+
+    /*
+     * Get dataspace of the open dataset.
+     */
+    fspaceid = H5Dget_space(datasetc);
+    VRFY((fspaceid >= 0), "file dataspace obtained succeeded");
+
+    fspaceid1 = H5Dget_space(dataseti);
+    VRFY((fspaceid1 >= 0), "file dataspace obtained succeeded");
+
+    /* The First selection for FILE to read
+     *
+     *  block (1,1)
+     *  stride(1.1)
+     *  count (3,768/mpi_size)
+     *  start (1,2+768*mpi_rank/mpi_size)
+     *
+     */
+    start[0]  = RFFHSTART0;
+    start[1]  = (hsize_t)(RFFHSTART1 + mpi_rank * RFFHCOUNT1);
+    block[0]  = RFFHBLOCK0;
+    block[1]  = RFFHBLOCK1;
+    stride[0] = RFFHSTRIDE0;
+    stride[1] = RFFHSTRIDE1;
+    count[0]  = RFFHCOUNT0;
+    count[1]  = RFFHCOUNT1;
+
+    /* The first selection of the dataset generated by collective write */
+    ret = H5Sselect_hyperslab(fspaceid, H5S_SELECT_SET, start, stride, count, block);
+    VRFY((ret >= 0), "hyperslab selection succeeded");
+
+    /* The first selection of the dataset generated by independent write */
+    ret = H5Sselect_hyperslab(fspaceid1, H5S_SELECT_SET, start, stride, count, block);
+    VRFY((ret >= 0), "hyperslab selection succeeded");
+
+    /* The Second selection for FILE to read
+     *
+     *  block (1,1)
+     *  stride(1.1)
+     *  count (3,1536/mpi_size)
+     *  start (2,4+1536*mpi_rank/mpi_size)
+     *
+     */
+
+    start[0]  = RFSHSTART0;
+    start[1]  = (hsize_t)(RFSHSTART1 + RFSHCOUNT1 * mpi_rank);
+    block[0]  = RFSHBLOCK0;
+    block[1]  = RFSHBLOCK1;
+    stride[0] = RFSHSTRIDE0;
+    stride[1] = RFSHSTRIDE0;
+    count[0]  = RFSHCOUNT0;
+    count[1]  = RFSHCOUNT1;
+
+    /* The second selection of the dataset generated by collective write */
+    ret = H5Sselect_hyperslab(fspaceid, H5S_SELECT_OR, start, stride, count, block);
+    VRFY((ret >= 0), "hyperslab selection succeeded");
+
+    /* The second selection of the dataset generated by independent write */
+    ret = H5Sselect_hyperslab(fspaceid1, H5S_SELECT_OR, start, stride, count, block);
+    VRFY((ret >= 0), "hyperslab selection succeeded");
+
+    /*
+     * Create memory dataspace.
+     * rank  = 2
+     * mdim1 = 9
+     * mdim2 = 3600
+     *
+     */
+    mspaceid = H5Screate_simple(MSPACE_RANK, mdim, NULL);
+
+    /*
+     * Select two hyperslabs in memory. Hyperslabs has the same
+     * size and shape as the selected hyperslabs for the file dataspace
+     * Only the starting point is different.
+     * The first selection
+     *  block (1,1)
+     *  stride(1.1)
+     *  count (3,768/mpi_size)
+     *  start (0,768*mpi_rank/mpi_size)
+     *
+     */
+
+    start[0]  = RMFHSTART0;
+    start[1]  = (hsize_t)(RMFHSTART1 + mpi_rank * RMFHCOUNT1);
+    block[0]  = RMFHBLOCK0;
+    block[1]  = RMFHBLOCK1;
+    stride[0] = RMFHSTRIDE0;
+    stride[1] = RMFHSTRIDE1;
+    count[0]  = RMFHCOUNT0;
+    count[1]  = RMFHCOUNT1;
+
+    ret = H5Sselect_hyperslab(mspaceid, H5S_SELECT_SET, start, stride, count, block);
+    VRFY((ret >= 0), "hyperslab selection succeeded");
+
+    /*
+     * Select two hyperslabs in memory. Hyperslabs has the same
+     * size and shape as the selected hyperslabs for the file dataspace
+     * Only the starting point is different.
+     * The second selection
+     *  block (1,1)
+     *  stride(1,1)
+     *  count (3,1536/mpi_size)
+     *  start (1,2+1536*mpi_rank/mpi_size)
+     *
+     */
+    start[0]  = RMSHSTART0;
+    start[1]  = (hsize_t)(RMSHSTART1 + mpi_rank * RMSHCOUNT1);
+    block[0]  = RMSHBLOCK0;
+    block[1]  = RMSHBLOCK1;
+    stride[0] = RMSHSTRIDE0;
+    stride[1] = RMSHSTRIDE1;
+    count[0]  = RMSHCOUNT0;
+    count[1]  = RMSHCOUNT1;
+
+    ret = H5Sselect_hyperslab(mspaceid, H5S_SELECT_OR, start, stride, count, block);
+    VRFY((ret >= 0), "hyperslab selection succeeded");
+
+    /*
+     * Initialize data buffer.
+     */
+
+    HDmemset(matrix_out, 0, sizeof(int) * (size_t)MSPACE_DIM1 * (size_t)MSPACE_DIM2 * (size_t)mpi_size);
+    HDmemset(matrix_out1, 0, sizeof(int) * (size_t)MSPACE_DIM1 * (size_t)MSPACE_DIM2 * (size_t)mpi_size);
+    /*
+     * Read data back to the buffer matrix_out.
+     */
+
+    ret = H5Dread(datasetc, H5T_NATIVE_INT, mspaceid, fspaceid, H5P_DEFAULT, matrix_out);
+    VRFY((ret >= 0), "H5D independent read succeed");
+
+    ret = H5Dread(dataseti, H5T_NATIVE_INT, mspaceid, fspaceid, H5P_DEFAULT, matrix_out1);
+    VRFY((ret >= 0), "H5D independent read succeed");
+
+    ret = 0;
+
+    for (i = 0; i < MSPACE_DIM1 * MSPACE_DIM2 * mpi_size; i++) {
+        if (matrix_out[i] != matrix_out1[i])
+            ret = -1;
+        if (ret < 0)
+            break;
+    }
+
+    VRFY((ret >= 0), "H5D irregular collective write succeed");
+
+    /*
+     * Close memory file and memory dataspaces.
+     */
+    ret = H5Sclose(mspaceid);
+    VRFY((ret >= 0), "");
+    ret = H5Sclose(fspaceid);
+    VRFY((ret >= 0), "");
+
+    /*
+     * Close dataset.
+     */
+    ret = H5Dclose(dataseti);
+    VRFY((ret >= 0), "");
+
+    ret = H5Dclose(datasetc);
+    VRFY((ret >= 0), "");
+
+    /*
+     * Close property list
+     */
+
+    ret = H5Pclose(facc_plist);
+    VRFY((ret >= 0), "");
+
+    /*
+     * Close the file.
+     */
+    ret = H5Fclose(file);
+    VRFY((ret >= 0), "");
+
+    if (vector)
+        HDfree(vector);
+    if (matrix_out)
+        HDfree(matrix_out);
+    if (matrix_out1)
+        HDfree(matrix_out1);
+
+    return;
 }
 
 /*-------------------------------------------------------------------------
@@ -665,243 +647,235 @@ static void
 coll_read_test(void)
 {
 
-  const   char *filename;
-  hid_t   facc_plist,dxfer_plist;
-  hid_t   file, dataseti;           /* File and dataset identifiers */
-  hid_t   mspaceid, fspaceid1;      /* Dataspace identifiers */
-
-
-  /* Dimension sizes of the dataset (on disk) */
-  hsize_t mdim[2];      /* Dimension sizes of the dataset in memory when we
-                         * read selection from the dataset on the disk
-                         */
-
-  hsize_t  start[2];  /* Start of hyperslab */
-  hsize_t  stride[2]; /* Stride of hyperslab */
-  hsize_t  count[2];  /* Block count */
-  hsize_t  block[2];  /* Block sizes */
-  herr_t   ret;
-
-  int      i;
-
-  int     *matrix_out;
-  int     *matrix_out1;     /* Buffer to read from the dataset */
-
-  int      mpi_size,mpi_rank;
-
-  MPI_Comm comm = MPI_COMM_WORLD;
-  MPI_Info info = MPI_INFO_NULL;
-
-  /*set up MPI parameters */
-  MPI_Comm_size(comm,&mpi_size);
-  MPI_Comm_rank(comm,&mpi_rank);
-
-
-  /* Obtain file name */
-  filename = GetTestParameters();
-
-
-  /* Initialize the buffer */
-
-  mdim[0] = MSPACE_DIM1;
-  mdim[1] = (hsize_t)(MSPACE_DIM2*mpi_size);
-  matrix_out =(int*)HDmalloc(sizeof(int)*(size_t)MSPACE_DIM1*(size_t)MSPACE_DIM2*(size_t)mpi_size);
-  matrix_out1=(int*)HDmalloc(sizeof(int)*(size_t)MSPACE_DIM1*(size_t)MSPACE_DIM2*(size_t)mpi_size);
-
-  /*** For testing collective hyperslab selection read ***/
-
-  /* Obtain file access property list */
-  facc_plist = create_faccess_plist(comm, info, facc_type);
-  VRFY((facc_plist >= 0),"");
-
-   /*
-   * Open the file.
-   */
-  file = H5Fopen(filename, H5F_ACC_RDONLY, facc_plist);
-  VRFY((file >= 0),"H5Fopen succeeded");
-
-  /*
-   * Open the dataset.
-   */
-  dataseti = H5Dopen2(file,"independ_write", H5P_DEFAULT);
-  VRFY((dataseti >= 0),"H5Dopen2 succeeded");
-
-  /*
-   * Get dataspace of the open dataset.
-   */
-  fspaceid1 = H5Dget_space(dataseti);
-  VRFY((fspaceid1 >= 0),"file dataspace obtained succeeded");
-
-  /* The First selection for FILE to read
-   *
-   *  block (1,1)
-   *  stride(1.1)
-   *  count (3,768/mpi_size)
-   *  start (1,2+768*mpi_rank/mpi_size)
-   *
-   */
-  start[0]  = RFFHSTART0;
-  start[1]  = (hsize_t)(RFFHSTART1+mpi_rank*RFFHCOUNT1);
-  block[0]  = RFFHBLOCK0;
-  block[1]  = RFFHBLOCK1;
-  stride[0] = RFFHSTRIDE0;
-  stride[1] = RFFHSTRIDE1;
-  count[0]  = RFFHCOUNT0;
-  count[1]  = RFFHCOUNT1;
-
-  ret = H5Sselect_hyperslab(fspaceid1, H5S_SELECT_SET, start, stride, count, block);
-  VRFY((ret >= 0),"hyperslab selection succeeded");
-
-  /* The Second selection for FILE to read
-   *
-   *  block (1,1)
-   *  stride(1.1)
-   *  count (3,1536/mpi_size)
-   *  start (2,4+1536*mpi_rank/mpi_size)
-   *
-   */
-  start[0]  = RFSHSTART0;
-  start[1]  = (hsize_t)(RFSHSTART1+RFSHCOUNT1*mpi_rank);
-  block[0]  = RFSHBLOCK0;
-  block[1]  = RFSHBLOCK1;
-  stride[0] = RFSHSTRIDE0;
-  stride[1] = RFSHSTRIDE0;
-  count[0]  = RFSHCOUNT0;
-  count[1]  = RFSHCOUNT1;
-
-  ret = H5Sselect_hyperslab(fspaceid1, H5S_SELECT_OR, start, stride, count, block);
-  VRFY((ret >= 0),"hyperslab selection succeeded");
-
-
-  /*
-   * Create memory dataspace.
-   */
-  mspaceid = H5Screate_simple(MSPACE_RANK, mdim, NULL);
-
-  /*
-   * Select two hyperslabs in memory. Hyperslabs has the same
-   * size and shape as the selected hyperslabs for the file dataspace.
-   * Only the starting point is different.
-   * The first selection
-   *  block (1,1)
-   *  stride(1.1)
-   *  count (3,768/mpi_size)
-   *  start (0,768*mpi_rank/mpi_size)
-   *
-   */
-
-  start[0]  = RMFHSTART0;
-  start[1]  = (hsize_t)(RMFHSTART1+mpi_rank*RMFHCOUNT1);
-  block[0]  = RMFHBLOCK0;
-  block[1]  = RMFHBLOCK1;
-  stride[0] = RMFHSTRIDE0;
-  stride[1] = RMFHSTRIDE1;
-  count[0]  = RMFHCOUNT0;
-  count[1]  = RMFHCOUNT1;
-  ret = H5Sselect_hyperslab(mspaceid, H5S_SELECT_SET, start, stride, count, block);
-  VRFY((ret >= 0),"hyperslab selection succeeded");
-
-  /*
-   * Select two hyperslabs in memory. Hyperslabs has the same
-   * size and shape as the selected hyperslabs for the file dataspace
-   * Only the starting point is different.
-   * The second selection
-   *  block (1,1)
-   *  stride(1,1)
-   *  count (3,1536/mpi_size)
-   *  start (1,2+1536*mpi_rank/mpi_size)
-   *
-   */
-  start[0]  = RMSHSTART0;
-  start[1]  = (hsize_t)(RMSHSTART1+mpi_rank*RMSHCOUNT1);
-  block[0]  = RMSHBLOCK0;
-  block[1]  = RMSHBLOCK1;
-  stride[0] = RMSHSTRIDE0;
-  stride[1] = RMSHSTRIDE1;
-  count[0]  = RMSHCOUNT0;
-  count[1]  = RMSHCOUNT1;
-  ret = H5Sselect_hyperslab(mspaceid, H5S_SELECT_OR, start, stride, count, block);
-  VRFY((ret >= 0),"hyperslab selection succeeded");
-
-
-  /*
-   * Initialize data buffer.
-   */
-
-  HDmemset(matrix_out,0,sizeof(int)*(size_t)MSPACE_DIM1*(size_t)MSPACE_DIM2*(size_t)mpi_size);
-  HDmemset(matrix_out1,0,sizeof(int)*(size_t)MSPACE_DIM1*(size_t)MSPACE_DIM2*(size_t)mpi_size);
-
-  /*
-   * Read data back to the buffer matrix_out.
-   */
-
-  dxfer_plist = H5Pcreate(H5P_DATASET_XFER);
-  VRFY((dxfer_plist >= 0),"");
-
-  ret = H5Pset_dxpl_mpio(dxfer_plist, H5FD_MPIO_COLLECTIVE);
-  VRFY((ret >= 0),"MPIO data transfer property list succeed");
-  if(dxfer_coll_type == DXFER_INDEPENDENT_IO) {
-     ret = H5Pset_dxpl_mpio_collective_opt(dxfer_plist,H5FD_MPIO_INDIVIDUAL_IO);
-     VRFY((ret>= 0),"set independent IO collectively succeeded");
-  }
-
-
-  /* Collective read */
-  ret = H5Dread(dataseti, H5T_NATIVE_INT, mspaceid, fspaceid1,
-        dxfer_plist, matrix_out);
-  VRFY((ret >= 0),"H5D collecive read succeed");
-
-  ret = H5Pclose(dxfer_plist);
-  VRFY((ret >= 0),"");
-
-  /* Independent read */
-  ret = H5Dread(dataseti, H5T_NATIVE_INT, mspaceid, fspaceid1,
-        H5P_DEFAULT, matrix_out1);
-  VRFY((ret >= 0),"H5D independent read succeed");
-
-  ret = 0;
-  for (i = 0; i < MSPACE_DIM1*MSPACE_DIM2*mpi_size; i++){
-      if(matrix_out[i]!=matrix_out1[i])ret = -1;
-      if(ret < 0) break;
-  }
-  VRFY((ret >= 0),"H5D contiguous irregular collective read succeed");
-
-  /*
-   * Free read buffers.
-   */
-  HDfree(matrix_out);
-  HDfree(matrix_out1);
-
-  /*
-   * Close memory file and memory dataspaces.
-   */
-  ret = H5Sclose(mspaceid);
-  VRFY((ret >= 0),"");
-  ret = H5Sclose(fspaceid1);
-  VRFY((ret >= 0),"");
-
-  /*
-   * Close dataset.
-   */
-  ret = H5Dclose(dataseti);
-  VRFY((ret >= 0),"");
-
-  /*
-   * Close property list
-   */
-  ret = H5Pclose(facc_plist);
-  VRFY((ret >= 0),"");
-
-
-  /*
-   * Close the file.
-   */
-  ret = H5Fclose(file);
-  VRFY((ret >= 0),"");
-
-  return;
-}
+    const char *filename;
+    hid_t       facc_plist, dxfer_plist;
+    hid_t       file, dataseti;      /* File and dataset identifiers */
+    hid_t       mspaceid, fspaceid1; /* Dataspace identifiers */
+
+    /* Dimension sizes of the dataset (on disk) */
+    hsize_t mdim[2]; /* Dimension sizes of the dataset in memory when we
+                      * read selection from the dataset on the disk
+                      */
+
+    hsize_t start[2];  /* Start of hyperslab */
+    hsize_t stride[2]; /* Stride of hyperslab */
+    hsize_t count[2];  /* Block count */
+    hsize_t block[2];  /* Block sizes */
+    herr_t  ret;
+
+    int i;
+
+    int *matrix_out;
+    int *matrix_out1; /* Buffer to read from the dataset */
+
+    int mpi_size, mpi_rank;
+
+    MPI_Comm comm = MPI_COMM_WORLD;
+    MPI_Info info = MPI_INFO_NULL;
+
+    /*set up MPI parameters */
+    MPI_Comm_size(comm, &mpi_size);
+    MPI_Comm_rank(comm, &mpi_rank);
+
+    /* Obtain file name */
+    filename = GetTestParameters();
+
+    /* Initialize the buffer */
+
+    mdim[0]     = MSPACE_DIM1;
+    mdim[1]     = (hsize_t)(MSPACE_DIM2 * mpi_size);
+    matrix_out  = (int *)HDmalloc(sizeof(int) * (size_t)MSPACE_DIM1 * (size_t)MSPACE_DIM2 * (size_t)mpi_size);
+    matrix_out1 = (int *)HDmalloc(sizeof(int) * (size_t)MSPACE_DIM1 * (size_t)MSPACE_DIM2 * (size_t)mpi_size);
+
+    /*** For testing collective hyperslab selection read ***/
+
+    /* Obtain file access property list */
+    facc_plist = create_faccess_plist(comm, info, facc_type);
+    VRFY((facc_plist >= 0), "");
+
+    /*
+     * Open the file.
+     */
+    file = H5Fopen(filename, H5F_ACC_RDONLY, facc_plist);
+    VRFY((file >= 0), "H5Fopen succeeded");
+
+    /*
+     * Open the dataset.
+     */
+    dataseti = H5Dopen2(file, "independ_write", H5P_DEFAULT);
+    VRFY((dataseti >= 0), "H5Dopen2 succeeded");
+
+    /*
+     * Get dataspace of the open dataset.
+     */
+    fspaceid1 = H5Dget_space(dataseti);
+    VRFY((fspaceid1 >= 0), "file dataspace obtained succeeded");
+
+    /* The First selection for FILE to read
+     *
+     *  block (1,1)
+     *  stride(1.1)
+     *  count (3,768/mpi_size)
+     *  start (1,2+768*mpi_rank/mpi_size)
+     *
+     */
+    start[0]  = RFFHSTART0;
+    start[1]  = (hsize_t)(RFFHSTART1 + mpi_rank * RFFHCOUNT1);
+    block[0]  = RFFHBLOCK0;
+    block[1]  = RFFHBLOCK1;
+    stride[0] = RFFHSTRIDE0;
+    stride[1] = RFFHSTRIDE1;
+    count[0]  = RFFHCOUNT0;
+    count[1]  = RFFHCOUNT1;
+
+    ret = H5Sselect_hyperslab(fspaceid1, H5S_SELECT_SET, start, stride, count, block);
+    VRFY((ret >= 0), "hyperslab selection succeeded");
+
+    /* The Second selection for FILE to read
+     *
+     *  block (1,1)
+     *  stride(1.1)
+     *  count (3,1536/mpi_size)
+     *  start (2,4+1536*mpi_rank/mpi_size)
+     *
+     */
+    start[0]  = RFSHSTART0;
+    start[1]  = (hsize_t)(RFSHSTART1 + RFSHCOUNT1 * mpi_rank);
+    block[0]  = RFSHBLOCK0;
+    block[1]  = RFSHBLOCK1;
+    stride[0] = RFSHSTRIDE0;
+    stride[1] = RFSHSTRIDE0;
+    count[0]  = RFSHCOUNT0;
+    count[1]  = RFSHCOUNT1;
+
+    ret = H5Sselect_hyperslab(fspaceid1, H5S_SELECT_OR, start, stride, count, block);
+    VRFY((ret >= 0), "hyperslab selection succeeded");
+
+    /*
+     * Create memory dataspace.
+     */
+    mspaceid = H5Screate_simple(MSPACE_RANK, mdim, NULL);
+
+    /*
+     * Select two hyperslabs in memory. Hyperslabs has the same
+     * size and shape as the selected hyperslabs for the file dataspace.
+     * Only the starting point is different.
+     * The first selection
+     *  block (1,1)
+     *  stride(1.1)
+     *  count (3,768/mpi_size)
+     *  start (0,768*mpi_rank/mpi_size)
+     *
+     */
+
+    start[0]  = RMFHSTART0;
+    start[1]  = (hsize_t)(RMFHSTART1 + mpi_rank * RMFHCOUNT1);
+    block[0]  = RMFHBLOCK0;
+    block[1]  = RMFHBLOCK1;
+    stride[0] = RMFHSTRIDE0;
+    stride[1] = RMFHSTRIDE1;
+    count[0]  = RMFHCOUNT0;
+    count[1]  = RMFHCOUNT1;
+    ret       = H5Sselect_hyperslab(mspaceid, H5S_SELECT_SET, start, stride, count, block);
+    VRFY((ret >= 0), "hyperslab selection succeeded");
+
+    /*
+     * Select two hyperslabs in memory. Hyperslabs has the same
+     * size and shape as the selected hyperslabs for the file dataspace
+     * Only the starting point is different.
+     * The second selection
+     *  block (1,1)
+     *  stride(1,1)
+     *  count (3,1536/mpi_size)
+     *  start (1,2+1536*mpi_rank/mpi_size)
+     *
+     */
+    start[0]  = RMSHSTART0;
+    start[1]  = (hsize_t)(RMSHSTART1 + mpi_rank * RMSHCOUNT1);
+    block[0]  = RMSHBLOCK0;
+    block[1]  = RMSHBLOCK1;
+    stride[0] = RMSHSTRIDE0;
+    stride[1] = RMSHSTRIDE1;
+    count[0]  = RMSHCOUNT0;
+    count[1]  = RMSHCOUNT1;
+    ret       = H5Sselect_hyperslab(mspaceid, H5S_SELECT_OR, start, stride, count, block);
+    VRFY((ret >= 0), "hyperslab selection succeeded");
+
+    /*
+     * Initialize data buffer.
+     */
+
+    HDmemset(matrix_out, 0, sizeof(int) * (size_t)MSPACE_DIM1 * (size_t)MSPACE_DIM2 * (size_t)mpi_size);
+    HDmemset(matrix_out1, 0, sizeof(int) * (size_t)MSPACE_DIM1 * (size_t)MSPACE_DIM2 * (size_t)mpi_size);
+
+    /*
+     * Read data back to the buffer matrix_out.
+     */
+
+    dxfer_plist = H5Pcreate(H5P_DATASET_XFER);
+    VRFY((dxfer_plist >= 0), "");
+
+    ret = H5Pset_dxpl_mpio(dxfer_plist, H5FD_MPIO_COLLECTIVE);
+    VRFY((ret >= 0), "MPIO data transfer property list succeed");
+    if (dxfer_coll_type == DXFER_INDEPENDENT_IO) {
+        ret = H5Pset_dxpl_mpio_collective_opt(dxfer_plist, H5FD_MPIO_INDIVIDUAL_IO);
+        VRFY((ret >= 0), "set independent IO collectively succeeded");
+    }
+
+    /* Collective read */
+    ret = H5Dread(dataseti, H5T_NATIVE_INT, mspaceid, fspaceid1, dxfer_plist, matrix_out);
+    VRFY((ret >= 0), "H5D collecive read succeed");
 
+    ret = H5Pclose(dxfer_plist);
+    VRFY((ret >= 0), "");
+
+    /* Independent read */
+    ret = H5Dread(dataseti, H5T_NATIVE_INT, mspaceid, fspaceid1, H5P_DEFAULT, matrix_out1);
+    VRFY((ret >= 0), "H5D independent read succeed");
+
+    ret = 0;
+    for (i = 0; i < MSPACE_DIM1 * MSPACE_DIM2 * mpi_size; i++) {
+        if (matrix_out[i] != matrix_out1[i])
+            ret = -1;
+        if (ret < 0)
+            break;
+    }
+    VRFY((ret >= 0), "H5D contiguous irregular collective read succeed");
+
+    /*
+     * Free read buffers.
+     */
+    HDfree(matrix_out);
+    HDfree(matrix_out1);
+
+    /*
+     * Close memory file and memory dataspaces.
+     */
+    ret = H5Sclose(mspaceid);
+    VRFY((ret >= 0), "");
+    ret = H5Sclose(fspaceid1);
+    VRFY((ret >= 0), "");
+
+    /*
+     * Close dataset.
+     */
+    ret = H5Dclose(dataseti);
+    VRFY((ret >= 0), "");
+
+    /*
+     * Close property list
+     */
+    ret = H5Pclose(facc_plist);
+    VRFY((ret >= 0), "");
+
+    /*
+     * Close the file.
+     */
+    ret = H5Fclose(file);
+    VRFY((ret >= 0), "");
+
+    return;
+}
 
 /****************************************************************
 **
@@ -928,7 +902,7 @@ coll_read_test(void)
 **
 ****************************************************************/
 
-#define LDSCT_DS_RANK    5
+#define LDSCT_DS_RANK 5
 #if LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG
 #define LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK 0
 #endif
@@ -936,64 +910,54 @@ coll_read_test(void)
 #define LOWER_DIM_SIZE_COMP_TEST__SELECT_CHECKER_BOARD__DEBUG 0
 
 static void
-lower_dim_size_comp_test__select_checker_board(
-                                 const int mpi_rank,
-                                 const hid_t tgt_sid,
-                                 const int tgt_rank,
-                                 const hsize_t dims[LDSCT_DS_RANK],
-                                 const int checker_edge_size,
-                                 const int sel_rank,
-                                 hsize_t sel_start[])
+lower_dim_size_comp_test__select_checker_board(const int mpi_rank, const hid_t tgt_sid, const int tgt_rank,
+                                               const hsize_t dims[LDSCT_DS_RANK], const int checker_edge_size,
+                                               const int sel_rank, hsize_t sel_start[])
 {
 #if LOWER_DIM_SIZE_COMP_TEST__SELECT_CHECKER_BOARD__DEBUG
-    const char *    fcnName =
-            "lower_dim_size_comp_test__select_checker_board():";
+    const char *fcnName = "lower_dim_size_comp_test__select_checker_board():";
 #endif
-    hbool_t        first_selection = TRUE;
-    int                 i, j, k, l, m;
-    int            ds_offset;
-    int            sel_offset;
-    const int        test_max_rank = LDSCT_DS_RANK;  /* must update code if */
-                                                        /* this changes        */
-    hsize_t        base_count;
-    hsize_t             offset_count;
-    hsize_t         start[LDSCT_DS_RANK];
-    hsize_t         stride[LDSCT_DS_RANK];
-    hsize_t         count[LDSCT_DS_RANK];
-    hsize_t         block[LDSCT_DS_RANK];
-    herr_t          ret;            /* Generic return value */
+    hbool_t   first_selection = TRUE;
+    int       i, j, k, l, m;
+    int       ds_offset;
+    int       sel_offset;
+    const int test_max_rank = LDSCT_DS_RANK; /* must update code if */
+                                             /* this changes        */
+    hsize_t base_count;
+    hsize_t offset_count;
+    hsize_t start[LDSCT_DS_RANK];
+    hsize_t stride[LDSCT_DS_RANK];
+    hsize_t count[LDSCT_DS_RANK];
+    hsize_t block[LDSCT_DS_RANK];
+    herr_t  ret; /* Generic return value */
 
 #if LOWER_DIM_SIZE_COMP_TEST__SELECT_CHECKER_BOARD__DEBUG
-    if ( mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK ) {
-        HDfprintf(stdout,
-                  "%s:%d: dims/checker_edge_size = %d %d %d %d %d / %d\n",
-                  fcnName, mpi_rank, (int)dims[0], (int)dims[1], (int)dims[2],
-                  (int)dims[3], (int)dims[4], checker_edge_size);
+    if (mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK) {
+        HDfprintf(stdout, "%s:%d: dims/checker_edge_size = %d %d %d %d %d / %d\n", fcnName, mpi_rank,
+                  (int)dims[0], (int)dims[1], (int)dims[2], (int)dims[3], (int)dims[4], checker_edge_size);
     }
 #endif /* LOWER_DIM_SIZE_COMP_TEST__SELECT_CHECKER_BOARD__DEBUG */
 
-    HDassert( 0 < checker_edge_size );
-    HDassert( 0 < sel_rank );
-    HDassert( sel_rank <= tgt_rank );
-    HDassert( tgt_rank <= test_max_rank );
-    HDassert( test_max_rank <= LDSCT_DS_RANK );
+    HDassert(0 < checker_edge_size);
+    HDassert(0 < sel_rank);
+    HDassert(sel_rank <= tgt_rank);
+    HDassert(tgt_rank <= test_max_rank);
+    HDassert(test_max_rank <= LDSCT_DS_RANK);
 
     sel_offset = test_max_rank - sel_rank;
-    HDassert( sel_offset >= 0 );
+    HDassert(sel_offset >= 0);
 
     ds_offset = test_max_rank - tgt_rank;
-    HDassert( ds_offset >= 0 );
-    HDassert( ds_offset <= sel_offset );
+    HDassert(ds_offset >= 0);
+    HDassert(ds_offset <= sel_offset);
 
-    HDassert( (hsize_t)checker_edge_size <= dims[sel_offset] );
-    HDassert( dims[sel_offset] == 10 );
+    HDassert((hsize_t)checker_edge_size <= dims[sel_offset]);
+    HDassert(dims[sel_offset] == 10);
 
 #if LOWER_DIM_SIZE_COMP_TEST__SELECT_CHECKER_BOARD__DEBUG
-    if ( mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK ) {
-        HDfprintf(stdout, "%s:%d: sel_rank/sel_offset = %d/%d.\n",
-                  fcnName, mpi_rank, sel_rank, sel_offset);
-        HDfprintf(stdout, "%s:%d: tgt_rank/ds_offset = %d/%d.\n",
-                  fcnName, mpi_rank, tgt_rank, ds_offset);
+    if (mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK) {
+        HDfprintf(stdout, "%s:%d: sel_rank/sel_offset = %d/%d.\n", fcnName, mpi_rank, sel_rank, sel_offset);
+        HDfprintf(stdout, "%s:%d: tgt_rank/ds_offset = %d/%d.\n", fcnName, mpi_rank, tgt_rank, ds_offset);
     }
 #endif /* LOWER_DIM_SIZE_COMP_TEST__SELECT_CHECKER_BOARD__DEBUG */
 
@@ -1012,25 +976,23 @@ lower_dim_size_comp_test__select_checker_board(
 
     base_count = dims[sel_offset] / (hsize_t)(checker_edge_size * 2);
 
-    if ( (dims[sel_rank] % (hsize_t)(checker_edge_size * 2)) > 0 ) {
+    if ((dims[sel_rank] % (hsize_t)(checker_edge_size * 2)) > 0) {
 
         base_count++;
     }
 
     offset_count =
-    (hsize_t)((dims[sel_offset] - (hsize_t)checker_edge_size) /
-                  ((hsize_t)(checker_edge_size * 2)));
+        (hsize_t)((dims[sel_offset] - (hsize_t)checker_edge_size) / ((hsize_t)(checker_edge_size * 2)));
 
-    if ( ((dims[sel_rank] - (hsize_t)checker_edge_size) %
-          ((hsize_t)(checker_edge_size * 2))) > 0 ) {
+    if (((dims[sel_rank] - (hsize_t)checker_edge_size) % ((hsize_t)(checker_edge_size * 2))) > 0) {
 
         offset_count++;
     }
 
 #if LOWER_DIM_SIZE_COMP_TEST__SELECT_CHECKER_BOARD__DEBUG
-    if ( mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK ) {
-        HDfprintf(stdout, "%s:%d: base_count/offset_count = %d/%d.\n",
-                  fcnName, mpi_rank, base_count, offset_count);
+    if (mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK) {
+        HDfprintf(stdout, "%s:%d: base_count/offset_count = %d/%d.\n", fcnName, mpi_rank, base_count,
+                  offset_count);
     }
 #endif /* LOWER_DIM_SIZE_COMP_TEST__SELECT_CHECKER_BOARD__DEBUG */
 
@@ -1039,235 +1001,193 @@ lower_dim_size_comp_test__select_checker_board(
      * the checker board.
      */
     i = 0;
-    while ( i < ds_offset ) {
+    while (i < ds_offset) {
 
         /* these values should never be used */
-        start[i] = 0;
+        start[i]  = 0;
         stride[i] = 0;
-        count[i] = 0;
-        block[i] = 0;
+        count[i]  = 0;
+        block[i]  = 0;
 
         i++;
     }
 
-    while ( i < sel_offset ) {
+    while (i < sel_offset) {
 
-        start[i] = sel_start[i];
+        start[i]  = sel_start[i];
         stride[i] = 2 * dims[i];
-        count[i] = 1;
-        block[i] = 1;
+        count[i]  = 1;
+        block[i]  = 1;
 
         i++;
     }
 
-    while ( i < test_max_rank ) {
+    while (i < test_max_rank) {
 
         stride[i] = (hsize_t)(2 * checker_edge_size);
-        block[i] = (hsize_t)checker_edge_size;
+        block[i]  = (hsize_t)checker_edge_size;
 
         i++;
     }
 
     i = 0;
     do {
-        if ( 0 >= sel_offset ) {
+        if (0 >= sel_offset) {
 
-            if ( i == 0 ) {
+            if (i == 0) {
 
                 start[0] = 0;
                 count[0] = base_count;
-
-            } else {
+            }
+            else {
 
                 start[0] = (hsize_t)checker_edge_size;
                 count[0] = offset_count;
-
             }
         }
 
         j = 0;
         do {
-            if ( 1 >= sel_offset ) {
+            if (1 >= sel_offset) {
 
-                if ( j == 0 ) {
+                if (j == 0) {
 
                     start[1] = 0;
                     count[1] = base_count;
-
-                } else {
+                }
+                else {
 
                     start[1] = (hsize_t)checker_edge_size;
                     count[1] = offset_count;
-
                 }
             }
 
             k = 0;
             do {
-                if ( 2 >= sel_offset ) {
+                if (2 >= sel_offset) {
 
-                    if ( k == 0 ) {
+                    if (k == 0) {
 
                         start[2] = 0;
                         count[2] = base_count;
-
-                    } else {
+                    }
+                    else {
 
                         start[2] = (hsize_t)checker_edge_size;
                         count[2] = offset_count;
-
                     }
                 }
 
                 l = 0;
                 do {
-                    if ( 3 >= sel_offset ) {
+                    if (3 >= sel_offset) {
 
-                        if ( l == 0 ) {
+                        if (l == 0) {
 
                             start[3] = 0;
                             count[3] = base_count;
-
-                        } else {
+                        }
+                        else {
 
                             start[3] = (hsize_t)checker_edge_size;
                             count[3] = offset_count;
-
                         }
                     }
 
                     m = 0;
                     do {
-                        if ( 4 >= sel_offset ) {
+                        if (4 >= sel_offset) {
 
-                            if ( m == 0 ) {
+                            if (m == 0) {
 
                                 start[4] = 0;
                                 count[4] = base_count;
-
-                            } else {
+                            }
+                            else {
 
                                 start[4] = (hsize_t)checker_edge_size;
                                 count[4] = offset_count;
-
                             }
                         }
 
-                        if ( ((i + j + k + l + m) % 2) == 0 ) {
+                        if (((i + j + k + l + m) % 2) == 0) {
 
 #if LOWER_DIM_SIZE_COMP_TEST__SELECT_CHECKER_BOARD__DEBUG
-                             if ( mpi_rank ==
-                                  LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK ) {
-
-                                HDfprintf(stdout,
-                                      "%s%d: *** first_selection = %d ***\n",
-                                      fcnName, mpi_rank, (int)first_selection);
-                                HDfprintf(stdout,
-                                      "%s:%d: i/j/k/l/m = %d/%d/%d/%d/%d\n",
-                                      fcnName, mpi_rank, i, j, k, l, m);
-                                HDfprintf(stdout,
-                                      "%s:%d: start = %d %d %d %d %d.\n",
-                                      fcnName, mpi_rank,
-                                      (int)start[0], (int)start[1],
-                                      (int)start[2], (int)start[3],
-                                      (int)start[4]);
-                                HDfprintf(stdout,
-                                      "%s:%d: stride = %d %d %d %d %d.\n",
-                                      fcnName, mpi_rank,
-                                      (int)stride[0], (int)stride[1],
-                                      (int)stride[2], (int)stride[3],
-                                      (int)stride[4]);
-                                HDfprintf(stdout,
-                                      "%s:%d: count = %d %d %d %d %d.\n",
-                                      fcnName, mpi_rank,
-                                      (int)count[0], (int)count[1],
-                                      (int)count[2], (int)count[3],
-                                      (int)count[4]);
-                                HDfprintf(stdout,
-                                      "%s:%d: block = %d %d %d %d %d.\n",
-                                      fcnName, mpi_rank,
-                                      (int)block[0], (int)block[1],
-                                      (int)block[2], (int)block[3],
-                                      (int)block[4]);
-                                HDfprintf(stdout,
-                                      "%s:%d: n-cube extent dims = %d.\n",
-                                      fcnName, mpi_rank,
-                                      H5Sget_simple_extent_ndims(tgt_sid));
-                                HDfprintf(stdout,
-                                      "%s:%d: selection rank = %d.\n",
-                                      fcnName, mpi_rank, sel_rank);
+                            if (mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK) {
+
+                                HDfprintf(stdout, "%s%d: *** first_selection = %d ***\n", fcnName, mpi_rank,
+                                          (int)first_selection);
+                                HDfprintf(stdout, "%s:%d: i/j/k/l/m = %d/%d/%d/%d/%d\n", fcnName, mpi_rank, i,
+                                          j, k, l, m);
+                                HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", fcnName, mpi_rank,
+                                          (int)start[0], (int)start[1], (int)start[2], (int)start[3],
+                                          (int)start[4]);
+                                HDfprintf(stdout, "%s:%d: stride = %d %d %d %d %d.\n", fcnName, mpi_rank,
+                                          (int)stride[0], (int)stride[1], (int)stride[2], (int)stride[3],
+                                          (int)stride[4]);
+                                HDfprintf(stdout, "%s:%d: count = %d %d %d %d %d.\n", fcnName, mpi_rank,
+                                          (int)count[0], (int)count[1], (int)count[2], (int)count[3],
+                                          (int)count[4]);
+                                HDfprintf(stdout, "%s:%d: block = %d %d %d %d %d.\n", fcnName, mpi_rank,
+                                          (int)block[0], (int)block[1], (int)block[2], (int)block[3],
+                                          (int)block[4]);
+                                HDfprintf(stdout, "%s:%d: n-cube extent dims = %d.\n", fcnName, mpi_rank,
+                                          H5Sget_simple_extent_ndims(tgt_sid));
+                                HDfprintf(stdout, "%s:%d: selection rank = %d.\n", fcnName, mpi_rank,
+                                          sel_rank);
                             }
 #endif
 
-                            if ( first_selection ) {
+                            if (first_selection) {
 
                                 first_selection = FALSE;
 
-                                ret = H5Sselect_hyperslab
-                                      (
-                                        tgt_sid,
-                                        H5S_SELECT_SET,
-                                        &(start[ds_offset]),
-                                        &(stride[ds_offset]),
-                                        &(count[ds_offset]),
-                                        &(block[ds_offset])
-                                      );
+                                ret = H5Sselect_hyperslab(tgt_sid, H5S_SELECT_SET, &(start[ds_offset]),
+                                                          &(stride[ds_offset]), &(count[ds_offset]),
+                                                          &(block[ds_offset]));
 
                                 VRFY((ret != FAIL), "H5Sselect_hyperslab(SET) succeeded");
+                            }
+                            else {
 
-                            } else {
-
-                                ret = H5Sselect_hyperslab
-                                      (
-                                        tgt_sid,
-                                        H5S_SELECT_OR,
-                                        &(start[ds_offset]),
-                                        &(stride[ds_offset]),
-                                        &(count[ds_offset]),
-                                        &(block[ds_offset])
-                                      );
+                                ret = H5Sselect_hyperslab(tgt_sid, H5S_SELECT_OR, &(start[ds_offset]),
+                                                          &(stride[ds_offset]), &(count[ds_offset]),
+                                                          &(block[ds_offset]));
 
                                 VRFY((ret != FAIL), "H5Sselect_hyperslab(OR) succeeded");
-
                             }
                         }
 
                         m++;
 
-                    } while ( ( m <= 1 ) &&
-                              ( 4 >= sel_offset ) );
+                    } while ((m <= 1) && (4 >= sel_offset));
 
                     l++;
 
-                } while ( ( l <= 1 ) &&
-                          ( 3 >= sel_offset ) );
+                } while ((l <= 1) && (3 >= sel_offset));
 
                 k++;
 
-            } while ( ( k <= 1 ) &&
-                      ( 2 >= sel_offset ) );
+            } while ((k <= 1) && (2 >= sel_offset));
 
             j++;
 
-        } while ( ( j <= 1 ) &&
-                  ( 1 >= sel_offset ) );
-
+        } while ((j <= 1) && (1 >= sel_offset));
 
         i++;
 
-    } while ( ( i <= 1 ) &&
-              ( 0 >= sel_offset ) );
+    } while ((i <= 1) && (0 >= sel_offset));
 
 #if LOWER_DIM_SIZE_COMP_TEST__SELECT_CHECKER_BOARD__DEBUG
-    if ( mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK ) {
-        HDfprintf(stdout, "%s%d: H5Sget_select_npoints(tgt_sid) = %d.\n",
-                  fcnName, mpi_rank, (int)H5Sget_select_npoints(tgt_sid));
+    if (mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK) {
+        HDfprintf(stdout, "%s%d: H5Sget_select_npoints(tgt_sid) = %d.\n", fcnName, mpi_rank,
+                  (int)H5Sget_select_npoints(tgt_sid));
     }
 #endif /* LOWER_DIM_SIZE_COMP_TEST__SELECT_CHECKER_BOARD__DEBUG */
 
     /* Clip the selection back to the dataspace proper. */
 
-    for ( i = 0; i < test_max_rank; i++ ) {
+    for (i = 0; i < test_max_rank; i++) {
 
         start[i]  = 0;
         stride[i] = dims[i];
@@ -1275,15 +1195,14 @@ lower_dim_size_comp_test__select_checker_board(
         block[i]  = dims[i];
     }
 
-    ret = H5Sselect_hyperslab(tgt_sid, H5S_SELECT_AND,
-                              start, stride, count, block);
+    ret = H5Sselect_hyperslab(tgt_sid, H5S_SELECT_AND, start, stride, count, block);
 
     VRFY((ret != FAIL), "H5Sselect_hyperslab(AND) succeeded");
 
 #if LOWER_DIM_SIZE_COMP_TEST__SELECT_CHECKER_BOARD__DEBUG
-    if ( mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK ) {
-        HDfprintf(stdout, "%s%d: H5Sget_select_npoints(tgt_sid) = %d.\n",
-                  fcnName, mpi_rank, (int)H5Sget_select_npoints(tgt_sid));
+    if (mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK) {
+        HDfprintf(stdout, "%s%d: H5Sget_select_npoints(tgt_sid) = %d.\n", fcnName, mpi_rank,
+                  (int)H5Sget_select_npoints(tgt_sid));
         HDfprintf(stdout, "%s%d: done.\n", fcnName, mpi_rank);
     }
 #endif /* LOWER_DIM_SIZE_COMP_TEST__SELECT_CHECKER_BOARD__DEBUG */
@@ -1292,7 +1211,6 @@ lower_dim_size_comp_test__select_checker_board(
 
 } /* lower_dim_size_comp_test__select_checker_board() */
 
-
 /****************************************************************
 **
 **  lower_dim_size_comp_test__verify_data():
@@ -1352,138 +1270,123 @@ lower_dim_size_comp_test__select_checker_board(
 #define LOWER_DIM_SIZE_COMP_TEST__VERIFY_DATA__DEBUG 0
 
 static hbool_t
-lower_dim_size_comp_test__verify_data(uint32_t * buf_ptr,
+lower_dim_size_comp_test__verify_data(uint32_t *buf_ptr,
 #if LOWER_DIM_SIZE_COMP_TEST__VERIFY_DATA__DEBUG
                                       const int mpi_rank,
 #endif /* LOWER_DIM_SIZE_COMP_TEST__VERIFY_DATA__DEBUG */
-                                      const int rank,
-                                      const int edge_size,
-                                      const int checker_edge_size,
-                                      uint32_t first_expected_val,
-                                      hbool_t buf_starts_in_checker)
+                                      const int rank, const int edge_size, const int checker_edge_size,
+                                      uint32_t first_expected_val, hbool_t buf_starts_in_checker)
 {
 #if LOWER_DIM_SIZE_COMP_TEST__VERIFY_DATA__DEBUG
-    const char *    fcnName =
-            "lower_dim_size_comp_test__verify_data():";
+    const char *fcnName = "lower_dim_size_comp_test__verify_data():";
 #endif
-    hbool_t good_data = TRUE;
-    hbool_t in_checker;
-    hbool_t start_in_checker[5];
-    uint32_t expected_value;
-    uint32_t * val_ptr;
-    int i, j, k, l, m;  /* to track position in n-cube */
-    int v, w, x, y, z;  /* to track position in checker */
+    hbool_t   good_data = TRUE;
+    hbool_t   in_checker;
+    hbool_t   start_in_checker[5];
+    uint32_t  expected_value;
+    uint32_t *val_ptr;
+    int       i, j, k, l, m;     /* to track position in n-cube */
+    int       v, w, x, y, z;     /* to track position in checker */
     const int test_max_rank = 5; /* code changes needed if this is increased */
 
-    HDassert( buf_ptr != NULL );
-    HDassert( 0 < rank );
-    HDassert( rank <= test_max_rank );
-    HDassert( edge_size >= 6 );
-    HDassert( 0 < checker_edge_size );
-    HDassert( checker_edge_size <= edge_size );
-    HDassert( test_max_rank <= LDSCT_DS_RANK );
+    HDassert(buf_ptr != NULL);
+    HDassert(0 < rank);
+    HDassert(rank <= test_max_rank);
+    HDassert(edge_size >= 6);
+    HDassert(0 < checker_edge_size);
+    HDassert(checker_edge_size <= edge_size);
+    HDassert(test_max_rank <= LDSCT_DS_RANK);
 
 #if LOWER_DIM_SIZE_COMP_TEST__VERIFY_DATA__DEBUG
-    if ( mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK ) {
+    if (mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK) {
         HDfprintf(stdout, "%s mpi_rank = %d.\n", fcnName, mpi_rank);
         HDfprintf(stdout, "%s rank = %d.\n", fcnName, rank);
         HDfprintf(stdout, "%s edge_size = %d.\n", fcnName, edge_size);
-        HDfprintf(stdout, "%s checker_edge_size = %d.\n",
-                  fcnName, checker_edge_size);
-        HDfprintf(stdout, "%s first_expected_val = %d.\n",
-                  fcnName, (int)first_expected_val);
-        HDfprintf(stdout, "%s starts_in_checker = %d.\n",
-                  fcnName, (int)buf_starts_in_checker);
+        HDfprintf(stdout, "%s checker_edge_size = %d.\n", fcnName, checker_edge_size);
+        HDfprintf(stdout, "%s first_expected_val = %d.\n", fcnName, (int)first_expected_val);
+        HDfprintf(stdout, "%s starts_in_checker = %d.\n", fcnName, (int)buf_starts_in_checker);
     }
 #endif
 
-    val_ptr = buf_ptr;
+    val_ptr        = buf_ptr;
     expected_value = first_expected_val;
 
-    i = 0;
-    v = 0;
+    i                   = 0;
+    v                   = 0;
     start_in_checker[0] = buf_starts_in_checker;
-    do
-    {
-        if ( v >= checker_edge_size ) {
+    do {
+        if (v >= checker_edge_size) {
 
-            start_in_checker[0] = ! start_in_checker[0];
-            v = 0;
+            start_in_checker[0] = !start_in_checker[0];
+            v                   = 0;
         }
 
-        j = 0;
-        w = 0;
+        j                   = 0;
+        w                   = 0;
         start_in_checker[1] = start_in_checker[0];
-        do
-        {
-            if ( w >= checker_edge_size ) {
+        do {
+            if (w >= checker_edge_size) {
 
-                start_in_checker[1] = ! start_in_checker[1];
-                w = 0;
+                start_in_checker[1] = !start_in_checker[1];
+                w                   = 0;
             }
 
-            k = 0;
-            x = 0;
+            k                   = 0;
+            x                   = 0;
             start_in_checker[2] = start_in_checker[1];
-            do
-            {
-                if ( x >= checker_edge_size ) {
+            do {
+                if (x >= checker_edge_size) {
 
-                    start_in_checker[2] = ! start_in_checker[2];
-                    x = 0;
+                    start_in_checker[2] = !start_in_checker[2];
+                    x                   = 0;
                 }
 
-                l = 0;
-                y = 0;
+                l                   = 0;
+                y                   = 0;
                 start_in_checker[3] = start_in_checker[2];
-                do
-                {
-                    if ( y >= checker_edge_size ) {
+                do {
+                    if (y >= checker_edge_size) {
 
-                        start_in_checker[3] = ! start_in_checker[3];
-                        y = 0;
+                        start_in_checker[3] = !start_in_checker[3];
+                        y                   = 0;
                     }
 
                     m = 0;
                     z = 0;
 #if LOWER_DIM_SIZE_COMP_TEST__VERIFY_DATA__DEBUG
-                    if ( mpi_rank ==
-                         LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK ) {
+                    if (mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK) {
                         HDfprintf(stdout, "%d, %d, %d, %d, %d:", i, j, k, l, m);
                     }
 #endif
                     in_checker = start_in_checker[3];
-                    do
-                    {
+                    do {
 #if LOWER_DIM_SIZE_COMP_TEST__VERIFY_DATA__DEBUG
-                        if ( mpi_rank ==
-                             LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK ) {
+                        if (mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK) {
                             HDfprintf(stdout, " %d", (int)(*val_ptr));
                         }
 #endif
-                        if ( z >= checker_edge_size ) {
+                        if (z >= checker_edge_size) {
 
-                            in_checker = ! in_checker;
-                            z = 0;
+                            in_checker = !in_checker;
+                            z          = 0;
                         }
 
-                        if ( in_checker ) {
+                        if (in_checker) {
 
-                            if ( *val_ptr != expected_value ) {
+                            if (*val_ptr != expected_value) {
 
                                 good_data = FALSE;
                             }
 
                             /* zero out buffer for re-use */
                             *val_ptr = 0;
-
-                        } else if ( *val_ptr != 0 ) {
+                        }
+                        else if (*val_ptr != 0) {
 
                             good_data = FALSE;
 
                             /* zero out buffer for re-use */
                             *val_ptr = 0;
-
                         }
 
                         val_ptr++;
@@ -1491,36 +1394,29 @@ lower_dim_size_comp_test__verify_data(uint32_t * buf_ptr,
                         m++;
                         z++;
 
-                    } while ( ( rank >= (test_max_rank - 4) ) &&
-                              ( m < edge_size ) );
+                    } while ((rank >= (test_max_rank - 4)) && (m < edge_size));
 #if LOWER_DIM_SIZE_COMP_TEST__VERIFY_DATA__DEBUG
-                    if ( mpi_rank ==
-                         LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK ) {
+                    if (mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK) {
                         HDfprintf(stdout, "\n");
                     }
 #endif
                     l++;
                     y++;
-                } while ( ( rank >= (test_max_rank - 3) ) &&
-                          ( l < edge_size ) );
+                } while ((rank >= (test_max_rank - 3)) && (l < edge_size));
                 k++;
                 x++;
-            } while ( ( rank >= (test_max_rank - 2) ) &&
-                      ( k < edge_size ) );
+            } while ((rank >= (test_max_rank - 2)) && (k < edge_size));
             j++;
             w++;
-        } while ( ( rank >= (test_max_rank - 1) ) &&
-                  ( j < edge_size ) );
+        } while ((rank >= (test_max_rank - 1)) && (j < edge_size));
         i++;
         v++;
-    } while ( ( rank >= test_max_rank ) &&
-              ( i < edge_size ) );
+    } while ((rank >= test_max_rank) && (i < edge_size));
 
-    return(good_data);
+    return (good_data);
 
 } /* lower_dim_size_comp_test__verify_data() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    lower_dim_size_comp_test__run_test()
  *
@@ -1535,103 +1431,97 @@ lower_dim_size_comp_test__verify_data(uint32_t * buf_ptr,
  *-------------------------------------------------------------------------
  */
 
-#define LDSCT_DS_RANK    5
+#define LDSCT_DS_RANK                             5
 #define LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG 0
 
 static void
-lower_dim_size_comp_test__run_test(const int chunk_edge_size,
-                                   const hbool_t use_collective_io,
+lower_dim_size_comp_test__run_test(const int chunk_edge_size, const hbool_t use_collective_io,
                                    const hid_t dset_type)
 {
 #if LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG
-    const char   *fcnName = "lower_dim_size_comp_test__run_test()";
-    int          rank;
-    hsize_t      dims[32];
-    hsize_t      max_dims[32];
+    const char *fcnName = "lower_dim_size_comp_test__run_test()";
+    int         rank;
+    hsize_t     dims[32];
+    hsize_t     max_dims[32];
 #endif /* LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG */
-    const char   *filename;
-    hbool_t      data_ok = FALSE;
-    hbool_t      mis_match = FALSE;
-    int           i;
-    int           start_index;
-    int           stop_index;
-    int          mrc;
-    int          mpi_rank;
-    int          mpi_size;
-    MPI_Comm      mpi_comm = MPI_COMM_NULL;
-    MPI_Info      mpi_info = MPI_INFO_NULL;
-    hid_t         fid;                    /* HDF5 file ID */
-    hid_t         acc_tpl;                /* File access templates */
-    hid_t         xfer_plist = H5P_DEFAULT;
-    size_t        small_ds_size;
-    size_t        small_ds_slice_size;
-    size_t        large_ds_size;
+    const char *filename;
+    hbool_t     data_ok   = FALSE;
+    hbool_t     mis_match = FALSE;
+    int         i;
+    int         start_index;
+    int         stop_index;
+    int         mrc;
+    int         mpi_rank;
+    int         mpi_size;
+    MPI_Comm    mpi_comm = MPI_COMM_NULL;
+    MPI_Info    mpi_info = MPI_INFO_NULL;
+    hid_t       fid;     /* HDF5 file ID */
+    hid_t       acc_tpl; /* File access templates */
+    hid_t       xfer_plist = H5P_DEFAULT;
+    size_t      small_ds_size;
+    size_t      small_ds_slice_size;
+    size_t      large_ds_size;
 #if LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG
-    size_t        large_ds_slice_size;
+    size_t large_ds_slice_size;
 #endif
-    uint32_t      expected_value;
-    uint32_t    * small_ds_buf_0 = NULL;
-    uint32_t    * small_ds_buf_1 = NULL;
-    uint32_t    * large_ds_buf_0 = NULL;
-    uint32_t    * large_ds_buf_1 = NULL;
-    uint32_t    * ptr_0;
-    uint32_t    * ptr_1;
-    hsize_t       small_chunk_dims[LDSCT_DS_RANK];
-    hsize_t       large_chunk_dims[LDSCT_DS_RANK];
-    hsize_t       small_dims[LDSCT_DS_RANK];
-    hsize_t       large_dims[LDSCT_DS_RANK];
-    hsize_t       start[LDSCT_DS_RANK];
-    hsize_t       stride[LDSCT_DS_RANK];
-    hsize_t       count[LDSCT_DS_RANK];
-    hsize_t       block[LDSCT_DS_RANK];
-    hsize_t       small_sel_start[LDSCT_DS_RANK];
-    hsize_t       large_sel_start[LDSCT_DS_RANK];
-    hid_t         full_mem_small_ds_sid;
-    hid_t         full_file_small_ds_sid;
-    hid_t         mem_small_ds_sid;
-    hid_t         file_small_ds_sid;
-    hid_t         full_mem_large_ds_sid;
-    hid_t         full_file_large_ds_sid;
-    hid_t         mem_large_ds_sid;
-    hid_t         file_large_ds_sid;
-    hid_t         small_ds_dcpl_id = H5P_DEFAULT;
-    hid_t         large_ds_dcpl_id = H5P_DEFAULT;
-    hid_t         small_dataset;     /* Dataset ID                   */
-    hid_t         large_dataset;     /* Dataset ID                   */
-    htri_t        check;          /* Shape comparison return value */
-    herr_t        ret;            /* Generic return value */
+    uint32_t  expected_value;
+    uint32_t *small_ds_buf_0 = NULL;
+    uint32_t *small_ds_buf_1 = NULL;
+    uint32_t *large_ds_buf_0 = NULL;
+    uint32_t *large_ds_buf_1 = NULL;
+    uint32_t *ptr_0;
+    uint32_t *ptr_1;
+    hsize_t   small_chunk_dims[LDSCT_DS_RANK];
+    hsize_t   large_chunk_dims[LDSCT_DS_RANK];
+    hsize_t   small_dims[LDSCT_DS_RANK];
+    hsize_t   large_dims[LDSCT_DS_RANK];
+    hsize_t   start[LDSCT_DS_RANK];
+    hsize_t   stride[LDSCT_DS_RANK];
+    hsize_t   count[LDSCT_DS_RANK];
+    hsize_t   block[LDSCT_DS_RANK];
+    hsize_t   small_sel_start[LDSCT_DS_RANK];
+    hsize_t   large_sel_start[LDSCT_DS_RANK];
+    hid_t     full_mem_small_ds_sid;
+    hid_t     full_file_small_ds_sid;
+    hid_t     mem_small_ds_sid;
+    hid_t     file_small_ds_sid;
+    hid_t     full_mem_large_ds_sid;
+    hid_t     full_file_large_ds_sid;
+    hid_t     mem_large_ds_sid;
+    hid_t     file_large_ds_sid;
+    hid_t     small_ds_dcpl_id = H5P_DEFAULT;
+    hid_t     large_ds_dcpl_id = H5P_DEFAULT;
+    hid_t     small_dataset; /* Dataset ID                   */
+    hid_t     large_dataset; /* Dataset ID                   */
+    htri_t    check;         /* Shape comparison return value */
+    herr_t    ret;           /* Generic return value */
 
     MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
     MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
 
-    HDassert( mpi_size >= 1 );
+    HDassert(mpi_size >= 1);
 
     mpi_comm = MPI_COMM_WORLD;
     mpi_info = MPI_INFO_NULL;
 
 #if LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG
-    if ( mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK ) {
-        HDfprintf(stdout, "%s:%d: chunk_edge_size = %d.\n",
-                  fcnName, mpi_rank, (int)chunk_edge_size);
-        HDfprintf(stdout, "%s:%d: use_collective_io = %d.\n",
-                  fcnName, mpi_rank, (int)use_collective_io);
+    if (mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK) {
+        HDfprintf(stdout, "%s:%d: chunk_edge_size = %d.\n", fcnName, mpi_rank, (int)chunk_edge_size);
+        HDfprintf(stdout, "%s:%d: use_collective_io = %d.\n", fcnName, mpi_rank, (int)use_collective_io);
     }
 #endif /* LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG */
 
-
-    small_ds_size       = (size_t)((mpi_size + 1) *  1 *  1 * 10 * 10);
-    small_ds_slice_size = (size_t)                 ( 1 *  1 * 10 * 10);
+    small_ds_size       = (size_t)((mpi_size + 1) * 1 * 1 * 10 * 10);
+    small_ds_slice_size = (size_t)(1 * 1 * 10 * 10);
     large_ds_size       = (size_t)((mpi_size + 1) * 10 * 10 * 10 * 10);
 
 #if LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG
-    large_ds_slice_size = (size_t)                 (10 * 10 * 10 * 10);
+    large_ds_slice_size = (size_t)(10 * 10 * 10 * 10);
 
-    if ( mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK ) {
-        HDfprintf(stdout, "%s:%d: small ds size / slice size = %d / %d.\n",
-                  fcnName, mpi_rank,
+    if (mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK) {
+        HDfprintf(stdout, "%s:%d: small ds size / slice size = %d / %d.\n", fcnName, mpi_rank,
                   (int)small_ds_size, (int)small_ds_slice_size);
-        HDfprintf(stdout, "%s:%d: large ds size / slice size = %d / %d.\n",
-                  fcnName, mpi_rank,
+        HDfprintf(stdout, "%s:%d: large ds size / slice size = %d / %d.\n", fcnName, mpi_rank,
                   (int)large_ds_size, (int)large_ds_slice_size);
     }
 #endif /* LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG */
@@ -1649,13 +1539,12 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
     large_ds_buf_1 = (uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_size);
     VRFY((large_ds_buf_1 != NULL), "malloc of large_ds_buf_1 succeeded");
 
-
     /* initialize the buffers */
 
     ptr_0 = small_ds_buf_0;
     ptr_1 = small_ds_buf_1;
 
-    for ( i = 0; i < (int)small_ds_size; i++ ) {
+    for (i = 0; i < (int)small_ds_size; i++) {
 
         *ptr_0 = (uint32_t)i;
         *ptr_1 = 0;
@@ -1667,7 +1556,7 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
     ptr_0 = large_ds_buf_0;
     ptr_1 = large_ds_buf_1;
 
-    for ( i = 0; i < (int)large_ds_size; i++ ) {
+    for (i = 0; i < (int)large_ds_size; i++) {
 
         *ptr_0 = (uint32_t)i;
         *ptr_1 = 0;
@@ -1676,12 +1565,10 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
         ptr_1++;
     }
 
-
     /* get the file name */
 
     filename = (const char *)GetTestParameters();
-    HDassert( filename != NULL );
-
+    HDassert(filename != NULL);
 
     /* ----------------------------------------
      * CREATE AN HDF5 FILE WITH PARALLEL ACCESS
@@ -1700,11 +1587,10 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
     ret = H5Pclose(acc_tpl);
     VRFY((ret >= 0), "H5Pclose(acc_tpl) succeeded");
 
-
     /* setup dims: */
     small_dims[0] = (hsize_t)(mpi_size + 1);
-    small_dims[1] =  1;
-    small_dims[2] =  1;
+    small_dims[1] = 1;
+    small_dims[2] = 1;
     small_dims[3] = 10;
     small_dims[4] = 10;
 
@@ -1715,51 +1601,39 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
     large_dims[4] = 10;
 
 #if LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG
-    if ( mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK ) {
-        HDfprintf(stdout, "%s:%d: small_dims[] = %d %d %d %d %d\n",
-                  fcnName, mpi_rank, (int)small_dims[0], (int)small_dims[1],
-                  (int)small_dims[2], (int)small_dims[3], (int)small_dims[4]);
-        HDfprintf(stdout, "%s:%d: large_dims[] = %d %d %d %d %d\n",
-                  fcnName, mpi_rank, (int)large_dims[0], (int)large_dims[1],
-                  (int)large_dims[2], (int)large_dims[3], (int)large_dims[4]);
+    if (mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK) {
+        HDfprintf(stdout, "%s:%d: small_dims[] = %d %d %d %d %d\n", fcnName, mpi_rank, (int)small_dims[0],
+                  (int)small_dims[1], (int)small_dims[2], (int)small_dims[3], (int)small_dims[4]);
+        HDfprintf(stdout, "%s:%d: large_dims[] = %d %d %d %d %d\n", fcnName, mpi_rank, (int)large_dims[0],
+                  (int)large_dims[1], (int)large_dims[2], (int)large_dims[3], (int)large_dims[4]);
     }
 #endif
 
     /* create dataspaces */
 
     full_mem_small_ds_sid = H5Screate_simple(5, small_dims, NULL);
-    VRFY((full_mem_small_ds_sid != 0),
-         "H5Screate_simple() full_mem_small_ds_sid succeeded");
+    VRFY((full_mem_small_ds_sid != 0), "H5Screate_simple() full_mem_small_ds_sid succeeded");
 
     full_file_small_ds_sid = H5Screate_simple(5, small_dims, NULL);
-    VRFY((full_file_small_ds_sid != 0),
-         "H5Screate_simple() full_file_small_ds_sid succeeded");
+    VRFY((full_file_small_ds_sid != 0), "H5Screate_simple() full_file_small_ds_sid succeeded");
 
     mem_small_ds_sid = H5Screate_simple(5, small_dims, NULL);
-    VRFY((mem_small_ds_sid != 0),
-         "H5Screate_simple() mem_small_ds_sid succeeded");
+    VRFY((mem_small_ds_sid != 0), "H5Screate_simple() mem_small_ds_sid succeeded");
 
     file_small_ds_sid = H5Screate_simple(5, small_dims, NULL);
-    VRFY((file_small_ds_sid != 0),
-          "H5Screate_simple() file_small_ds_sid succeeded");
-
+    VRFY((file_small_ds_sid != 0), "H5Screate_simple() file_small_ds_sid succeeded");
 
     full_mem_large_ds_sid = H5Screate_simple(5, large_dims, NULL);
-    VRFY((full_mem_large_ds_sid != 0),
-         "H5Screate_simple() full_mem_large_ds_sid succeeded");
+    VRFY((full_mem_large_ds_sid != 0), "H5Screate_simple() full_mem_large_ds_sid succeeded");
 
     full_file_large_ds_sid = H5Screate_simple(5, large_dims, NULL);
-    VRFY((full_file_large_ds_sid != 0),
-         "H5Screate_simple() full_file_large_ds_sid succeeded");
+    VRFY((full_file_large_ds_sid != 0), "H5Screate_simple() full_file_large_ds_sid succeeded");
 
     mem_large_ds_sid = H5Screate_simple(5, large_dims, NULL);
-    VRFY((mem_large_ds_sid != 0),
-         "H5Screate_simple() mem_large_ds_sid succeeded");
+    VRFY((mem_large_ds_sid != 0), "H5Screate_simple() mem_large_ds_sid succeeded");
 
     file_large_ds_sid = H5Screate_simple(5, large_dims, NULL);
-    VRFY((file_large_ds_sid != 0),
-          "H5Screate_simple() file_large_ds_sid succeeded");
-
+    VRFY((file_large_ds_sid != 0), "H5Screate_simple() file_large_ds_sid succeeded");
 
     /* Select the entire extent of the full small ds dataspaces */
     ret = H5Sselect_all(full_mem_small_ds_sid);
@@ -1768,7 +1642,6 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
     ret = H5Sselect_all(full_file_small_ds_sid);
     VRFY((ret != FAIL), "H5Sselect_all(full_file_small_ds_sid) succeeded");
 
-
     /* Select the entire extent of the full large ds dataspaces */
     ret = H5Sselect_all(full_mem_large_ds_sid);
     VRFY((ret != FAIL), "H5Sselect_all(full_mem_large_ds_sid) succeeded");
@@ -1776,22 +1649,20 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
     ret = H5Sselect_all(full_file_large_ds_sid);
     VRFY((ret != FAIL), "H5Sselect_all(full_file_large_ds_sid) succeeded");
 
-
     /* if chunk edge size is greater than zero, set up the small and
      * large data set creation property lists to specify chunked
      * datasets.
      */
-    if ( chunk_edge_size > 0 ) {
+    if (chunk_edge_size > 0) {
 
         small_chunk_dims[0] = (hsize_t)(1);
         small_chunk_dims[1] = small_chunk_dims[2] = (hsize_t)1;
         small_chunk_dims[3] = small_chunk_dims[4] = (hsize_t)chunk_edge_size;
 
 #if LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG
-        if ( mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK ) {
-            HDfprintf(stdout, "%s:%d: small chunk dims[] = %d %d %d %d %d\n",
-                      fcnName, mpi_rank, (int)small_chunk_dims[0],
-                      (int)small_chunk_dims[1], (int)small_chunk_dims[2],
+        if (mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK) {
+            HDfprintf(stdout, "%s:%d: small chunk dims[] = %d %d %d %d %d\n", fcnName, mpi_rank,
+                      (int)small_chunk_dims[0], (int)small_chunk_dims[1], (int)small_chunk_dims[2],
                       (int)small_chunk_dims[3], (int)small_chunk_dims[4]);
         }
 #endif
@@ -1806,15 +1677,13 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
         VRFY((ret != FAIL), "H5Pset_chunk() small_ds_dcpl_id succeeded");
 
         large_chunk_dims[0] = (hsize_t)(1);
-        large_chunk_dims[1] = large_chunk_dims[2] =
-            large_chunk_dims[3] = large_chunk_dims[4] = (hsize_t)chunk_edge_size;
-
+        large_chunk_dims[1] = large_chunk_dims[2] = large_chunk_dims[3] = large_chunk_dims[4] =
+            (hsize_t)chunk_edge_size;
 
 #if LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG
-        if ( mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK ) {
-            HDfprintf(stdout, "%s:%d: large chunk dims[] = %d %d %d %d %d\n",
-                      fcnName, mpi_rank, (int)large_chunk_dims[0],
-                      (int)large_chunk_dims[1], (int)large_chunk_dims[2],
+        if (mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK) {
+            HDfprintf(stdout, "%s:%d: large chunk dims[] = %d %d %d %d %d\n", fcnName, mpi_rank,
+                      (int)large_chunk_dims[0], (int)large_chunk_dims[1], (int)large_chunk_dims[2],
                       (int)large_chunk_dims[3], (int)large_chunk_dims[4]);
         }
 #endif
@@ -1829,30 +1698,23 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
         VRFY((ret != FAIL), "H5Pset_chunk() large_ds_dcpl_id succeeded");
     }
 
-
     /* create the small dataset */
-    small_dataset = H5Dcreate2(fid, "small_dataset", dset_type,
-                               file_small_ds_sid, H5P_DEFAULT,
+    small_dataset = H5Dcreate2(fid, "small_dataset", dset_type, file_small_ds_sid, H5P_DEFAULT,
                                small_ds_dcpl_id, H5P_DEFAULT);
     VRFY((ret >= 0), "H5Dcreate2() small_dataset succeeded");
 
-
     /* create the large dataset */
-    large_dataset = H5Dcreate2(fid, "large_dataset", dset_type,
-                               file_large_ds_sid, H5P_DEFAULT,
+    large_dataset = H5Dcreate2(fid, "large_dataset", dset_type, file_large_ds_sid, H5P_DEFAULT,
                                large_ds_dcpl_id, H5P_DEFAULT);
     VRFY((ret >= 0), "H5Dcreate2() large_dataset succeeded");
 
 #if LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG
-    if ( mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK ) {
-        HDfprintf(stdout,
-                  "%s:%d: small/large ds id = %d / %d.\n",
-                  fcnName, mpi_rank, (int)small_dataset,
+    if (mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK) {
+        HDfprintf(stdout, "%s:%d: small/large ds id = %d / %d.\n", fcnName, mpi_rank, (int)small_dataset,
                   (int)large_dataset);
     }
 #endif /* LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG */
 
-
     /* setup xfer property list */
     xfer_plist = H5Pcreate(H5P_DATASET_XFER);
     VRFY((xfer_plist >= 0), "H5Pcreate(H5P_DATASET_XFER) succeeded");
@@ -1860,14 +1722,12 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
     ret = H5Pset_dxpl_mpio(xfer_plist, H5FD_MPIO_COLLECTIVE);
     VRFY((ret >= 0), "H5Pset_dxpl_mpio succeeded");
 
-    if ( ! use_collective_io ) {
+    if (!use_collective_io) {
 
-        ret = H5Pset_dxpl_mpio_collective_opt(xfer_plist,
-                                              H5FD_MPIO_INDIVIDUAL_IO);
-        VRFY((ret>= 0), "H5Pset_dxpl_mpio_collective_opt() suceeded");
+        ret = H5Pset_dxpl_mpio_collective_opt(xfer_plist, H5FD_MPIO_INDIVIDUAL_IO);
+        VRFY((ret >= 0), "H5Pset_dxpl_mpio_collective_opt() suceeded");
     }
 
-
     /* setup selection to write initial data to the small data sets */
     start[0] = (hsize_t)(mpi_rank + 1);
     start[1] = start[2] = start[3] = start[4] = 0;
@@ -1882,135 +1742,89 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
     block[3] = block[4] = 10;
 
 #if LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG
-    if ( mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK ) {
-        HDfprintf(stdout,
-                  "%s:%d: settings for small data set initialization.\n",
-                  fcnName, mpi_rank);
-        HDfprintf(stdout, "%s:%d: start[]  = %d %d %d %d %d\n",
-                  fcnName, mpi_rank, (int)start[0], (int)start[1],
-                  (int)start[2], (int)start[3], (int)start[4]);
-        HDfprintf(stdout, "%s:%d: stride[] = %d %d %d %d %d\n",
-                  fcnName, mpi_rank, (int)stride[0], (int)stride[1],
-                  (int)stride[2], (int)stride[3], (int)stride[4]);
-        HDfprintf(stdout, "%s:%d: count[]  = %d %d %d %d %d\n",
-                  fcnName, mpi_rank, (int)count[0], (int)count[1],
-                  (int)count[2], (int)count[3], (int)count[4]);
-        HDfprintf(stdout, "%s:%d: block[]  = %d %d %d %d %d\n",
-                  fcnName, mpi_rank, (int)block[0], (int)block[1],
-                  (int)block[2], (int)block[3], (int)block[4]);
+    if (mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK) {
+        HDfprintf(stdout, "%s:%d: settings for small data set initialization.\n", fcnName, mpi_rank);
+        HDfprintf(stdout, "%s:%d: start[]  = %d %d %d %d %d\n", fcnName, mpi_rank, (int)start[0],
+                  (int)start[1], (int)start[2], (int)start[3], (int)start[4]);
+        HDfprintf(stdout, "%s:%d: stride[] = %d %d %d %d %d\n", fcnName, mpi_rank, (int)stride[0],
+                  (int)stride[1], (int)stride[2], (int)stride[3], (int)stride[4]);
+        HDfprintf(stdout, "%s:%d: count[]  = %d %d %d %d %d\n", fcnName, mpi_rank, (int)count[0],
+                  (int)count[1], (int)count[2], (int)count[3], (int)count[4]);
+        HDfprintf(stdout, "%s:%d: block[]  = %d %d %d %d %d\n", fcnName, mpi_rank, (int)block[0],
+                  (int)block[1], (int)block[2], (int)block[3], (int)block[4]);
     }
 #endif /* LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG */
 
     /* setup selections for writing initial data to the small data set */
-    ret = H5Sselect_hyperslab(mem_small_ds_sid,
-                              H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
+    ret = H5Sselect_hyperslab(mem_small_ds_sid, H5S_SELECT_SET, start, stride, count, block);
     VRFY((ret >= 0), "H5Sselect_hyperslab(mem_small_ds_sid, set) suceeded");
 
-    ret = H5Sselect_hyperslab(file_small_ds_sid,
-                              H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
+    ret = H5Sselect_hyperslab(file_small_ds_sid, H5S_SELECT_SET, start, stride, count, block);
     VRFY((ret >= 0), "H5Sselect_hyperslab(file_small_ds_sid, set) suceeded");
 
-    if ( MAINPROCESS ) { /* add an additional slice to the selections */
+    if (MAINPROCESS) { /* add an additional slice to the selections */
 
         start[0] = 0;
 
 #if LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG
-        if ( mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK ) {
-            HDfprintf(stdout,
-                      "%s:%d: added settings for main process.\n",
-                      fcnName, mpi_rank);
-            HDfprintf(stdout, "%s:%d: start[]  = %d %d %d %d %d\n",
-                      fcnName, mpi_rank, (int)start[0], (int)start[1],
-                      (int)start[2], (int)start[3], (int)start[4]);
-            HDfprintf(stdout, "%s:%d: stride[] = %d %d %d %d %d\n",
-                      fcnName, mpi_rank, (int)stride[0], (int)stride[1],
-                      (int)stride[2], (int)stride[3], (int)stride[4]);
-            HDfprintf(stdout, "%s:%d: count[]  = %d %d %d %d %d\n",
-                      fcnName, mpi_rank, (int)count[0], (int)count[1],
-                      (int)count[2], (int)count[3], (int)count[4]);
-            HDfprintf(stdout, "%s:%d: block[]  = %d %d %d %d %d\n",
-                      fcnName, mpi_rank, (int)block[0], (int)block[1],
-                      (int)block[2], (int)block[3], (int)block[4]);
+        if (mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK) {
+            HDfprintf(stdout, "%s:%d: added settings for main process.\n", fcnName, mpi_rank);
+            HDfprintf(stdout, "%s:%d: start[]  = %d %d %d %d %d\n", fcnName, mpi_rank, (int)start[0],
+                      (int)start[1], (int)start[2], (int)start[3], (int)start[4]);
+            HDfprintf(stdout, "%s:%d: stride[] = %d %d %d %d %d\n", fcnName, mpi_rank, (int)stride[0],
+                      (int)stride[1], (int)stride[2], (int)stride[3], (int)stride[4]);
+            HDfprintf(stdout, "%s:%d: count[]  = %d %d %d %d %d\n", fcnName, mpi_rank, (int)count[0],
+                      (int)count[1], (int)count[2], (int)count[3], (int)count[4]);
+            HDfprintf(stdout, "%s:%d: block[]  = %d %d %d %d %d\n", fcnName, mpi_rank, (int)block[0],
+                      (int)block[1], (int)block[2], (int)block[3], (int)block[4]);
         }
 #endif /* LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG */
 
-        ret = H5Sselect_hyperslab(mem_small_ds_sid,
-                                  H5S_SELECT_OR,
-                                  start,
-                                  stride,
-                                  count,
-                                  block);
-        VRFY((ret>= 0), "H5Sselect_hyperslab(mem_small_ds_sid, or) suceeded");
-
-        ret = H5Sselect_hyperslab(file_small_ds_sid,
-                                  H5S_SELECT_OR,
-                                  start,
-                                  stride,
-                                  count,
-                                  block);
-        VRFY((ret>= 0), "H5Sselect_hyperslab(file_small_ds_sid, or) suceeded");
-    }
+        ret = H5Sselect_hyperslab(mem_small_ds_sid, H5S_SELECT_OR, start, stride, count, block);
+        VRFY((ret >= 0), "H5Sselect_hyperslab(mem_small_ds_sid, or) suceeded");
 
-    check =  H5Sselect_valid(mem_small_ds_sid);
-    VRFY((check == TRUE),"H5Sselect_valid(mem_small_ds_sid) returns TRUE");
+        ret = H5Sselect_hyperslab(file_small_ds_sid, H5S_SELECT_OR, start, stride, count, block);
+        VRFY((ret >= 0), "H5Sselect_hyperslab(file_small_ds_sid, or) suceeded");
+    }
 
-    check =  H5Sselect_valid(file_small_ds_sid);
-    VRFY((check == TRUE),"H5Sselect_valid(file_small_ds_sid) returns TRUE");
+    check = H5Sselect_valid(mem_small_ds_sid);
+    VRFY((check == TRUE), "H5Sselect_valid(mem_small_ds_sid) returns TRUE");
 
+    check = H5Sselect_valid(file_small_ds_sid);
+    VRFY((check == TRUE), "H5Sselect_valid(file_small_ds_sid) returns TRUE");
 
     /* write the initial value of the small data set to file */
 #if LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG
-    if ( mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK ) {
-        HDfprintf(stdout, "%s:%d: writing init value of small ds to file.\n",
-                  fcnName, mpi_rank);
+    if (mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK) {
+        HDfprintf(stdout, "%s:%d: writing init value of small ds to file.\n", fcnName, mpi_rank);
     }
 #endif /* LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG */
-    ret = H5Dwrite(small_dataset,
-                   dset_type,
-                   mem_small_ds_sid,
-                   file_small_ds_sid,
-                   xfer_plist,
-                   small_ds_buf_0);
+    ret = H5Dwrite(small_dataset, dset_type, mem_small_ds_sid, file_small_ds_sid, xfer_plist, small_ds_buf_0);
     VRFY((ret >= 0), "H5Dwrite() small_dataset initial write succeeded");
 
-
     /* read the small data set back to verify that it contains the
      * expected data.  Note that each process reads in the entire
      * data set and verifies it.
      */
-    ret = H5Dread(small_dataset,
-                  H5T_NATIVE_UINT32,
-                  full_mem_small_ds_sid,
-                  full_file_small_ds_sid,
-                  xfer_plist,
+    ret = H5Dread(small_dataset, H5T_NATIVE_UINT32, full_mem_small_ds_sid, full_file_small_ds_sid, xfer_plist,
                   small_ds_buf_1);
     VRFY((ret >= 0), "H5Dread() small_dataset initial read succeeded");
 
-
     /* sync with the other processes before checking data */
     mrc = MPI_Barrier(MPI_COMM_WORLD);
-    VRFY((mrc==MPI_SUCCESS), "Sync after small dataset writes");
-
+    VRFY((mrc == MPI_SUCCESS), "Sync after small dataset writes");
 
     /* verify that the correct data was written to the small data set,
      * and reset the buffer to zero in passing.
      */
     expected_value = 0;
-    mis_match = FALSE;
-    ptr_1 = small_ds_buf_1;
+    mis_match      = FALSE;
+    ptr_1          = small_ds_buf_1;
 
     i = 0;
-    for ( i = 0; i < (int)small_ds_size; i++ ) {
+    for (i = 0; i < (int)small_ds_size; i++) {
 
-        if ( *ptr_1 != expected_value ) {
+        if (*ptr_1 != expected_value) {
 
             mis_match = TRUE;
         }
@@ -2020,9 +1834,7 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
         ptr_1++;
         expected_value++;
     }
-    VRFY( (mis_match == FALSE), "small ds init data good.");
-
-
+    VRFY((mis_match == FALSE), "small ds init data good.");
 
     /* setup selections for writing initial data to the large data set */
     start[0] = (hsize_t)(mpi_rank + 1);
@@ -2037,104 +1849,64 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
     block[1] = block[2] = block[3] = block[4] = (hsize_t)10;
 
 #if LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG
-    if ( mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK ) {
-        HDfprintf(stdout,
-                  "%s:%d: settings for large data set initialization.\n",
-                  fcnName, mpi_rank);
-        HDfprintf(stdout, "%s:%d: start[]  = %d %d %d %d %d\n",
-                  fcnName, mpi_rank, (int)start[0], (int)start[1],
-                  (int)start[2], (int)start[3], (int)start[4]);
-        HDfprintf(stdout, "%s:%d: stride[] = %d %d %d %d %d\n",
-                  fcnName, mpi_rank, (int)stride[0], (int)stride[1],
-                  (int)stride[2], (int)stride[3], (int)stride[4]);
-        HDfprintf(stdout, "%s:%d: count[]  = %d %d %d %d %d\n",
-                  fcnName, mpi_rank, (int)count[0], (int)count[1],
-                  (int)count[2], (int)count[3], (int)count[4]);
-        HDfprintf(stdout, "%s:%d: block[]  = %d %d %d %d %d\n",
-                  fcnName, mpi_rank, (int)block[0], (int)block[1],
-                  (int)block[2], (int)block[3], (int)block[4]);
+    if (mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK) {
+        HDfprintf(stdout, "%s:%d: settings for large data set initialization.\n", fcnName, mpi_rank);
+        HDfprintf(stdout, "%s:%d: start[]  = %d %d %d %d %d\n", fcnName, mpi_rank, (int)start[0],
+                  (int)start[1], (int)start[2], (int)start[3], (int)start[4]);
+        HDfprintf(stdout, "%s:%d: stride[] = %d %d %d %d %d\n", fcnName, mpi_rank, (int)stride[0],
+                  (int)stride[1], (int)stride[2], (int)stride[3], (int)stride[4]);
+        HDfprintf(stdout, "%s:%d: count[]  = %d %d %d %d %d\n", fcnName, mpi_rank, (int)count[0],
+                  (int)count[1], (int)count[2], (int)count[3], (int)count[4]);
+        HDfprintf(stdout, "%s:%d: block[]  = %d %d %d %d %d\n", fcnName, mpi_rank, (int)block[0],
+                  (int)block[1], (int)block[2], (int)block[3], (int)block[4]);
     }
 #endif /* LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG */
 
-    ret = H5Sselect_hyperslab(mem_large_ds_sid,
-                              H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
+    ret = H5Sselect_hyperslab(mem_large_ds_sid, H5S_SELECT_SET, start, stride, count, block);
     VRFY((ret >= 0), "H5Sselect_hyperslab(mem_large_ds_sid, set) suceeded");
 
-    ret = H5Sselect_hyperslab(file_large_ds_sid,
-                              H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
+    ret = H5Sselect_hyperslab(file_large_ds_sid, H5S_SELECT_SET, start, stride, count, block);
     VRFY((ret >= 0), "H5Sselect_hyperslab(file_large_ds_sid, set) suceeded");
 
 #if LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG
-    if ( mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK ) {
-    HDfprintf(stdout,
-              "%s%d: H5Sget_select_npoints(mem_large_ds_sid) = %d.\n",
-              fcnName, mpi_rank,
-              (int)H5Sget_select_npoints(mem_large_ds_sid));
-    HDfprintf(stdout,
-              "%s%d: H5Sget_select_npoints(file_large_ds_sid) = %d.\n",
-              fcnName, mpi_rank,
-              (int)H5Sget_select_npoints(file_large_ds_sid));
+    if (mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK) {
+        HDfprintf(stdout, "%s%d: H5Sget_select_npoints(mem_large_ds_sid) = %d.\n", fcnName, mpi_rank,
+                  (int)H5Sget_select_npoints(mem_large_ds_sid));
+        HDfprintf(stdout, "%s%d: H5Sget_select_npoints(file_large_ds_sid) = %d.\n", fcnName, mpi_rank,
+                  (int)H5Sget_select_npoints(file_large_ds_sid));
     }
 #endif /* LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG */
 
-    if ( MAINPROCESS ) { /* add an additional slice to the selections */
+    if (MAINPROCESS) { /* add an additional slice to the selections */
 
         start[0] = (hsize_t)0;
 
 #if LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG
-        if ( mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK ) {
-            HDfprintf(stdout,
-                      "%s:%d: added settings for main process.\n",
-                      fcnName, mpi_rank);
-            HDfprintf(stdout, "%s:%d: start[]  = %d %d %d %d %d\n",
-                      fcnName, mpi_rank, (int)start[0], (int)start[1],
-                      (int)start[2], (int)start[3], (int)start[4]);
-            HDfprintf(stdout, "%s:%d: stride[] = %d %d %d %d %d\n",
-                      fcnName, mpi_rank, (int)stride[0], (int)stride[1],
-                      (int)stride[2], (int)stride[3], (int)stride[4]);
-            HDfprintf(stdout, "%s:%d: count[]  = %d %d %d %d %d\n",
-                      fcnName, mpi_rank, (int)count[0], (int)count[1],
-                      (int)count[2], (int)count[3], (int)count[4]);
-            HDfprintf(stdout, "%s:%d: block[]  = %d %d %d %d %d\n",
-                      fcnName, mpi_rank, (int)block[0], (int)block[1],
-                      (int)block[2], (int)block[3], (int)block[4]);
+        if (mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK) {
+            HDfprintf(stdout, "%s:%d: added settings for main process.\n", fcnName, mpi_rank);
+            HDfprintf(stdout, "%s:%d: start[]  = %d %d %d %d %d\n", fcnName, mpi_rank, (int)start[0],
+                      (int)start[1], (int)start[2], (int)start[3], (int)start[4]);
+            HDfprintf(stdout, "%s:%d: stride[] = %d %d %d %d %d\n", fcnName, mpi_rank, (int)stride[0],
+                      (int)stride[1], (int)stride[2], (int)stride[3], (int)stride[4]);
+            HDfprintf(stdout, "%s:%d: count[]  = %d %d %d %d %d\n", fcnName, mpi_rank, (int)count[0],
+                      (int)count[1], (int)count[2], (int)count[3], (int)count[4]);
+            HDfprintf(stdout, "%s:%d: block[]  = %d %d %d %d %d\n", fcnName, mpi_rank, (int)block[0],
+                      (int)block[1], (int)block[2], (int)block[3], (int)block[4]);
         }
 #endif /* LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG */
 
-        ret = H5Sselect_hyperslab(mem_large_ds_sid,
-                                  H5S_SELECT_OR,
-                                  start,
-                                  stride,
-                                  count,
-                                  block);
-        VRFY((ret>= 0), "H5Sselect_hyperslab(mem_large_ds_sid, or) suceeded");
-
-        ret = H5Sselect_hyperslab(file_large_ds_sid,
-                                  H5S_SELECT_OR,
-                                  start,
-                                  stride,
-                                  count,
-                                  block);
-        VRFY((ret>= 0), "H5Sselect_hyperslab(file_large_ds_sid, or) suceeded");
+        ret = H5Sselect_hyperslab(mem_large_ds_sid, H5S_SELECT_OR, start, stride, count, block);
+        VRFY((ret >= 0), "H5Sselect_hyperslab(mem_large_ds_sid, or) suceeded");
+
+        ret = H5Sselect_hyperslab(file_large_ds_sid, H5S_SELECT_OR, start, stride, count, block);
+        VRFY((ret >= 0), "H5Sselect_hyperslab(file_large_ds_sid, or) suceeded");
 
 #if LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG
-        if ( mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK ) {
-        HDfprintf(stdout,
-                  "%s%d: H5Sget_select_npoints(mem_large_ds_sid) = %d.\n",
-                  fcnName, mpi_rank,
-                  (int)H5Sget_select_npoints(mem_large_ds_sid));
-        HDfprintf(stdout,
-                  "%s%d: H5Sget_select_npoints(file_large_ds_sid) = %d.\n",
-                  fcnName, mpi_rank,
-                  (int)H5Sget_select_npoints(file_large_ds_sid));
+        if (mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK) {
+            HDfprintf(stdout, "%s%d: H5Sget_select_npoints(mem_large_ds_sid) = %d.\n", fcnName, mpi_rank,
+                      (int)H5Sget_select_npoints(mem_large_ds_sid));
+            HDfprintf(stdout, "%s%d: H5Sget_select_npoints(file_large_ds_sid) = %d.\n", fcnName, mpi_rank,
+                      (int)H5Sget_select_npoints(file_large_ds_sid));
         }
 #endif /* LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG */
     }
@@ -2150,93 +1922,70 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
     block[0] = (hsize_t)(mpi_size + 1);
     block[1] = block[2] = block[3] = block[4] = (hsize_t)10;
 
-    ret = H5Sselect_hyperslab(mem_large_ds_sid, H5S_SELECT_AND,
-                              start, stride, count, block);
-    VRFY((ret != FAIL),"H5Sselect_hyperslab(mem_large_ds_sid, and) succeeded");
+    ret = H5Sselect_hyperslab(mem_large_ds_sid, H5S_SELECT_AND, start, stride, count, block);
+    VRFY((ret != FAIL), "H5Sselect_hyperslab(mem_large_ds_sid, and) succeeded");
 
-    ret = H5Sselect_hyperslab(file_large_ds_sid, H5S_SELECT_AND,
-                              start, stride, count, block);
-    VRFY((ret != FAIL),"H5Sselect_hyperslab(file_large_ds_sid, and) succeeded");
+    ret = H5Sselect_hyperslab(file_large_ds_sid, H5S_SELECT_AND, start, stride, count, block);
+    VRFY((ret != FAIL), "H5Sselect_hyperslab(file_large_ds_sid, and) succeeded");
 
 #if LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG
-    if ( mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK ) {
+    if (mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK) {
 
         rank = H5Sget_simple_extent_dims(mem_large_ds_sid, dims, max_dims);
-        HDfprintf(stdout,
-                  "%s:%d: mem_large_ds_sid dims[%d] = %d %d %d %d %d\n",
-                  fcnName, mpi_rank, rank, (int)dims[0], (int)dims[1],
-                  (int)dims[2], (int)dims[3], (int)dims[4]);
+        HDfprintf(stdout, "%s:%d: mem_large_ds_sid dims[%d] = %d %d %d %d %d\n", fcnName, mpi_rank, rank,
+                  (int)dims[0], (int)dims[1], (int)dims[2], (int)dims[3], (int)dims[4]);
 
         rank = H5Sget_simple_extent_dims(file_large_ds_sid, dims, max_dims);
-        HDfprintf(stdout,
-                  "%s:%d: file_large_ds_sid dims[%d] = %d %d %d %d %d\n",
-                  fcnName, mpi_rank, rank, (int)dims[0], (int)dims[1],
-                  (int)dims[2], (int)dims[3], (int)dims[4]);
+        HDfprintf(stdout, "%s:%d: file_large_ds_sid dims[%d] = %d %d %d %d %d\n", fcnName, mpi_rank, rank,
+                  (int)dims[0], (int)dims[1], (int)dims[2], (int)dims[3], (int)dims[4]);
     }
 #endif /* LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG */
 
-    check =  H5Sselect_valid(mem_large_ds_sid);
-    VRFY((check == TRUE),"H5Sselect_valid(mem_large_ds_sid) returns TRUE");
-
-    check =  H5Sselect_valid(file_large_ds_sid);
-    VRFY((check == TRUE),"H5Sselect_valid(file_large_ds_sid) returns TRUE");
+    check = H5Sselect_valid(mem_large_ds_sid);
+    VRFY((check == TRUE), "H5Sselect_valid(mem_large_ds_sid) returns TRUE");
 
+    check = H5Sselect_valid(file_large_ds_sid);
+    VRFY((check == TRUE), "H5Sselect_valid(file_large_ds_sid) returns TRUE");
 
     /* write the initial value of the large data set to file */
 #if LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG
-    if ( mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK ) {
-        HDfprintf(stdout, "%s:%d: writing init value of large ds to file.\n",
-                  fcnName, mpi_rank);
-        HDfprintf(stdout,
-                  "%s:%d: large_dataset = %d.\n",
-                  fcnName, mpi_rank,
-                  (int)large_dataset);
-        HDfprintf(stdout,
-                  "%s:%d: mem_large_ds_sid = %d, file_large_ds_sid = %d.\n",
-                  fcnName, mpi_rank,
+    if (mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK) {
+        HDfprintf(stdout, "%s:%d: writing init value of large ds to file.\n", fcnName, mpi_rank);
+        HDfprintf(stdout, "%s:%d: large_dataset = %d.\n", fcnName, mpi_rank, (int)large_dataset);
+        HDfprintf(stdout, "%s:%d: mem_large_ds_sid = %d, file_large_ds_sid = %d.\n", fcnName, mpi_rank,
                   (int)mem_large_ds_sid, (int)file_large_ds_sid);
     }
 #endif /* LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG */
 
-    ret = H5Dwrite(large_dataset,
-                   dset_type,
-                   mem_large_ds_sid,
-                   file_large_ds_sid,
-                   xfer_plist,
-                   large_ds_buf_0);
+    ret = H5Dwrite(large_dataset, dset_type, mem_large_ds_sid, file_large_ds_sid, xfer_plist, large_ds_buf_0);
 
-    if ( ret < 0 ) H5Eprint2(H5E_DEFAULT, stderr);
+    if (ret < 0)
+        H5Eprint2(H5E_DEFAULT, stderr);
     VRFY((ret >= 0), "H5Dwrite() large_dataset initial write succeeded");
 
-
     /* sync with the other processes before checking data */
     mrc = MPI_Barrier(MPI_COMM_WORLD);
-    VRFY((mrc==MPI_SUCCESS), "Sync after large dataset writes");
+    VRFY((mrc == MPI_SUCCESS), "Sync after large dataset writes");
 
     /* read the large data set back to verify that it contains the
      * expected data.  Note that each process reads in the entire
      * data set.
      */
-    ret = H5Dread(large_dataset,
-                  H5T_NATIVE_UINT32,
-                  full_mem_large_ds_sid,
-                  full_file_large_ds_sid,
-                  xfer_plist,
+    ret = H5Dread(large_dataset, H5T_NATIVE_UINT32, full_mem_large_ds_sid, full_file_large_ds_sid, xfer_plist,
                   large_ds_buf_1);
     VRFY((ret >= 0), "H5Dread() large_dataset initial read succeeded");
 
-
     /* verify that the correct data was written to the large data set.
      * in passing, reset the buffer to zeros
      */
     expected_value = 0;
-    mis_match = FALSE;
-    ptr_1 = large_ds_buf_1;
+    mis_match      = FALSE;
+    ptr_1          = large_ds_buf_1;
 
     i = 0;
-    for ( i = 0; i < (int)large_ds_size; i++ ) {
+    for (i = 0; i < (int)large_ds_size; i++) {
 
-        if ( *ptr_1 != expected_value ) {
+        if (*ptr_1 != expected_value) {
 
             mis_match = TRUE;
         }
@@ -2246,52 +1995,39 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
         ptr_1++;
         expected_value++;
     }
-    VRFY( (mis_match == FALSE), "large ds init data good.");
+    VRFY((mis_match == FALSE), "large ds init data good.");
 
     /***********************************/
     /***** INITIALIZATION COMPLETE *****/
     /***********************************/
 
-
     /* read a checkerboard selection of the process slice of the
      * small on disk data set into the process slice of the large
      * in memory data set, and verify the data read.
      */
 
     small_sel_start[0] = (hsize_t)(mpi_rank + 1);
-    small_sel_start[1] = small_sel_start[2] =
-    small_sel_start[3] = small_sel_start[4] = 0;
-
-    lower_dim_size_comp_test__select_checker_board(mpi_rank,
-                                                   file_small_ds_sid,
-                                                   /* tgt_rank          = */  5,
-                                                   small_dims,
-                                                   /* checker_edge_size = */  3,
-                                                   /* sel_rank */             2,
-                                                   small_sel_start);
-
-    expected_value = (uint32_t)
-                     ((small_sel_start[0] * small_dims[1] * small_dims[2] *
-                                            small_dims[3] * small_dims[4]) +
-                      (small_sel_start[1] * small_dims[2] * small_dims[3] *
-                                            small_dims[4]) +
-                      (small_sel_start[2] * small_dims[3] * small_dims[4]) +
-                      (small_sel_start[3] * small_dims[4]) +
-                      (small_sel_start[4]));
+    small_sel_start[1] = small_sel_start[2] = small_sel_start[3] = small_sel_start[4] = 0;
 
+    lower_dim_size_comp_test__select_checker_board(mpi_rank, file_small_ds_sid,
+                                                   /* tgt_rank          = */ 5, small_dims,
+                                                   /* checker_edge_size = */ 3,
+                                                   /* sel_rank */ 2, small_sel_start);
+
+    expected_value =
+        (uint32_t)((small_sel_start[0] * small_dims[1] * small_dims[2] * small_dims[3] * small_dims[4]) +
+                   (small_sel_start[1] * small_dims[2] * small_dims[3] * small_dims[4]) +
+                   (small_sel_start[2] * small_dims[3] * small_dims[4]) +
+                   (small_sel_start[3] * small_dims[4]) + (small_sel_start[4]));
 
     large_sel_start[0] = (hsize_t)(mpi_rank + 1);
     large_sel_start[1] = 5;
     large_sel_start[2] = large_sel_start[3] = large_sel_start[4] = 0;
 
-    lower_dim_size_comp_test__select_checker_board(mpi_rank,
-                                                   mem_large_ds_sid,
-                                                   /* tgt_rank          = */  5,
-                                                   large_dims,
-                                                   /* checker_edge_size = */  3,
-                                                   /* sel_rank          = */  2,
-                                                   large_sel_start);
-
+    lower_dim_size_comp_test__select_checker_board(mpi_rank, mem_large_ds_sid,
+                                                   /* tgt_rank          = */ 5, large_dims,
+                                                   /* checker_edge_size = */ 3,
+                                                   /* sel_rank          = */ 2, large_sel_start);
 
     /* verify that H5Sselect_shape_same() reports the two
      * selections as having the same shape.
@@ -2299,18 +2035,13 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
     check = H5Sselect_shape_same(mem_large_ds_sid, file_small_ds_sid);
     VRFY((check == TRUE), "H5Sselect_shape_same passed (1)");
 
-
-    ret = H5Dread(small_dataset,
-                  H5T_NATIVE_UINT32,
-                  mem_large_ds_sid,
-                  file_small_ds_sid,
-                  xfer_plist,
+    ret = H5Dread(small_dataset, H5T_NATIVE_UINT32, mem_large_ds_sid, file_small_ds_sid, xfer_plist,
                   large_ds_buf_1);
 
     VRFY((ret >= 0), "H5Sread() slice from small ds succeeded.");
 
 #if LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG
-    if ( mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK ) {
+    if (mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK) {
         HDfprintf(stdout, "%s:%d: H5Dread() returns.\n", fcnName, mpi_rank);
     }
 #endif /* LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG */
@@ -2319,28 +2050,25 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
 
     data_ok = TRUE;
 
-    start_index = (int)((large_sel_start[0] * large_dims[1] * large_dims[2] *
-                                              large_dims[3] * large_dims[4]) +
-                        (large_sel_start[1] * large_dims[2] * large_dims[3] *
-                                              large_dims[4]) +
+    start_index = (int)((large_sel_start[0] * large_dims[1] * large_dims[2] * large_dims[3] * large_dims[4]) +
+                        (large_sel_start[1] * large_dims[2] * large_dims[3] * large_dims[4]) +
                         (large_sel_start[2] * large_dims[3] * large_dims[4]) +
-                        (large_sel_start[3] * large_dims[4]) +
-                        (large_sel_start[4]));
+                        (large_sel_start[3] * large_dims[4]) + (large_sel_start[4]));
 
-    stop_index  = start_index + (int)small_ds_slice_size;
+    stop_index = start_index + (int)small_ds_slice_size;
 
-    HDassert( 0 <= start_index );
-    HDassert( start_index < stop_index );
-    HDassert( stop_index <= (int)large_ds_size );
+    HDassert(0 <= start_index);
+    HDassert(start_index < stop_index);
+    HDassert(stop_index <= (int)large_ds_size);
 
     ptr_1 = large_ds_buf_1;
 
-    for ( i = 0; i < start_index; i++ ) {
+    for (i = 0; i < start_index; i++) {
 
-        if ( *ptr_1 != (uint32_t)0 ) {
+        if (*ptr_1 != (uint32_t)0) {
 
             data_ok = FALSE;
-            *ptr_1 = (uint32_t)0;
+            *ptr_1  = (uint32_t)0;
         }
 
         ptr_1++;
@@ -2348,16 +2076,14 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
 
     VRFY((data_ok == TRUE), "slice read from small ds data good(1).");
 
-
     data_ok = lower_dim_size_comp_test__verify_data(ptr_1,
 #if LOWER_DIM_SIZE_COMP_TEST__VERIFY_DATA__DEBUG
-                                            mpi_rank,
+                                                    mpi_rank,
 #endif /* LOWER_DIM_SIZE_COMP_TEST__VERIFY_DATA__DEBUG */
-                                            /* rank */ 2,
-                                            /* edge_size */ 10,
-                                            /*  checker_edge_size */ 3,
-                                            expected_value,
-                                            /* buf_starts_in_checker */ TRUE);
+                                                    /* rank */ 2,
+                                                    /* edge_size */ 10,
+                                                    /*  checker_edge_size */ 3, expected_value,
+                                                    /* buf_starts_in_checker */ TRUE);
 
     VRFY((data_ok == TRUE), "slice read from small ds data good(2).");
 
@@ -2365,13 +2091,12 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
 
     ptr_1 += small_ds_slice_size;
 
+    for (i = stop_index; i < (int)large_ds_size; i++) {
 
-    for ( i = stop_index; i < (int)large_ds_size; i++ ) {
-
-        if ( *ptr_1 != (uint32_t)0 ) {
+        if (*ptr_1 != (uint32_t)0) {
 
             data_ok = FALSE;
-            *ptr_1 = (uint32_t)0;
+            *ptr_1  = (uint32_t)0;
         }
 
         ptr_1++;
@@ -2379,39 +2104,27 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
 
     VRFY((data_ok == TRUE), "slice read from small ds data good(3).");
 
-
-
-
-
     /* read a checkerboard selection of a slice of the process slice of
      * the large on disk data set into the process slice of the small
      * in memory data set, and verify the data read.
      */
 
     small_sel_start[0] = (hsize_t)(mpi_rank + 1);
-    small_sel_start[1] = small_sel_start[2] =
-    small_sel_start[3] = small_sel_start[4] = 0;
+    small_sel_start[1] = small_sel_start[2] = small_sel_start[3] = small_sel_start[4] = 0;
 
-    lower_dim_size_comp_test__select_checker_board(mpi_rank,
-                                                   mem_small_ds_sid,
-                                                   /* tgt_rank          = */  5,
-                                                   small_dims,
-                                                   /* checker_edge_size = */  3,
-                                                   /* sel_rank */             2,
-                                                   small_sel_start);
+    lower_dim_size_comp_test__select_checker_board(mpi_rank, mem_small_ds_sid,
+                                                   /* tgt_rank          = */ 5, small_dims,
+                                                   /* checker_edge_size = */ 3,
+                                                   /* sel_rank */ 2, small_sel_start);
 
     large_sel_start[0] = (hsize_t)(mpi_rank + 1);
     large_sel_start[1] = 5;
     large_sel_start[2] = large_sel_start[3] = large_sel_start[4] = 0;
 
-    lower_dim_size_comp_test__select_checker_board(mpi_rank,
-                                                   file_large_ds_sid,
-                                                   /* tgt_rank          = */  5,
-                                                   large_dims,
-                                                   /* checker_edge_size = */  3,
-                                                   /* sel_rank          = */  2,
-                                                   large_sel_start);
-
+    lower_dim_size_comp_test__select_checker_board(mpi_rank, file_large_ds_sid,
+                                                   /* tgt_rank          = */ 5, large_dims,
+                                                   /* checker_edge_size = */ 3,
+                                                   /* sel_rank          = */ 2, large_sel_start);
 
     /* verify that H5Sselect_shape_same() reports the two
      * selections as having the same shape.
@@ -2419,18 +2132,13 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
     check = H5Sselect_shape_same(mem_small_ds_sid, file_large_ds_sid);
     VRFY((check == TRUE), "H5Sselect_shape_same passed (2)");
 
-
-    ret = H5Dread(large_dataset,
-                  H5T_NATIVE_UINT32,
-                  mem_small_ds_sid,
-                  file_large_ds_sid,
-                  xfer_plist,
+    ret = H5Dread(large_dataset, H5T_NATIVE_UINT32, mem_small_ds_sid, file_large_ds_sid, xfer_plist,
                   small_ds_buf_1);
 
     VRFY((ret >= 0), "H5Sread() slice from large ds succeeded.");
 
 #if LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG
-    if ( mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK ) {
+    if (mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK) {
         HDfprintf(stdout, "%s:%d: H5Dread() returns.\n", fcnName, mpi_rank);
     }
 #endif /* LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG */
@@ -2439,31 +2147,28 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
 
     data_ok = TRUE;
 
-    expected_value = (uint32_t)
-                     ((large_sel_start[0] * large_dims[1] * large_dims[2] *
-                                            large_dims[3] * large_dims[4]) +
-                      (large_sel_start[1] * large_dims[2] * large_dims[3] *
-                                            large_dims[4]) +
-                      (large_sel_start[2] * large_dims[3] * large_dims[4]) +
-                      (large_sel_start[3] * large_dims[4]) +
-                      (large_sel_start[4]));
+    expected_value =
+        (uint32_t)((large_sel_start[0] * large_dims[1] * large_dims[2] * large_dims[3] * large_dims[4]) +
+                   (large_sel_start[1] * large_dims[2] * large_dims[3] * large_dims[4]) +
+                   (large_sel_start[2] * large_dims[3] * large_dims[4]) +
+                   (large_sel_start[3] * large_dims[4]) + (large_sel_start[4]));
 
     start_index = (int)(mpi_rank + 1) * (int)small_ds_slice_size;
 
-    stop_index  = start_index + (int)small_ds_slice_size;
+    stop_index = start_index + (int)small_ds_slice_size;
 
-    HDassert( 0 <= start_index );
-    HDassert( start_index < stop_index );
-    HDassert( stop_index <= (int)small_ds_size );
+    HDassert(0 <= start_index);
+    HDassert(start_index < stop_index);
+    HDassert(stop_index <= (int)small_ds_size);
 
     ptr_1 = small_ds_buf_1;
 
-    for ( i = 0; i < start_index; i++ ) {
+    for (i = 0; i < start_index; i++) {
 
-        if ( *ptr_1 != (uint32_t)0 ) {
+        if (*ptr_1 != (uint32_t)0) {
 
             data_ok = FALSE;
-            *ptr_1 = (uint32_t)0;
+            *ptr_1  = (uint32_t)0;
         }
 
         ptr_1++;
@@ -2471,15 +2176,13 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
 
     VRFY((data_ok == TRUE), "slice read from large ds data good(1).");
 
-
     data_ok = lower_dim_size_comp_test__verify_data(ptr_1,
 #if LOWER_DIM_SIZE_COMP_TEST__VERIFY_DATA__DEBUG
                                                     mpi_rank,
 #endif /* LOWER_DIM_SIZE_COMP_TEST__VERIFY_DATA__DEBUG */
                                                     /* rank */ 2,
                                                     /* edge_size */ 10,
-                                                    /*  checker_edge_size */ 3,
-                                                    expected_value,
+                                                    /*  checker_edge_size */ 3, expected_value,
                                                     /* buf_starts_in_checker */ TRUE);
 
     VRFY((data_ok == TRUE), "slice read from large ds data good(2).");
@@ -2488,20 +2191,19 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
 
     ptr_1 += small_ds_slice_size;
 
+    for (i = stop_index; i < (int)small_ds_size; i++) {
 
-    for ( i = stop_index; i < (int)small_ds_size; i++ ) {
-
-        if ( *ptr_1 != (uint32_t)0 ) {
+        if (*ptr_1 != (uint32_t)0) {
 
 #if LOWER_DIM_SIZE_COMP_TEST__VERIFY_DATA__DEBUG
-            if ( mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK ) {
-                HDfprintf(stdout, "%s:%d: unexpected value at index %d: %d.\n",
-                          fcnName, mpi_rank, (int)i, (int)(*ptr_1));
+            if (mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK) {
+                HDfprintf(stdout, "%s:%d: unexpected value at index %d: %d.\n", fcnName, mpi_rank, (int)i,
+                          (int)(*ptr_1));
             }
 #endif /* LOWER_DIM_SIZE_COMP_TEST__VERIFY_DATA__DEBUG */
 
             data_ok = FALSE;
-            *ptr_1 = (uint32_t)0;
+            *ptr_1  = (uint32_t)0;
         }
 
         ptr_1++;
@@ -2509,7 +2211,6 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
 
     VRFY((data_ok == TRUE), "slice read from large ds data good(3).");
 
-
     /* Close dataspaces */
     ret = H5Sclose(full_mem_small_ds_sid);
     VRFY((ret != FAIL), "H5Sclose(full_mem_small_ds_sid) succeeded");
@@ -2523,7 +2224,6 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
     ret = H5Sclose(file_small_ds_sid);
     VRFY((ret != FAIL), "H5Sclose(file_small_ds_sid) succeeded");
 
-
     ret = H5Sclose(full_mem_large_ds_sid);
     VRFY((ret != FAIL), "H5Sclose(full_mem_large_ds_sid) succeeded");
 
@@ -2536,7 +2236,6 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
     ret = H5Sclose(file_large_ds_sid);
     VRFY((ret != FAIL), "H5Sclose(file_large_ds_sid) succeeded");
 
-
     /* Close Datasets */
     ret = H5Dclose(small_dataset);
     VRFY((ret != FAIL), "H5Dclose(small_dataset) succeeded");
@@ -2544,24 +2243,26 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
     ret = H5Dclose(large_dataset);
     VRFY((ret != FAIL), "H5Dclose(large_dataset) succeeded");
 
-
     /* close the file collectively */
     MESG("about to close file.");
     ret = H5Fclose(fid);
     VRFY((ret != FAIL), "file close succeeded");
 
     /* Free memory buffers */
-    if ( small_ds_buf_0 != NULL ) HDfree(small_ds_buf_0);
-    if ( small_ds_buf_1 != NULL ) HDfree(small_ds_buf_1);
+    if (small_ds_buf_0 != NULL)
+        HDfree(small_ds_buf_0);
+    if (small_ds_buf_1 != NULL)
+        HDfree(small_ds_buf_1);
 
-    if ( large_ds_buf_0 != NULL ) HDfree(large_ds_buf_0);
-    if ( large_ds_buf_1 != NULL ) HDfree(large_ds_buf_1);
+    if (large_ds_buf_0 != NULL)
+        HDfree(large_ds_buf_0);
+    if (large_ds_buf_1 != NULL)
+        HDfree(large_ds_buf_1);
 
     return;
 
 } /* lower_dim_size_comp_test__run_test() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    lower_dim_size_comp_test()
  *
@@ -2580,26 +2281,21 @@ void
 lower_dim_size_comp_test(void)
 {
     /* const char *fcnName = "lower_dim_size_comp_test()"; */
-    int      chunk_edge_size = 0;
-    int      use_collective_io;
+    int chunk_edge_size = 0;
+    int use_collective_io;
 
     HDcompile_assert(sizeof(uint32_t) == sizeof(unsigned));
-    for(use_collective_io = 0; use_collective_io <= 1; use_collective_io++) {
+    for (use_collective_io = 0; use_collective_io <= 1; use_collective_io++) {
         chunk_edge_size = 0;
-        lower_dim_size_comp_test__run_test(chunk_edge_size,
-                                           (hbool_t)use_collective_io,
-                                           H5T_NATIVE_UINT);
+        lower_dim_size_comp_test__run_test(chunk_edge_size, (hbool_t)use_collective_io, H5T_NATIVE_UINT);
 
         chunk_edge_size = 5;
-        lower_dim_size_comp_test__run_test(chunk_edge_size,
-                                           (hbool_t)use_collective_io,
-                                           H5T_NATIVE_UINT);
+        lower_dim_size_comp_test__run_test(chunk_edge_size, (hbool_t)use_collective_io, H5T_NATIVE_UINT);
     } /* end for */
 
     return;
 } /* lower_dim_size_comp_test() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    link_chunk_collective_io_test()
  *
@@ -2629,48 +2325,48 @@ lower_dim_size_comp_test(void)
  *-------------------------------------------------------------------------
  */
 
-#define LINK_CHUNK_COLLECTIVE_IO_TEST_CHUNK_SIZE    16
+#define LINK_CHUNK_COLLECTIVE_IO_TEST_CHUNK_SIZE 16
 
 void
 link_chunk_collective_io_test(void)
 {
     /* const char *fcnName = "link_chunk_collective_io_test()"; */
     const char *filename;
-    hbool_t    mis_match = FALSE;
-    int           i;
-    int           mrc;
-    int        mpi_rank;
-    int        mpi_size;
-    MPI_Comm   mpi_comm = MPI_COMM_WORLD;
-    MPI_Info   mpi_info = MPI_INFO_NULL;
-    hsize_t    count[1] = {1};
-    hsize_t    stride[1] = {2 * LINK_CHUNK_COLLECTIVE_IO_TEST_CHUNK_SIZE};
-    hsize_t    block[1] = {LINK_CHUNK_COLLECTIVE_IO_TEST_CHUNK_SIZE};
-    hsize_t    start[1];
-    hsize_t    dims[1];
-    hsize_t    chunk_dims[1] = {LINK_CHUNK_COLLECTIVE_IO_TEST_CHUNK_SIZE};
-    herr_t     ret;            /* Generic return value */
-    hid_t      file_id;
-    hid_t      acc_tpl;
-    hid_t      dset_id;
-    hid_t      file_ds_sid;
-    hid_t      write_mem_ds_sid;
-    hid_t      read_mem_ds_sid;
-    hid_t      ds_dcpl_id;
-    hid_t      xfer_plist;
-    double     diff;
-    double     expected_value;
-    double     local_data_written[LINK_CHUNK_COLLECTIVE_IO_TEST_CHUNK_SIZE];
-    double     local_data_read[LINK_CHUNK_COLLECTIVE_IO_TEST_CHUNK_SIZE];
+    hbool_t     mis_match = FALSE;
+    int         i;
+    int         mrc;
+    int         mpi_rank;
+    int         mpi_size;
+    MPI_Comm    mpi_comm  = MPI_COMM_WORLD;
+    MPI_Info    mpi_info  = MPI_INFO_NULL;
+    hsize_t     count[1]  = {1};
+    hsize_t     stride[1] = {2 * LINK_CHUNK_COLLECTIVE_IO_TEST_CHUNK_SIZE};
+    hsize_t     block[1]  = {LINK_CHUNK_COLLECTIVE_IO_TEST_CHUNK_SIZE};
+    hsize_t     start[1];
+    hsize_t     dims[1];
+    hsize_t     chunk_dims[1] = {LINK_CHUNK_COLLECTIVE_IO_TEST_CHUNK_SIZE};
+    herr_t      ret; /* Generic return value */
+    hid_t       file_id;
+    hid_t       acc_tpl;
+    hid_t       dset_id;
+    hid_t       file_ds_sid;
+    hid_t       write_mem_ds_sid;
+    hid_t       read_mem_ds_sid;
+    hid_t       ds_dcpl_id;
+    hid_t       xfer_plist;
+    double      diff;
+    double      expected_value;
+    double      local_data_written[LINK_CHUNK_COLLECTIVE_IO_TEST_CHUNK_SIZE];
+    double      local_data_read[LINK_CHUNK_COLLECTIVE_IO_TEST_CHUNK_SIZE];
 
     MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
     MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
 
-    HDassert( mpi_size > 0 );
+    HDassert(mpi_size > 0);
 
     /* get the file name */
     filename = (const char *)GetTestParameters();
-    HDassert( filename != NULL );
+    HDassert(filename != NULL);
 
     /* setup file access template */
     acc_tpl = create_faccess_plist(mpi_comm, mpi_info, facc_type);
@@ -2691,16 +2387,13 @@ link_chunk_collective_io_test(void)
 
     /* setup mem and file dataspaces */
     write_mem_ds_sid = H5Screate_simple(1, chunk_dims, NULL);
-    VRFY((write_mem_ds_sid != 0),
-         "H5Screate_simple() write_mem_ds_sid succeeded");
+    VRFY((write_mem_ds_sid != 0), "H5Screate_simple() write_mem_ds_sid succeeded");
 
     read_mem_ds_sid = H5Screate_simple(1, chunk_dims, NULL);
-    VRFY((read_mem_ds_sid != 0),
-         "H5Screate_simple() read_mem_ds_sid succeeded");
+    VRFY((read_mem_ds_sid != 0), "H5Screate_simple() read_mem_ds_sid succeeded");
 
     file_ds_sid = H5Screate_simple(1, dims, NULL);
-    VRFY((file_ds_sid != 0),
-         "H5Screate_simple() file_ds_sid succeeded");
+    VRFY((file_ds_sid != 0), "H5Screate_simple() file_ds_sid succeeded");
 
     /* setup data set creation property list */
     ds_dcpl_id = H5Pcreate(H5P_DATASET_CREATE);
@@ -2713,9 +2406,8 @@ link_chunk_collective_io_test(void)
     VRFY((ret != FAIL), "H5Pset_chunk() small_ds_dcpl_id succeeded");
 
     /* create the data set */
-    dset_id = H5Dcreate2(file_id, "dataset", H5T_NATIVE_DOUBLE,
-                         file_ds_sid, H5P_DEFAULT,
-                         ds_dcpl_id, H5P_DEFAULT);
+    dset_id =
+        H5Dcreate2(file_id, "dataset", H5T_NATIVE_DOUBLE, file_ds_sid, H5P_DEFAULT, ds_dcpl_id, H5P_DEFAULT);
     VRFY((dset_id >= 0), "H5Dcreate2() dataset succeeded");
 
     /* close the dataset creation property list */
@@ -2723,23 +2415,17 @@ link_chunk_collective_io_test(void)
     VRFY((ret >= 0), "H5Pclose(ds_dcpl_id) succeeded");
 
     /* setup local data */
-    expected_value = (double)(LINK_CHUNK_COLLECTIVE_IO_TEST_CHUNK_SIZE) *
-                     (double)(mpi_rank);
-    for ( i = 0; i < LINK_CHUNK_COLLECTIVE_IO_TEST_CHUNK_SIZE; i++ ) {
+    expected_value = (double)(LINK_CHUNK_COLLECTIVE_IO_TEST_CHUNK_SIZE) * (double)(mpi_rank);
+    for (i = 0; i < LINK_CHUNK_COLLECTIVE_IO_TEST_CHUNK_SIZE; i++) {
 
         local_data_written[i] = expected_value;
-    local_data_read[i] = 0.0;
-    expected_value += 1.0;
+        local_data_read[i]    = 0.0;
+        expected_value += 1.0;
     }
 
     /* select the file and mem spaces */
     start[0] = (hsize_t)(mpi_rank * LINK_CHUNK_COLLECTIVE_IO_TEST_CHUNK_SIZE);
-    ret = H5Sselect_hyperslab(file_ds_sid,
-                              H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
+    ret      = H5Sselect_hyperslab(file_ds_sid, H5S_SELECT_SET, start, stride, count, block);
     VRFY((ret >= 0), "H5Sselect_hyperslab(file_ds_sid, set) suceeded");
 
     ret = H5Sselect_all(write_mem_ds_sid);
@@ -2755,26 +2441,16 @@ link_chunk_collective_io_test(void)
     VRFY((ret >= 0), "H5Pset_dxpl_mpio succeeded");
 
     /* write the data set */
-    ret = H5Dwrite(dset_id,
-                   H5T_NATIVE_DOUBLE,
-                   write_mem_ds_sid,
-                   file_ds_sid,
-                   xfer_plist,
-                   local_data_written);
+    ret = H5Dwrite(dset_id, H5T_NATIVE_DOUBLE, write_mem_ds_sid, file_ds_sid, xfer_plist, local_data_written);
 
     VRFY((ret >= 0), "H5Dwrite() dataset initial write succeeded");
 
     /* sync with the other processes before checking data */
     mrc = MPI_Barrier(MPI_COMM_WORLD);
-    VRFY((mrc==MPI_SUCCESS), "Sync after dataset write");
+    VRFY((mrc == MPI_SUCCESS), "Sync after dataset write");
 
     /* read this processes slice of the dataset back in */
-    ret = H5Dread(dset_id,
-                  H5T_NATIVE_DOUBLE,
-                  read_mem_ds_sid,
-                  file_ds_sid,
-                  xfer_plist,
-                  local_data_read);
+    ret = H5Dread(dset_id, H5T_NATIVE_DOUBLE, read_mem_ds_sid, file_ds_sid, xfer_plist, local_data_read);
     VRFY((ret >= 0), "H5Dread() dataset read succeeded");
 
     /* close the xfer property list */
@@ -2783,17 +2459,17 @@ link_chunk_collective_io_test(void)
 
     /* verify the data */
     mis_match = FALSE;
-    for ( i = 0; i < LINK_CHUNK_COLLECTIVE_IO_TEST_CHUNK_SIZE; i++ ) {
+    for (i = 0; i < LINK_CHUNK_COLLECTIVE_IO_TEST_CHUNK_SIZE; i++) {
 
         diff = local_data_written[i] - local_data_read[i];
         diff = fabs(diff);
 
-        if ( diff >= 0.001 ) {
+        if (diff >= 0.001) {
 
             mis_match = TRUE;
         }
     }
-    VRFY( (mis_match == FALSE), "dataset data good.");
+    VRFY((mis_match == FALSE), "dataset data good.");
 
     /* Close dataspaces */
     ret = H5Sclose(write_mem_ds_sid);
@@ -2816,4 +2492,3 @@ link_chunk_collective_io_test(void)
     return;
 
 } /* link_chunk_collective_io_test() */
-