Add script and update mostly whitespace

10 files changed, 274 insertions, 293 deletions

diff --git a/testpar/t_coll_chunk.c b/testpar/t_coll_chunk.c
index c6fa3d4..40cc1ca 100644
--- a/testpar/t_coll_chunk.c
+++ b/testpar/t_coll_chunk.c
@@ -1134,7 +1134,7 @@ ccslab_set(int mpi_rank,
 	break;
     }
     if (VERBOSE_MED){
-      printf("start[]=(%lu,%lu), count[]=(%lu,%lu), stride[]=(%lu,%lu), block[]=(%lu,%lu), total datapoints=%lu\n",
+      HDprintf("start[]=(%lu,%lu), count[]=(%lu,%lu), stride[]=(%lu,%lu), block[]=(%lu,%lu), total datapoints=%lu\n",
 	(unsigned long)start[0], (unsigned long)start[1], (unsigned long)count[0], (unsigned long)count[1],
 	(unsigned long)stride[0], (unsigned long)stride[1], (unsigned long)block[0], (unsigned long)block[1],
 	(unsigned long)(block[0]*block[1]*count[0]*count[1]));
@@ -1197,20 +1197,20 @@ ccdataset_print(hsize_t start[],
     hsize_t i, j;
 
     /* print the column heading */
-    printf("Print only the first block of the dataset\n");
-    printf("%-8s", "Cols:");
+    HDprintf("Print only the first block of the dataset\n");
+    HDprintf("%-8s", "Cols:");
     for (j=0; j < block[1]; j++){
-	printf("%3lu ", (unsigned long)(start[1]+j));
+	HDprintf("%3lu ", (unsigned long)(start[1]+j));
     }
-    printf("\n");
+    HDprintf("\n");
 
     /* print the slab data */
     for (i=0; i < block[0]; i++){
-	printf("Row %2lu: ", (unsigned long)(i+start[0]));
+	HDprintf("Row %2lu: ", (unsigned long)(i+start[0]));
 	for (j=0; j < block[1]; j++){
-	    printf("%03d ", *dataptr++);
+	    HDprintf("%03d ", *dataptr++);
 	}
-	printf("\n");
+	HDprintf("\n");
     }
 }
 
@@ -1233,13 +1233,13 @@ ccdataset_vrfy(hsize_t start[],
 
     /* print it if VERBOSE_MED */
     if (VERBOSE_MED) {
-	printf("dataset_vrfy dumping:::\n");
-	printf("start(%lu, %lu), count(%lu, %lu), stride(%lu, %lu), block(%lu, %lu)\n",
+	HDprintf("dataset_vrfy dumping:::\n");
+	HDprintf("start(%lu, %lu), count(%lu, %lu), stride(%lu, %lu), block(%lu, %lu)\n",
 	    (unsigned long)start[0], (unsigned long)start[1], (unsigned long)count[0], (unsigned long)count[1],
 	    (unsigned long)stride[0], (unsigned long)stride[1], (unsigned long)block[0], (unsigned long)block[1]);
-	printf("original values:\n");
+	HDprintf("original values:\n");
 	ccdataset_print(start, block, original);
-	printf("compared values:\n");
+	HDprintf("compared values:\n");
 	ccdataset_print(start, block, dataset);
     }
 
@@ -1262,7 +1262,7 @@ ccdataset_vrfy(hsize_t start[],
                     }
                     if (*dataptr != *oriptr){
                         if (vrfyerrs++ < MAX_ERR_REPORT || VERBOSE_MED){
-                            printf("Dataset Verify failed at [%lu][%lu]: expect %d, got %d\n",
+                            HDprintf("Dataset Verify failed at [%lu][%lu]: expect %d, got %d\n",
                                    (unsigned long)i, (unsigned long)j,
                                    *(oriptr), *(dataptr));
                         }
@@ -1272,8 +1272,8 @@ ccdataset_vrfy(hsize_t start[],
         }
     }
     if (vrfyerrs > MAX_ERR_REPORT && !VERBOSE_MED)
-	printf("[more errors ...]\n");
+	HDprintf("[more errors ...]\n");
     if (vrfyerrs)
-	printf("%d errors found in ccdataset_vrfy\n", vrfyerrs);
+	HDprintf("%d errors found in ccdataset_vrfy\n", vrfyerrs);
     return(vrfyerrs);
 }
diff --git a/testpar/t_file.c b/testpar/t_file.c
index 2d42e10..88801dd 100644
--- a/testpar/t_file.c
+++ b/testpar/t_file.c
@@ -36,15 +36,15 @@ test_split_comm_access(void)
     MPI_Info info = MPI_INFO_NULL;
     int is_old, mrc;
     int newrank, newprocs;
-    hid_t fid;			/* file IDs */
-    hid_t acc_tpl;		/* File access properties */
-    herr_t ret;			/* generic return value */
+    hid_t fid;            /* file IDs */
+    hid_t acc_tpl;        /* File access properties */
+    herr_t ret;            /* generic return value */
     const char *filename;
 
     filename = (const char *)GetTestParameters();
     if (VERBOSE_MED)
-	printf("Split Communicator access test on file %s\n",
-	    filename);
+    HDprintf("Split Communicator access test on file %s\n",
+        filename);
 
     /* set up MPI parameters */
     MPI_Comm_size(MPI_COMM_WORLD,&mpi_size);
@@ -56,35 +56,35 @@ test_split_comm_access(void)
     MPI_Comm_rank(comm,&newrank);
 
     if (is_old){
-	/* odd-rank processes */
-	mrc = MPI_Barrier(comm);
-	VRFY((mrc==MPI_SUCCESS), "");
+    /* odd-rank processes */
+    mrc = MPI_Barrier(comm);
+    VRFY((mrc==MPI_SUCCESS), "");
     }else{
-	/* even-rank processes */
-	int sub_mpi_rank;	/* rank in the sub-comm */
-	MPI_Comm_rank(comm,&sub_mpi_rank);
+    /* even-rank processes */
+    int sub_mpi_rank;    /* rank in the sub-comm */
+    MPI_Comm_rank(comm,&sub_mpi_rank);
 
-	/* setup file access template */
-	acc_tpl = create_faccess_plist(comm, info, facc_type);
-	VRFY((acc_tpl >= 0), "");
+    /* setup file access template */
+    acc_tpl = create_faccess_plist(comm, info, facc_type);
+    VRFY((acc_tpl >= 0), "");
 
-	/* create the file collectively */
-	fid=H5Fcreate(filename,H5F_ACC_TRUNC,H5P_DEFAULT,acc_tpl);
-	VRFY((fid >= 0), "H5Fcreate succeeded");
+    /* create the file collectively */
+    fid=H5Fcreate(filename,H5F_ACC_TRUNC,H5P_DEFAULT,acc_tpl);
+    VRFY((fid >= 0), "H5Fcreate succeeded");
 
-	/* Release file-access template */
-	ret=H5Pclose(acc_tpl);
-	VRFY((ret >= 0), "");
+    /* Release file-access template */
+    ret=H5Pclose(acc_tpl);
+    VRFY((ret >= 0), "");
 
-	/* close the file */
-	ret=H5Fclose(fid);
-	VRFY((ret >= 0), "");
+    /* close the file */
+    ret=H5Fclose(fid);
+    VRFY((ret >= 0), "");
 
-	/* delete the test file */
-	if (sub_mpi_rank == 0){
-	    mrc = MPI_File_delete((char *)filename, info);
-	    /*VRFY((mrc==MPI_SUCCESS), ""); */
-	}
+    /* delete the test file */
+    if (sub_mpi_rank == 0){
+        mrc = MPI_File_delete((char *)filename, info);
+        /*VRFY((mrc==MPI_SUCCESS), ""); */
+    }
     }
     mrc = MPI_Comm_free(&comm);
     VRFY((mrc==MPI_SUCCESS), "MPI_Comm_free succeeded");
diff --git a/testpar/t_filter_read.c b/testpar/t_filter_read.c
index df0e446..3d89c6d 100644
--- a/testpar/t_filter_read.c
+++ b/testpar/t_filter_read.c
@@ -37,9 +37,9 @@ static int mpi_size, mpi_rank;
 #define HS_DIM1       200
 #define HS_DIM2       100
 
-
+
 /*-------------------------------------------------------------------------
- * Function:	filter_read_internal
+ * Function:    filter_read_internal
  *
  * Purpose:     Tests parallel reading of a 2D dataset written serially using
  *              filters. During the parallel reading phase, the dataset is
@@ -54,13 +54,13 @@ static void
 filter_read_internal(const char *filename, hid_t dcpl,
                      hsize_t *dset_size)
 {
-    hid_t		file, dataset;        /* HDF5 IDs */
-    hid_t		access_plist;         /* Access property list ID */
-    hid_t		sid, memspace;            /* Dataspace IDs */
-    hsize_t	        size[2];           /* Dataspace dimensions */
-    hsize_t	        hs_offset[2]; /* Hyperslab offset */
-    hsize_t	        hs_size[2];   /* Hyperslab size */
-    size_t		i, j;        /* Local index variables */
+    hid_t        file, dataset;        /* HDF5 IDs */
+    hid_t        access_plist;         /* Access property list ID */
+    hid_t        sid, memspace;            /* Dataspace IDs */
+    hsize_t            size[2];           /* Dataspace dimensions */
+    hsize_t            hs_offset[2]; /* Hyperslab offset */
+    hsize_t            hs_size[2];   /* Hyperslab size */
+    size_t        i, j;        /* Local index variables */
     char                name[32] = "dataset";
     herr_t              hrc;         /* Error status */
     int                 *points = NULL; /* Writing buffer for entire dataset */
@@ -151,17 +151,17 @@ filter_read_internal(const char *filename, hid_t dcpl,
         for (j=0; j<hs_size[1]; j++) {
             if(points[i*size[1]+(size_t)hs_offset[1]+j] !=
                       check[i*hs_size[1]+j]) {
-		  HDfprintf(stderr,"    Read different values than written.\n");
-		  HDfprintf(stderr,"    At index %lu,%lu\n",
-		         (unsigned long)(i),
-		         (unsigned long)(hs_offset[1]+j));
-		  HDfprintf(stderr,"    At original: %d\n",
-		         (int)points[i*size[1]+(size_t)hs_offset[1]+j]);
-		  HDfprintf(stderr,"    At returned: %d\n",
-		         (int)check[i*hs_size[1]+j]);
+                HDfprintf(stderr,"    Read different values than written.\n");
+                HDfprintf(stderr,"    At index %lu,%lu\n",
+                (unsigned long)(i),
+                (unsigned long)(hs_offset[1]+j));
+                HDfprintf(stderr,"    At original: %d\n",
+                (int)points[i*size[1]+(size_t)hs_offset[1]+j]);
+                HDfprintf(stderr,"    At returned: %d\n",
+                (int)check[i*hs_size[1]+j]);
                   VRFY(FALSE, "");
-	    }
-	}
+        }
+    }
     }
 
     /* Get the storage size of the dataset */
@@ -194,10 +194,10 @@ filter_read_internal(const char *filename, hid_t dcpl,
 /*-------------------------------------------------------------------------
  * Function:    test_filter_read
  *
- * Purpose:	Tests parallel reading of datasets written serially using
+ * Purpose:    Tests parallel reading of datasets written serially using
  *              several (combinations of) filters.
  *
- * Programmer:	Christian Chilan
+ * Programmer:    Christian Chilan
  *              Tuesday, May 15, 2007
  *
  * Modifications:
@@ -208,7 +208,7 @@ filter_read_internal(const char *filename, hid_t dcpl,
 void
 test_filter_read(void)
 {
-    hid_t	dc;                 /* HDF5 IDs */
+    hid_t    dc;                 /* HDF5 IDs */
     const hsize_t chunk_size[2] = {CHUNK_DIM1, CHUNK_DIM2};  /* Chunk dimensions */
     hsize_t     null_size;          /* Size of dataset without filters */
     herr_t      hrc;
@@ -234,7 +234,7 @@ test_filter_read(void)
     filename = GetTestParameters();
 
     if(VERBOSE_MED)
-        printf("Parallel reading of dataset written with filters %s\n", filename);
+        HDprintf("Parallel reading of dataset written with filters %s\n", filename);
 
     /*----------------------------------------------------------
      * STEP 0: Test without filters.
@@ -416,10 +416,10 @@ test_filter_read(void)
 
     /* Make sure encoding is enabled */
     if(h5_szip_can_encode() == 1) {
-	hrc = H5Pset_szip(dc, szip_options_mask, szip_pixels_per_block);
+    hrc = H5Pset_szip(dc, szip_options_mask, szip_pixels_per_block);
         VRFY(hrc>=0, "H5Pset_szip");
 
-	filter_read_internal(filename,dc,&combo_size);
+    filter_read_internal(filename,dc,&combo_size);
     }
 
     /* Clean up objects used for this test */
@@ -429,25 +429,25 @@ test_filter_read(void)
     /* Testing shuffle+szip(with encoder)+checksum filters(checksum last) */
     /* Make sure encoding is enabled */
     if(h5_szip_can_encode() == 1) {
-	dc = H5Pcreate(H5P_DATASET_CREATE);
+    dc = H5Pcreate(H5P_DATASET_CREATE);
         VRFY(dc>=0, "H5Pcreate");
 
-	hrc = H5Pset_chunk (dc, 2, chunk_size);
+    hrc = H5Pset_chunk (dc, 2, chunk_size);
         VRFY(hrc>=0, "H5Pset_chunk");
 
-	hrc = H5Pset_shuffle (dc);
+    hrc = H5Pset_shuffle (dc);
         VRFY(hrc>=0, "H5Pset_shuffle");
 
-	hrc = H5Pset_szip(dc, szip_options_mask, szip_pixels_per_block);
+    hrc = H5Pset_szip(dc, szip_options_mask, szip_pixels_per_block);
         VRFY(hrc>=0, "H5Pset_szip");
 
-	hrc = H5Pset_fletcher32 (dc);
+    hrc = H5Pset_fletcher32 (dc);
         VRFY(hrc>=0, "H5Pset_fletcher32");
 
-	filter_read_internal(filename,dc,&combo_size);
+    filter_read_internal(filename,dc,&combo_size);
 
-	/* Clean up objects used for this test */
-	hrc = H5Pclose (dc);
+    /* Clean up objects used for this test */
+    hrc = H5Pclose (dc);
         VRFY(hrc>=0, "H5Pclose");
     }
 
diff --git a/testpar/t_mdset.c b/testpar/t_mdset.c
index 6b4890d..acada43 100644
--- a/testpar/t_mdset.c
+++ b/testpar/t_mdset.c
@@ -1139,7 +1139,7 @@ create_group_recursive(hid_t memspace, hid_t filespace, hid_t gid, int counter)
 
 #ifdef BARRIER_CHECKS
    if(!((counter+1) % 10)) {
-    HDprintf("created %dth child groups\n", counter+1);
+        HDprintf("created %dth child groups\n", counter+1);
         MPI_Barrier(MPI_COMM_WORLD);
    }
 #endif /* BARRIER_CHECKS */
diff --git a/testpar/t_ph5basic.c b/testpar/t_ph5basic.c
index 574591c..73d262e 100644
--- a/testpar/t_ph5basic.c
+++ b/testpar/t_ph5basic.c
@@ -22,17 +22,15 @@
  * Function:    test_fapl_mpio_dup
  *
  * Purpose:     Test if fapl_mpio property list keeps a duplicate of the
- * 		communicator and INFO objects given when set; and returns
- * 		duplicates of its components when H5Pget_fapl_mpio is called.
+ *              communicator and INFO objects given when set; and returns
+ *              duplicates of its components when H5Pget_fapl_mpio is called.
  *
- * Return:      Success:        None
- *
- *              Failure:        Abort
+ * Return:      Success:    None
+ *              Failure:    Abort
  *
  * Programmer:  Albert Cheng
  *              January 9, 2003
  *
- * Modifications:
  *-------------------------------------------------------------------------
  */
 void
@@ -44,43 +42,43 @@ test_fapl_mpio_dup(void)
     int mpi_size_tmp, mpi_rank_tmp;
     MPI_Info info = MPI_INFO_NULL;
     MPI_Info info_tmp = MPI_INFO_NULL;
-    int mrc;			/* MPI return value */
-    hid_t acc_pl;		/* File access properties */
-    herr_t ret;			/* hdf5 return value */
+    int mrc;            /* MPI return value */
+    hid_t acc_pl;       /* File access properties */
+    herr_t ret;         /* HDF5 return value */
     int nkeys, nkeys_tmp;
 
     if (VERBOSE_MED)
-	printf("Verify fapl_mpio duplicates communicator and INFO objects\n");
+        HDprintf("Verify fapl_mpio duplicates communicator and INFO objects\n");
 
     /* set up MPI parameters */
     MPI_Comm_size(MPI_COMM_WORLD,&mpi_size);
     MPI_Comm_rank(MPI_COMM_WORLD,&mpi_rank);
     if (VERBOSE_MED)
-	printf("rank/size of MPI_COMM_WORLD are %d/%d\n", mpi_rank, mpi_size);
+        HDprintf("rank/size of MPI_COMM_WORLD are %d/%d\n", mpi_rank, mpi_size);
 
     /* Create a new communicator that has the same processes as MPI_COMM_WORLD.
      * Use MPI_Comm_split because it is simplier than MPI_Comm_create
      */
     mrc = MPI_Comm_split(MPI_COMM_WORLD, 0, 0, &comm);
-    VRFY((mrc==MPI_SUCCESS), "MPI_Comm_split");
-    MPI_Comm_size(comm,&mpi_size_old);
-    MPI_Comm_rank(comm,&mpi_rank_old);
+    VRFY((mrc == MPI_SUCCESS), "MPI_Comm_split");
+    MPI_Comm_size(comm, &mpi_size_old);
+    MPI_Comm_rank(comm, &mpi_rank_old);
     if (VERBOSE_MED)
-	printf("rank/size of comm are %d/%d\n", mpi_rank_old, mpi_size_old);
+        HDprintf("rank/size of comm are %d/%d\n", mpi_rank_old, mpi_size_old);
 
     /* create a new INFO object with some trivial information. */
     mrc = MPI_Info_create(&info);
-    VRFY((mrc==MPI_SUCCESS), "MPI_Info_create");
+    VRFY((mrc == MPI_SUCCESS), "MPI_Info_create");
     mrc = MPI_Info_set(info, "hdf_info_name", "XYZ");
-    VRFY((mrc==MPI_SUCCESS), "MPI_Info_set");
-    if (MPI_INFO_NULL != info){
-	mrc=MPI_Info_get_nkeys(info, &nkeys);
-	VRFY((mrc==MPI_SUCCESS), "MPI_Info_get_nkeys");
+    VRFY((mrc == MPI_SUCCESS), "MPI_Info_set");
+    if (MPI_INFO_NULL != info) {
+        mrc = MPI_Info_get_nkeys(info, &nkeys);
+        VRFY((mrc == MPI_SUCCESS), "MPI_Info_get_nkeys");
     }
     if (VERBOSE_MED)
-	h5_dump_info_object(info);
+        h5_dump_info_object(info);
 
-    acc_pl = H5Pcreate (H5P_FILE_ACCESS);
+    acc_pl = H5Pcreate(H5P_FILE_ACCESS);
     VRFY((acc_pl >= 0), "H5P_FILE_ACCESS");
 
     ret = H5Pset_fapl_mpio(acc_pl, comm, info);
@@ -92,28 +90,27 @@ test_fapl_mpio_dup(void)
      * valid communicator and INFO object.
      */
     mrc = MPI_Comm_free(&comm);
-    VRFY((mrc==MPI_SUCCESS), "MPI_Comm_free");
-    if (MPI_INFO_NULL!=info){
-	mrc = MPI_Info_free(&info);
-	VRFY((mrc==MPI_SUCCESS), "MPI_Info_free");
+    VRFY((mrc == MPI_SUCCESS), "MPI_Comm_free");
+    if (MPI_INFO_NULL != info) {
+        mrc = MPI_Info_free(&info);
+        VRFY((mrc == MPI_SUCCESS), "MPI_Info_free");
     }
 
     ret = H5Pget_fapl_mpio(acc_pl, &comm_tmp, &info_tmp);
     VRFY((ret >= 0), "H5Pget_fapl_mpio");
-    MPI_Comm_size(comm_tmp,&mpi_size_tmp);
-    MPI_Comm_rank(comm_tmp,&mpi_rank_tmp);
+    MPI_Comm_size(comm_tmp, &mpi_size_tmp);
+    MPI_Comm_rank(comm_tmp, &mpi_rank_tmp);
     if (VERBOSE_MED)
-	printf("After H5Pget_fapl_mpio: rank/size of comm are %d/%d\n",
-	mpi_rank_tmp, mpi_size_tmp);
-    VRFY((mpi_size_tmp==mpi_size), "MPI_Comm_size");
-    VRFY((mpi_rank_tmp==mpi_rank), "MPI_Comm_rank");
-    if (MPI_INFO_NULL != info_tmp){
-	mrc=MPI_Info_get_nkeys(info_tmp, &nkeys_tmp);
-	VRFY((mrc==MPI_SUCCESS), "MPI_Info_get_nkeys");
-	VRFY((nkeys_tmp==nkeys), "new and old nkeys equal");
+        HDprintf("After H5Pget_fapl_mpio: rank/size of comm are %d/%d\n", mpi_rank_tmp, mpi_size_tmp);
+    VRFY((mpi_size_tmp == mpi_size), "MPI_Comm_size");
+    VRFY((mpi_rank_tmp == mpi_rank), "MPI_Comm_rank");
+    if (MPI_INFO_NULL != info_tmp) {
+        mrc = MPI_Info_get_nkeys(info_tmp, &nkeys_tmp);
+        VRFY((mrc == MPI_SUCCESS), "MPI_Info_get_nkeys");
+        VRFY((nkeys_tmp == nkeys), "new and old nkeys equal");
     }
     if (VERBOSE_MED)
-	h5_dump_info_object(info_tmp);
+        h5_dump_info_object(info_tmp);
 
     /* Case 2:
      * Free the retrieved communicator and INFO object.
@@ -122,23 +119,23 @@ test_fapl_mpio_dup(void)
      * Also verify the NULL argument option.
      */
     mrc = MPI_Comm_free(&comm_tmp);
-    VRFY((mrc==MPI_SUCCESS), "MPI_Comm_free");
-    if (MPI_INFO_NULL!=info_tmp){
-	mrc = MPI_Info_free(&info_tmp);
-	VRFY((mrc==MPI_SUCCESS), "MPI_Info_free");
+    VRFY((mrc == MPI_SUCCESS), "MPI_Comm_free");
+    if (MPI_INFO_NULL != info_tmp) {
+        mrc = MPI_Info_free(&info_tmp);
+        VRFY((mrc == MPI_SUCCESS), "MPI_Info_free");
     }
 
     /* check NULL argument options. */
     ret = H5Pget_fapl_mpio(acc_pl, &comm_tmp, NULL);
     VRFY((ret >= 0), "H5Pget_fapl_mpio Comm only");
     mrc = MPI_Comm_free(&comm_tmp);
-    VRFY((mrc==MPI_SUCCESS), "MPI_Comm_free");
+    VRFY((mrc == MPI_SUCCESS), "MPI_Comm_free");
 
     ret = H5Pget_fapl_mpio(acc_pl, NULL, &info_tmp);
     VRFY((ret >= 0), "H5Pget_fapl_mpio Info only");
-    if (MPI_INFO_NULL!=info_tmp){
-	mrc = MPI_Info_free(&info_tmp);
-	VRFY((mrc==MPI_SUCCESS), "MPI_Info_free");
+    if (MPI_INFO_NULL != info_tmp) {
+        mrc = MPI_Info_free(&info_tmp);
+        VRFY((mrc == MPI_SUCCESS), "MPI_Info_free");
     }
 
     ret = H5Pget_fapl_mpio(acc_pl, NULL, NULL);
@@ -148,44 +145,44 @@ test_fapl_mpio_dup(void)
     /* Donot free the returned objects which are used in the next case. */
     ret = H5Pget_fapl_mpio(acc_pl, &comm_tmp, &info_tmp);
     VRFY((ret >= 0), "H5Pget_fapl_mpio");
-    MPI_Comm_size(comm_tmp,&mpi_size_tmp);
-    MPI_Comm_rank(comm_tmp,&mpi_rank_tmp);
+    MPI_Comm_size(comm_tmp, &mpi_size_tmp);
+    MPI_Comm_rank(comm_tmp, &mpi_rank_tmp);
     if (VERBOSE_MED)
-	printf("After second H5Pget_fapl_mpio: rank/size of comm are %d/%d\n",
-	mpi_rank_tmp, mpi_size_tmp);
-    VRFY((mpi_size_tmp==mpi_size), "MPI_Comm_size");
-    VRFY((mpi_rank_tmp==mpi_rank), "MPI_Comm_rank");
-    if (MPI_INFO_NULL != info_tmp){
-	mrc=MPI_Info_get_nkeys(info_tmp, &nkeys_tmp);
-	VRFY((mrc==MPI_SUCCESS), "MPI_Info_get_nkeys");
-	VRFY((nkeys_tmp==nkeys), "new and old nkeys equal");
+        HDprintf("After second H5Pget_fapl_mpio: rank/size of comm are %d/%d\n",
+        mpi_rank_tmp, mpi_size_tmp);
+    VRFY((mpi_size_tmp == mpi_size), "MPI_Comm_size");
+    VRFY((mpi_rank_tmp == mpi_rank), "MPI_Comm_rank");
+    if (MPI_INFO_NULL != info_tmp) {
+        mrc = MPI_Info_get_nkeys(info_tmp, &nkeys_tmp);
+        VRFY((mrc == MPI_SUCCESS), "MPI_Info_get_nkeys");
+        VRFY((nkeys_tmp == nkeys), "new and old nkeys equal");
     }
     if (VERBOSE_MED)
-	h5_dump_info_object(info_tmp);
+        h5_dump_info_object(info_tmp);
 
     /* Case 3:
      * Close the property list and verify the retrieved communicator and INFO
      * object are still valid.
      */
     H5Pclose(acc_pl);
-    MPI_Comm_size(comm_tmp,&mpi_size_tmp);
-    MPI_Comm_rank(comm_tmp,&mpi_rank_tmp);
+    MPI_Comm_size(comm_tmp, &mpi_size_tmp);
+    MPI_Comm_rank(comm_tmp, &mpi_rank_tmp);
     if (VERBOSE_MED)
-	printf("After Property list closed: rank/size of comm are %d/%d\n",
-	mpi_rank_tmp, mpi_size_tmp);
-    if (MPI_INFO_NULL != info_tmp){
-	mrc=MPI_Info_get_nkeys(info_tmp, &nkeys_tmp);
-	VRFY((mrc==MPI_SUCCESS), "MPI_Info_get_nkeys");
+        HDprintf("After Property list closed: rank/size of comm are %d/%d\n",
+    mpi_rank_tmp, mpi_size_tmp);
+    if (MPI_INFO_NULL != info_tmp) {
+        mrc = MPI_Info_get_nkeys(info_tmp, &nkeys_tmp);
+        VRFY((mrc == MPI_SUCCESS), "MPI_Info_get_nkeys");
     }
     if (VERBOSE_MED)
-	h5_dump_info_object(info_tmp);
+        h5_dump_info_object(info_tmp);
 
     /* clean up */
     mrc = MPI_Comm_free(&comm_tmp);
-    VRFY((mrc==MPI_SUCCESS), "MPI_Comm_free");
-    if (MPI_INFO_NULL!=info_tmp){
-	mrc = MPI_Info_free(&info_tmp);
-	VRFY((mrc==MPI_SUCCESS), "MPI_Info_free");
+    VRFY((mrc == MPI_SUCCESS), "MPI_Comm_free");
+    if (MPI_INFO_NULL != info_tmp) {
+        mrc = MPI_Info_free(&info_tmp);
+        VRFY((mrc == MPI_SUCCESS), "MPI_Info_free");
     }
-}
+} /* end test_fapl_mpio_dup() */
 
diff --git a/testpar/t_prestart.c b/testpar/t_prestart.c
index 719d150..d75e627 100644
--- a/testpar/t_prestart.c
+++ b/testpar/t_prestart.c
@@ -107,7 +107,7 @@ main (int argc, char **argv)
     for (i=0; i < block[0]; i++){
 	for (j=0; j < block[1]; j++){
 	    if(*dataptr != mpi_rank+1) {
-                printf("Dataset Verify failed at [%lu][%lu](row %lu, col %lu): expect %d, got %d\n",
+                HDprintf("Dataset Verify failed at [%lu][%lu](row %lu, col %lu): expect %d, got %d\n",
                        (unsigned long)i, (unsigned long)j,
                        (unsigned long)(i+start[0]), (unsigned long)(j+start[1]),
                        mpi_rank+1, *(dataptr));
diff --git a/testpar/t_shapesame.c b/testpar/t_shapesame.c
index caaf14c..2822f9c 100644
--- a/testpar/t_shapesame.c
+++ b/testpar/t_shapesame.c
@@ -22,10 +22,8 @@
 #define H5S_TESTING
 
 
-#include "hdf5.h"
-#include "H5private.h"
-#include "testphdf5.h"
 #include "H5Spkg.h"             /* Dataspaces                           */
+#include "testphdf5.h"
 
 
 /* On Lustre (and perhaps other parallel file systems?), we have severe
@@ -1964,21 +1962,6 @@ contig_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t * tv_ptr)
  *
  * Programmer:    JRM -- 9/18/09
  *
- * Modifications:
- *
- *        JRM -- 9/16/10
- *        Added express_test parameter.  Use it to control whether
- *        we set up the chunks so that no chunk is shared between
- *        processes, and also whether we set an alignment when we
- *        create the test file.
- *
- *        JRM -- 8/11/11
- *        Refactored function heavily & broke it into six functions.
- *        Added the skips_ptr, max_skips, total_tests_ptr,
- *        tests_run_ptr, and tests_skiped_ptr parameters to support
- *        skipping portions of the test according to the express
- *        test value.
- *
  *-------------------------------------------------------------------------
  */
 
@@ -2186,20 +2169,6 @@ contig_hs_dr_pio_test__run_test(const int test_num,
  *
  * Programmer:    JRM -- 9/18/09
  *
- * Modifications:
- *
- *          Modified function to take a sample of the run times
- *        of the different tests, and skip some of them if
- *        run times are too long.
- *
- *        We need to do this because Lustre runns very slowly
- *        if two or more processes are banging on the same
- *        block of memory.
- *                        JRM -- 9/10/10
- *              Break this one big test into 4 smaller tests according
- *              to {independent,collective}x{contigous,chunked} datasets.
- *        AKC -- 2010/01/14
- *
  *-------------------------------------------------------------------------
  */
 
@@ -4249,14 +4218,6 @@ ckrbrd_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t * tv_ptr)
  *
  * Programmer:    JRM -- 10/10/09
  *
- * Modifications:
- *
- *        JRM -- 9/16/10
- *        Added the express_test parameter.  Use it to control
- *        whether we set an alignment, and whether we allocate
- *        chunks such that no two processes will normally touch
- *        the same chunk.
- *
  *-------------------------------------------------------------------------
  */
 
@@ -4456,20 +4417,6 @@ ckrbrd_hs_dr_pio_test__run_test(const int test_num,
  *
  * Programmer:    JRM -- 9/18/09
  *
- * Modifications:
- *
- *          Modified function to take a sample of the run times
- *        of the different tests, and skip some of them if
- *        run times are too long.
- *
- *        We need to do this because Lustre runns very slowly
- *        if two or more processes are banging on the same
- *        block of memory.
- *                        JRM -- 9/10/10
- *          Break this one big test into 4 smaller tests according
- *          to {independent,collective}x{contigous,chunked} datasets.
- *        AKC -- 2010/01/17
- *
  *-------------------------------------------------------------------------
  */
 
@@ -4717,10 +4664,10 @@ 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",
+        HDprintf("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);
+        HDprintf("waiting(%ds) for file %s ...\n", time_int, greenlight);
         fflush(stdout);
             HDsleep(time_int);
     }
@@ -4744,18 +4691,18 @@ int MPI_Init(int *argc, char ***argv)
 static void
 usage(void)
 {
-    printf("    [-r] [-w] [-m<n_datasets>] [-n<n_groups>] "
+    HDprintf("    [-r] [-w] [-m<n_datasets>] [-n<n_groups>] "
     "[-o] [-f <prefix>] [-d <dim0> <dim1>]\n");
-    printf("\t-m<n_datasets>"
+    HDprintf("\t-m<n_datasets>"
     "\tset number of datasets for the multiple dataset test\n");
-    printf("\t-n<n_groups>"
+    HDprintf("\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",
+    HDprintf("\t-f <prefix>\tfilename prefix\n");
+    HDprintf("\t-2\t\tuse Split-file together with MPIO\n");
+    HDprintf("\t-d <factor0> <factor1>\tdataset dimensions factors. Defaults (%d,%d)\n",
     ROW_FACTOR, COL_FACTOR);
-    printf("\t-c <dim0> <dim1>\tdataset chunk dimensions. Defaults (dim0/10,dim1/10)\n");
-    printf("\n");
+    HDprintf("\t-c <dim0> <dim1>\tdataset chunk dimensions. Defaults (dim0/10,dim1/10)\n");
+    HDprintf("\n");
 }
 
 
@@ -4833,7 +4780,7 @@ parse_options(int argc, char **argv)
                 break;
         case 'h':   /* print help message--return with nerrors set */
                 return(1);
-        default:    printf("Illegal option(%s)\n", *argv);
+        default:    HDprintf("Illegal option(%s)\n", *argv);
                 nerrors++;
                 return(1);
         }
@@ -4842,12 +4789,12 @@ parse_options(int argc, char **argv)
 
     /* check validity of dimension and chunk sizes */
     if (dim0 <= 0 || dim1 <= 0){
-    printf("Illegal dim sizes (%d, %d)\n", dim0, dim1);
+    HDprintf("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);
+    HDprintf("Illegal chunkdim sizes (%d, %d)\n", chunkdim0, chunkdim1);
     nerrors++;
     return(1);
     }
@@ -4855,7 +4802,7 @@ parse_options(int argc, char **argv)
     /* 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",
+        HDprintf("dim0(%d) and dim1(%d) must be multiples of processes(%d)\n",
             dim0, dim1, mpi_size);
     nerrors++;
     return(1);
@@ -4870,13 +4817,13 @@ parse_options(int argc, char **argv)
     for (i=0; i < n; i++)
         if (h5_fixname(FILENAME[i],fapl,filenames[i],sizeof(filenames[i]))
         == NULL){
-        printf("h5_fixname failed\n");
+        HDprintf("h5_fixname failed\n");
         nerrors++;
         return(1);
         }
-    printf("Test filenames are:\n");
+    HDprintf("Test filenames are:\n");
     for (i=0; i < n; i++)
-        printf("    %s\n", filenames[i]);
+        HDprintf("    %s\n", filenames[i]);
     }
 
     return(0);
@@ -5009,10 +4956,10 @@ int main(int argc, char **argv)
     dim1 = COL_FACTOR*mpi_size;
 
     if (MAINPROCESS){
-    printf("===================================\n");
-    printf("Shape Same Tests Start\n");
-        printf("    express_test = %d.\n", GetTestExpress());
-    printf("===================================\n");
+    HDprintf("===================================\n");
+    HDprintf("Shape Same Tests Start\n");
+        HDprintf("    express_test = %d.\n", GetTestExpress());
+    HDprintf("===================================\n");
     }
 
     /* Attempt to turn off atexit post processing so that in case errors
@@ -5021,7 +4968,7 @@ int main(int argc, char **argv)
      * calls.  By then, MPI calls may not work.
      */
     if (H5dont_atexit() < 0){
-    printf("%d: Failed to turn off atexit processing. Continue.\n", mpi_rank);
+    HDprintf("%d: Failed to turn off atexit processing. Continue.\n", mpi_rank);
     };
     H5open();
     h5_show_hostname();
@@ -5060,7 +5007,7 @@ int main(int argc, char **argv)
     TestParseCmdLine(argc, argv);
 
     if (dxfer_coll_type == DXFER_INDEPENDENT_IO && MAINPROCESS){
-    printf("===================================\n"
+    HDprintf("===================================\n"
         "   Using Independent I/O with file set view to replace collective I/O \n"
         "===================================\n");
     }
@@ -5091,12 +5038,12 @@ int main(int argc, char **argv)
     }
 
     if (MAINPROCESS){        /* only process 0 reports */
-    printf("===================================\n");
+    HDprintf("===================================\n");
     if (nerrors)
-        printf("***Shape Same tests detected %d errors***\n", nerrors);
+        HDprintf("***Shape Same tests detected %d errors***\n", nerrors);
     else
-        printf("Shape Same tests finished with no errors\n");
-    printf("===================================\n");
+        HDprintf("Shape Same tests finished with no errors\n");
+    HDprintf("===================================\n");
     }
 
     /* close HDF5 library */
diff --git a/testpar/t_span_tree.c b/testpar/t_span_tree.c
index 960bedc..b69645d 100644
--- a/testpar/t_span_tree.c
+++ b/testpar/t_span_tree.c
@@ -32,7 +32,6 @@
 
  */
 
-#include "hdf5.h"
 #include "H5private.h"
 #include "testphdf5.h"
 
@@ -45,7 +44,7 @@ static void coll_read_test(int chunk_factor);
  * Function:    coll_irregular_cont_write
  *
  * Purpose:    Wrapper to test the collectively irregular hyperslab write in
-                contiguous storage
+ *             contiguous storage
  *
  * Return:    Success:    0
  *
@@ -70,7 +69,7 @@ coll_irregular_cont_write(void)
  * Function:    coll_irregular_cont_read
  *
  * Purpose:    Wrapper to test the collectively irregular hyperslab read in
-                contiguous storage
+ *             contiguous storage
  *
  * Return:    Success:    0
  *
@@ -94,7 +93,7 @@ coll_irregular_cont_read(void)
  * Function:    coll_irregular_simple_chunk_write
  *
  * Purpose:    Wrapper to test the collectively irregular hyperslab write in
-                chunk storage(1 chunk)
+ *             chunk storage(1 chunk)
  *
  * Return:    Success:    0
  *
@@ -119,7 +118,7 @@ coll_irregular_simple_chunk_write(void)
  * Function:    coll_irregular_simple_chunk_read
  *
  * Purpose:    Wrapper to test the collectively irregular hyperslab read in chunk
-                storage(1 chunk)
+ *             storage(1 chunk)
  *
  * Return:    Success:    0
  *
@@ -142,7 +141,7 @@ coll_irregular_simple_chunk_read(void)
  * Function:    coll_irregular_complex_chunk_write
  *
  * Purpose:    Wrapper to test the collectively irregular hyperslab write in chunk
-                storage(4 chunks)
+ *             storage(4 chunks)
  *
  * Return:    Success:    0
  *
@@ -167,7 +166,7 @@ coll_irregular_complex_chunk_write(void)
  * Function:    coll_irregular_complex_chunk_read
  *
  * Purpose:    Wrapper to test the collectively irregular hyperslab read in chunk
-                storage(1 chunk)
+ *             storage(1 chunk)
  *
  * Return:    Success:    0
  *
@@ -191,9 +190,9 @@ coll_irregular_complex_chunk_read(void)
  * Function:    coll_write_test
  *
  * Purpose:    To test the collectively irregular hyperslab write in chunk
-                storage
+ *              storage
  *  Input:      number of chunks on each dimension
-                if number is equal to 0, contiguous storage
+ *              if number is equal to 0, contiguous storage
  * Return:    Success:    0
  *
  *        Failure:    -1
@@ -211,19 +210,11 @@ void coll_write_test(int chunk_factor)
   hid_t    file, datasetc,dataseti;      /* File and dataset identifiers */
   hid_t    mspaceid1, mspaceid, fspaceid,fspaceid1; /* Dataspace identifiers */
 
-  hsize_t mdim1[1],fsdim[2],mdim[2];
-
-#if 0
-  hsize_t  mdim1[] = {MSPACE1_DIM};  /* Dimension size of the first dataset
-                    (in memory) */
-  hsize_t  fsdim[] = {FSPACE_DIM1, FSPACE_DIM2}; /* Dimension sizes of the dataset
-                                                    (on disk) */
-
-  hsize_t  mdim[] = {MSPACE_DIM1, MSPACE_DIM2}; /* Dimension sizes of the
-                        dataset in memory when we
-                        read selection from the
-                        dataset on the disk */
-#endif
+  hsize_t  mdim1[1];    /* Dimension size of the first dataset (in memory) */
+  hsize_t  fsdim[2];    /* Dimension sizes of the dataset (on disk) */
+  hsize_t  mdim[2];     /* Dimension sizes of the dataset in memory when we
+                         * read selection from the dataset on the disk
+                         */
 
   hsize_t  start[2];  /* Start of hyperslab */
   hsize_t  stride[2]; /* Stride of hyperslab */
@@ -235,15 +226,9 @@ void coll_write_test(int chunk_factor)
   unsigned i;
   int      fillvalue = 0;   /* Fill value for the dataset */
 
-#if 0
-  int      matrix_out[MSPACE_DIM1][MSPACE_DIM2];
-  int      matrix_out1[MSPACE_DIM1][MSPACE_DIM2];   /* Buffer to read from the
-                            dataset */
-  int      vector[MSPACE1_DIM];
-#endif
-
-
-  int      *matrix_out = NULL, *matrix_out1 = NULL, *vector = NULL;
+  int      *matrix_out = NULL;
+  int      *matrix_out1 = NULL;     /* Buffer to read from the dataset */
+  int      *vector = NULL;
 
   int      mpi_size,mpi_rank;
 
@@ -664,9 +649,9 @@ void coll_write_test(int chunk_factor)
  * Function:    coll_read_test
  *
  * Purpose:    To test the collectively irregular hyperslab read in chunk
-                storage
+ *              storage
  * Input:       number of chunks on each dimension
-                if number is equal to 0, contiguous storage
+ *              if number is equal to 0, contiguous storage
  * Return:    Success:    0
  *
  *        Failure:    -1
@@ -687,14 +672,10 @@ coll_read_test(int chunk_factor)
 
 
   /* Dimension sizes of the dataset (on disk) */
-#if 0
-  hsize_t mdim[] = {MSPACE_DIM1, MSPACE_DIM2}; /* Dimension sizes of the
-                        dataset in memory when we
-                        read selection from the
-                        dataset on the disk */
+  hsize_t mdim[2];      /* Dimension sizes of the dataset in memory when we
+                         * read selection from the dataset on the disk
+                         */
 
-#endif
-  hsize_t mdim[2];
   hsize_t  start[2];  /* Start of hyperslab */
   hsize_t  stride[2]; /* Stride of hyperslab */
   hsize_t  count[2];  /* Block count */
@@ -704,13 +685,8 @@ coll_read_test(int chunk_factor)
   unsigned i;
 
   int     *matrix_out;
-  int     *matrix_out1;
-#if 0
-  int      matrix_out[MSPACE_DIM1][MSPACE_DIM2];
-  int      matrix_out1[MSPACE_DIM1][MSPACE_DIM2];   /* Buffer to read from the
-                            dataset */
+  int     *matrix_out1;     /* Buffer to read from the dataset */
 
-#endif
   int      mpi_size,mpi_rank;
 
   MPI_Comm comm = MPI_COMM_WORLD;
@@ -917,7 +893,7 @@ coll_read_test(int chunk_factor)
   ret = H5Fclose(file);
   VRFY((ret >= 0),"");
 
-  return ;
+  return;
 }
 
 
@@ -2596,10 +2572,6 @@ lower_dim_size_comp_test(void)
     int      chunk_edge_size = 0;
     int      use_collective_io;
 
-#if 0
-   HDsleep(60);
-#endif
-
     HDcompile_assert(sizeof(uint32_t) == sizeof(unsigned));
     for(use_collective_io = 0; use_collective_io <= 1; use_collective_io++) {
         chunk_edge_size = 0;
diff --git a/testpar/testpar.h b/testpar/testpar.h
index 84c073f..86677d1 100644
--- a/testpar/testpar.h
+++ b/testpar/testpar.h
@@ -32,7 +32,7 @@
  */
 #define MESG(mesg)                                                     \
     if (VERBOSE_MED && *mesg != '\0')                                  \
-	printf("%s\n", mesg)
+        HDprintf("%s\n", mesg)
 
 /* 
  * VRFY: Verify if the condition val is true.
@@ -46,16 +46,17 @@
  */
 #define VRFY(val, mesg) do {                                            \
     if (val) {                                                          \
-	MESG(mesg);                                                     \
-    } else {                                                            \
-        printf("Proc %d: ", mpi_rank);                                  \
-        printf("*** Parallel ERROR ***\n");                             \
-        printf("    VRFY (%s) failed at line %4d in %s\n",              \
+        MESG(mesg);                                                     \
+    }                                                                   \
+    else {                                                              \
+        HDprintf("Proc %d: ", mpi_rank);                                \
+        HDprintf("*** Parallel ERROR ***\n");                           \
+        HDprintf("    VRFY (%s) failed at line %4d in %s\n",            \
                mesg, (int)__LINE__, __FILE__);                          \
         ++nerrors;                                                      \
         fflush(stdout);                                                 \
         if (!VERBOSE_MED) {                                             \
-            printf("aborting MPI processes\n");                         \
+            HDprintf("aborting MPI processes\n");                       \
             MPI_Abort(MPI_COMM_WORLD, 1);                               \
         }                                                               \
     }                                                                   \
@@ -70,9 +71,9 @@
     if (val) {                                                          \
 	MESG(mesg);                                                 \
     } else {                                                            \
-        printf("Proc %d: ", mpi_rank);                                  \
-        printf("*** PHDF5 REMARK (not an error) ***\n");                \
-        printf("        Condition (%s) failed at line %4d in %s\n",     \
+        HDprintf("Proc %d: ", mpi_rank);                                  \
+        HDprintf("*** PHDF5 REMARK (not an error) ***\n");                \
+        HDprintf("        Condition (%s) failed at line %4d in %s\n",     \
                mesg, (int)__LINE__, __FILE__);                          \
         fflush(stdout);                                                 \
     }                                                                   \
@@ -80,10 +81,10 @@
 
 #define MPI_BANNER(mesg) do {                                           \
     if (VERBOSE_MED || MAINPROCESS){                                    \
-	printf("--------------------------------\n");                   \
-	printf("Proc %d: ", mpi_rank);                                  \
-	printf("*** %s\n", mesg);                                       \
-	printf("--------------------------------\n");                   \
+	HDprintf("--------------------------------\n");                   \
+	HDprintf("Proc %d: ", mpi_rank);                                  \
+	HDprintf("*** %s\n", mesg);                                       \
+	HDprintf("--------------------------------\n");                   \
     }                                                                   \
 } while(0)
 
diff --git a/testpar/testpflush.sh.in b/testpar/testpflush.sh.in
new file mode 100644
index 0000000..02f0e26
--- /dev/null
+++ b/testpar/testpflush.sh.in
@@ -0,0 +1,64 @@
+#! /bin/sh
+#
+# Copyright by The HDF Group.
+# Copyright by the Board of Trustees of the University of Illinois.
+# All rights reserved.
+#
+# This file is part of HDF5.  The full HDF5 copyright notice, including
+# terms governing use, modification, and redistribution, is contained in
+# the COPYING file, which can be found at the root of the source code
+# distribution tree, or in https://support.hdfgroup.org/ftp/HDF5/releases.
+# If you do not have access to either file, you may request a copy from
+# help@hdfgroup.org.
+#
+#
+# Test script for the parallel flush test
+#
+# The parallel flush test uses two programs to test flush operations
+# in parallel HDF5. The first program purposely exits without calling
+# MPI_Finalize(), which is an error under the MPI standard and mpiexec
+# in some implementations will return an error code even though all
+# processes exit successfully. This script lets us swallow the error
+# from the first program.
+#
+# True errors in the first program will be detected as errors in the
+# second program, so watch out for that.
+#
+# Programmer:   Dana Robinson
+#               Fall 2018
+
+# The build (current) directory might be different than the source directory.
+if test -z "$srcdir"; then
+   srcdir=.
+fi
+
+# Turn the $$ we use to avoid Autotools munging into $
+#
+# Allowing $$ to substitute in both the RUNPARALLEL string and the
+# regexp is intentional. There doesn't seem to be a way around
+# this using quote shenanigans. The downside is that there is a remote
+# chance that the shell's pid will match a number in the RUNPARALLEL
+# variable, but that seems less likely to cause problems than expecting
+# library builders to specify two almost identical versions of the
+# RUNPARALLEL command, one for use in scripts and one via Makefiles.
+RUNPARALLELSCRIPT=`echo "@RUNPARALLEL@" | sed "s/$$/\$/g"`
+
+# ==========================================
+# Run the first parallel flush test program
+# (note that we ignore any errors here)
+# ==========================================
+echo "*** NOTE ***********************************************************"
+echo "You may see complaints from mpiexec et al. that not all processes"
+echo "called MPI_Finalize(). This is an intended characteristic of the"
+echo "test and should not be considered an  error."
+echo "********************************************************************"
+eval ${RUNPARALLELSCRIPT} ./t_pflush1
+
+
+# ===========================================
+# Run the second parallel flush test program
+# The return code of this call is the return
+# code of the script.
+# ===========================================
+eval ${RUNPARALLELSCRIPT} ./t_pflush2
+