[svn-r21363] files from HDF5-33 review - all changes ran correctly in trunk. Changes have been tested in cmake branch.

Tested: local linux

3 files changed, 821 insertions, 821 deletions

diff --git a/testpar/t_chunk_alloc.c b/testpar/t_chunk_alloc.c
index bb13d4e..43b45af 100644
--- a/testpar/t_chunk_alloc.c
+++ b/testpar/t_chunk_alloc.c
@@ -22,27 +22,27 @@
  */
 
 #include "testphdf5.h"
-static int	mpi_size, mpi_rank;
+static int  mpi_size, mpi_rank;
 
 #define DSET_NAME "ExtendibleArray"
-#define CHUNK_SIZE	1000		/* #elements per chunk */
-#define CHUNK_FACTOR	200     /* default dataset size in terms of chunks */
+#define CHUNK_SIZE  1000    /* #elements per chunk */
+#define CHUNK_FACTOR  200     /* default dataset size in terms of chunks */
 #define CLOSE           1
 #define NO_CLOSE        0
 
 static MPI_Offset
 get_filesize(const char *filename)
 {
-    int		mpierr;
-    MPI_File	fd;
-    MPI_Offset	filesize;
+    int    mpierr;
+    MPI_File  fd;
+    MPI_Offset  filesize;
 #ifndef H5_HAVE_MPI_GET_SIZE
-    struct stat stat_buf;
+    h5_stat_t stat_buf;
 #endif
 
 #ifdef H5_HAVE_MPI_GET_SIZE
     mpierr = MPI_File_open(MPI_COMM_SELF, (char*)filename, MPI_MODE_RDONLY,
-	MPI_INFO_NULL, &fd);
+  MPI_INFO_NULL, &fd);
     VRFY((mpierr == MPI_SUCCESS), "");
 
     mpierr = MPI_File_get_size(fd, &filesize);
@@ -54,7 +54,7 @@ get_filesize(const char *filename)
     /* Some systems (only SGI Altix Propack 4 so far) doesn't return correct
      * file size for MPI_File_get_size.  Use stat instead.
      */
-    if((mpierr=stat(filename, &stat_buf))<0)
+    if((mpierr=HDstat(filename, &stat_buf))<0)
     VRFY((mpierr == MPI_SUCCESS), "");
 
     /* Hopefully this casting is safe */
@@ -101,8 +101,8 @@ create_chunked_dataset(const char *filename, int chunk_factor, write_type write_
     long         nchunks;
     herr_t       hrc;
 
-    MPI_Offset  filesize,	    /* actual file size */
-		est_filesize;	    /* estimated file size */
+    MPI_Offset  filesize,      /* actual file size */
+    est_filesize;      /* estimated file size */
 
     /* set up MPI parameters */
     MPI_Comm_size(MPI_COMM_WORLD,&mpi_size);
@@ -111,34 +111,34 @@ create_chunked_dataset(const char *filename, int chunk_factor, write_type write_
     /* Only MAINPROCESS should create the file.  Others just wait. */
     if (MAINPROCESS){
         nchunks=chunk_factor*mpi_size;
-	dims[0]=nchunks*CHUNK_SIZE;
-	/* Create the data space with unlimited dimensions. */
-	dataspace = H5Screate_simple (1, dims, maxdims);
-	VRFY((dataspace >= 0), "");
+  dims[0]=nchunks*CHUNK_SIZE;
+  /* Create the data space with unlimited dimensions. */
+  dataspace = H5Screate_simple (1, dims, maxdims);
+  VRFY((dataspace >= 0), "");
 
-	memspace = H5Screate_simple(1, chunk_dims, NULL);
-	VRFY((memspace >= 0), "");
+  memspace = H5Screate_simple(1, chunk_dims, NULL);
+  VRFY((memspace >= 0), "");
 
-	/* Create a new file. If file exists its contents will be overwritten. */
-	file_id = H5Fcreate(h5_rmprefix(filename), H5F_ACC_TRUNC, H5P_DEFAULT,
-		    H5P_DEFAULT);
-	VRFY((file_id >= 0), "H5Fcreate");
+  /* Create a new file. If file exists its contents will be overwritten. */
+  file_id = H5Fcreate(h5_rmprefix(filename), H5F_ACC_TRUNC, H5P_DEFAULT,
+        H5P_DEFAULT);
+  VRFY((file_id >= 0), "H5Fcreate");
 
-	/* Modify dataset creation properties, i.e. enable chunking  */
-	cparms = H5Pcreate(H5P_DATASET_CREATE);
-	VRFY((cparms >= 0), "");
+  /* Modify dataset creation properties, i.e. enable chunking  */
+  cparms = H5Pcreate(H5P_DATASET_CREATE);
+  VRFY((cparms >= 0), "");
 
-	hrc = H5Pset_alloc_time(cparms, H5D_ALLOC_TIME_EARLY);
-	VRFY((hrc >= 0), "");
+  hrc = H5Pset_alloc_time(cparms, H5D_ALLOC_TIME_EARLY);
+  VRFY((hrc >= 0), "");
 
-	hrc = H5Pset_chunk(cparms, 1, chunk_dims);
-	VRFY((hrc >= 0), "");
+  hrc = H5Pset_chunk(cparms, 1, chunk_dims);
+  VRFY((hrc >= 0), "");
 
-	/* Create a new dataset within the file using cparms creation properties. */
-	dataset = H5Dcreate2(file_id, DSET_NAME, H5T_NATIVE_UCHAR, dataspace, H5P_DEFAULT, cparms, H5P_DEFAULT);
-	VRFY((dataset >= 0), "");
+  /* Create a new dataset within the file using cparms creation properties. */
+  dataset = H5Dcreate2(file_id, DSET_NAME, H5T_NATIVE_UCHAR, dataspace, H5P_DEFAULT, cparms, H5P_DEFAULT);
+  VRFY((dataset >= 0), "");
 
-	if(write_pattern == sec_last) {
+  if(write_pattern == sec_last) {
             HDmemset(buffer, 100, CHUNK_SIZE);
 
             count[0] = 1;
@@ -154,28 +154,28 @@ create_chunked_dataset(const char *filename, int chunk_factor, write_type write_
             VRFY((hrc >= 0), "H5Dwrite");
         } /* end if */
 
-	/* Close resources */
-	hrc = H5Dclose (dataset);
-	VRFY((hrc >= 0), "");
-	dataset = -1;
+  /* Close resources */
+  hrc = H5Dclose (dataset);
+  VRFY((hrc >= 0), "");
+  dataset = -1;
 
-	hrc = H5Sclose (dataspace);
-	VRFY((hrc >= 0), "");
+  hrc = H5Sclose (dataspace);
+  VRFY((hrc >= 0), "");
 
-	hrc = H5Sclose (memspace);
-	VRFY((hrc >= 0), "");
+  hrc = H5Sclose (memspace);
+  VRFY((hrc >= 0), "");
 
-	hrc = H5Pclose (cparms);
-	VRFY((hrc >= 0), "");
+  hrc = H5Pclose (cparms);
+  VRFY((hrc >= 0), "");
 
-	hrc = H5Fclose (file_id);
-	VRFY((hrc >= 0), "");
-	file_id = -1;
+  hrc = H5Fclose (file_id);
+  VRFY((hrc >= 0), "");
+  file_id = -1;
 
-	/* verify file size */
-	filesize = get_filesize(filename);
-	est_filesize = nchunks * CHUNK_SIZE * sizeof(unsigned char);
-	VRFY((filesize >= est_filesize), "file size check");
+  /* verify file size */
+  filesize = get_filesize(filename);
+  est_filesize = nchunks * CHUNK_SIZE * sizeof(unsigned char);
+  VRFY((filesize >= est_filesize), "file size check");
 
     }
 
@@ -216,8 +216,8 @@ parallel_access_dataset(const char *filename, int chunk_factor, access_type acti
     int         i;
     long        nchunks;
     /* MPI Gubbins */
-    MPI_Offset  filesize,	    /* actual file size */
-		est_filesize;	    /* estimated file size */
+    MPI_Offset  filesize,      /* actual file size */
+    est_filesize;      /* estimated file size */
 
     /* Initialize MPI */
     MPI_Comm_size(MPI_COMM_WORLD,&mpi_size);
@@ -257,19 +257,19 @@ parallel_access_dataset(const char *filename, int chunk_factor, access_type acti
         /* all chunks are written by all the processes in an interleaved way*/
         case write_all:
 
-	    memset(buffer, mpi_rank+1, CHUNK_SIZE);
-	    count[0] = 1;
-	    stride[0] = 1;
-	    block[0] = chunk_dims[0];
+      memset(buffer, mpi_rank+1, CHUNK_SIZE);
+      count[0] = 1;
+      stride[0] = 1;
+      block[0] = chunk_dims[0];
             for (i=0; i<nchunks/mpi_size; i++){
-		    offset[0] = (i*mpi_size+mpi_rank)*chunk_dims[0];
+        offset[0] = (i*mpi_size+mpi_rank)*chunk_dims[0];
 
-		    hrc = H5Sselect_hyperslab(dataspace, H5S_SELECT_SET, offset, stride, count, block);
-		    VRFY((hrc >= 0), "");
+        hrc = H5Sselect_hyperslab(dataspace, H5S_SELECT_SET, offset, stride, count, block);
+        VRFY((hrc >= 0), "");
 
-		    /* Write the buffer out */
-		    hrc = H5Dwrite(*dataset, H5T_NATIVE_UCHAR, memspace, dataspace, H5P_DEFAULT, buffer);
-		    VRFY((hrc >= 0), "H5Dwrite");
+        /* Write the buffer out */
+        hrc = H5Dwrite(*dataset, H5T_NATIVE_UCHAR, memspace, dataspace, H5P_DEFAULT, buffer);
+        VRFY((hrc >= 0), "H5Dwrite");
             }
 
             break;
@@ -386,8 +386,8 @@ verify_data(const char *filename, int chunk_factor, write_type write_pattern, in
     stride[0] = 1;
     block[0] = chunk_dims[0];
     for (i=0; i<nchunks; i++){
-	/* reset buffer values */
-	memset(buffer, -1, CHUNK_SIZE);
+  /* reset buffer values */
+  memset(buffer, -1, CHUNK_SIZE);
 
         offset[0] = i*chunk_dims[0];
 
@@ -399,19 +399,19 @@ verify_data(const char *filename, int chunk_factor, write_type write_pattern, in
         VRFY((hrc >= 0), "H5Dread");
 
         /* set expected value according the write pattern */
-	switch (write_pattern) {
-	    case all:
-		value = i%mpi_size + 1;
-		break;
-	    case none:
-		value = 0;
-		break;
+  switch (write_pattern) {
+      case all:
+    value = i%mpi_size + 1;
+    break;
+      case none:
+    value = 0;
+    break;
             case sec_last:
-		if (i==nchunks-2)
-		    value = 100;
-		else
-		    value = 0;
-	}
+    if (i==nchunks-2)
+        value = 100;
+    else
+        value = 0;
+  }
 
         /* verify content of the chunk */
         for (index = 0; index < CHUNK_SIZE; index++)
@@ -419,10 +419,10 @@ verify_data(const char *filename, int chunk_factor, write_type write_pattern, in
     }
 
     hrc = H5Sclose (dataspace);
-	VRFY((hrc >= 0), "");
+  VRFY((hrc >= 0), "");
 
-	hrc = H5Sclose (memspace);
-	VRFY((hrc >= 0), "");
+  hrc = H5Sclose (memspace);
+  VRFY((hrc >= 0), "");
 
     /* Can close some plists */
     hrc = H5Pclose(access_plist);
@@ -480,7 +480,7 @@ test_chunk_alloc(void)
 
     filename = GetTestParameters();
     if (VERBOSE_MED)
-	printf("Extend Chunked allocation test on file %s\n", filename);
+  printf("Extend Chunked allocation test on file %s\n", filename);
 
     /* Case 1 */
     /* Create chunked dataset without writing anything.*/
diff --git a/testpar/t_mpi.c b/testpar/t_mpi.c
index c3e04de..7f3fe17 100644
--- a/testpar/t_mpi.c
+++ b/testpar/t_mpi.c
@@ -31,11 +31,11 @@
 
 /* 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 */
+      "MPItest",
+      NULL};
+char  filenames[2][200];
+int  nerrors = 0;
+hid_t  fapl;        /* file access property list */
 
 /* protocols */
 static int errors_sum(int nerrs);
@@ -49,10 +49,10 @@ test_mpio_overlap_writes(char *filename)
     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;
@@ -60,8 +60,8 @@ test_mpio_overlap_writes(char *filename)
 
 
     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 */
@@ -70,10 +70,10 @@ test_mpio_overlap_writes(char *filename)
 
     /* 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 */
@@ -82,85 +82,85 @@ test_mpio_overlap_writes(char *filename)
     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");
+  /* 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");
+  /* 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");
     }
 
     /*
@@ -194,19 +194,19 @@ 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 */
+    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;
-    struct stat stat_buf;
+    h5_stat_t stat_buf;
     int is_signed, sizeof_mpi_offset;
 
     nerrs = 0;
@@ -226,159 +226,159 @@ test_mpio_gb_file(char *filename)
      * 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");
-	    }
-	}
+    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.
      */
     if (VERBOSE_MED)
-	printf("MPIO GB file test %s\n", filename);
+  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");
+  printf("Skipped GB file range test "
+    "because MPI_Offset cannot support it\n");
     }else{
-	buf = malloc(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");
+  buf = malloc(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");
 
         /*
          * Check if MPI_File_get_size works correctly.  Some systems (only SGI Altix
@@ -386,17 +386,17 @@ test_mpio_gb_file(char *filename)
          * with "--disable-mpi-size".
          */
 #ifdef H5_HAVE_MPI_GET_SIZE
-	printf("Test if MPI_File_get_size works correctly with %s\n", filename);
+  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);
+  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((mrc==MPI_SUCCESS), "");
 
-            mrc=stat(filename, &stat_buf);
-	    VRFY((mrc==0), "");
+            mrc=HDstat(filename, &stat_buf);
+      VRFY((mrc==0), "");
 
             /* Hopefully this casting is safe */
             if(size != (MPI_Offset)(stat_buf.st_size)) {
@@ -404,16 +404,16 @@ test_mpio_gb_file(char *filename)
             }
         }
 
-	/* 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");
 #else
         printf("Skipped testing MPI_File_get_size because it's disabled\n");
 #endif
@@ -421,7 +421,7 @@ test_mpio_gb_file(char *filename)
 
 finish:
     if (buf)
-	HDfree(buf);
+  HDfree(buf);
     return (nerrs);
 }
 
@@ -443,11 +443,11 @@ 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
@@ -462,7 +462,7 @@ test_mpio_1wMr(char *filename, int special_request)
     unsigned char writedata[DIMSIZE], readdata[DIMSIZE];
     unsigned char expect_val;
     int  i, irank;
-    int  nerrs = 0;		/* number of errors */
+    int  nerrs = 0;    /* number of errors */
     int  atomicity;
     MPI_Offset  mpi_off;
     MPI_Status  mpi_stat;
@@ -472,35 +472,35 @@ test_mpio_1wMr(char *filename, int special_request)
 
     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 (gethostname(hostname, 128) < 0){
+      PRINTID;
+      printf("gethostname failed\n");
+      return 1;
+  }
+  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){
@@ -509,31 +509,31 @@ if (special_request & USEATOM){
      * 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);
+  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);
+  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);
+  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);
+  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);
+  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");
+  PRINTID;
+  printf("between MPI_Barrier and MPI_File_write_at\n");
     }
 
     /* ==================================================
@@ -542,31 +542,31 @@ if (special_request & USEATOM){
      * ==================================================*/
     irank=0;
     for (i=0; i < DIMSIZE; i++)
-	writedata[i] = irank*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 (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);
+  PRINTID;
+  printf("MPI_Bcast: mpi_err = %d\n", mpi_err);
     }
 
 if (special_request & USEFSYNC){
@@ -575,19 +575,19 @@ if (special_request & USEFSYNC){
      * should not need this.
      * ==================================================*/
     if (VERBOSE_HI)
-	printf("Apply MPI_File_sync\n");
+  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_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);
+  MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
+  PRINTID;
+  printf("MPI_File_sync failed (%s)\n", mpi_err_str);
     }
 }
 
@@ -595,8 +595,8 @@ if (special_request & USEFSYNC){
     /* should take care of it.  Do it anyway. */
     MPI_Barrier(MPI_COMM_WORLD);
     if (VERBOSE_HI){
-	PRINTID;
-	printf("after MPI_Barrier\n");
+  PRINTID;
+  printf("after MPI_Barrier\n");
     }
 
     /* ==================================================
@@ -605,29 +605,29 @@ if (special_request & USEFSYNC){
     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++;
-	}
+  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);
+  PRINTID;
+  printf("%d data errors detected\n", nerrs);
     }
 
     mpi_err = MPI_Barrier(MPI_COMM_WORLD);
@@ -645,18 +645,18 @@ and this platform.
 1. Details for the test:
 1) Create two derived datatypes with MPI_Type_hindexed:
         datatype1:
-	count = 1, blocklens = 1, offsets = 0,
-	base type = MPI_BYTE(essentially a char)
+  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
+  count = 1, blocklens = 1, offsets = 1(byte),
+  base type = MPI_BYTE
 
 2) Using these two derived datatypes,
    Build another derived datatype with MPI_Type_struct:
         advtype: derived from datatype1 and datatype2
         advtype:
-	count = 2, blocklens[0] = 1, blocklens[1]=1,
-	offsets[0] = 0, offsets[1] = 1(byte),
+  count = 2, blocklens[0] = 1, blocklens[1]=1,
+  offsets[0] = 0, offsets[1] = 1(byte),
         bas_type[0]=datatype1,
         bas_type[1] = datatype2;
 
@@ -695,7 +695,7 @@ static int test_mpio_derived_dtype(char *filename) {
     int  mpi_err_strlen;
     int  mpi_err;
     int  i;
-    int  nerrors = 0;		/* number of errors */
+    int  nerrors = 0;    /* number of errors */
     MPI_Datatype  etype,filetype;
     MPI_Datatype  adv_filetype,bas_filetype[2];
     MPI_Datatype  etypenew, filetypenew;
@@ -719,12 +719,12 @@ static int test_mpio_derived_dtype(char *filename) {
 
 
     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;
@@ -736,15 +736,15 @@ static int test_mpio_derived_dtype(char *filename) {
 
     if((mpi_err= MPI_Type_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;
+        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){
         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;
@@ -752,15 +752,15 @@ static int test_mpio_derived_dtype(char *filename) {
     offsets[0] = 1;
     if((mpi_err= MPI_Type_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;
+        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){
         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;
@@ -773,48 +773,48 @@ static int test_mpio_derived_dtype(char *filename) {
 
     if((mpi_err= MPI_Type_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_struct failed (%s)\n", mpi_err_str);
-	return 1;
+        MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
+  printf("MPI_Type_struct failed (%s)\n", mpi_err_str);
+  return 1;
     }
     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;
+  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){
         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;
+  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;
+  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){
         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);
@@ -837,36 +837,36 @@ static int test_mpio_derived_dtype(char *filename) {
 
     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;
+  printf("MPI_File_close failed (%s)\n", mpi_err_str);
+  return 1;
     }
 
 
     mpi_err = MPI_Barrier(MPI_COMM_WORLD);
 #ifdef H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS
     if(retcode == -1) {
-	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 (for example, powerpc-ibm-aix5.x) and add\n");
-	    printf("hdf5_cv_mpi_complex_derived_datatype_works=${hdf5_cv_mpi_complex_derived_datatype-works='no'}\n");
-	    printf(" at the end of the file.\n");
-	    printf(" Please report to hdfhelp@ncsa.uiuc.edu about this problem.\n");
-	}
-	retcode = 1;
+  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 (for example, powerpc-ibm-aix5.x) and add\n");
+      printf("hdf5_cv_mpi_complex_derived_datatype_works=${hdf5_cv_mpi_complex_derived_datatype-works='no'}\n");
+      printf(" at the end of the file.\n");
+      printf(" Please report to hdfhelp@ncsa.uiuc.edu about this problem.\n");
+  }
+  retcode = 1;
     }
 #else
     if(retcode == 0) {
-	if(mpi_rank == 0) {
-	    printf(" This is NOT an error, What it really says is\n");
-	    printf("Complicated derived datatype is WORKING at this platform\n");
-	    printf(" Go back to hdf5/config and find the corresponding \n");
-	    printf(" configure-specific file (for example, powerpc-ibm-aix5.x) and delete the line\n");
-	    printf("hdf5_cv_mpi_complex_derived_datatype_works=${hdf5_cv_mpi_complex_derived_datatype-works='no'}\n");
-	    printf(" at the end of the file.\n");
-	    printf("Please report to hdfhelp@ncsa.uiuc.edu about this problem.\n");
-	}
-	retcode = 1;
+  if(mpi_rank == 0) {
+      printf(" This is NOT an error, What it really says is\n");
+      printf("Complicated derived datatype is WORKING at this platform\n");
+      printf(" Go back to hdf5/config and find the corresponding \n");
+      printf(" configure-specific file (for example, powerpc-ibm-aix5.x) and delete the line\n");
+      printf("hdf5_cv_mpi_complex_derived_datatype_works=${hdf5_cv_mpi_complex_derived_datatype-works='no'}\n");
+      printf(" at the end of the file.\n");
+      printf("Please report to hdfhelp@ncsa.uiuc.edu about this problem.\n");
+  }
+  retcode = 1;
     }
     if(retcode == -1) retcode = 0;
 #endif
@@ -940,29 +940,29 @@ test_mpio_special_collective(char *filename)
     if(count !=0) {
       if((mpi_err= MPI_Type_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;
+        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){
         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_Type_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;
+        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(&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;
+  printf("MPI_Type_commit failed (%s)\n", mpi_err_str);
+  return 1;
       }
      }
      else {
@@ -973,69 +973,69 @@ test_mpio_special_collective(char *filename)
 
    /* 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){
-	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;
     }
 
     /* each process writes some data */
     for (i=0; i < 2*DIMSIZE; i++)
-	writedata[i] = mpi_rank*DIMSIZE + i;
+  writedata[i] = mpi_rank*DIMSIZE + i;
 
 
      mpi_off = 0;
     if((mpi_err = MPI_File_set_view(fh, mpi_off, MPI_BYTE, 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;
+  MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
+  printf("MPI_File_set_view failed (%s)\n", mpi_err_str);
+  return 1;
     }
 
     buf   = writedata;
     if ((mpi_err = MPI_File_write_at_all(fh, mpi_off, buf, 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);
-	return 1;
+      &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);
+  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. \n");
-	return 1;
+      != MPI_SUCCESS){
+  MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
+  printf("MPI_File_close failed. \n");
+  return 1;
     };
 
     mpi_err = MPI_Barrier(MPI_COMM_WORLD);
 #ifdef H5_MPI_SPECIAL_COLLECTIVE_IO_WORKS
     if(retcode != 0) {
-	if(mpi_rank == 0) {
-	    printf("special collective IO is NOT working at this platform\n");
-	    printf("Go back to hdf5/config and find the corresponding\n");
-	    printf("configure-specific file (for example, powerpc-ibm-aix5.x) and add\n");
-	    printf("hdf5_cv_mpi_special_collective_io_works=${hdf5_cv_mpi_special_collective_io_works='no'}\n");
-	    printf(" at the end of the file.\n");
-	    printf(" Please report to hdfhelp@ncsa.uiuc.edu about this problem.\n");
-	}
-	retcode = 1;
+  if(mpi_rank == 0) {
+      printf("special collective IO is NOT working at this platform\n");
+      printf("Go back to hdf5/config and find the corresponding\n");
+      printf("configure-specific file (for example, powerpc-ibm-aix5.x) and add\n");
+      printf("hdf5_cv_mpi_special_collective_io_works=${hdf5_cv_mpi_special_collective_io_works='no'}\n");
+      printf(" at the end of the file.\n");
+      printf(" Please report to hdfhelp@ncsa.uiuc.edu about this problem.\n");
+  }
+  retcode = 1;
     }
 #else
     if(retcode == 0) {
-	if(mpi_rank == 0) {
-	    printf(" This is NOT an error, What it really says is\n");
-	    printf("special collective IO is WORKING at this platform\n");
-	    printf(" Go back to hdf5/config and find the corresponding \n");
-	    printf(" configure-specific file (for example, powerpc-ibm-aix5.x) and delete the line\n");
-	    printf("hdf5_cv_mpi_special_collective_io_works=${hdf5_cv_mpi_special_collective_io_works='no'}\n");
-	    printf(" at the end of the file.\n");
-	    printf("Please report to hdfhelp@ncsa.uiuc.edu about this problem.\n");
-	}
-	retcode = 1;
+  if(mpi_rank == 0) {
+      printf(" This is NOT an error, What it really says is\n");
+      printf("special collective IO is WORKING at this platform\n");
+      printf(" Go back to hdf5/config and find the corresponding \n");
+      printf(" configure-specific file (for example, powerpc-ibm-aix5.x) and delete the line\n");
+      printf("hdf5_cv_mpi_special_collective_io_works=${hdf5_cv_mpi_special_collective_io_works='no'}\n");
+      printf(" at the end of the file.\n");
+      printf("Please report to hdfhelp@ncsa.uiuc.edu about this problem.\n");
+  }
+  retcode = 1;
     }
 #endif
     return retcode;
@@ -1048,55 +1048,55 @@ 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);
-	    }
-	}
+  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);
@@ -1130,7 +1130,7 @@ errors_sum(int nerrs)
 int
 main(int argc, char **argv)
 {
-    int mpi_size, mpi_rank;				/* mpi variables */
+    int mpi_size, mpi_rank;        /* mpi variables */
     int ret_code;
 
     MPI_Init(&argc, &argv);
@@ -1143,23 +1143,23 @@ 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", mpi_rank);
+  printf("Failed to turn off atexit processing. Continue.\n", mpi_rank);
     };
     H5open();
     if (parse_options(argc, argv) != 0){
-	if (MAINPROCESS)
-	    usage();
-	goto finish;
+  if (MAINPROCESS)
+      usage();
+  goto finish;
     }
 
     if (MAINPROCESS){
-	printf("===================================\n");
-	printf("MPI functionality tests\n");
-	printf("===================================\n");
+  printf("===================================\n");
+  printf("MPI functionality tests\n");
+  printf("===================================\n");
     }
 
     if (VERBOSE_MED)
-	h5_show_hostname();
+  h5_show_hostname();
 
     fapl = H5Pcreate (H5P_FILE_ACCESS);
     H5Pset_fapl_mpio(fapl, MPI_COMM_WORLD, MPI_INFO_NULL);
@@ -1175,28 +1175,28 @@ main(int argc, char **argv)
     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;
+  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;
-	}
+  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;
+  }
     }
 
 
@@ -1207,8 +1207,8 @@ main(int argc, char **argv)
     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;
+  printf("***FAILED with %d total errors\n", ret_code);
+  nerrors += ret_code;
     }
 
 
@@ -1219,8 +1219,8 @@ main(int argc, char **argv)
     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;
+  printf("***FAILED with %d total errors\n", ret_code);
+  nerrors += ret_code;
     }
 
     /*=======================================
@@ -1235,17 +1235,17 @@ main(int argc, char **argv)
     ret_code = test_mpio_derived_dtype(filenames[0]);
 #else
     if (VERBOSE_HI){
-	MPI_BANNER("MPIO complicated derived datatype test...");
-	ret_code = test_mpio_derived_dtype(filenames[0]);
+  MPI_BANNER("MPIO complicated derived datatype test...");
+  ret_code = test_mpio_derived_dtype(filenames[0]);
     }else{
-	MPI_BANNER("MPIO complicated derived datatype test SKIPPED.");
-	ret_code = 0;	/* fake ret_code */
+  MPI_BANNER("MPIO complicated derived datatype test SKIPPED.");
+  ret_code = 0;  /* fake ret_code */
     }
 #endif
     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;
+  printf("***FAILED with %d total errors\n", ret_code);
+  nerrors += ret_code;
     }
 
     /*=======================================
@@ -1271,19 +1271,19 @@ main(int argc, char **argv)
 
 #else
     if (VERBOSE_HI){
-	MPI_BANNER("MPIO special collective io test...");
-	ret_code = test_mpio_special_collective(filenames[0]);
+  MPI_BANNER("MPIO special collective io test...");
+  ret_code = test_mpio_special_collective(filenames[0]);
     }else{
-	MPI_BANNER("MPIO special collective io test SKIPPED.");
-	ret_code = 0;	/* fake ret_code */
+  MPI_BANNER("MPIO special collective io test SKIPPED.");
+  ret_code = 0;  /* fake ret_code */
     }
 #endif
 
 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;
+  printf("***FAILED with %d total errors\n", ret_code);
+  nerrors += ret_code;
     }
 
 
@@ -1292,15 +1292,15 @@ finish:
      * 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 */
diff --git a/testpar/testphdf5.c b/testpar/testphdf5.c
index 8b24f87..da5cc97 100644
--- a/testpar/testphdf5.c
+++ b/testpar/testphdf5.c
@@ -28,15 +28,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 */
 
@@ -48,10 +48,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. */
@@ -64,7 +64,7 @@ void pause_proc(void)
 {
 
     int pid;
-    h5_stat_t	statbuf;
+    h5_stat_t  statbuf;
     char greenlight[] = "go";
     int maxloop = 10;
     int loops = 0;
@@ -81,15 +81,15 @@ void pause_proc(void)
     MPI_Get_processor_name(mpi_name, &mpi_namelen);
 
     if (MAINPROCESS)
-	while ((stat(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);
-	    sleep(time_int);
-	}
+  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);
+      sleep(time_int);
+  }
     MPI_Barrier(MPI_COMM_WORLD);
 }
 
@@ -101,7 +101,7 @@ int MPI_Init(int *argc, char ***argv)
     pause_proc();
     return (ret_code);
 }
-#endif	/* USE_PAUSE */
+#endif  /* USE_PAUSE */
 
 
 /*
@@ -111,16 +111,16 @@ 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-p\t\tuse combo MPI-POSIX driver\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");
 }
@@ -132,7 +132,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);
@@ -143,110 +143,110 @@ 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 'p':   /* Use the MPI-POSIX driver access */
-			    facc_type = FACC_MPIPOSIX;
-			    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 'p':   /* Use the MPI-POSIX driver access */
+          facc_type = FACC_MPIPOSIX;
+          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);
@@ -262,7 +262,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);
@@ -271,39 +271,39 @@ 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), "");
-	return(ret_pl);
+  /* set Parallel access with communicator */
+  ret = H5Pset_fapl_mpio(ret_pl, comm, info);
+  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);
     }
 
     if (l_facc_type == FACC_MPIPOSIX) {
-	/* set Parallel access with communicator */
-	ret = H5Pset_fapl_mpiposix(ret_pl, comm, use_gpfs);
-	VRFY((ret >= 0), "H5Pset_fapl_mpiposix succeeded");
-	return(ret_pl);
+  /* set Parallel access with communicator */
+  ret = H5Pset_fapl_mpiposix(ret_pl, comm, use_gpfs);
+  VRFY((ret >= 0), "H5Pset_fapl_mpiposix succeeded");
+  return(ret_pl);
     }
 
     /* unknown file access types */
@@ -313,7 +313,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;
@@ -331,9 +331,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
@@ -342,7 +342,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", mpi_rank);
+  printf("Failed to turn off atexit processing. Continue.\n", mpi_rank);
     };
     H5open();
     h5_show_hostname();
@@ -352,140 +352,140 @@ 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("posixdup", test_fapl_mpiposix_dup, NULL,
-	    "fapl_mpiposix duplicate", NULL);
+      "fapl_mpiposix duplicate", NULL);
 
     AddTest("split", test_split_comm_access, NULL,
-	    "dataset using split communicators", PARATESTFILE);
+      "dataset using split communicators", 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);
+      "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 */
 
     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);
+      "collective group and dataset write", &collngroups_params);
     AddTest("ingrpr", independent_group_read, NULL,
-	    "independent group and dataset read", &collngroups_params);
+      "independent group and dataset read", &collngroups_params);
     AddTest("bigdset", big_dataset, NULL,
             "big dataset test", PARATESTFILE);
     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 without optimization",PARATESTFILE);
+  coll_chunk6,NULL,
+  "multi-chunk collective IO without optimization",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);
 
     rr_obj_flush_confusion_params.name = PARATESTFILE;
     rr_obj_flush_confusion_params.count = 0; /* value not used */
     AddTest("rrobjflushconf", rr_obj_hdr_flush_confusion, NULL,
-	    "round robin object header flush confusion test",
+      "round robin object header flush confusion test",
             &rr_obj_flush_confusion_params);
 
     AddTest("tldsc",
@@ -510,15 +510,15 @@ int main(int argc, char **argv)
     TestParseCmdLine(argc, argv);
 
     if (facc_type == FACC_MPIPOSIX && MAINPROCESS){
-	printf("===================================\n"
-	       "   Using MPIPOSIX driver\n"
-	       "===================================\n");
+  printf("===================================\n"
+         "   Using MPIPOSIX driver\n"
+         "===================================\n");
     }
 
     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");
     }
 
 
@@ -543,16 +543,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 */
     H5close();