Merge pull request #1814 in HDFFV/hdf5 from ~BYRN/hdf5_adb:hdf5_1_10 to hdf5_1_10

* commit '58d941293aa7ab7d5a824ea5951d7eff32bc1ac5':
  Mostly whitespace and consistent test format
  Cleanup when merging to other branches
  Correct syntax
  Minor code fixes
  Revert unintended whitespace
  Minor comment fix
  HDFFV-10845, 10529 and CMake changes from develop
  Merge from develop, mostly HDFFV-10845

8 files changed, 984 insertions, 1024 deletions

diff --git a/testpar/CMakeTests.cmake b/testpar/CMakeTests.cmake
index 0702d13..ad244b5 100644
--- a/testpar/CMakeTests.cmake
+++ b/testpar/CMakeTests.cmake
@@ -16,11 +16,10 @@
 ##############################################################################
 ##############################################################################
 # Remove any output file left over from previous test run
-add_test (NAME MPI_TEST-clear-testphdf5-objects
-    COMMAND    ${CMAKE_COMMAND}
-        -E remove ParaTest.h5
-    WORKING_DIRECTORY
-        ${HDF5_TEST_PAR_BINARY_DIR}
+add_test (
+    NAME MPI_TEST-clear-testphdf5-objects
+    COMMAND ${CMAKE_COMMAND} -E remove ParaTest.h5
+    WORKING_DIRECTORY ${HDF5_TEST_PAR_BINARY_DIR}
 )
 set_tests_properties (MPI_TEST-clear-testphdf5-objects PROPERTIES FIXTURES_SETUP par_clear_testphdf5)
 
@@ -93,12 +92,10 @@ set (test_par_CLEANFILES
 )
 
 # Remove any output file left over from previous test run
-add_test (NAME MPI_TEST-clear-objects
-    COMMAND    ${CMAKE_COMMAND}
-        -E remove
-        ${test_par_CLEANFILES}
-    WORKING_DIRECTORY
-        ${HDF5_TEST_PAR_BINARY_DIR}
+add_test (
+    NAME MPI_TEST-clear-objects
+    COMMAND ${CMAKE_COMMAND} -E remove ${test_par_CLEANFILES}
+    WORKING_DIRECTORY ${HDF5_TEST_PAR_BINARY_DIR}
 )
 set_tests_properties (MPI_TEST-clear-objects PROPERTIES FIXTURES_SETUP par_clear_objects)
 
diff --git a/testpar/CMakeVFDTests.cmake b/testpar/CMakeVFDTests.cmake
index 7333c6d..7db99de 100644
--- a/testpar/CMakeVFDTests.cmake
+++ b/testpar/CMakeVFDTests.cmake
@@ -41,15 +41,9 @@ endforeach ()
     if (NOT HDF5_ENABLE_USING_MEMCHECKER)
       foreach (h5_test ${H5P_VFD_TESTS})
         add_test (
-            NAME MPI_TEST_VFD-${vfdname}-${h5_test}-clear-objects
-            COMMAND    ${CMAKE_COMMAND}
-                -E remove
-                    ${vfdname}/${vfdname}-${h5_test}.out
-                    ${vfdname}/${vfdname}-${h5_test}.out.err
-        )
-        add_test (
           NAME MPI_TEST_VFD-${vfdname}-${h5_test}
           COMMAND "${CMAKE_COMMAND}"
+              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:${h5_test}>"
               -D "TEST_ARGS:STRING="
               -D "TEST_VFD:STRING=${vfdname}"
@@ -59,7 +53,6 @@ endforeach ()
               -P "${HDF_RESOURCES_DIR}/vfdTest.cmake"
         )
         set_tests_properties (MPI_TEST_VFD-${vfdname}-${h5_test} PROPERTIES
-            DEPENDS MPI_TEST_VFD-${vfdname}-${h5_test}-clear-objects
             ENVIRONMENT "srcdir=${HDF5_TEST_PAR_BINARY_DIR}/${vfdname}"
             WORKING_DIRECTORY ${HDF5_TEST_PAR_BINARY_DIR}/${vfdname}
         )
diff --git a/testpar/t_cache.c b/testpar/t_cache.c
index 29c6f4a..3004f9f 100644
--- a/testpar/t_cache.c
+++ b/testpar/t_cache.c
@@ -1228,7 +1228,7 @@ setup_derived_types(void)
         nerrors++;
         success = FALSE;
         if ( verbose ) {
-            HDfprintf(stdout, "%d:%s: MPI_Get_Address() call failed.\n",
+            HDfprintf(stdout, "%d:%s: MPI_Get_address() call failed.\n",
                       world_mpi_rank, FUNC);
         }
 
@@ -1250,7 +1250,7 @@ setup_derived_types(void)
             nerrors++;
             success = FALSE;
             if ( verbose ) {
-                HDfprintf(stdout, "%d:%s: MPI_Type_struct() call failed.\n",
+                HDfprintf(stdout, "%d:%s: MPI_Type_create_struct() call failed.\n",
                           world_mpi_rank, FUNC);
             }
         }
diff --git a/testpar/t_filters_parallel.c b/testpar/t_filters_parallel.c
index 1f26e0d..db5bd13 100644
--- a/testpar/t_filters_parallel.c
+++ b/testpar/t_filters_parallel.c
@@ -3683,6 +3683,8 @@ test_read_filtered_dataset_point_selection(void)
     if (read_buf) HDfree(read_buf);
     if (correct_buf) HDfree(correct_buf);
 
+    HDfree(coords);
+
     VRFY((H5Dclose(dset_id) >= 0), "Dataset close succeeded");
     VRFY((H5Sclose(filespace) >= 0), "File dataspace close succeeded");
     VRFY((H5Sclose(memspace) >= 0), "Memory dataspace close succeeded");
@@ -5791,6 +5793,9 @@ test_write_parallel_read_serial(void)
 
         VRFY((H5Dclose(dset_id) >= 0), "Dataset close succeeded");
         VRFY((H5Fclose(file_id) >= 0), "File close succeeded");
+
+        HDfree(correct_buf);
+        HDfree(read_buf);
     }
 
     return;
diff --git a/testpar/t_mpi.c b/testpar/t_mpi.c
index 3d501c9..94ecbfa 100644
--- a/testpar/t_mpi.c
+++ b/testpar/t_mpi.c
@@ -28,149 +28,143 @@
 #include "testpar.h"
 
 /* FILENAME and filenames must have the same number of names */
-const char *FILENAME[2]={
-	    "MPItest",
-	    NULL};
-char	filenames[2][200];
-int	nerrors = 0;
-hid_t	fapl;				/* file access property list */
+const char *FILENAME[2] = { "MPItest", NULL };
+char filenames[2][200];
+int nerrors = 0;
+hid_t fapl; /* file access property list */
 
 /* protocols */
 static int errors_sum(int nerrs);
 
 #define MPIO_TEST_WRITE_SIZE 1024*1024     /* 1 MB */
 
-static int
-test_mpio_overlap_writes(char *filename)
-{
+static int test_mpio_overlap_writes(char *filename) {
     int mpi_size, mpi_rank;
     MPI_Comm comm;
     MPI_Info info = MPI_INFO_NULL;
     int color, mrc;
-    MPI_File	fh;
+    MPI_File fh;
     int i;
     int vrfyerrs, nerrs;
-    unsigned char  buf[4093];		/* use some prime number for size */
+    unsigned char buf[4093]; /* use some prime number for size */
     int bufsize = sizeof(buf);
-    MPI_Offset  stride;
-    MPI_Offset  mpi_off;
-    MPI_Status  mpi_stat;
-
+    MPI_Offset stride;
+    MPI_Offset mpi_off;
+    MPI_Status mpi_stat;
 
     if (VERBOSE_MED)
-	printf("MPIO independent overlapping writes test on file %s\n",
-	    filename);
+        printf("MPIO independent overlapping writes test on file %s\n",
+                filename);
 
     nerrs = 0;
     /* set up MPI parameters */
-    MPI_Comm_size(MPI_COMM_WORLD,&mpi_size);
-    MPI_Comm_rank(MPI_COMM_WORLD,&mpi_rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
+    MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
 
     /* Need at least 2 processes */
     if (mpi_size < 2) {
-	if (MAINPROCESS)
-	    printf("Need at least 2 processes to run MPIO test.\n");
-	    printf(" -SKIP- \n");
-	return 0;
+        if (MAINPROCESS)
+            printf("Need at least 2 processes to run MPIO test.\n");
+        printf(" -SKIP- \n");
+        return 0;
     }
 
     /* splits processes 0 to n-2 into one comm. and the last one into another */
     color = ((mpi_rank < (mpi_size - 1)) ? 0 : 1);
-    mrc = MPI_Comm_split (MPI_COMM_WORLD, color, mpi_rank, &comm);
-    VRFY((mrc==MPI_SUCCESS), "Comm_split succeeded");
-
-    if (color==0){
-	/* First n-1 processes (color==0) open a file and write it */
-	mrc = MPI_File_open(comm, filename, MPI_MODE_CREATE|MPI_MODE_RDWR,
-		info, &fh);
-	VRFY((mrc==MPI_SUCCESS), "");
-
-	stride = 1;
-	mpi_off = mpi_rank*stride;
-	while (mpi_off < MPIO_TEST_WRITE_SIZE){
-	    /* make sure the write does not exceed the TEST_WRITE_SIZE */
-	    if (mpi_off+stride > MPIO_TEST_WRITE_SIZE)
-		stride = MPIO_TEST_WRITE_SIZE - mpi_off;
-
-	    /* set data to some trivial pattern for easy verification */
-	    for (i=0; i<stride; i++)
-		buf[i] = (unsigned char)(mpi_off+i);
-	    mrc = MPI_File_write_at(fh, mpi_off, buf, (int)stride, MPI_BYTE,
-		    &mpi_stat);
-	    VRFY((mrc==MPI_SUCCESS), "");
-
-	    /* move the offset pointer to last byte written by all processes */
-	    mpi_off += (mpi_size - 1 - mpi_rank) * stride;
-
-	    /* Increase chunk size without exceeding buffer size. */
-	    /* Then move the starting offset for next write. */
-	    stride *= 2;
-	    if (stride > bufsize)
-		stride = bufsize;
-	    mpi_off += mpi_rank*stride;
-	}
-
-	/* close file and free the communicator */
-	mrc = MPI_File_close(&fh);
-	VRFY((mrc==MPI_SUCCESS), "MPI_FILE_CLOSE");
-	mrc = MPI_Comm_free(&comm);
-	VRFY((mrc==MPI_SUCCESS), "MPI_Comm_free");
-
-	/* sync with the other waiting processes */
-	mrc = MPI_Barrier(MPI_COMM_WORLD);
-	VRFY((mrc==MPI_SUCCESS), "Sync after writes");
-    }else{
-	/* last process waits till writes are done,
-	 * then opens file to verify data.
-	 */
-	mrc = MPI_Barrier(MPI_COMM_WORLD);
-	VRFY((mrc==MPI_SUCCESS), "Sync after writes");
-
-	mrc = MPI_File_open(comm, filename, MPI_MODE_RDONLY,
-		info, &fh);
-	VRFY((mrc==MPI_SUCCESS), "");
-
-	stride = bufsize;
-	for (mpi_off=0; mpi_off < MPIO_TEST_WRITE_SIZE; mpi_off += bufsize){
-	    /* make sure it does not read beyond end of data */
-	    if (mpi_off+stride > MPIO_TEST_WRITE_SIZE)
-		stride = MPIO_TEST_WRITE_SIZE - mpi_off;
-	    mrc = MPI_File_read_at(fh, mpi_off, buf, (int)stride, MPI_BYTE,
-		    &mpi_stat);
-	    VRFY((mrc==MPI_SUCCESS), "");
-	    vrfyerrs=0;
-	    for (i=0; i<stride; i++){
-		unsigned char expected;
-		expected = (unsigned char)(mpi_off+i);
-		if ((expected != buf[i]) &&
-		    (vrfyerrs++ < MAX_ERR_REPORT || VERBOSE_MED)) {
-			printf("proc %d: found data error at [%ld], expect %u, got %u\n",
-			    mpi_rank, (long)(mpi_off+i), expected, buf[i]);
-		}
-	    }
-	    if (vrfyerrs > MAX_ERR_REPORT && !VERBOSE_MED)
-		printf("proc %d: [more errors ...]\n", mpi_rank);
-
-	    nerrs += vrfyerrs;
-	}
-
-	/* close file and free the communicator */
-	mrc = MPI_File_close(&fh);
-	VRFY((mrc==MPI_SUCCESS), "MPI_FILE_CLOSE");
-	mrc = MPI_Comm_free(&comm);
-	VRFY((mrc==MPI_SUCCESS), "MPI_Comm_free");
+    mrc = MPI_Comm_split(MPI_COMM_WORLD, color, mpi_rank, &comm);
+    VRFY((mrc == MPI_SUCCESS), "Comm_split succeeded");
+
+    if (color == 0) {
+        /* First n-1 processes (color==0) open a file and write it */
+        mrc = MPI_File_open(comm, filename, MPI_MODE_CREATE | MPI_MODE_RDWR,
+                info, &fh);
+        VRFY((mrc == MPI_SUCCESS), "");
+
+        stride = 1;
+        mpi_off = mpi_rank * stride;
+        while (mpi_off < MPIO_TEST_WRITE_SIZE) {
+            /* make sure the write does not exceed the TEST_WRITE_SIZE */
+            if (mpi_off + stride > MPIO_TEST_WRITE_SIZE)
+                stride = MPIO_TEST_WRITE_SIZE - mpi_off;
+
+            /* set data to some trivial pattern for easy verification */
+            for (i = 0; i < stride; i++)
+                buf[i] = (unsigned char) (mpi_off + i);
+            mrc = MPI_File_write_at(fh, mpi_off, buf, (int) stride, MPI_BYTE,
+                    &mpi_stat);
+            VRFY((mrc == MPI_SUCCESS), "");
+
+            /* move the offset pointer to last byte written by all processes */
+            mpi_off += (mpi_size - 1 - mpi_rank) * stride;
+
+            /* Increase chunk size without exceeding buffer size. */
+            /* Then move the starting offset for next write. */
+            stride *= 2;
+            if (stride > bufsize)
+                stride = bufsize;
+            mpi_off += mpi_rank * stride;
+        }
+
+        /* close file and free the communicator */
+        mrc = MPI_File_close(&fh);
+        VRFY((mrc == MPI_SUCCESS), "MPI_FILE_CLOSE");
+        mrc = MPI_Comm_free(&comm);
+        VRFY((mrc == MPI_SUCCESS), "MPI_Comm_free");
+
+        /* sync with the other waiting processes */
+        mrc = MPI_Barrier(MPI_COMM_WORLD);
+        VRFY((mrc == MPI_SUCCESS), "Sync after writes");
+    } else {
+        /* last process waits till writes are done,
+        * then opens file to verify data.
+        */
+        mrc = MPI_Barrier(MPI_COMM_WORLD);
+        VRFY((mrc == MPI_SUCCESS), "Sync after writes");
+
+        mrc = MPI_File_open(comm, filename, MPI_MODE_RDONLY, info, &fh);
+        VRFY((mrc == MPI_SUCCESS), "");
+
+        stride = bufsize;
+        for (mpi_off = 0; mpi_off < MPIO_TEST_WRITE_SIZE; mpi_off += bufsize) {
+            /* make sure it does not read beyond end of data */
+            if (mpi_off + stride > MPIO_TEST_WRITE_SIZE)
+                stride = MPIO_TEST_WRITE_SIZE - mpi_off;
+            mrc = MPI_File_read_at(fh, mpi_off, buf, (int) stride, MPI_BYTE,
+                    &mpi_stat);
+            VRFY((mrc == MPI_SUCCESS), "");
+            vrfyerrs = 0;
+            for (i = 0; i < stride; i++) {
+                unsigned char expected;
+                expected = (unsigned char) (mpi_off + i);
+                if ((expected != buf[i])
+                        && (vrfyerrs++ < MAX_ERR_REPORT || VERBOSE_MED)) {
+                    printf(
+                            "proc %d: found data error at [%ld], expect %u, got %u\n",
+                            mpi_rank, (long) (mpi_off + i), expected, buf[i]);
+                }
+            }
+            if (vrfyerrs > MAX_ERR_REPORT && !VERBOSE_MED)
+                printf("proc %d: [more errors ...]\n", mpi_rank);
+
+            nerrs += vrfyerrs;
+        }
+
+        /* close file and free the communicator */
+        mrc = MPI_File_close(&fh);
+        VRFY((mrc == MPI_SUCCESS), "MPI_FILE_CLOSE");
+        mrc = MPI_Comm_free(&comm);
+        VRFY((mrc == MPI_SUCCESS), "MPI_Comm_free");
     }
 
     /*
-     * one more sync to ensure all processes have done reading
-     * before ending this test.
-     */
+    * one more sync to ensure all processes have done reading
+    * before ending this test.
+    */
     mrc = MPI_Barrier(MPI_COMM_WORLD);
-    VRFY((mrc==MPI_SUCCESS), "Sync before leaving test");
+    VRFY((mrc == MPI_SUCCESS), "Sync before leaving test");
     return (nerrs);
 }
 
-
 #define MB      1048576        /* 1024*1024 == 2**20 */
 #define GB      1073741824     /* 1024**3 == 2**30 */
 #define TWO_GB_LESS1    2147483647     /* 2**31 - 1 */
@@ -186,30 +180,28 @@ test_mpio_overlap_writes(char *filename)
  * Then reads the file back in by reverse order, that is process 0
  * reads the data of process n-1 and vice versa.
  */
-static int
-test_mpio_gb_file(char *filename)
-{
+static int test_mpio_gb_file(char *filename) {
     int mpi_size, mpi_rank;
     MPI_Info info = MPI_INFO_NULL;
     int mrc;
-    MPI_File	fh;
+    MPI_File fh;
     int i, j, n;
     int vrfyerrs;
-    int writerrs;		/* write errors */
+    int writerrs; /* write errors */
     int nerrs;
-    int ntimes;			/* how many times */
-    char  *buf = NULL;
-    char  expected;
-    MPI_Offset  size;
-    MPI_Offset  mpi_off;
-    MPI_Offset  mpi_off_old;
-    MPI_Status  mpi_stat;
+    int ntimes; /* how many times */
+    char *buf = NULL;
+    char expected;
+    MPI_Offset size;
+    MPI_Offset mpi_off;
+    MPI_Offset mpi_off_old;
+    MPI_Status mpi_stat;
     int is_signed, sizeof_mpi_offset;
 
     nerrs = 0;
     /* set up MPI parameters */
-    MPI_Comm_size(MPI_COMM_WORLD,&mpi_size);
-    MPI_Comm_rank(MPI_COMM_WORLD,&mpi_rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
+    MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
 
     if (VERBOSE_MED)
         printf("MPI_Offset range test\n");
@@ -217,196 +209,207 @@ test_mpio_gb_file(char *filename)
     /* figure out the signness and sizeof MPI_Offset */
     mpi_off = 0;
     is_signed = ((MPI_Offset)(mpi_off - 1)) < 0;
-    sizeof_mpi_offset = (int)(sizeof(MPI_Offset));
+    sizeof_mpi_offset = (int) (sizeof(MPI_Offset));
 
     /*
-     * Verify the sizeof MPI_Offset and correctness of handling multiple GB
-     * sizes.
-     */
-    if (MAINPROCESS){			/* only process 0 needs to check it*/
-	printf("MPI_Offset is %s %d bytes integeral type\n",
-	    is_signed ? "signed" : "unsigned", (int)sizeof(MPI_Offset));
-	if (sizeof_mpi_offset <= 4 && is_signed){
-	    printf("Skipped 2GB range test "
-		    "because MPI_Offset cannot support it\n");
-	}else {
-	    /* verify correctness of assigning 2GB sizes */
-	    mpi_off = 2 * 1024 * (MPI_Offset)MB;
-	    INFO((mpi_off>0), "2GB OFFSET assignment no overflow");
-	    INFO((mpi_off-1)==TWO_GB_LESS1, "2GB OFFSET assignment succeed");
-
-	    /* verify correctness of increasing from below 2 GB to above 2GB */
-	    mpi_off = TWO_GB_LESS1;
-	    for (i=0; i < 3; i++){
-		mpi_off_old = mpi_off;
-		mpi_off = mpi_off + 1;
-		/* no overflow */
-		INFO((mpi_off>0), "2GB OFFSET increment no overflow");
-		/* correct inc. */
-		INFO((mpi_off-1)==mpi_off_old, "2GB OFFSET increment succeed");
-	    }
-	}
-
-	if (sizeof_mpi_offset <= 4){
-	    printf("Skipped 4GB range test "
-		    "because MPI_Offset cannot support it\n");
-	}else {
-	    /* verify correctness of assigning 4GB sizes */
-	    mpi_off = 4 * 1024 * (MPI_Offset)MB;
-	    INFO((mpi_off>0), "4GB OFFSET assignment no overflow");
-	    INFO((mpi_off-1)==FOUR_GB_LESS1, "4GB OFFSET assignment succeed");
-
-	    /* verify correctness of increasing from below 4 GB to above 4 GB */
-	    mpi_off = FOUR_GB_LESS1;
-	    for (i=0; i < 3; i++){
-		mpi_off_old = mpi_off;
-		mpi_off = mpi_off + 1;
-		/* no overflow */
-		INFO((mpi_off>0), "4GB OFFSET increment no overflow");
-		/* correct inc. */
-		INFO((mpi_off-1)==mpi_off_old, "4GB OFFSET increment succeed");
-	    }
-	}
+    * Verify the sizeof MPI_Offset and correctness of handling multiple GB
+    * sizes.
+    */
+    if (MAINPROCESS) { /* only process 0 needs to check it*/
+        printf("MPI_Offset is %s %d bytes integeral type\n",
+                is_signed ? "signed" : "unsigned", (int) sizeof(MPI_Offset));
+        if (sizeof_mpi_offset <= 4 && is_signed) {
+            printf("Skipped 2GB range test "
+                    "because MPI_Offset cannot support it\n");
+        } else {
+            /* verify correctness of assigning 2GB sizes */
+            mpi_off = 2 * 1024 * (MPI_Offset) MB;
+            INFO((mpi_off > 0), "2GB OFFSET assignment no overflow");
+            INFO((mpi_off-1)==TWO_GB_LESS1, "2GB OFFSET assignment succeed");
+
+            /* verify correctness of increasing from below 2 GB to above 2GB */
+            mpi_off = TWO_GB_LESS1;
+            for (i = 0; i < 3; i++) {
+                mpi_off_old = mpi_off;
+                mpi_off = mpi_off + 1;
+                /* no overflow */
+                INFO((mpi_off > 0), "2GB OFFSET increment no overflow");
+                /* correct inc. */
+                INFO((mpi_off - 1) == mpi_off_old,
+                        "2GB OFFSET increment succeed");
+            }
+        }
+
+        if (sizeof_mpi_offset <= 4) {
+            printf("Skipped 4GB range test "
+                    "because MPI_Offset cannot support it\n");
+        } else {
+            /* verify correctness of assigning 4GB sizes */
+            mpi_off = 4 * 1024 * (MPI_Offset) MB;
+            INFO((mpi_off > 0), "4GB OFFSET assignment no overflow");
+            INFO((mpi_off-1)==FOUR_GB_LESS1, "4GB OFFSET assignment succeed");
+
+            /* verify correctness of increasing from below 4 GB to above 4 GB */
+            mpi_off = FOUR_GB_LESS1;
+            for (i = 0; i < 3; i++) {
+                mpi_off_old = mpi_off;
+                mpi_off = mpi_off + 1;
+                /* no overflow */
+                INFO((mpi_off > 0), "4GB OFFSET increment no overflow");
+                /* correct inc. */
+                INFO((mpi_off - 1) == mpi_off_old,
+                        "4GB OFFSET increment succeed");
+            }
+        }
     }
 
     /*
-     * Verify if we can write to a file of multiple GB sizes.
-     */
+    * Verify if we can write to a file of multiple GB sizes.
+    */
     if (VERBOSE_MED)
-	printf("MPIO GB file test %s\n", filename);
-
-    if (sizeof_mpi_offset <= 4){
-	printf("Skipped GB file range test "
-		"because MPI_Offset cannot support it\n");
-    }else{
-	buf = (char *)HDmalloc(MB);
-	VRFY((buf!=NULL), "malloc succeed");
-
-	/* open a new file. Remove it first in case it exists. */
-	/* Must delete because MPI_File_open does not have a Truncate mode. */
-	/* Don't care if it has error. */
-	MPI_File_delete(filename, MPI_INFO_NULL);
-	MPI_Barrier(MPI_COMM_WORLD);	/* prevent racing condition */
-
-	mrc = MPI_File_open(MPI_COMM_WORLD, filename, MPI_MODE_CREATE|MPI_MODE_RDWR,
-		    info, &fh);
-	VRFY((mrc==MPI_SUCCESS), "MPI_FILE_OPEN");
-
-	printf("MPIO GB file write test %s\n", filename);
-
-	/* instead of writing every bytes of the file, we will just write
-	 * some data around the 2 and 4 GB boundaries.  That should cover
-	 * potential integer overflow and filesystem size limits.
-	 */
-	writerrs = 0;
-	for (n=2; n <= 4; n+=2){
-	    ntimes = GB/MB*n/mpi_size + 1;
-	    for (i=ntimes-2; i <= ntimes; i++){
-		mpi_off = (i*mpi_size + mpi_rank)*(MPI_Offset)MB;
-		if (VERBOSE_MED)
-		    HDfprintf(stdout,"proc %d: write to mpi_off=%016llx, %lld\n",
-			mpi_rank, mpi_off, mpi_off);
-		/* set data to some trivial pattern for easy verification */
-		for (j=0; j<MB; j++)
-		    *(buf+j) = i*mpi_size + mpi_rank;
-		if (VERBOSE_MED)
-		    HDfprintf(stdout,"proc %d: writing %d bytes at offset %lld\n",
-			mpi_rank, MB, mpi_off);
-		mrc = MPI_File_write_at(fh, mpi_off, buf, MB, MPI_BYTE, &mpi_stat);
-		INFO((mrc==MPI_SUCCESS), "GB size file write");
-		if (mrc!=MPI_SUCCESS)
-		    writerrs++;
-	    }
-	}
-
-	/* close file and free the communicator */
-	mrc = MPI_File_close(&fh);
-	VRFY((mrc==MPI_SUCCESS), "MPI_FILE_CLOSE");
-
-	mrc = MPI_Barrier(MPI_COMM_WORLD);
-	VRFY((mrc==MPI_SUCCESS), "Sync after writes");
-
-	/*
-	 * Verify if we can read the multiple GB file just created.
-	 */
-	/* open it again to verify the data written */
-	/* but only if there was no write errors */
-	printf("MPIO GB file read test %s\n", filename);
-	if (errors_sum(writerrs)>0){
-	    printf("proc %d: Skip read test due to previous write errors\n",
-		mpi_rank);
-	    goto finish;
-	}
-	mrc = MPI_File_open(MPI_COMM_WORLD, filename, MPI_MODE_RDONLY, info, &fh);
-	VRFY((mrc==MPI_SUCCESS), "");
-
-	/* Only read back parts of the file that have been written. */
-	for (n=2; n <= 4; n+=2){
-	    ntimes = GB/MB*n/mpi_size + 1;
-	    for (i=ntimes-2; i <= ntimes; i++){
-		mpi_off = (i*mpi_size + (mpi_size - mpi_rank - 1))*(MPI_Offset)MB;
-		if (VERBOSE_MED)
-		    HDfprintf(stdout,"proc %d: read from mpi_off=%016llx, %lld\n",
-			mpi_rank, mpi_off, mpi_off);
-		mrc = MPI_File_read_at(fh, mpi_off, buf, MB, MPI_BYTE, &mpi_stat);
-		INFO((mrc==MPI_SUCCESS), "GB size file read");
-		expected = i*mpi_size + (mpi_size - mpi_rank - 1);
-		vrfyerrs=0;
-		for (j=0; j<MB; j++){
-		    if ((*(buf+j) != expected) &&
-			(vrfyerrs++ < MAX_ERR_REPORT || VERBOSE_MED)){
-			    printf("proc %d: found data error at [%ld+%d], expect %d, got %d\n",
-				mpi_rank, (long)mpi_off, j, expected, *(buf+j));
-		    }
-		}
-		if (vrfyerrs > MAX_ERR_REPORT && !VERBOSE_MED)
-		    printf("proc %d: [more errors ...]\n", mpi_rank);
-
-		nerrs += vrfyerrs;
-	    }
-	}
-
-	/* close file and free the communicator */
-	mrc = MPI_File_close(&fh);
-	VRFY((mrc==MPI_SUCCESS), "MPI_FILE_CLOSE");
-
-	/*
-	 * one more sync to ensure all processes have done reading
-	 * before ending this test.
-	 */
-	mrc = MPI_Barrier(MPI_COMM_WORLD);
-	VRFY((mrc==MPI_SUCCESS), "Sync before leaving test");
+        printf("MPIO GB file test %s\n", filename);
+
+    if (sizeof_mpi_offset <= 4) {
+        printf("Skipped GB file range test "
+                "because MPI_Offset cannot support it\n");
+    } else {
+        buf = (char *) HDmalloc(MB);
+        VRFY((buf != NULL), "malloc succeed");
+
+        /* open a new file. Remove it first in case it exists. */
+        /* Must delete because MPI_File_open does not have a Truncate mode. */
+        /* Don't care if it has error. */
+        MPI_File_delete(filename, MPI_INFO_NULL);
+        MPI_Barrier(MPI_COMM_WORLD); /* prevent racing condition */
+
+        mrc = MPI_File_open(MPI_COMM_WORLD, filename,
+                MPI_MODE_CREATE | MPI_MODE_RDWR, info, &fh);
+        VRFY((mrc == MPI_SUCCESS), "MPI_FILE_OPEN");
+
+        printf("MPIO GB file write test %s\n", filename);
+
+        /* instead of writing every bytes of the file, we will just write
+        * some data around the 2 and 4 GB boundaries.  That should cover
+        * potential integer overflow and filesystem size limits.
+        */
+        writerrs = 0;
+        for (n = 2; n <= 4; n += 2) {
+            ntimes = GB / MB * n / mpi_size + 1;
+            for (i = ntimes - 2; i <= ntimes; i++) {
+                mpi_off = (i * mpi_size + mpi_rank) * (MPI_Offset) MB;
+                if (VERBOSE_MED)
+                    HDfprintf(stdout,
+                            "proc %d: write to mpi_off=%016llx, %lld\n",
+                            mpi_rank, mpi_off, mpi_off);
+                /* set data to some trivial pattern for easy verification */
+                for (j = 0; j < MB; j++)
+                    *(buf + j) = i * mpi_size + mpi_rank;
+                if (VERBOSE_MED)
+                    HDfprintf(stdout,
+                            "proc %d: writing %d bytes at offset %lld\n",
+                            mpi_rank, MB, mpi_off);
+                mrc = MPI_File_write_at(fh, mpi_off, buf, MB, MPI_BYTE,
+                        &mpi_stat);
+                INFO((mrc == MPI_SUCCESS), "GB size file write");
+                if (mrc != MPI_SUCCESS)
+                    writerrs++;
+            }
+        }
+
+        /* close file and free the communicator */
+        mrc = MPI_File_close(&fh);
+        VRFY((mrc == MPI_SUCCESS), "MPI_FILE_CLOSE");
+
+        mrc = MPI_Barrier(MPI_COMM_WORLD);
+        VRFY((mrc == MPI_SUCCESS), "Sync after writes");
+
+        /*
+        * Verify if we can read the multiple GB file just created.
+        */
+        /* open it again to verify the data written */
+        /* but only if there was no write errors */
+        printf("MPIO GB file read test %s\n", filename);
+        if (errors_sum(writerrs) > 0) {
+            printf("proc %d: Skip read test due to previous write errors\n",
+                    mpi_rank);
+            goto finish;
+        }
+        mrc = MPI_File_open(MPI_COMM_WORLD, filename, MPI_MODE_RDONLY, info,
+                &fh);
+        VRFY((mrc == MPI_SUCCESS), "");
+
+        /* Only read back parts of the file that have been written. */
+        for (n = 2; n <= 4; n += 2) {
+            ntimes = GB / MB * n / mpi_size + 1;
+            for (i = ntimes - 2; i <= ntimes; i++) {
+                mpi_off = (i * mpi_size + (mpi_size - mpi_rank - 1))
+                        * (MPI_Offset) MB;
+                if (VERBOSE_MED)
+                    HDfprintf(stdout,
+                            "proc %d: read from mpi_off=%016llx, %lld\n",
+                            mpi_rank, mpi_off, mpi_off);
+                mrc = MPI_File_read_at(fh, mpi_off, buf, MB, MPI_BYTE,
+                        &mpi_stat);
+                INFO((mrc == MPI_SUCCESS), "GB size file read");
+                expected = i * mpi_size + (mpi_size - mpi_rank - 1);
+                vrfyerrs = 0;
+                for (j = 0; j < MB; j++) {
+                    if ((*(buf + j) != expected)
+                            && (vrfyerrs++ < MAX_ERR_REPORT || VERBOSE_MED)) {
+                        printf(
+                                "proc %d: found data error at [%ld+%d], expect %d, got %d\n",
+                                mpi_rank, (long) mpi_off, j, expected,
+                                *(buf + j));
+                    }
+                }
+                if (vrfyerrs > MAX_ERR_REPORT && !VERBOSE_MED)
+                    printf("proc %d: [more errors ...]\n", mpi_rank);
+
+                nerrs += vrfyerrs;
+            }
+        }
+
+        /* close file and free the communicator */
+        mrc = MPI_File_close(&fh);
+        VRFY((mrc == MPI_SUCCESS), "MPI_FILE_CLOSE");
+
+        /*
+        * one more sync to ensure all processes have done reading
+        * before ending this test.
+        */
+        mrc = MPI_Barrier(MPI_COMM_WORLD);
+        VRFY((mrc == MPI_SUCCESS), "Sync before leaving test");
 
         printf("Test if MPI_File_get_size works correctly with %s\n", filename);
 
-	mrc = MPI_File_open(MPI_COMM_WORLD, filename, MPI_MODE_RDONLY, info, &fh);
-        VRFY((mrc==MPI_SUCCESS), "");
+        mrc = MPI_File_open(MPI_COMM_WORLD, filename, MPI_MODE_RDONLY, info,
+                &fh);
+        VRFY((mrc == MPI_SUCCESS), "");
 
-        if (MAINPROCESS){			/* only process 0 needs to check it*/
+        if (MAINPROCESS) { /* only process 0 needs to check it*/
             mrc = MPI_File_get_size(fh, &size);
-	    VRFY((mrc==MPI_SUCCESS), "");
-            VRFY((size == mpi_off+MB), "MPI_File_get_size doesn't return correct file size.");
+            VRFY((mrc == MPI_SUCCESS), "");
+            VRFY((size == mpi_off+MB),
+                    "MPI_File_get_size doesn't return correct file size.");
         }
 
-	/* close file and free the communicator */
-	mrc = MPI_File_close(&fh);
-	VRFY((mrc==MPI_SUCCESS), "MPI_FILE_CLOSE");
+        /* close file and free the communicator */
+        mrc = MPI_File_close(&fh);
+        VRFY((mrc == MPI_SUCCESS), "MPI_FILE_CLOSE");
 
-	/*
-	 * one more sync to ensure all processes have done reading
-	 * before ending this test.
-	 */
-	mrc = MPI_Barrier(MPI_COMM_WORLD);
-	VRFY((mrc==MPI_SUCCESS), "Sync before leaving test");
+        /*
+        * one more sync to ensure all processes have done reading
+        * before ending this test.
+        */
+        mrc = MPI_Barrier(MPI_COMM_WORLD);
+        VRFY((mrc == MPI_SUCCESS), "Sync before leaving test");
     }
 
-finish:
-    if (buf)
-	HDfree(buf);
+    finish: if (buf)
+        HDfree(buf);
     return (nerrs);
 }
 
-
 /*
  * MPI-IO Test: One writes, Many reads.
  * Verify if only one process writes some data and then all other
@@ -424,191 +427,190 @@ finish:
  * Each process writes something, then reads all data back.
  */
 
-#define DIMSIZE	32		/* Dimension size. */
+#define DIMSIZE    32        /* Dimension size. */
 #define PRINTID printf("Proc %d: ", mpi_rank)
 #define USENONE 0
-#define USEATOM 1		/* request atomic I/O */
-#define USEFSYNC 2		/* request file_sync */
-
+#define USEATOM 1        /* request atomic I/O */
+#define USEFSYNC 2        /* request file_sync */
 
-static int
-test_mpio_1wMr(char *filename, int special_request)
-{
+static int test_mpio_1wMr(char *filename, int special_request) {
     char hostname[128];
-    int  mpi_size, mpi_rank;
+    int mpi_size, mpi_rank;
     MPI_File fh;
     char mpi_err_str[MPI_MAX_ERROR_STRING];
-    int  mpi_err_strlen;
-    int  mpi_err;
+    int mpi_err_strlen;
+    int mpi_err;
     unsigned char writedata[DIMSIZE], readdata[DIMSIZE];
     unsigned char expect_val;
-    int  i, irank;
-    int  nerrs = 0;		/* number of errors */
-    int  atomicity;
-    MPI_Offset  mpi_off;
-    MPI_Status  mpi_stat;
+    int i, irank;
+    int nerrs = 0; /* number of errors */
+    int atomicity;
+    MPI_Offset mpi_off;
+    MPI_Status mpi_stat;
 
     MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
     MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
 
-    if (MAINPROCESS && VERBOSE_MED){
+    if (MAINPROCESS && VERBOSE_MED) {
         printf("Testing one process writes, all processes read.\n");
-	printf("Using %d processes accessing file %s\n", mpi_size, filename);
+        printf("Using %d processes accessing file %s\n", mpi_size, filename);
         printf("    (Filename can be specified via program argument)\n");
     }
 
     /* show the hostname so that we can tell where the processes are running */
-    if (VERBOSE_DEF){
-	if (gethostname(hostname, 128) < 0){
-	    PRINTID;
-	    printf("gethostname failed\n");
-	    return 1;
-	}
-	PRINTID;
-	printf("hostname=%s\n", hostname);
+    if (VERBOSE_DEF) {
+#ifdef H5_HAVE_GETHOSTNAME
+        if(HDgethostname(hostname, sizeof(hostname)) < 0) {
+            printf("gethostname failed\n");
+            hostname[0] = '\0';
+        }
+#else
+        printf("gethostname unavailable\n");
+        hostname[0] = '\0';
+#endif
+        PRINTID;
+        printf("hostname=%s\n", hostname);
     }
 
     /* Delete any old file in order to start anew. */
     /* Must delete because MPI_File_open does not have a Truncate mode. */
     /* Don't care if it has error. */
     MPI_File_delete(filename, MPI_INFO_NULL);
-    MPI_Barrier(MPI_COMM_WORLD);	/* prevent racing condition */
+    MPI_Barrier(MPI_COMM_WORLD); /* prevent racing condition */
 
     if ((mpi_err = MPI_File_open(MPI_COMM_WORLD, filename,
-	    MPI_MODE_RDWR | MPI_MODE_CREATE ,
-	    MPI_INFO_NULL, &fh))
-	    != MPI_SUCCESS){
-	MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
-	PRINTID;
-	printf("MPI_File_open failed (%s)\n", mpi_err_str);
-	return 1;
+            MPI_MODE_RDWR | MPI_MODE_CREATE, MPI_INFO_NULL, &fh))
+            != MPI_SUCCESS) {
+        MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
+        PRINTID;
+        printf("MPI_File_open failed (%s)\n", mpi_err_str);
+        return 1;
     }
 
-if (special_request & USEATOM){
-    /* ==================================================
-     * Set atomcity to true (1).  A POSIX compliant filesystem
-     * should not need this.
-     * ==================================================*/
-    if ((mpi_err = MPI_File_get_atomicity(fh, &atomicity)) != MPI_SUCCESS){
-	MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
-	PRINTID;
-	printf("MPI_File_get_atomicity failed (%s)\n", mpi_err_str);
-    }
-    if (VERBOSE_HI)
-	printf("Initial atomicity = %d\n", atomicity);
-    if ((mpi_err = MPI_File_set_atomicity(fh, 1)) != MPI_SUCCESS){
-	MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
-	PRINTID;
-	printf("MPI_File_set_atomicity failed (%s)\n", mpi_err_str);
-    }
-    if ((mpi_err = MPI_File_get_atomicity(fh, &atomicity)) != MPI_SUCCESS){
-	MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
-	PRINTID;
-	printf("MPI_File_get_atomicity failed (%s)\n", mpi_err_str);
+    if (special_request & USEATOM) {
+        /* ==================================================
+        * Set atomcity to true (1).  A POSIX compliant filesystem
+        * should not need this.
+        * ==================================================*/
+        if ((mpi_err = MPI_File_get_atomicity(fh, &atomicity)) != MPI_SUCCESS) {
+            MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
+            PRINTID;
+            printf("MPI_File_get_atomicity failed (%s)\n", mpi_err_str);
+        }
+        if (VERBOSE_HI)
+            printf("Initial atomicity = %d\n", atomicity);
+        if ((mpi_err = MPI_File_set_atomicity(fh, 1)) != MPI_SUCCESS) {
+            MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
+            PRINTID;
+            printf("MPI_File_set_atomicity failed (%s)\n", mpi_err_str);
+        }
+        if ((mpi_err = MPI_File_get_atomicity(fh, &atomicity)) != MPI_SUCCESS) {
+            MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
+            PRINTID;
+            printf("MPI_File_get_atomicity failed (%s)\n", mpi_err_str);
+        }
+        if (VERBOSE_HI)
+            printf("After set_atomicity atomicity = %d\n", atomicity);
     }
-    if (VERBOSE_HI)
-	printf("After set_atomicity atomicity = %d\n", atomicity);
-}
 
     /* This barrier is not necessary but do it anyway. */
     MPI_Barrier(MPI_COMM_WORLD);
-    if (VERBOSE_HI){
-	PRINTID;
-	printf("between MPI_Barrier and MPI_File_write_at\n");
+    if (VERBOSE_HI) {
+        PRINTID;
+        printf("between MPI_Barrier and MPI_File_write_at\n");
     }
 
     /* ==================================================
-     * Each process calculates what to write but
-     * only process irank(0) writes.
-     * ==================================================*/
-    irank=0;
-    for (i=0; i < DIMSIZE; i++)
-	writedata[i] = irank*DIMSIZE + i;
-    mpi_off = irank*DIMSIZE;
+    * Each process calculates what to write but
+    * only process irank(0) writes.
+    * ==================================================*/
+    irank = 0;
+    for (i = 0; i < DIMSIZE; i++)
+        writedata[i] = irank * DIMSIZE + i;
+    mpi_off = irank * DIMSIZE;
 
     /* Only one process writes */
-    if (mpi_rank==irank){
-	if (VERBOSE_HI){
-	    PRINTID; printf("wrote %d bytes at %ld\n", DIMSIZE, (long)mpi_off);
-	}
-	if ((mpi_err = MPI_File_write_at(fh, mpi_off, writedata, DIMSIZE,
-			MPI_BYTE, &mpi_stat))
-		!= MPI_SUCCESS){
-	    MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
-	    PRINTID;
-	    printf("MPI_File_write_at offset(%ld), bytes (%d), failed (%s)\n",
-		    (long) mpi_off, DIMSIZE, mpi_err_str);
-	    return 1;
-	};
+    if (mpi_rank == irank) {
+        if (VERBOSE_HI) {
+            PRINTID;
+            printf("wrote %d bytes at %ld\n", DIMSIZE, (long) mpi_off);
+        }
+        if ((mpi_err = MPI_File_write_at(fh, mpi_off, writedata, DIMSIZE,
+                MPI_BYTE, &mpi_stat)) != MPI_SUCCESS) {
+            MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
+            PRINTID;
+            printf("MPI_File_write_at offset(%ld), bytes (%d), failed (%s)\n",
+                    (long) mpi_off, DIMSIZE, mpi_err_str);
+            return 1;
+        };
     };
 
     /* Bcast the return code and */
     /* make sure all writing are done before reading. */
     MPI_Bcast(&mpi_err, 1, MPI_INT, irank, MPI_COMM_WORLD);
-    if (VERBOSE_HI){
-	PRINTID;
-	printf("MPI_Bcast: mpi_err = %d\n", mpi_err);
+    if (VERBOSE_HI) {
+        PRINTID;
+        printf("MPI_Bcast: mpi_err = %d\n", mpi_err);
     }
 
-if (special_request & USEFSYNC){
-    /* ==================================================
-     * Do a file sync.  A POSIX compliant filesystem
-     * should not need this.
-     * ==================================================*/
-    if (VERBOSE_HI)
-	printf("Apply MPI_File_sync\n");
-    /* call file_sync to force the write out */
-    if ((mpi_err = MPI_File_sync(fh)) != MPI_SUCCESS){
-	MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
-	PRINTID;
-	printf("MPI_File_sync failed (%s)\n", mpi_err_str);
-    }
-    MPI_Barrier(MPI_COMM_WORLD);
-    /* call file_sync to force the write out */
-    if ((mpi_err = MPI_File_sync(fh)) != MPI_SUCCESS){
-	MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
-	PRINTID;
-	printf("MPI_File_sync failed (%s)\n", mpi_err_str);
+    if (special_request & USEFSYNC) {
+        /* ==================================================
+        * Do a file sync.  A POSIX compliant filesystem
+        * should not need this.
+        * ==================================================*/
+        if (VERBOSE_HI)
+            printf("Apply MPI_File_sync\n");
+        /* call file_sync to force the write out */
+        if ((mpi_err = MPI_File_sync(fh)) != MPI_SUCCESS) {
+            MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
+            PRINTID;
+            printf("MPI_File_sync failed (%s)\n", mpi_err_str);
+        }
+        MPI_Barrier(MPI_COMM_WORLD);
+        /* call file_sync to force the write out */
+        if ((mpi_err = MPI_File_sync(fh)) != MPI_SUCCESS) {
+            MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
+            PRINTID;
+            printf("MPI_File_sync failed (%s)\n", mpi_err_str);
+        }
     }
-}
 
     /* This barrier is not necessary because the Bcase or File_sync above */
     /* should take care of it.  Do it anyway. */
     MPI_Barrier(MPI_COMM_WORLD);
-    if (VERBOSE_HI){
-	PRINTID;
-	printf("after MPI_Barrier\n");
+    if (VERBOSE_HI) {
+        PRINTID;
+        printf("after MPI_Barrier\n");
     }
 
     /* ==================================================
-     * Each process reads what process 0 wrote and verify.
-     * ==================================================*/
-    irank=0;
-    mpi_off = irank*DIMSIZE;
+    * Each process reads what process 0 wrote and verify.
+    * ==================================================*/
+    irank = 0;
+    mpi_off = irank * DIMSIZE;
     if ((mpi_err = MPI_File_read_at(fh, mpi_off, readdata, DIMSIZE, MPI_BYTE,
-	    &mpi_stat))
-	    != MPI_SUCCESS){
-	MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
-	PRINTID;
-	printf("MPI_File_read_at offset(%ld), bytes (%d), failed (%s)\n",
-		(long) mpi_off, DIMSIZE, mpi_err_str);
-	return 1;
+            &mpi_stat)) != MPI_SUCCESS) {
+        MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
+        PRINTID;
+        printf("MPI_File_read_at offset(%ld), bytes (%d), failed (%s)\n",
+                (long) mpi_off, DIMSIZE, mpi_err_str);
+        return 1;
     };
-    for (i=0; i < DIMSIZE; i++){
-	expect_val = irank*DIMSIZE + i;
-	if (readdata[i] != expect_val){
-	    PRINTID;
-	    printf("read data[%d:%d] got %02x, expect %02x\n", irank, i,
-		    readdata[i], expect_val);
-	    nerrs++;
-	}
+    for (i = 0; i < DIMSIZE; i++) {
+        expect_val = irank * DIMSIZE + i;
+        if (readdata[i] != expect_val) {
+            PRINTID;
+            printf("read data[%d:%d] got %02x, expect %02x\n", irank, i,
+                    readdata[i], expect_val);
+            nerrs++;
+        }
     }
 
     MPI_File_close(&fh);
 
-    if (VERBOSE_HI){
-	PRINTID;
-	printf("%d data errors detected\n", nerrs);
+    if (VERBOSE_HI) {
+        PRINTID;
+        printf("%d data errors detected\n", nerrs);
     }
 
     mpi_err = MPI_Barrier(MPI_COMM_WORLD);
@@ -617,272 +619,268 @@ if (special_request & USEFSYNC){
 
 /*
 
-Function: test_mpio_derived_dtype
-
-Test Whether the Displacement of MPI derived datatype
-(+ File_set_view + MPI_write)works or not on this MPI-IO package
-and this platform.
-
-1. Details for the test:
-1) Create two derived datatypes with MPI_Type_create_hindexed:
-        datatype1:
-	count = 1, blocklens = 1, offsets = 0,
-	base type = MPI_BYTE(essentially a char)
-        datatype2:
-	count = 1, blocklens = 1, offsets = 1(byte),
-	base type = MPI_BYTE
-
-2) Using these two derived datatypes,
-   Build another derived datatype with MPI_Type_create_struct:
-        advtype: derived from datatype1 and datatype2
-        advtype:
-	count = 2, blocklens[0] = 1, blocklens[1]=1,
-	offsets[0] = 0, offsets[1] = 1(byte),
-        bas_type[0]=datatype1,
-        bas_type[1] = datatype2;
-
-3) Setting MPI file view with advtype
-4) Writing 2 bytes 1 to 2 using MPI_File_write to a file
-5) File content:
-Suppose the fill value of the file is 0(most machines indeed do so)
-and Fill value is embraced with "() in the following output:
-Expected output should be:
-1,0,2
-
-
-
-However, at some platforms, for example, IBM AIX(at March 23rd, 2005):
-the following values were obtained:
-1,2,0
-
-The problem is that the displacement of the second derived datatype(datatype2) which formed the final derived datatype(advtype)
+ Function: test_mpio_derived_dtype
+
+ Test Whether the Displacement of MPI derived datatype
+ (+ File_set_view + MPI_write)works or not on this MPI-IO package
+ and this platform.
+
+ 1. Details for the test:
+ 1) Create two derived datatypes with MPI_Type_create_hindexed:
+ datatype1:
+ count = 1, blocklens = 1, offsets = 0,
+ base type = MPI_BYTE(essentially a char)
+ datatype2:
+ count = 1, blocklens = 1, offsets = 1(byte),
+ base type = MPI_BYTE
+
+ 2) Using these two derived datatypes,
+ Build another derived datatype with MPI_Type_create_struct:
+ advtype: derived from datatype1 and datatype2
+ advtype:
+ count = 2, blocklens[0] = 1, blocklens[1]=1,
+ offsets[0] = 0, offsets[1] = 1(byte),
+ bas_type[0]=datatype1,
+ bas_type[1] = datatype2;
+
+ 3) Setting MPI file view with advtype
+ 4) Writing 2 bytes 1 to 2 using MPI_File_write to a file
+ 5) File content:
+ Suppose the fill value of the file is 0(most machines indeed do so)
+ and Fill value is embraced with "() in the following output:
+ Expected output should be:
+ 1,0,2
+
+
+
+ However, at some platforms, for example, IBM AIX(at March 23rd, 2005):
+ the following values were obtained:
+ 1,2,0
+
+ The problem is that the displacement of the second derived datatype(datatype2) which formed the final derived datatype(advtype)
  has been put after the basic datatype(MPI_BYTE) of datatype2. This is a bug.
 
 
-2. This test will verify whether the complicated derived datatype is working on
-the current platform.
+ 2. This test will verify whether the complicated derived datatype is working on
+ the current platform.
 
-If this bug has been fixed in the previous not-working package, this test will issue a printf message to tell the developer to change
-the configuration specific file of HDF5 so that we can change our configurationsetting to support collective IO for irregular selections.
+ If this bug has been fixed in the previous not-working package, this test will issue a printf message to tell the developer to change
+ the configuration specific file of HDF5 so that we can change our configurationsetting to support collective IO for irregular selections.
 
-If it turns out that the previous working MPI-IO package no longer works, this test will also issue a message to inform the corresponding failure so that
-we can turn off collective IO support for irregular selections.
-*/
+ If it turns out that the previous working MPI-IO package no longer works, this test will also issue a message to inform the corresponding failure so that
+ we can turn off collective IO support for irregular selections.
+ */
 
 static int test_mpio_derived_dtype(char *filename) {
 
     MPI_File fh;
     char mpi_err_str[MPI_MAX_ERROR_STRING];
-    int  mpi_err_strlen;
-    int  mpi_err;
-    int  i;
-    MPI_Datatype  etype,filetype;
-    MPI_Datatype  adv_filetype,bas_filetype[2];
-    MPI_Datatype  filetypenew;
-    MPI_Offset    disp;
-    MPI_Status    Status;
-    MPI_Aint      adv_disp[2];
-    MPI_Aint      offsets[1];
-    int           blocklens[1],adv_blocklens[2];
-    int           count,outcount;
-    int           retcode;
-
-    int mpi_rank,mpi_size;
-
-    char          buf[3],outbuf[3] = {0};
+    int mpi_err_strlen;
+    int mpi_err;
+    int i;
+    MPI_Datatype etype, filetype;
+    MPI_Datatype adv_filetype, bas_filetype[2];
+    MPI_Datatype filetypenew;
+    MPI_Offset disp;
+    MPI_Status Status;
+    MPI_Aint adv_disp[2];
+    MPI_Aint offsets[1];
+    int blocklens[1], adv_blocklens[2];
+    int count, outcount;
+    int retcode;
+
+    int mpi_rank, mpi_size;
+
+    char buf[3], outbuf[3] = { 0 };
 
     MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
     MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
     retcode = 0;
-    for(i=0;i<3;i++)
-      buf[i] = i+1;
-
+    for (i = 0; i < 3; i++)
+        buf[i] = i + 1;
 
     if ((mpi_err = MPI_File_open(MPI_COMM_WORLD, filename,
-				 MPI_MODE_RDWR | MPI_MODE_CREATE,
-				 MPI_INFO_NULL, &fh))
-	    != MPI_SUCCESS){
-	MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
-	printf("MPI_File_open failed (%s)\n", mpi_err_str);
-	return 1;
+            MPI_MODE_RDWR | MPI_MODE_CREATE, MPI_INFO_NULL, &fh))
+            != MPI_SUCCESS) {
+        MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
+        printf("MPI_File_open failed (%s)\n", mpi_err_str);
+        return 1;
     }
 
-    disp  = 0;
+    disp = 0;
     etype = MPI_BYTE;
 
     count = 1;
     blocklens[0] = 1;
-    offsets[0]   = 0;
+    offsets[0] = 0;
 
-    if((mpi_err= MPI_Type_create_hindexed(count,blocklens,offsets,MPI_BYTE,&filetype))
-       != MPI_SUCCESS){
-      	MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
-	printf("MPI_Type_contiguous failed (%s)\n", mpi_err_str);
-	return 1;
+    if ((mpi_err = MPI_Type_create_hindexed(count, blocklens, offsets, MPI_BYTE,
+            &filetype)) != MPI_SUCCESS) {
+        MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
+        printf("MPI_Type_contiguous failed (%s)\n", mpi_err_str);
+        return 1;
     }
 
-    if((mpi_err=MPI_Type_commit(&filetype))!=MPI_SUCCESS){
+    if ((mpi_err = MPI_Type_commit(&filetype)) != MPI_SUCCESS) {
         MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
-	printf("MPI_Type_commit failed (%s)\n", mpi_err_str);
-	return 1;
+        printf("MPI_Type_commit failed (%s)\n", mpi_err_str);
+        return 1;
     }
 
     count = 1;
-    blocklens[0]=1;
+    blocklens[0] = 1;
     offsets[0] = 1;
-    if((mpi_err= MPI_Type_create_hindexed(count,blocklens,offsets,MPI_BYTE,&filetypenew))
-       != MPI_SUCCESS){
-      	MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
-	printf("MPI_Type_contiguous failed (%s)\n", mpi_err_str);
-	return 1;
+    if ((mpi_err = MPI_Type_create_hindexed(count, blocklens, offsets, MPI_BYTE,
+            &filetypenew)) != MPI_SUCCESS) {
+        MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
+        printf("MPI_Type_contiguous failed (%s)\n", mpi_err_str);
+        return 1;
     }
 
-    if((mpi_err=MPI_Type_commit(&filetypenew))!=MPI_SUCCESS){
+    if ((mpi_err = MPI_Type_commit(&filetypenew)) != MPI_SUCCESS) {
         MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
-	printf("MPI_Type_commit failed (%s)\n", mpi_err_str);
-	return 1;
+        printf("MPI_Type_commit failed (%s)\n", mpi_err_str);
+        return 1;
     }
 
-    outcount         = 2;
+    outcount = 2;
     adv_blocklens[0] = 1;
     adv_blocklens[1] = 1;
-    adv_disp[0]      = 0;
-    adv_disp[1]      = 1;
-    bas_filetype[0]  = filetype;
-    bas_filetype[1]  = filetypenew;
-
-    if((mpi_err= MPI_Type_create_struct(outcount,adv_blocklens,adv_disp,bas_filetype,&adv_filetype))
-       != MPI_SUCCESS){
-      	MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
-	printf("MPI_Type_create_struct failed (%s)\n", mpi_err_str);
-	return 1;
+    adv_disp[0] = 0;
+    adv_disp[1] = 1;
+    bas_filetype[0] = filetype;
+    bas_filetype[1] = filetypenew;
+
+    if ((mpi_err = MPI_Type_create_struct(outcount, adv_blocklens, adv_disp,
+            bas_filetype, &adv_filetype)) != MPI_SUCCESS) {
+        MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
+        printf("MPI_Type_create_struct failed (%s)\n", mpi_err_str);
+        return 1;
     }
-    if((mpi_err=MPI_Type_commit(&adv_filetype))!=MPI_SUCCESS){
+    if ((mpi_err = MPI_Type_commit(&adv_filetype)) != MPI_SUCCESS) {
         MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
-	printf("MPI_Type_commit failed (%s)\n", mpi_err_str);
-	return 1;
+        printf("MPI_Type_commit failed (%s)\n", mpi_err_str);
+        return 1;
     }
 
-
-    if((mpi_err = MPI_File_set_view(fh,disp,etype,adv_filetype,"native",MPI_INFO_NULL))!= MPI_SUCCESS){
-      MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
-	printf("MPI_File_set_view failed (%s)\n", mpi_err_str);
-	return 1;
+    if ((mpi_err = MPI_File_set_view(fh, disp, etype, adv_filetype, "native",
+            MPI_INFO_NULL)) != MPI_SUCCESS) {
+        MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
+        printf("MPI_File_set_view failed (%s)\n", mpi_err_str);
+        return 1;
     }
 
-    if((mpi_err = MPI_File_write(fh,buf,3,MPI_BYTE,&Status))!= MPI_SUCCESS){
+    if ((mpi_err = MPI_File_write(fh, buf, 3, MPI_BYTE, &Status))
+            != MPI_SUCCESS) {
         MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
-	printf("MPI_File_write failed (%s)\n", mpi_err_str);
-	return 1;
-      ;
+        printf("MPI_File_write failed (%s)\n", mpi_err_str);
+        return 1;
     }
 
-
-    if((mpi_err = MPI_File_close(&fh)) != MPI_SUCCESS){
-       MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
-	printf("MPI_File_close failed (%s)\n", mpi_err_str);
-	return 1;
+    if ((mpi_err = MPI_File_close(&fh)) != MPI_SUCCESS) {
+        MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
+        printf("MPI_File_close failed (%s)\n", mpi_err_str);
+        return 1;
     }
 
-
-    if((mpi_err = MPI_File_open(MPI_COMM_WORLD,filename,MPI_MODE_RDONLY,MPI_INFO_NULL,&fh)) != MPI_SUCCESS){
-       MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
-	printf("MPI_File_open failed (%s)\n", mpi_err_str);
-	return 1;
+    if ((mpi_err = MPI_File_open(MPI_COMM_WORLD, filename, MPI_MODE_RDONLY,
+            MPI_INFO_NULL, &fh)) != MPI_SUCCESS) {
+        MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
+        printf("MPI_File_open failed (%s)\n", mpi_err_str);
+        return 1;
     }
 
-    if((mpi_err = MPI_File_set_view(fh,0,MPI_BYTE,MPI_BYTE,"native",MPI_INFO_NULL))!= MPI_SUCCESS){
+    if ((mpi_err = MPI_File_set_view(fh, 0, MPI_BYTE, MPI_BYTE, "native",
+            MPI_INFO_NULL)) != MPI_SUCCESS) {
         MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
-	printf("MPI_File_set_view failed (%s)\n", mpi_err_str);
-	return 1;
+        printf("MPI_File_set_view failed (%s)\n", mpi_err_str);
+        return 1;
     }
-    if((mpi_err = MPI_File_read(fh,outbuf,3,MPI_BYTE,&Status))!=MPI_SUCCESS){
-      MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
-      printf("MPI_File_read failed (%s)\n", mpi_err_str);
-      return 1;
+    if ((mpi_err = MPI_File_read(fh, outbuf, 3, MPI_BYTE, &Status))
+            != MPI_SUCCESS) {
+        MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
+        printf("MPI_File_read failed (%s)\n", mpi_err_str);
+        return 1;
     }
 
-    if(outbuf[2]==2) {
-       retcode = 0;
-    }
-    else {
-/*      if(mpi_rank == 0) {
-       printf("complicated derived datatype is NOT working at this platform\n");
-       printf("go back to hdf5/config and find the corresponding\n");
-       printf("configure-specific file and change ?????\n");
-      }
-*/
-       retcode = -1;
-   }
-
-    if((mpi_err = MPI_File_close(&fh)) != MPI_SUCCESS){
-       MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
-	printf("MPI_File_close failed (%s)\n", mpi_err_str);
-	return 1;
+    if (outbuf[2] == 2) {
+        retcode = 0;
+    } else {
+        /*      if(mpi_rank == 0) {
+        printf("complicated derived datatype is NOT working at this platform\n");
+        printf("go back to hdf5/config and find the corresponding\n");
+        printf("configure-specific file and change ?????\n");
+        }
+        */
+        retcode = -1;
     }
 
+    if ((mpi_err = MPI_File_close(&fh)) != MPI_SUCCESS) {
+        MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
+        printf("MPI_File_close failed (%s)\n", mpi_err_str);
+        return 1;
+    }
 
     mpi_err = MPI_Barrier(MPI_COMM_WORLD);
-    if(retcode == -1) {
-	if(mpi_rank == 0) {
-	    printf("Complicated derived datatype is NOT working at this platform\n");
-	    printf(" Please report to help@hdfgroup.org about this problem.\n");
-	}
-	retcode = 1;
+    if (retcode == -1) {
+        if (mpi_rank == 0) {
+            printf(
+                    "Complicated derived datatype is NOT working at this platform\n");
+            printf(" Please report to help@hdfgroup.org about this problem.\n");
+        }
+        retcode = 1;
     }
     return retcode;
 }
 /*
 
-Function: test_mpio_special_collective
+ Function: test_mpio_special_collective
 
-Test Whether collective IO is still working when more than one process
-has no contribution to IO. To properly test this case, at least FOUR
-processes are needed.
+ Test Whether collective IO is still working when more than one process
+ has no contribution to IO. To properly test this case, at least FOUR
+ processes are needed.
 
-1. Details for the test:
-1) Create one derived datatype with MPI_Type_create_hindexed:
+ 1. Details for the test:
+ 1) Create one derived datatype with MPI_Type_create_hindexed:
 
-2) Choosing at least two processes to contribute none for IO with
-   the buf size inside MPI_Write_at_all to 0.
-3) Choosing at least two processes to have real contributions for IO.
-4) Do collective IO.
+ 2) Choosing at least two processes to contribute none for IO with
+ the buf size inside MPI_Write_at_all to 0.
+ 3) Choosing at least two processes to have real contributions for IO.
+ 4) Do collective IO.
 
-2. This test will fail with the MPI-IO package that doesn't support this. For example,
-mpich 1.2.6.
+ 2. This test will fail with the MPI-IO package that doesn't support this. For example,
+ mpich 1.2.6.
 
-If this bug has been fixed in the previous not-working package, this test will issue a printf message to tell the developer to change
-the configuration specific file of HDF5 so that we can change our configurationsetting to support special collective IO; currently only special collective IO.
+ If this bug has been fixed in the previous not-working package, this test will issue a printf message to tell the developer to change
+ the configuration specific file of HDF5 so that we can change our configurationsetting to support special collective IO; currently only special collective IO.
 
-If it turns out that the previous working MPI-IO package no longer works, this test will also issue a message to inform the corresponding failure so that
-we can turn off the support for special collective IO; currently only special collective IO.
-*/
+ If it turns out that the previous working MPI-IO package no longer works, this test will also issue a message to inform the corresponding failure so that
+ we can turn off the support for special collective IO; currently only special collective IO.
+ */
 
-static int
-test_mpio_special_collective(char *filename)
-{
-    int  mpi_size, mpi_rank;
+static int test_mpio_special_collective(char *filename) {
+    int mpi_size, mpi_rank;
     MPI_File fh;
-    MPI_Datatype etype,buftype,filetype;
+    MPI_Datatype etype, buftype, filetype;
     char mpi_err_str[MPI_MAX_ERROR_STRING];
-    int  mpi_err_strlen;
-    int  mpi_err;
-    char writedata[2*DIMSIZE];
+    int mpi_err_strlen;
+    int mpi_err;
+    char writedata[2 * DIMSIZE];
     char filerep[7] = "native";
-    int  i;
-    int  count,bufcount;
+    int i;
+    int count, bufcount;
     int blocklens[2];
     MPI_Aint offsets[2];
-    MPI_Offset  mpi_off = 0;
-    MPI_Status  mpi_stat;
-    int  retcode = 0;
+    MPI_Offset mpi_off = 0;
+    MPI_Status mpi_stat;
+    int retcode = 0;
 
     MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
     MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
 
     /* create MPI data type */
     etype = MPI_BYTE;
-    if(mpi_rank == 0 || mpi_rank == 1) {
+    if (mpi_rank == 0 || mpi_rank == 1) {
         count = DIMSIZE;
         bufcount = 1;
     } /* end if */
@@ -892,38 +890,32 @@ test_mpio_special_collective(char *filename)
     } /* end else */
 
     blocklens[0] = count;
-    offsets[0] = mpi_rank*count;
+    offsets[0] = mpi_rank * count;
     blocklens[1] = count;
-    offsets[1] = (mpi_size+mpi_rank)*count;
-
-    if(count !=0) {
-        if((mpi_err = MPI_Type_create_hindexed(2,
-                                        blocklens,
-                                        offsets,
-                                        etype,
-                                        &filetype)) != MPI_SUCCESS) {
+    offsets[1] = (mpi_size + mpi_rank) * count;
+
+    if (count != 0) {
+        if ((mpi_err = MPI_Type_create_hindexed(2, blocklens, offsets, etype,
+                &filetype)) != MPI_SUCCESS) {
             MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
             printf("MPI_Type_contiguous failed (%s)\n", mpi_err_str);
             return 1;
         } /* end if */
 
-        if((mpi_err = MPI_Type_commit(&filetype)) != MPI_SUCCESS) {
+        if ((mpi_err = MPI_Type_commit(&filetype)) != MPI_SUCCESS) {
             MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
             printf("MPI_Type_commit failed (%s)\n", mpi_err_str);
             return 1;
         } /* end if */
 
-        if((mpi_err = MPI_Type_create_hindexed(2,
-                                        blocklens,
-                                        offsets,
-                                        etype,
-                                        &buftype)) != MPI_SUCCESS) {
+        if ((mpi_err = MPI_Type_create_hindexed(2, blocklens, offsets, etype,
+                &buftype)) != MPI_SUCCESS) {
             MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
             printf("MPI_Type_contiguous failed (%s)\n", mpi_err_str);
             return 1;
         } /* end if */
 
-        if((mpi_err = MPI_Type_commit(&buftype)) != MPI_SUCCESS) {
+        if ((mpi_err = MPI_Type_commit(&buftype)) != MPI_SUCCESS) {
             MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
             printf("MPI_Type_commit failed (%s)\n", mpi_err_str);
             return 1;
@@ -931,46 +923,36 @@ test_mpio_special_collective(char *filename)
     } /* end if */
     else {
         filetype = MPI_BYTE;
-        buftype  = MPI_BYTE;
+        buftype = MPI_BYTE;
     } /* end else */
 
     /* Open a file */
-    if ((mpi_err = MPI_File_open(MPI_COMM_WORLD,
-                                 filename,
-                                 MPI_MODE_RDWR | MPI_MODE_CREATE,
-                                 MPI_INFO_NULL,
-                                 &fh)) != MPI_SUCCESS) {
+    if ((mpi_err = MPI_File_open(MPI_COMM_WORLD, filename,
+            MPI_MODE_RDWR | MPI_MODE_CREATE, MPI_INFO_NULL, &fh))
+            != MPI_SUCCESS) {
         MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
         printf("MPI_File_open failed (%s)\n", mpi_err_str);
         return 1;
     } /* end if */
 
     /* each process writes some data */
-    for (i=0; i < 2*DIMSIZE; i++)
-        writedata[i] = (char)(mpi_rank*DIMSIZE + i);
+    for (i = 0; i < 2 * DIMSIZE; i++)
+        writedata[i] = (char) (mpi_rank * DIMSIZE + i);
 
     /* Set the file view */
-    if((mpi_err = MPI_File_set_view(fh,
-                                    mpi_off,
-                                    MPI_BYTE,
-                                    filetype,
-                                    filerep,
-                                    MPI_INFO_NULL)) != MPI_SUCCESS) {
+    if ((mpi_err = MPI_File_set_view(fh, mpi_off, MPI_BYTE, filetype, filerep,
+            MPI_INFO_NULL)) != MPI_SUCCESS) {
         MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
         printf("MPI_File_set_view failed (%s)\n", mpi_err_str);
         return 1;
     } /* end if */
 
     /* Collectively write into the file */
-    if ((mpi_err = MPI_File_write_at_all(fh,
-                                         mpi_off,
-                                         writedata,
-                                         bufcount,
-                                         buftype,
-                                         &mpi_stat)) != MPI_SUCCESS) {
+    if ((mpi_err = MPI_File_write_at_all(fh, mpi_off, writedata, bufcount,
+            buftype, &mpi_stat)) != MPI_SUCCESS) {
         MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
         printf("MPI_File_write_at offset(%ld), bytes (%d), failed (%s)\n",
-               (long) mpi_off, bufcount, mpi_err_str);
+                (long) mpi_off, bufcount, mpi_err_str);
         return 1;
     } /* end if */
 
@@ -983,8 +965,8 @@ test_mpio_special_collective(char *filename)
 
     /* Perform a barrier */
     mpi_err = MPI_Barrier(MPI_COMM_WORLD);
-    if(retcode != 0) {
-        if(mpi_rank == 0) {
+    if (retcode != 0) {
+        if (mpi_rank == 0) {
             printf("special collective IO is NOT working at this platform\n");
             printf(" Please report to help@hdfgroup.org about this problem.\n");
         } /* end if */
@@ -998,71 +980,69 @@ test_mpio_special_collective(char *filename)
 /*
  * parse the command line options
  */
-static int
-parse_options(int argc, char **argv)
-{
-    while (--argc){
-	if (**(++argv) != '-'){
-	    break;
-	}else{
-	    switch(*(*argv+1)){
-		case 'v':   if (*((*argv+1)+1))
-				ParseTestVerbosity((*argv+1)+1);
-			    else
-				SetTestVerbosity(VERBO_MED);
-			    break;
-		case 'f':   if (--argc < 1) {
-				nerrors++;
-				return(1);
-			    }
-			    if (**(++argv) == '-') {
-				nerrors++;
-				return(1);
-			    }
-			    paraprefix = *argv;
-			    break;
-		case 'h':   /* print help message--return with nerrors set */
-			    return(1);
-		default:    nerrors++;
-			    return(1);
-	    }
-	}
+static int parse_options(int argc, char **argv) {
+    while (--argc) {
+        if (**(++argv) != '-') {
+            break;
+        } else {
+            switch (*(*argv + 1)) {
+            case 'v':
+                if (*((*argv + 1) + 1))
+                    ParseTestVerbosity((*argv + 1) + 1);
+                else
+                    SetTestVerbosity(VERBO_MED);
+                break;
+            case 'f':
+                if (--argc < 1) {
+                    nerrors++;
+                    return (1);
+                }
+                if (**(++argv) == '-') {
+                    nerrors++;
+                    return (1);
+                }
+                paraprefix = *argv;
+                break;
+            case 'h': /* print help message--return with nerrors set */
+                return (1);
+            default:
+                nerrors++;
+                return (1);
+            }
+        }
     } /*while*/
 
     /* compose the test filenames */
     {
-	int i, n;
-	hid_t plist;
-
-	plist = H5Pcreate (H5P_FILE_ACCESS);
-	H5Pset_fapl_mpio(plist, MPI_COMM_WORLD, MPI_INFO_NULL);
-	n = sizeof(FILENAME)/sizeof(FILENAME[0]) - 1;	/* exclude the NULL */
-
-	for (i=0; i < n; i++)
-	    if (h5_fixname(FILENAME[i],plist,filenames[i],sizeof(filenames[i]))
-		== NULL){
-		printf("h5_fixname failed\n");
-		nerrors++;
-		return(1);
-	    }
-	H5Pclose(plist);
-	if (VERBOSE_MED){
-	    printf("Test filenames are:\n");
-	    for (i=0; i < n; i++)
-		printf("    %s\n", filenames[i]);
-	}
+        int i, n;
+        hid_t plist;
+
+        plist = H5Pcreate(H5P_FILE_ACCESS);
+        H5Pset_fapl_mpio(plist, MPI_COMM_WORLD, MPI_INFO_NULL);
+        n = sizeof(FILENAME) / sizeof(FILENAME[0]) - 1; /* exclude the NULL */
+
+        for (i = 0; i < n; i++)
+            if (h5_fixname(FILENAME[i], plist, filenames[i],
+                    sizeof(filenames[i])) == NULL) {
+                printf("h5_fixname failed\n");
+                nerrors++;
+                return (1);
+            }
+        H5Pclose(plist);
+        if (VERBOSE_MED) {
+            printf("Test filenames are:\n");
+            for (i = 0; i < n; i++)
+                printf("    %s\n", filenames[i]);
+        }
     }
 
-    return(0);
+    return (0);
 }
 
-
 /*
  * Show command usage
  */
-static void
-usage(void)
-{
+static void usage(void) {
     printf("Usage: t_mpi [-v<verbosity>] [-f <prefix>]\n");
     printf("\t-v<verbosity>\tset verbose level (0-9,l,m,h)\n");
     printf("\t-f <prefix>\tfilename prefix\n");
@@ -1072,19 +1052,14 @@ usage(void)
 /*
  * return the sum of all errors.
  */
-static int
-errors_sum(int nerrs)
-{
+static int errors_sum(int nerrs) {
     int temp;
     MPI_Allreduce(&nerrs, &temp, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD);
-    return(temp);
+    return (temp);
 }
 
-
-int
-main(int argc, char **argv)
-{
-    int mpi_size, mpi_rank;				/* mpi variables */
+int main(int argc, char **argv) {
+    int mpi_size, mpi_rank; /* mpi variables */
     int ret_code;
 
     MPI_Init(&argc, &argv);
@@ -1092,78 +1067,76 @@ main(int argc, char **argv)
     MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
 
     /* Attempt to turn off atexit post processing so that in case errors
-     * happen during the test and the process is aborted, it will not get
-     * hang in the atexit post processing in which it may try to make MPI
-     * calls.  By then, MPI calls may not work.
-     */
-    if (H5dont_atexit() < 0){
-	printf("Failed to turn off atexit processing. Continue.\n");
+    * happen during the test and the process is aborted, it will not get
+    * hang in the atexit post processing in which it may try to make MPI
+    * calls.  By then, MPI calls may not work.
+    */
+    if (H5dont_atexit() < 0) {
+        printf("Failed to turn off atexit processing. Continue.\n");
     };
     H5open();
-    if (parse_options(argc, argv) != 0){
-	if (MAINPROCESS)
-	    usage();
-	goto finish;
+    if (parse_options(argc, argv) != 0) {
+        if (MAINPROCESS)
+            usage();
+        goto finish;
     }
 
-    if (MAINPROCESS){
-	printf("===================================\n");
-	printf("MPI functionality tests\n");
-	printf("===================================\n");
+    if (MAINPROCESS) {
+        printf("===================================\n");
+        printf("MPI functionality tests\n");
+        printf("===================================\n");
     }
 
     if (VERBOSE_MED)
-	h5_show_hostname();
+        h5_show_hostname();
 
-    fapl = H5Pcreate (H5P_FILE_ACCESS);
+    fapl = H5Pcreate(H5P_FILE_ACCESS);
     H5Pset_fapl_mpio(fapl, MPI_COMM_WORLD, MPI_INFO_NULL);
 
     /* set alarm. */
     ALARM_ON;
 
-
     /*=======================================
-     * MPIO 1 write Many read test
-     *=======================================*/
+    * MPIO 1 write Many read test
+    *=======================================*/
     MPI_BANNER("MPIO 1 write Many read test...");
     ret_code = test_mpio_1wMr(filenames[0], USENONE);
     ret_code = errors_sum(ret_code);
-    if (mpi_rank==0 && ret_code > 0){
-	printf("***FAILED with %d total errors\n", ret_code);
-	nerrors += ret_code;
+    if (mpi_rank == 0 && ret_code > 0) {
+        printf("***FAILED with %d total errors\n", ret_code);
+        nerrors += ret_code;
     }
 
     /* test atomicity and file sync in high verbose mode only         */
     /* since they often hang when broken and PHDF5 does not use them. */
-    if (VERBOSE_HI){
-	MPI_BANNER("MPIO 1 write Many read test with atomicity...");
-	ret_code = test_mpio_1wMr(filenames[0], USEATOM);
-	ret_code = errors_sum(ret_code);
-	if (mpi_rank==0 && ret_code > 0){
-	    printf("***FAILED with %d total errors\n", ret_code);
-	    nerrors += ret_code;
-	}
-
-	MPI_BANNER("MPIO 1 write Many read test with file sync...");
-	ret_code = test_mpio_1wMr(filenames[0], USEFSYNC);
-	ret_code = errors_sum(ret_code);
-	if (mpi_rank==0 && ret_code > 0){
-	    printf("***FAILED with %d total errors\n", ret_code);
-	    nerrors += ret_code;
-	}
-    }
+    if (VERBOSE_HI) {
+        MPI_BANNER("MPIO 1 write Many read test with atomicity...");
+        ret_code = test_mpio_1wMr(filenames[0], USEATOM);
+        ret_code = errors_sum(ret_code);
+        if (mpi_rank == 0 && ret_code > 0) {
+            printf("***FAILED with %d total errors\n", ret_code);
+            nerrors += ret_code;
+        }
 
+        MPI_BANNER("MPIO 1 write Many read test with file sync...");
+        ret_code = test_mpio_1wMr(filenames[0], USEFSYNC);
+        ret_code = errors_sum(ret_code);
+        if (mpi_rank == 0 && ret_code > 0) {
+            printf("***FAILED with %d total errors\n", ret_code);
+            nerrors += ret_code;
+        }
+    }
 
     /*=======================================
-     * MPIO MPIO File size range test
-     *=======================================*/
+    * MPIO MPIO File size range test
+    *=======================================*/
     MPI_BANNER("MPIO File size range test...");
 #ifndef H5_HAVE_WIN32_API
     ret_code = test_mpio_gb_file(filenames[0]);
     ret_code = errors_sum(ret_code);
-    if (mpi_rank==0 && ret_code > 0){
-	printf("***FAILED with %d total errors\n", ret_code);
-	nerrors += ret_code;
+    if (mpi_rank == 0 && ret_code > 0) {
+        printf("***FAILED with %d total errors\n", ret_code);
+        nerrors += ret_code;
     }
 #else
     if (mpi_rank==0)
@@ -1171,30 +1144,30 @@ main(int argc, char **argv)
 #endif
 
     /*=======================================
-     * MPIO independent overlapping writes
-     *=======================================*/
+    * MPIO independent overlapping writes
+    *=======================================*/
     MPI_BANNER("MPIO independent overlapping writes...");
     ret_code = test_mpio_overlap_writes(filenames[0]);
     ret_code = errors_sum(ret_code);
-    if (mpi_rank==0 && ret_code > 0){
-	printf("***FAILED with %d total errors\n", ret_code);
-	nerrors += ret_code;
+    if (mpi_rank == 0 && ret_code > 0) {
+        printf("***FAILED with %d total errors\n", ret_code);
+        nerrors += ret_code;
     }
 
     /*=======================================
-     * MPIO complicated derived datatype test
-     *=======================================*/
+    * MPIO complicated derived datatype test
+    *=======================================*/
     MPI_BANNER("MPIO complicated derived datatype test...");
     ret_code = test_mpio_derived_dtype(filenames[0]);
     ret_code = errors_sum(ret_code);
-    if (mpi_rank==0 && ret_code > 0){
-	printf("***FAILED with %d total errors\n", ret_code);
-	nerrors += ret_code;
+    if (mpi_rank == 0 && ret_code > 0) {
+        printf("***FAILED with %d total errors\n", ret_code);
+        nerrors += ret_code;
     }
 
     /*=======================================
-     * MPIO special collective IO  test
-     *=======================================*/
+    * MPIO special collective IO  test
+    *=======================================*/
     if (mpi_size < 4) {
         MPI_BANNER("MPIO special collective io test SKIPPED.");
         if (mpi_rank == 0)
@@ -1206,28 +1179,26 @@ main(int argc, char **argv)
     MPI_BANNER("MPIO special collective io test...");
     ret_code = test_mpio_special_collective(filenames[0]);
 
-sc_finish:
-    ret_code = errors_sum(ret_code);
-    if (mpi_rank==0 && ret_code > 0){
-	printf("***FAILED with %d total errors\n", ret_code);
-	nerrors += ret_code;
+    sc_finish: ret_code = errors_sum(ret_code);
+    if (mpi_rank == 0 && ret_code > 0) {
+        printf("***FAILED with %d total errors\n", ret_code);
+        nerrors += ret_code;
     }
 
-
-finish:
+    finish:
     /* make sure all processes are finished before final report, cleanup
-     * and exit.
-     */
+    * and exit.
+    */
     MPI_Barrier(MPI_COMM_WORLD);
-    if (MAINPROCESS){		/* only process 0 reports */
-	printf("===================================\n");
-	if (nerrors){
-	    printf("***MPI tests detected %d errors***\n", nerrors);
-	}
-	else{
-	    printf("MPI tests finished with no errors\n");
-	}
-	printf("===================================\n");
+    if (MAINPROCESS) { /* only process 0 reports */
+        printf("===================================\n");
+        if (nerrors) {
+            printf("***MPI tests detected %d errors***\n", nerrors);
+        }
+        else {
+            printf("MPI tests finished with no errors\n");
+        }
+        printf("===================================\n");
     }
 
     /* turn off alarm */
@@ -1240,6 +1211,6 @@ finish:
     MPI_Finalize();
 
     /* cannot just return (nerrors) because exit code is limited to 1byte */
-    return(nerrors!=0);
+    return (nerrors != 0);
 }
 
diff --git a/testpar/t_pread.c b/testpar/t_pread.c
index ac33b88..74feeb6 100644
--- a/testpar/t_pread.c
+++ b/testpar/t_pread.c
@@ -1079,18 +1079,11 @@ test_parallel_read(MPI_Comm comm, int mpi_rank, int mpi_size, int group_id)
  *              with the opening and validation of the data contained
  *              therein.
  *
- *              WARNING: This test uses fork() and execve(), and
- *                       therefore will not run on Windows.
- *
  * Return:      Success: 0
- *
  *              Failure: 1
  *
  * Programmer:  Richard Warren
  *              10/1/17
- *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 
diff --git a/testpar/testphdf5.c b/testpar/testphdf5.c
index 999e17a..e1ccbed 100644
--- a/testpar/testphdf5.c
+++ b/testpar/testphdf5.c
@@ -26,15 +26,15 @@ int dim0;
 int dim1;
 int chunkdim0;
 int chunkdim1;
-int nerrors = 0;			/* errors count */
-int ndatasets = 300;			/* number of datasets to create*/
+int nerrors = 0;            /* errors count */
+int ndatasets = 300;            /* number of datasets to create*/
 int ngroups = 512;                      /* number of groups to create in root
                                          * group. */
-int facc_type = FACC_MPIO;		/*Test file access type */
+int facc_type = FACC_MPIO;        /*Test file access type */
 int dxfer_coll_type = DXFER_COLLECTIVE_IO;
 
-H5E_auto2_t old_func;		        /* previous error handler */
-void *old_client_data;			/* previous error handler arg.*/
+H5E_auto2_t old_func;                /* previous error handler */
+void *old_client_data;            /* previous error handler arg.*/
 
 /* other option flags */
 
@@ -46,10 +46,10 @@ void *old_client_data;			/* previous error handler arg.*/
 #define NFILENAME 2
 #define PARATESTFILE filenames[0]
 const char *FILENAME[NFILENAME]={
-	    "ParaTest",
-	    NULL};
-char	filenames[NFILENAME][PATH_MAX];
-hid_t	fapl;				/* file access property list */
+        "ParaTest",
+        NULL};
+char    filenames[NFILENAME][PATH_MAX];
+hid_t    fapl;                /* file access property list */
 
 #ifdef USE_PAUSE
 /* pause the process for a moment to allow debugger to attach if desired. */
@@ -62,7 +62,7 @@ void pause_proc(void)
 {
 
     int pid;
-    h5_stat_t	statbuf;
+    h5_stat_t    statbuf;
     char greenlight[] = "go";
     int maxloop = 10;
     int loops = 0;
@@ -80,14 +80,14 @@ void pause_proc(void)
 
     if (MAINPROCESS)
   while ((HDstat(greenlight, &statbuf) == -1) && loops < maxloop){
-	    if (!loops++){
-		printf("Proc %d (%*s, %d): to debug, attach %d\n",
-		    mpi_rank, mpi_namelen, mpi_name, pid, pid);
-	    }
-	    printf("waiting(%ds) for file %s ...\n", time_int, greenlight);
-	    fflush(stdout);
+        if (!loops++){
+        printf("Proc %d (%*s, %d): to debug, attach %d\n",
+            mpi_rank, mpi_namelen, mpi_name, pid, pid);
+        }
+        printf("waiting(%ds) for file %s ...\n", time_int, greenlight);
+        fflush(stdout);
             HDsleep(time_int);
-	}
+    }
     MPI_Barrier(MPI_COMM_WORLD);
 }
 
@@ -99,7 +99,7 @@ int MPI_Init(int *argc, char ***argv)
     pause_proc();
     return (ret_code);
 }
-#endif	/* USE_PAUSE */
+#endif    /* USE_PAUSE */
 
 
 /*
@@ -109,15 +109,15 @@ static void
 usage(void)
 {
     printf("    [-r] [-w] [-m<n_datasets>] [-n<n_groups>] "
-	"[-o] [-f <prefix>] [-d <dim0> <dim1>]\n");
+    "[-o] [-f <prefix>] [-d <dim0> <dim1>]\n");
     printf("\t-m<n_datasets>"
-	"\tset number of datasets for the multiple dataset test\n");
+    "\tset number of datasets for the multiple dataset test\n");
     printf("\t-n<n_groups>"
         "\tset number of groups for the multiple group test\n");
     printf("\t-f <prefix>\tfilename prefix\n");
     printf("\t-2\t\tuse Split-file together with MPIO\n");
     printf("\t-d <factor0> <factor1>\tdataset dimensions factors. Defaults (%d,%d)\n",
-	ROW_FACTOR, COL_FACTOR);
+    ROW_FACTOR, COL_FACTOR);
     printf("\t-c <dim0> <dim1>\tdataset chunk dimensions. Defaults (dim0/10,dim1/10)\n");
     printf("\n");
 }
@@ -129,7 +129,7 @@ usage(void)
 static int
 parse_options(int argc, char **argv)
 {
-    int mpi_size, mpi_rank;				/* mpi variables */
+    int mpi_size, mpi_rank;                /* mpi variables */
 
     MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
     MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
@@ -140,107 +140,107 @@ parse_options(int argc, char **argv)
     chunkdim1 = (dim1+9)/10;
 
     while (--argc){
-	if (**(++argv) != '-'){
-	    break;
-	}else{
-	    switch(*(*argv+1)){
-		case 'm':   ndatasets = atoi((*argv+1)+1);
-			    if (ndatasets < 0){
-				nerrors++;
-				return(1);
-			    }
-			    break;
-	        case 'n':   ngroups = atoi((*argv+1)+1);
-		            if (ngroups < 0){
+    if (**(++argv) != '-'){
+        break;
+    }else{
+        switch(*(*argv+1)){
+        case 'm':   ndatasets = atoi((*argv+1)+1);
+                if (ndatasets < 0){
+                nerrors++;
+                return(1);
+                }
+                break;
+            case 'n':   ngroups = atoi((*argv+1)+1);
+                    if (ngroups < 0){
                                 nerrors++;
                                 return(1);
-			    }
+                }
                             break;
-		case 'f':   if (--argc < 1) {
-				nerrors++;
-				return(1);
-			    }
-			    if (**(++argv) == '-') {
-				nerrors++;
-				return(1);
-			    }
-			    paraprefix = *argv;
-			    break;
-		case 'i':   /* Collective MPI-IO access with independent IO  */
-			    dxfer_coll_type = DXFER_INDEPENDENT_IO;
-			    break;
-		case '2':   /* Use the split-file driver with MPIO access */
-			    /* Can use $HDF5_METAPREFIX to define the */
-			    /* meta-file-prefix. */
-			    facc_type = FACC_MPIO | FACC_SPLIT;
-			    break;
-		case 'd':   /* dimensizes */
-			    if (--argc < 2){
-				nerrors++;
-				return(1);
-			    }
-			    dim0 = atoi(*(++argv))*mpi_size;
-			    argc--;
-			    dim1 = atoi(*(++argv))*mpi_size;
-			    /* set default chunkdim sizes too */
-			    chunkdim0 = (dim0+9)/10;
-			    chunkdim1 = (dim1+9)/10;
-			    break;
-		case 'c':   /* chunk dimensions */
-			    if (--argc < 2){
-				nerrors++;
-				return(1);
-			    }
-			    chunkdim0 = atoi(*(++argv));
-			    argc--;
-			    chunkdim1 = atoi(*(++argv));
-			    break;
-		case 'h':   /* print help message--return with nerrors set */
-			    return(1);
-		default:    printf("Illegal option(%s)\n", *argv);
-			    nerrors++;
-			    return(1);
-	    }
-	}
+        case 'f':   if (--argc < 1) {
+                nerrors++;
+                return(1);
+                }
+                if (**(++argv) == '-') {
+                nerrors++;
+                return(1);
+                }
+                paraprefix = *argv;
+                break;
+        case 'i':   /* Collective MPI-IO access with independent IO  */
+                dxfer_coll_type = DXFER_INDEPENDENT_IO;
+                break;
+        case '2':   /* Use the split-file driver with MPIO access */
+                /* Can use $HDF5_METAPREFIX to define the */
+                /* meta-file-prefix. */
+                facc_type = FACC_MPIO | FACC_SPLIT;
+                break;
+        case 'd':   /* dimensizes */
+                if (--argc < 2){
+                nerrors++;
+                return(1);
+                }
+                dim0 = atoi(*(++argv))*mpi_size;
+                argc--;
+                dim1 = atoi(*(++argv))*mpi_size;
+                /* set default chunkdim sizes too */
+                chunkdim0 = (dim0+9)/10;
+                chunkdim1 = (dim1+9)/10;
+                break;
+        case 'c':   /* chunk dimensions */
+                if (--argc < 2){
+                nerrors++;
+                return(1);
+                }
+                chunkdim0 = atoi(*(++argv));
+                argc--;
+                chunkdim1 = atoi(*(++argv));
+                break;
+        case 'h':   /* print help message--return with nerrors set */
+                return(1);
+        default:    printf("Illegal option(%s)\n", *argv);
+                nerrors++;
+                return(1);
+        }
+    }
     } /*while*/
 
     /* check validity of dimension and chunk sizes */
     if (dim0 <= 0 || dim1 <= 0){
-	printf("Illegal dim sizes (%d, %d)\n", dim0, dim1);
-	nerrors++;
-	return(1);
+    printf("Illegal dim sizes (%d, %d)\n", dim0, dim1);
+    nerrors++;
+    return(1);
     }
     if (chunkdim0 <= 0 || chunkdim1 <= 0){
-	printf("Illegal chunkdim sizes (%d, %d)\n", chunkdim0, chunkdim1);
-	nerrors++;
-	return(1);
+    printf("Illegal chunkdim sizes (%d, %d)\n", chunkdim0, chunkdim1);
+    nerrors++;
+    return(1);
     }
 
     /* Make sure datasets can be divided into equal portions by the processes */
     if ((dim0 % mpi_size) || (dim1 % mpi_size)){
-	if (MAINPROCESS)
-	    printf("dim0(%d) and dim1(%d) must be multiples of processes(%d)\n",
-		    dim0, dim1, mpi_size);
-	nerrors++;
-	return(1);
+    if (MAINPROCESS)
+        printf("dim0(%d) and dim1(%d) must be multiples of processes(%d)\n",
+            dim0, dim1, mpi_size);
+    nerrors++;
+    return(1);
     }
 
     /* compose the test filenames */
     {
-	int i, n;
-
-	n = sizeof(FILENAME)/sizeof(FILENAME[0]) - 1;	/* exclude the NULL */
-
-	for (i=0; i < n; i++)
-	    if (h5_fixname(FILENAME[i],fapl,filenames[i],sizeof(filenames[i]))
-		== NULL){
-		printf("h5_fixname failed\n");
-		nerrors++;
-		return(1);
-	    }
-	printf("Test filenames are:\n");
-	for (i=0; i < n; i++)
-	    printf("    %s\n", filenames[i]);
+    int i, n;
+
+    n = sizeof(FILENAME)/sizeof(FILENAME[0]) - 1;    /* exclude the NULL */
+
+    for (i=0; i < n; i++)
+        if (h5_fixname(FILENAME[i],fapl,filenames[i],sizeof(filenames[i]))
+        == NULL){
+        printf("h5_fixname failed\n");
+        nerrors++;
+        return(1);
+        }
+    printf("Test filenames are:\n");
+    for (i=0; i < n; i++)
+        printf("    %s\n", filenames[i]);
     }
 
     return(0);
@@ -255,7 +255,7 @@ create_faccess_plist(MPI_Comm comm, MPI_Info info, int l_facc_type)
 {
     hid_t ret_pl = -1;
     herr_t ret;                 /* generic return value */
-    int mpi_rank;		/* mpi variables */
+    int mpi_rank;        /* mpi variables */
 
     /* need the rank for error checking macros */
     MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
@@ -264,36 +264,36 @@ create_faccess_plist(MPI_Comm comm, MPI_Info info, int l_facc_type)
     VRFY((ret_pl >= 0), "H5P_FILE_ACCESS");
 
     if (l_facc_type == FACC_DEFAULT)
-	return (ret_pl);
+    return (ret_pl);
 
     if (l_facc_type == FACC_MPIO){
-	/* set Parallel access with communicator */
-	ret = H5Pset_fapl_mpio(ret_pl, comm, info);
-	VRFY((ret >= 0), "");
+    /* set Parallel access with communicator */
+    ret = H5Pset_fapl_mpio(ret_pl, comm, info);
+    VRFY((ret >= 0), "");
         ret = H5Pset_all_coll_metadata_ops(ret_pl, TRUE);
-	VRFY((ret >= 0), "");
+    VRFY((ret >= 0), "");
         ret = H5Pset_coll_metadata_write(ret_pl, TRUE);
-	VRFY((ret >= 0), "");
-	return(ret_pl);
+    VRFY((ret >= 0), "");
+    return(ret_pl);
     }
 
     if (l_facc_type == (FACC_MPIO | FACC_SPLIT)){
-	hid_t mpio_pl;
-
-	mpio_pl = H5Pcreate (H5P_FILE_ACCESS);
-	VRFY((mpio_pl >= 0), "");
-	/* set Parallel access with communicator */
-	ret = H5Pset_fapl_mpio(mpio_pl, comm, info);
-	VRFY((ret >= 0), "");
-
-	/* setup file access template */
-	ret_pl = H5Pcreate (H5P_FILE_ACCESS);
-	VRFY((ret_pl >= 0), "");
-	/* set Parallel access with communicator */
-	ret = H5Pset_fapl_split(ret_pl, ".meta", mpio_pl, ".raw", mpio_pl);
-	VRFY((ret >= 0), "H5Pset_fapl_split succeeded");
-	H5Pclose(mpio_pl);
-	return(ret_pl);
+    hid_t mpio_pl;
+
+    mpio_pl = H5Pcreate (H5P_FILE_ACCESS);
+    VRFY((mpio_pl >= 0), "");
+    /* set Parallel access with communicator */
+    ret = H5Pset_fapl_mpio(mpio_pl, comm, info);
+    VRFY((ret >= 0), "");
+
+    /* setup file access template */
+    ret_pl = H5Pcreate (H5P_FILE_ACCESS);
+    VRFY((ret_pl >= 0), "");
+    /* set Parallel access with communicator */
+    ret = H5Pset_fapl_split(ret_pl, ".meta", mpio_pl, ".raw", mpio_pl);
+    VRFY((ret >= 0), "H5Pset_fapl_split succeeded");
+    H5Pclose(mpio_pl);
+    return(ret_pl);
     }
 
     /* unknown file access types */
@@ -303,7 +303,7 @@ create_faccess_plist(MPI_Comm comm, MPI_Info info, int l_facc_type)
 
 int main(int argc, char **argv)
 {
-    int mpi_size, mpi_rank;				/* mpi variables */
+    int mpi_size, mpi_rank;                /* mpi variables */
     H5Ptest_param_t ndsets_params, ngroups_params;
     H5Ptest_param_t collngroups_params;
     H5Ptest_param_t io_mode_confusion_params;
@@ -323,9 +323,9 @@ int main(int argc, char **argv)
     dim1 = COL_FACTOR*mpi_size;
 
     if (MAINPROCESS){
-	printf("===================================\n");
-	printf("PHDF5 TESTS START\n");
-	printf("===================================\n");
+    printf("===================================\n");
+    printf("PHDF5 TESTS START\n");
+    printf("===================================\n");
     }
 
     /* Attempt to turn off atexit post processing so that in case errors
@@ -334,7 +334,7 @@ int main(int argc, char **argv)
      * calls.  By then, MPI calls may not work.
      */
     if (H5dont_atexit() < 0){
-	printf("Failed to turn off atexit processing. Continue.\n");
+    printf("Failed to turn off atexit processing. Continue.\n");
     };
     H5open();
     h5_show_hostname();
@@ -344,10 +344,10 @@ int main(int argc, char **argv)
 
     /* Tests are generally arranged from least to most complexity... */
     AddTest("mpiodup", test_fapl_mpio_dup, NULL,
-	    "fapl_mpio duplicate", NULL);
+        "fapl_mpio duplicate", NULL);
 
     AddTest("split", test_split_comm_access, NULL,
-	    "dataset using split communicators", PARATESTFILE);
+        "dataset using split communicators", PARATESTFILE);
 
 #ifdef PB_OUT /* temporary: disable page buffering when parallel */
     AddTest("page_buffer", test_page_buffer_access, NULL,
@@ -355,64 +355,64 @@ int main(int argc, char **argv)
 #endif
 
     AddTest("props", test_file_properties, NULL,
-	    "Coll Metadata file property settings", PARATESTFILE);
+        "Coll Metadata file property settings", PARATESTFILE);
 
     AddTest("idsetw", dataset_writeInd, NULL,
-	    "dataset independent write", PARATESTFILE);
+        "dataset independent write", PARATESTFILE);
     AddTest("idsetr", dataset_readInd, NULL,
-	    "dataset independent read", PARATESTFILE);
+        "dataset independent read", PARATESTFILE);
 
     AddTest("cdsetw", dataset_writeAll, NULL,
-	    "dataset collective write", PARATESTFILE);
+        "dataset collective write", PARATESTFILE);
     AddTest("cdsetr", dataset_readAll, NULL,
-	    "dataset collective read", PARATESTFILE);
+        "dataset collective read", PARATESTFILE);
 
     AddTest("eidsetw", extend_writeInd, NULL,
-	    "extendible dataset independent write", PARATESTFILE);
+        "extendible dataset independent write", PARATESTFILE);
     AddTest("eidsetr", extend_readInd, NULL,
-	    "extendible dataset independent read", PARATESTFILE);
+        "extendible dataset independent read", PARATESTFILE);
     AddTest("ecdsetw", extend_writeAll, NULL,
-	    "extendible dataset collective write", PARATESTFILE);
+        "extendible dataset collective write", PARATESTFILE);
     AddTest("ecdsetr", extend_readAll, NULL,
-	    "extendible dataset collective read", PARATESTFILE);
+        "extendible dataset collective read", PARATESTFILE);
     AddTest("eidsetw2", extend_writeInd2, NULL,
-	    "extendible dataset independent write #2", PARATESTFILE);
+        "extendible dataset independent write #2", PARATESTFILE);
     AddTest("selnone", none_selection_chunk, NULL,
             "chunked dataset with none-selection", PARATESTFILE);
     AddTest("calloc", test_chunk_alloc, NULL,
             "parallel extend Chunked allocation on serial file", PARATESTFILE);
     AddTest("fltread", test_filter_read, NULL,
-	    "parallel read of dataset written serially with filters", PARATESTFILE);
+        "parallel read of dataset written serially with filters", PARATESTFILE);
 
 #ifdef H5_HAVE_FILTER_DEFLATE
     AddTest("cmpdsetr", compress_readAll, NULL,
-	    "compressed dataset collective read", PARATESTFILE);
+        "compressed dataset collective read", PARATESTFILE);
 #endif /* H5_HAVE_FILTER_DEFLATE */
 
     AddTest("zerodsetr", zero_dim_dset, NULL,
-	    "zero dim dset", PARATESTFILE);
+        "zero dim dset", PARATESTFILE);
 
     ndsets_params.name = PARATESTFILE;
     ndsets_params.count = ndatasets;
     AddTest("ndsetw", multiple_dset_write, NULL,
-	    "multiple datasets write", &ndsets_params);
+        "multiple datasets write", &ndsets_params);
 
     ngroups_params.name = PARATESTFILE;
     ngroups_params.count = ngroups;
     AddTest("ngrpw", multiple_group_write, NULL,
-	    "multiple groups write", &ngroups_params);
+        "multiple groups write", &ngroups_params);
     AddTest("ngrpr", multiple_group_read, NULL,
-	    "multiple groups read", &ngroups_params);
+        "multiple groups read", &ngroups_params);
 
     AddTest("compact", compact_dataset, NULL,
-	    "compact dataset test", PARATESTFILE);
+        "compact dataset test", PARATESTFILE);
 
     collngroups_params.name = PARATESTFILE;
     collngroups_params.count = ngroups;
-    AddTest("cngrpw", collective_group_write, NULL,
-	    "collective group and dataset write", &collngroups_params);
-    AddTest("ingrpr", independent_group_read, NULL,
-	    "independent group and dataset read", &collngroups_params);
+    /* combined cngrpw and ingrpr tests because ingrpr reads file created by cngrpw. */
+    AddTest("cngrpw-ingrpr", collective_group_write_independent_group_read, NULL,
+            "collective grp/dset write - independent grp/dset read",
+            &collngroups_params);
 #ifndef H5_HAVE_WIN32_API
     AddTest("bigdset", big_dataset, NULL,
             "big dataset test", PARATESTFILE);
@@ -420,71 +420,71 @@ int main(int argc, char **argv)
     printf("big dataset test will be skipped on Windows (JIRA HDDFV-8064)\n");
 #endif
     AddTest("fill", dataset_fillvalue, NULL,
-	    "dataset fill value", PARATESTFILE);
+        "dataset fill value", PARATESTFILE);
 
     AddTest("cchunk1",
-	coll_chunk1,NULL, "simple collective chunk io",PARATESTFILE);
+    coll_chunk1,NULL, "simple collective chunk io",PARATESTFILE);
     AddTest("cchunk2",
-	coll_chunk2,NULL, "noncontiguous collective chunk io",PARATESTFILE);
+    coll_chunk2,NULL, "noncontiguous collective chunk io",PARATESTFILE);
     AddTest("cchunk3",
-	coll_chunk3,NULL, "multi-chunk collective chunk io",PARATESTFILE);
+    coll_chunk3,NULL, "multi-chunk collective chunk io",PARATESTFILE);
     AddTest("cchunk4",
         coll_chunk4,NULL, "collective chunk io with partial non-selection ",PARATESTFILE);
 
     if((mpi_size < 3)&& MAINPROCESS ) {
-	printf("Collective chunk IO optimization APIs ");
-	printf("needs at least 3 processes to participate\n");
-	printf("Collective chunk IO API tests will be skipped \n");
+    printf("Collective chunk IO optimization APIs ");
+    printf("needs at least 3 processes to participate\n");
+    printf("Collective chunk IO API tests will be skipped \n");
     }
     AddTest((mpi_size <3)? "-cchunk5":"cchunk5" ,
         coll_chunk5,NULL,
-	"linked chunk collective IO without optimization",PARATESTFILE);
+    "linked chunk collective IO without optimization",PARATESTFILE);
     AddTest((mpi_size < 3)? "-cchunk6" : "cchunk6",
-	coll_chunk6,NULL,
-	"multi-chunk collective IO with direct request",PARATESTFILE);
+    coll_chunk6,NULL,
+    "multi-chunk collective IO with direct request",PARATESTFILE);
     AddTest((mpi_size < 3)? "-cchunk7" : "cchunk7",
-	coll_chunk7,NULL,
-	"linked chunk collective IO with optimization",PARATESTFILE);
+    coll_chunk7,NULL,
+    "linked chunk collective IO with optimization",PARATESTFILE);
     AddTest((mpi_size < 3)? "-cchunk8" : "cchunk8",
-	coll_chunk8,NULL,
-	"linked chunk collective IO transferring to multi-chunk",PARATESTFILE);
+    coll_chunk8,NULL,
+    "linked chunk collective IO transferring to multi-chunk",PARATESTFILE);
     AddTest((mpi_size < 3)? "-cchunk9" : "cchunk9",
-	coll_chunk9,NULL,
-	"multiple chunk collective IO with optimization",PARATESTFILE);
+    coll_chunk9,NULL,
+    "multiple chunk collective IO with optimization",PARATESTFILE);
     AddTest((mpi_size < 3)? "-cchunk10" : "cchunk10",
-	coll_chunk10,NULL,
-	"multiple chunk collective IO transferring to independent IO",PARATESTFILE);
+    coll_chunk10,NULL,
+    "multiple chunk collective IO transferring to independent IO",PARATESTFILE);
 
 
 
 /* irregular collective IO tests*/
     AddTest("ccontw",
-	coll_irregular_cont_write,NULL,
-	"collective irregular contiguous write",PARATESTFILE);
+    coll_irregular_cont_write,NULL,
+    "collective irregular contiguous write",PARATESTFILE);
     AddTest("ccontr",
-	coll_irregular_cont_read,NULL,
-	"collective irregular contiguous read",PARATESTFILE);
+    coll_irregular_cont_read,NULL,
+    "collective irregular contiguous read",PARATESTFILE);
     AddTest("cschunkw",
-	coll_irregular_simple_chunk_write,NULL,
-	"collective irregular simple chunk write",PARATESTFILE);
+    coll_irregular_simple_chunk_write,NULL,
+    "collective irregular simple chunk write",PARATESTFILE);
     AddTest("cschunkr",
-	coll_irregular_simple_chunk_read,NULL,
-	"collective irregular simple chunk read",PARATESTFILE);
+    coll_irregular_simple_chunk_read,NULL,
+    "collective irregular simple chunk read",PARATESTFILE);
     AddTest("ccchunkw",
-	coll_irregular_complex_chunk_write,NULL,
-	"collective irregular complex chunk write",PARATESTFILE);
+    coll_irregular_complex_chunk_write,NULL,
+    "collective irregular complex chunk write",PARATESTFILE);
     AddTest("ccchunkr",
-	coll_irregular_complex_chunk_read,NULL,
-	"collective irregular complex chunk read",PARATESTFILE);
+    coll_irregular_complex_chunk_read,NULL,
+    "collective irregular complex chunk read",PARATESTFILE);
 
     AddTest("null", null_dataset, NULL,
-	    "null dataset test", PARATESTFILE);
+        "null dataset test", PARATESTFILE);
 
     io_mode_confusion_params.name  = PARATESTFILE;
     io_mode_confusion_params.count = 0; /* value not used */
 
     AddTest("I/Omodeconf", io_mode_confusion, NULL,
-	    "I/O mode confusion test -- hangs quickly on failure",
+        "I/O mode confusion test -- hangs quickly on failure",
             &io_mode_confusion_params);
 
     if((mpi_size < 3) && MAINPROCESS) {
@@ -506,12 +506,12 @@ int main(int argc, char **argv)
 
     AddTest("tldsc",
             lower_dim_size_comp_test, NULL,
-            "test lower dim size comp in span tree to mpi derived type", 
+            "test lower dim size comp in span tree to mpi derived type",
             PARATESTFILE);
 
     AddTest("lccio",
             link_chunk_collective_io_test, NULL,
-            "test mpi derived type management", 
+            "test mpi derived type management",
             PARATESTFILE);
 
     AddTest("actualio", actual_io_mode_tests, NULL,
@@ -523,7 +523,7 @@ int main(int argc, char **argv)
             PARATESTFILE);
 
     AddTest("edpl", test_plist_ed, NULL,
-	    "encode/decode Property Lists", NULL);
+        "encode/decode Property Lists", NULL);
 
     if((mpi_size < 2) && MAINPROCESS) {
         printf("File Image Ops daisy chain test needs at least 2 processes.\n");
@@ -533,11 +533,11 @@ int main(int argc, char **argv)
             "file image ops daisy chain", NULL);
 
     if((mpi_size < 2)&& MAINPROCESS ) {
-	printf("Atomicity tests need at least 2 processes to participate\n");
-	printf("8 is more recommended.. Atomicity tests will be skipped \n");
+    printf("Atomicity tests need at least 2 processes to participate\n");
+    printf("8 is more recommended.. Atomicity tests will be skipped \n");
     }
     else if (facc_type != FACC_MPIO && MAINPROCESS) {
-	printf("Atomicity tests will not work with a non MPIO VFD\n");        
+    printf("Atomicity tests will not work with a non MPIO VFD\n");
     }
     else if(mpi_size >= 2 && facc_type == FACC_MPIO){
         AddTest("atomicity", dataset_atomicity, NULL,
@@ -545,13 +545,13 @@ int main(int argc, char **argv)
     }
 
     AddTest("denseattr", test_dense_attr, NULL,
-	    "Store Dense Attributes", PARATESTFILE);
+        "Store Dense Attributes", PARATESTFILE);
 
     AddTest("noselcollmdread", test_partial_no_selection_coll_md_read, NULL,
             "Collective Metadata read with some ranks having no selection", PARATESTFILE);
-    AddTest("MC coll MD read", test_multi_chunk_io_addrmap_issue, NULL,
+    AddTest("MC_coll_MD_read", test_multi_chunk_io_addrmap_issue, NULL,
             "Collective MD read with multi chunk I/O (H5D__chunk_addrmap)", PARATESTFILE);
-    AddTest("LC coll MD read", test_link_chunk_io_sort_chunk_issue, NULL,
+    AddTest("LC_coll_MD_read", test_link_chunk_io_sort_chunk_issue, NULL,
             "Collective MD read with link chunk I/O (H5D__sort_chunk)", PARATESTFILE);
 
     /* Display testing information */
@@ -565,9 +565,9 @@ int main(int argc, char **argv)
     TestParseCmdLine(argc, argv);
 
     if (dxfer_coll_type == DXFER_INDEPENDENT_IO && MAINPROCESS){
-	printf("===================================\n"
-	       "   Using Independent I/O with file set view to replace collective I/O \n"
-	       "===================================\n");
+    printf("===================================\n"
+        "   Using Independent I/O with file set view to replace collective I/O \n"
+        "===================================\n");
     }
 
 
@@ -592,16 +592,16 @@ int main(int argc, char **argv)
     {
         int temp;
         MPI_Allreduce(&nerrors, &temp, 1, MPI_INT, MPI_MAX, MPI_COMM_WORLD);
-	nerrors=temp;
+    nerrors=temp;
     }
 
-    if (MAINPROCESS){		/* only process 0 reports */
-	printf("===================================\n");
-	if (nerrors)
-	    printf("***PHDF5 tests detected %d errors***\n", nerrors);
-	else
-	    printf("PHDF5 tests finished with no errors\n");
-	printf("===================================\n");
+    if (MAINPROCESS){        /* only process 0 reports */
+    printf("===================================\n");
+    if (nerrors)
+        printf("***PHDF5 tests detected %d errors***\n", nerrors);
+    else
+        printf("PHDF5 tests finished with no errors\n");
+    printf("===================================\n");
     }
 
     /* close HDF5 library */
diff --git a/testpar/testphdf5.h b/testpar/testphdf5.h
index 4409221..9fece12 100644
--- a/testpar/testphdf5.h
+++ b/testpar/testphdf5.h
@@ -240,6 +240,7 @@ void test_file_properties(void);
 void multiple_dset_write(void);
 void multiple_group_write(void);
 void multiple_group_read(void);
+void collective_group_write_independent_group_read(void);
 void collective_group_write(void);
 void independent_group_read(void);
 void test_fapl_mpio_dup(void);