[svn-r21260] Refactored shape same tests heavily, and added code to skip a configurable

fraction of the subtests depending on the current express test level.  Also
added code to display fraction of subtests skipped.

The current tables controlling the fraction of tests skipped as a function 
of express test level is a guess at what will be needed.  It will be necessary
to tune this table against the express test targets and our worst case system.


Initially commit tested on Jam, Koala, and Heiwa, but ran into an unrelated
failure on Heiwa (bug reported).  Replaced Heiws with Linew and got a clean
h5commit test.

Also tested parallel on Koala.  Initially got very bad results (test timed out
roughly 1/3 to 1/2 the way through).  Discussed matters with Matthew, and moved
the build to the solid state drive on Koala.  This dealt with the performance
issues completely.

1 files changed, 2765 insertions, 2536 deletions

diff --git a/testpar/t_shapesame.c b/testpar/t_shapesame.c
index a62e4f9..7601587 100644
--- a/testpar/t_shapesame.c
+++ b/testpar/t_shapesame.c
@@ -29,47 +29,6 @@
 #include "testphdf5.h"
 #include "H5Spkg.h"             /* Dataspaces                           */
 
-/* The following macros are used in the detection of tests that run overlong --
- * so that tests can be ommitted if necessary to get the overall set of tests
- * to complete.
- *
- * Observe that we can't do this if we don't have gettimeofday(), so in that
- * case, the macros resolve to the empty string.
- */
-
-#ifdef H5_HAVE_GETTIMEOFDAY
-
-#define	START_TIMER(time_tests, start_time, vrfy_msg)			\
-	{								\
-            int result;							\
-            if ( time_tests ) {						\
-                    result = HDgettimeofday(&(start_time), NULL);	\
-                    VRFY( (result == 0), (vrfy_msg));			\
-            }								\
-	}
-
-#define STOP_TIMER_AND_UPDATE(time_tests, end_time, vrfy_msg, times)	\
-        {								\
-            int result;							\
-            long long delta_usecs;					\
-            if ( time_tests ) {						\
-                result = HDgettimeofday(&(end_time), NULL);		\
-                VRFY( (result == 0), (vrfy_msg));			\
-                delta_usecs = 						\
-                   (1000000 * (timeval_b.tv_sec - timeval_a.tv_sec)) +	\
-                   (timeval_b.tv_usec - timeval_a.tv_usec);		\
-                HDassert( delta_usecs >= 0L );				\
-                (times) += delta_usecs;					\
-            }								\
-	}
-
-#else /* H5_HAVE_GETTIMEOFDAY */
-
-#define START_TIMER(time_tests, start_time, vrfy_msg)
-
-#define STOP_TIMER_AND_UPDATE(time_tests, end_time, vrfy_msg, times)
-
-#endif /* H5_HAVE_GETTIMEOFDAY */
 
 /* On Lustre (and perhaps other parallel file systems?), we have severe
  * slow downs if two or more processes attempt to access the same file system
@@ -81,101 +40,116 @@
 #define SHAPE_SAME_TEST_ALIGNMENT	((hsize_t)(4 * 1024 * 1024))
 
 
+#define PAR_SS_DR_MAX_RANK	5 	/* must update code if this changes */
+
+struct hs_dr_pio_test_vars_t
+{
+    int		mpi_size;
+    int         mpi_rank;
+    MPI_Comm    mpi_comm;
+    MPI_Info	mpi_info;
+    int         test_num;
+    int         edge_size;
+    int		checker_edge_size;
+    int         chunk_edge_size;
+    int         small_rank;
+    int         large_rank;
+    hid_t       dset_type;
+    uint32_t  * small_ds_buf_0;
+    uint32_t  * small_ds_buf_1;
+    uint32_t  * small_ds_buf_2;
+    uint32_t  * small_ds_slice_buf;
+    uint32_t  * large_ds_buf_0;
+    uint32_t  * large_ds_buf_1;
+    uint32_t  * large_ds_buf_2;
+    uint32_t  * large_ds_slice_buf;
+    int         small_ds_offset;
+    int         large_ds_offset;
+    hid_t       fid;               /* HDF5 file ID */
+    hid_t	xfer_plist;
+    hid_t       full_mem_small_ds_sid;
+    hid_t       full_file_small_ds_sid;
+    hid_t       mem_small_ds_sid;
+    hid_t       file_small_ds_sid_0;
+    hid_t       file_small_ds_sid_1;
+    hid_t	small_ds_slice_sid;
+    hid_t       full_mem_large_ds_sid;
+    hid_t       full_file_large_ds_sid;
+    hid_t       mem_large_ds_sid;
+    hid_t       file_large_ds_sid_0;
+    hid_t       file_large_ds_sid_1;
+    hid_t       file_large_ds_process_slice_sid;
+    hid_t       mem_large_ds_process_slice_sid;
+    hid_t	large_ds_slice_sid;
+    hid_t       small_dataset;     /* Dataset ID */
+    hid_t       large_dataset;     /* Dataset ID */
+    size_t      small_ds_size;
+    size_t      small_ds_slice_size;
+    size_t      large_ds_size;
+    size_t      large_ds_slice_size;
+    hsize_t     dims[PAR_SS_DR_MAX_RANK];
+    hsize_t     chunk_dims[PAR_SS_DR_MAX_RANK];
+    hsize_t     start[PAR_SS_DR_MAX_RANK];
+    hsize_t     stride[PAR_SS_DR_MAX_RANK];
+    hsize_t     count[PAR_SS_DR_MAX_RANK];
+    hsize_t     block[PAR_SS_DR_MAX_RANK];
+    hsize_t   * start_ptr;
+    hsize_t   * stride_ptr;
+    hsize_t   * count_ptr;
+    hsize_t   * block_ptr;
+    int         skips;
+    int	        max_skips;
+    int64_t	total_tests;
+    int64_t	tests_run;
+    int64_t	tests_skipped;
+};
+
 /*-------------------------------------------------------------------------
- * Function:	contig_hyperslab_dr_pio_test__run_test()
+ * Function:	hs_dr_pio_test__setup()
  *
- * Purpose:	Test I/O to/from hyperslab selections of different rank in
- *		the parallel.
+ * Purpose:	Do setup for tests of I/O to/from hyperslab selections of 
+ * 		different rank in the parallel case.
  *
  * Return:	void
  *
- * Programmer:	JRM -- 9/18/09
+ * Programmer:	JRM -- 8/9/11
  *
  * 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.
+ *		None.
  *
  *-------------------------------------------------------------------------
  */
 
-#define PAR_SS_DR_MAX_RANK	5
-#define CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 0
+#define CONTIG_HS_DR_PIO_TEST__SETUP__DEBUG 0
 
 static void
-contig_hyperslab_dr_pio_test__run_test(const int test_num,
-                                       const int edge_size,
-                                       const int chunk_edge_size,
-                                       const int small_rank,
-                                       const int large_rank,
-                                       const hbool_t use_collective_io,
-                                       const hid_t dset_type,
-                                       const int express_test)
+hs_dr_pio_test__setup(const int test_num,
+                      const int edge_size,
+                      const int checker_edge_size,
+                      const int chunk_edge_size,
+                      const int small_rank,
+                      const int large_rank,
+                      const hbool_t use_collective_io,
+                      const hid_t dset_type,
+                      const int express_test,
+                      struct hs_dr_pio_test_vars_t * tv_ptr)
 {
-#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
-    const char *fcnName = "contig_hyperslab_dr_pio_test__run_test()";
-#endif /* CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG */
+#if CONTIG_HS_DR_PIO_TEST__SETUP__DEBUG 
+    const char *fcnName = "hs_dr_pio_test__setup()";
+#endif /* CONTIG_HS_DR_PIO_TEST__SETUP__DEBUG */
     const char *filename;
     hbool_t	use_gpfs = FALSE;   /* Use GPFS hints */
     hbool_t	mis_match = FALSE;
-    int		i, j, k, l;
-    size_t	n;
+    int		i;
     int         mrc;
-    int		mpi_size = -1;
-    int         mpi_rank = -1;
-    size_t      start_index;
-    size_t      stop_index;
-    const int   test_max_rank = 5;  /* must update code if this changes */
+    int		mpi_rank; /* needed by the VRFY macro */
     uint32_t	expected_value;
-    uint32_t  * small_ds_buf_0 = NULL;
-    uint32_t  * small_ds_buf_1 = NULL;
-    uint32_t  * small_ds_buf_2 = NULL;
-    uint32_t  * small_ds_slice_buf = NULL;
-    uint32_t  * large_ds_buf_0 = NULL;
-    uint32_t  * large_ds_buf_1 = NULL;
-    uint32_t  * large_ds_buf_2 = NULL;
-    uint32_t  * large_ds_slice_buf = NULL;
     uint32_t  * ptr_0;
     uint32_t  * ptr_1;
-    MPI_Comm    mpi_comm = MPI_COMM_NULL;
-    MPI_Info	mpi_info = MPI_INFO_NULL;
-    hid_t       fid;			/* HDF5 file ID */
     hid_t	acc_tpl;		/* File access templates */
-    hid_t	xfer_plist = H5P_DEFAULT;
-    hid_t       full_mem_small_ds_sid;
-    hid_t       full_file_small_ds_sid;
-    hid_t       mem_small_ds_sid;
-    hid_t       file_small_ds_sid;
-    hid_t	small_ds_slice_sid;
-    hid_t       full_mem_large_ds_sid;
-    hid_t       full_file_large_ds_sid;
-    hid_t       mem_large_ds_sid;
-    hid_t       file_large_ds_sid;
-    hid_t       file_large_ds_process_slice_sid;
-    hid_t       mem_large_ds_process_slice_sid;
-    hid_t	large_ds_slice_sid;
     hid_t       small_ds_dcpl_id = H5P_DEFAULT;
     hid_t       large_ds_dcpl_id = H5P_DEFAULT;
-    hid_t       small_dataset;     /* Dataset ID                   */
-    hid_t       large_dataset;     /* Dataset ID                   */
-    size_t      small_ds_size = 1;
-    size_t      small_ds_slice_size = 1;
-    size_t      large_ds_size = 1;
-    size_t      large_ds_slice_size = 1;
-    hsize_t     dims[PAR_SS_DR_MAX_RANK];
-    hsize_t     chunk_dims[PAR_SS_DR_MAX_RANK];
-    hsize_t     start[PAR_SS_DR_MAX_RANK];
-    hsize_t     stride[PAR_SS_DR_MAX_RANK];
-    hsize_t     count[PAR_SS_DR_MAX_RANK];
-    hsize_t     block[PAR_SS_DR_MAX_RANK];
-    hsize_t   * start_ptr = NULL;
-    hsize_t   * stride_ptr = NULL;
-    hsize_t   * count_ptr = NULL;
-    hsize_t   * block_ptr = NULL;
-    htri_t      check;          /* Shape comparison return value */
     herr_t	ret;		/* Generic return value */
 
     HDassert( edge_size >= 6 );
@@ -183,107 +157,132 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
     HDassert( ( chunk_edge_size == 0 ) || ( chunk_edge_size >= 3 ) );
     HDassert( 1 < small_rank );
     HDassert( small_rank < large_rank );
-    HDassert( large_rank <= test_max_rank );
-    HDassert( test_max_rank <= PAR_SS_DR_MAX_RANK );
+    HDassert( large_rank <= PAR_SS_DR_MAX_RANK );
 
-    MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
-    MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
+    tv_ptr->test_num = test_num;
+    tv_ptr->edge_size = edge_size;
+    tv_ptr->checker_edge_size = checker_edge_size;
+    tv_ptr->chunk_edge_size = chunk_edge_size;
+    tv_ptr->small_rank = small_rank;
+    tv_ptr->large_rank = large_rank;
+    tv_ptr->dset_type = dset_type;
 
-    HDassert( mpi_size >= 1 );
+    MPI_Comm_size(MPI_COMM_WORLD, &(tv_ptr->mpi_size));
+    MPI_Comm_rank(MPI_COMM_WORLD, &(tv_ptr->mpi_rank));
+    /* the VRFY() macro needs the local variable mpi_rank -- set it up now */
+    mpi_rank = tv_ptr->mpi_rank;
 
-    mpi_comm = MPI_COMM_WORLD;
-    mpi_info = MPI_INFO_NULL;
+    HDassert( tv_ptr->mpi_size >= 1 );
 
-    for ( i = 0; i < small_rank - 1; i++ )
+    tv_ptr->mpi_comm = MPI_COMM_WORLD;
+    tv_ptr->mpi_info = MPI_INFO_NULL;
+
+    for ( i = 0; i < tv_ptr->small_rank - 1; i++ )
     {
-        small_ds_size *= (size_t)edge_size;
-        small_ds_slice_size *= (size_t)edge_size;
+        tv_ptr->small_ds_size *= (size_t)(tv_ptr->edge_size);
+        tv_ptr->small_ds_slice_size *= (size_t)(tv_ptr->edge_size);
     }
-    small_ds_size *= (size_t)(mpi_size + 1);
+    tv_ptr->small_ds_size *= (size_t)(tv_ptr->mpi_size + 1);
+
+    /* used by checker board tests only */
+    tv_ptr->small_ds_offset = PAR_SS_DR_MAX_RANK - tv_ptr->small_rank;
 
+    HDassert( 0 < tv_ptr->small_ds_offset );
+    HDassert( tv_ptr->small_ds_offset < PAR_SS_DR_MAX_RANK );
 
-    for ( i = 0; i < large_rank - 1; i++ ) {
+    for ( i = 0; i < tv_ptr->large_rank - 1; i++ ) {
 
-        large_ds_size *= (size_t)edge_size;
-        large_ds_slice_size *= (size_t)edge_size;
+        tv_ptr->large_ds_size *= (size_t)(tv_ptr->edge_size);
+        tv_ptr->large_ds_slice_size *= (size_t)(tv_ptr->edge_size);
     }
-    large_ds_size *= (size_t)(mpi_size + 1);
+    tv_ptr->large_ds_size *= (size_t)(tv_ptr->mpi_size + 1);
+
+    /* used by checker board tests only */
+    tv_ptr->large_ds_offset = PAR_SS_DR_MAX_RANK - tv_ptr->large_rank;
+
+    HDassert( 0 <= tv_ptr->large_ds_offset );
+    HDassert( tv_ptr->large_ds_offset < PAR_SS_DR_MAX_RANK );
 
 
     /* set up the start, stride, count, and block pointers */
-    start_ptr  = &(start[PAR_SS_DR_MAX_RANK - large_rank]);
-    stride_ptr = &(stride[PAR_SS_DR_MAX_RANK - large_rank]);
-    count_ptr  = &(count[PAR_SS_DR_MAX_RANK - large_rank]);
-    block_ptr  = &(block[PAR_SS_DR_MAX_RANK - large_rank]);
+    /* used by contiguous tests only */
+    tv_ptr->start_ptr  = &(tv_ptr->start[PAR_SS_DR_MAX_RANK - tv_ptr->large_rank]);
+    tv_ptr->stride_ptr = &(tv_ptr->stride[PAR_SS_DR_MAX_RANK - tv_ptr->large_rank]);
+    tv_ptr->count_ptr  = &(tv_ptr->count[PAR_SS_DR_MAX_RANK - tv_ptr->large_rank]);
+    tv_ptr->block_ptr  = &(tv_ptr->block[PAR_SS_DR_MAX_RANK - tv_ptr->large_rank]);
 
 
     /* Allocate buffers */
-    small_ds_buf_0 = (uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_size);
-    VRFY((small_ds_buf_0 != NULL), "malloc of small_ds_buf_0 succeeded");
+    tv_ptr->small_ds_buf_0 = (uint32_t *)HDmalloc(sizeof(uint32_t) * tv_ptr->small_ds_size);
+    VRFY((tv_ptr->small_ds_buf_0 != NULL), "malloc of small_ds_buf_0 succeeded");
 
-    small_ds_buf_1 = (uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_size);
-    VRFY((small_ds_buf_1 != NULL), "malloc of small_ds_buf_1 succeeded");
+    tv_ptr->small_ds_buf_1 = (uint32_t *)HDmalloc(sizeof(uint32_t) * tv_ptr->small_ds_size);
+    VRFY((tv_ptr->small_ds_buf_1 != NULL), "malloc of small_ds_buf_1 succeeded");
 
-    small_ds_buf_2 = (uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_size);
-    VRFY((small_ds_buf_2 != NULL), "malloc of small_ds_buf_2 succeeded");
+    tv_ptr->small_ds_buf_2 = (uint32_t *)HDmalloc(sizeof(uint32_t) * tv_ptr->small_ds_size);
+    VRFY((tv_ptr->small_ds_buf_2 != NULL), "malloc of small_ds_buf_2 succeeded");
 
-    small_ds_slice_buf = 
-	(uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_slice_size);
-    VRFY((small_ds_slice_buf != NULL), "malloc of small_ds_slice_buf succeeded");
+    tv_ptr->small_ds_slice_buf = 
+        (uint32_t *)HDmalloc(sizeof(uint32_t) * tv_ptr->small_ds_slice_size);
+    VRFY((tv_ptr->small_ds_slice_buf != NULL), "malloc of small_ds_slice_buf succeeded");
 
-    large_ds_buf_0 = (uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_size);
-    VRFY((large_ds_buf_0 != NULL), "malloc of large_ds_buf_0 succeeded");
+    tv_ptr->large_ds_buf_0 = (uint32_t *)HDmalloc(sizeof(uint32_t) * tv_ptr->large_ds_size);
+    VRFY((tv_ptr->large_ds_buf_0 != NULL), "malloc of large_ds_buf_0 succeeded");
 
-    large_ds_buf_1 = (uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_size);
-    VRFY((large_ds_buf_1 != NULL), "malloc of large_ds_buf_1 succeeded");
+    tv_ptr->large_ds_buf_1 = (uint32_t *)HDmalloc(sizeof(uint32_t) * tv_ptr->large_ds_size);
+    VRFY((tv_ptr->large_ds_buf_1 != NULL), "malloc of large_ds_buf_1 succeeded");
 
-    large_ds_buf_2 = (uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_size);
-    VRFY((large_ds_buf_2 != NULL), "malloc of large_ds_buf_2 succeeded");
+    tv_ptr->large_ds_buf_2 = (uint32_t *)HDmalloc(sizeof(uint32_t) * tv_ptr->large_ds_size);
+    VRFY((tv_ptr->large_ds_buf_2 != NULL), "malloc of large_ds_buf_2 succeeded");
 
-    large_ds_slice_buf = 
-	(uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_slice_size);
-    VRFY((large_ds_slice_buf != NULL), "malloc of large_ds_slice_buf succeeded");
+    tv_ptr->large_ds_slice_buf = 
+        (uint32_t *)HDmalloc(sizeof(uint32_t) * tv_ptr->large_ds_slice_size);
+    VRFY((tv_ptr->large_ds_slice_buf != NULL), "malloc of large_ds_slice_buf succeeded");
 
     /* initialize the buffers */
 
-    ptr_0 = small_ds_buf_0;
-    for(i = 0; i < (int)small_ds_size; i++)
+    ptr_0 = tv_ptr->small_ds_buf_0;
+    for(i = 0; i < (int)(tv_ptr->small_ds_size); i++)
         *ptr_0++ = (uint32_t)i;
-    HDmemset(small_ds_buf_1, 0, sizeof(uint32_t) * small_ds_size);
-    HDmemset(small_ds_buf_2, 0, sizeof(uint32_t) * small_ds_size);
+    HDmemset(tv_ptr->small_ds_buf_1, 0, sizeof(uint32_t) * tv_ptr->small_ds_size);
+    HDmemset(tv_ptr->small_ds_buf_2, 0, sizeof(uint32_t) * tv_ptr->small_ds_size);
 
-    HDmemset(small_ds_slice_buf, 0, sizeof(uint32_t) * small_ds_slice_size);
+    HDmemset(tv_ptr->small_ds_slice_buf, 0, sizeof(uint32_t) * tv_ptr->small_ds_slice_size);
 
-    ptr_0 = large_ds_buf_0;
-    for(i = 0; i < (int)large_ds_size; i++)
+    ptr_0 = tv_ptr->large_ds_buf_0;
+    for(i = 0; i < (int)(tv_ptr->large_ds_size); i++)
         *ptr_0++ = (uint32_t)i;
-    HDmemset(large_ds_buf_1, 0, sizeof(uint32_t) * large_ds_size);
-    HDmemset(large_ds_buf_2, 0, sizeof(uint32_t) * large_ds_size);
+    HDmemset(tv_ptr->large_ds_buf_1, 0, sizeof(uint32_t) * tv_ptr->large_ds_size);
+    HDmemset(tv_ptr->large_ds_buf_2, 0, sizeof(uint32_t) * tv_ptr->large_ds_size);
 
-    HDmemset(large_ds_slice_buf, 0, sizeof(uint32_t) * large_ds_slice_size);
+    HDmemset(tv_ptr->large_ds_slice_buf, 0, sizeof(uint32_t) * tv_ptr->large_ds_slice_size);
 
     filename = (const char *)GetTestParameters();
     HDassert( filename != NULL );
-#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
+#if CONTIG_HS_DR_PIO_TEST__SETUP__DEBUG 
     if ( MAINPROCESS ) {
 
-        HDfprintf(stdout, "%d: test num = %d.\n", mpi_rank, test_num);
-        HDfprintf(stdout, "%d: mpi_size = %d.\n", mpi_rank, mpi_size);
+        HDfprintf(stdout, "%d: test num = %d.\n", tv_ptr->mpi_rank, tv_ptr->test_num);
+        HDfprintf(stdout, "%d: mpi_size = %d.\n", tv_ptr->mpi_rank, tv_ptr->mpi_size);
         HDfprintf(stdout, 
                   "%d: small/large rank = %d/%d, use_collective_io = %d.\n",
-                  mpi_rank, small_rank, large_rank, (int)use_collective_io);
+                  tv_ptr->mpi_rank, tv_ptr->small_rank, tv_ptr->large_rank, 
+                  (int)use_collective_io);
         HDfprintf(stdout, "%d: edge_size = %d, chunk_edge_size = %d.\n",
-                  mpi_rank, edge_size, chunk_edge_size);
+                  tv_ptr->mpi_rank, tv_ptr->edge_size, tv_ptr->chunk_edge_size);
+        HDfprintf(stdout, "%d: checker_edge_size = %d.\n",
+                  tv_ptr->mpi_rank, tv_ptr->checker_edge_size);
         HDfprintf(stdout, "%d: small_ds_size = %d, large_ds_size = %d.\n",
-                  mpi_rank, (int)small_ds_size, (int)large_ds_size);
-        HDfprintf(stdout, "%d: filename = %s.\n", mpi_rank, filename);
+                  tv_ptr->mpi_rank, (int)(tv_ptr->small_ds_size), 
+                  (int)(tv_ptr->large_ds_size));
+        HDfprintf(stdout, "%d: filename = %s.\n", tv_ptr->mpi_rank, filename);
     }
-#endif
+#endif /* CONTIG_HS_DR_PIO_TEST__SETUP__DEBUG */
     /* ----------------------------------------
      * CREATE AN HDF5 FILE WITH PARALLEL ACCESS
      * ---------------------------------------*/
     /* setup file access template */
-    acc_tpl = create_faccess_plist(mpi_comm, mpi_info, facc_type, use_gpfs);
+    acc_tpl = create_faccess_plist(tv_ptr->mpi_comm, tv_ptr->mpi_info, facc_type, use_gpfs);
     VRFY((acc_tpl >= 0), "create_faccess_plist() succeeded");
 
     /* set the alignment -- need it large so that we aren't always hitting the
@@ -297,8 +296,8 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
     }
 
     /* create the file collectively */
-    fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, acc_tpl);
-    VRFY((fid >= 0), "H5Fcreate succeeded");
+    tv_ptr->fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, acc_tpl);
+    VRFY((tv_ptr->fid >= 0), "H5Fcreate succeeded");
 
     MESG("File opened.");
 
@@ -308,60 +307,79 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
 
 
     /* setup dims: */
-    dims[0] = (hsize_t)(mpi_size + 1);
-    dims[1] = dims[2] = dims[3] = dims[4] = (hsize_t)edge_size;
+    tv_ptr->dims[0] = (hsize_t)(tv_ptr->mpi_size + 1);
+    tv_ptr->dims[1] = tv_ptr->dims[2] = 
+        tv_ptr->dims[3] = tv_ptr->dims[4] = (hsize_t)(tv_ptr->edge_size);
 
 
     /* Create small ds dataspaces */
-    full_mem_small_ds_sid = H5Screate_simple(small_rank, dims, NULL);
-    VRFY((full_mem_small_ds_sid != 0), 
+    tv_ptr->full_mem_small_ds_sid = 
+        H5Screate_simple(tv_ptr->small_rank, tv_ptr->dims, NULL);
+    VRFY((tv_ptr->full_mem_small_ds_sid != 0), 
          "H5Screate_simple() full_mem_small_ds_sid succeeded");
 
-    full_file_small_ds_sid = H5Screate_simple(small_rank, dims, NULL);
-    VRFY((full_file_small_ds_sid != 0), 
+    tv_ptr->full_file_small_ds_sid = 
+        H5Screate_simple(tv_ptr->small_rank, tv_ptr->dims, NULL);
+    VRFY((tv_ptr->full_file_small_ds_sid != 0), 
          "H5Screate_simple() full_file_small_ds_sid succeeded");
 
-    mem_small_ds_sid = H5Screate_simple(small_rank, dims, NULL);
-    VRFY((mem_small_ds_sid != 0), 
-	 "H5Screate_simple() mem_small_ds_sid succeeded");
+    tv_ptr->mem_small_ds_sid = H5Screate_simple(tv_ptr->small_rank, tv_ptr->dims, NULL);
+    VRFY((tv_ptr->mem_small_ds_sid != 0), 
+         "H5Screate_simple() mem_small_ds_sid succeeded");
 
-    file_small_ds_sid = H5Screate_simple(small_rank, dims, NULL);
-    VRFY((file_small_ds_sid != 0), 
-         "H5Screate_simple() file_small_ds_sid succeeded");
+    tv_ptr->file_small_ds_sid_0 = H5Screate_simple(tv_ptr->small_rank, tv_ptr->dims, NULL);
+    VRFY((tv_ptr->file_small_ds_sid_0 != 0), 
+         "H5Screate_simple() file_small_ds_sid_0 succeeded");
+
+    /* used by checker board tests only */
+    tv_ptr->file_small_ds_sid_1 = H5Screate_simple(tv_ptr->small_rank, tv_ptr->dims, NULL);
+    VRFY((tv_ptr->file_small_ds_sid_1 != 0), 
+         "H5Screate_simple() file_small_ds_sid_1 succeeded");
 
-    small_ds_slice_sid = H5Screate_simple(small_rank - 1, &(dims[1]), NULL);
-    VRFY((small_ds_slice_sid != 0), 
+    tv_ptr->small_ds_slice_sid = 
+        H5Screate_simple(tv_ptr->small_rank - 1, &(tv_ptr->dims[1]), NULL);
+    VRFY((tv_ptr->small_ds_slice_sid != 0), 
          "H5Screate_simple() small_ds_slice_sid succeeded");
 
 
     /* Create large ds dataspaces */
-    full_mem_large_ds_sid = H5Screate_simple(large_rank, dims, NULL);
-    VRFY((full_mem_large_ds_sid != 0), 
+    tv_ptr->full_mem_large_ds_sid = 
+        H5Screate_simple(tv_ptr->large_rank, tv_ptr->dims, NULL);
+    VRFY((tv_ptr->full_mem_large_ds_sid != 0), 
          "H5Screate_simple() full_mem_large_ds_sid succeeded");
 
-    full_file_large_ds_sid = H5Screate_simple(large_rank, dims, NULL);
-    VRFY((full_file_large_ds_sid != FAIL), 
+    tv_ptr->full_file_large_ds_sid = 
+        H5Screate_simple(tv_ptr->large_rank, tv_ptr->dims, NULL);
+    VRFY((tv_ptr->full_file_large_ds_sid != FAIL), 
          "H5Screate_simple() full_file_large_ds_sid succeeded");
 
-    mem_large_ds_sid = H5Screate_simple(large_rank, dims, NULL);
-    VRFY((mem_large_ds_sid != FAIL), 
+    tv_ptr->mem_large_ds_sid = H5Screate_simple(tv_ptr->large_rank, tv_ptr->dims, NULL);
+    VRFY((tv_ptr->mem_large_ds_sid != FAIL), 
          "H5Screate_simple() mem_large_ds_sid succeeded");
 
-    file_large_ds_sid = H5Screate_simple(large_rank, dims, NULL);
-    VRFY((file_large_ds_sid != FAIL), 
-         "H5Screate_simple() file_large_ds_sid succeeded");
+    tv_ptr->file_large_ds_sid_0 = H5Screate_simple(tv_ptr->large_rank, tv_ptr->dims, NULL);
+    VRFY((tv_ptr->file_large_ds_sid_0 != FAIL), 
+         "H5Screate_simple() file_large_ds_sid_0 succeeded");
 
-    mem_large_ds_process_slice_sid = H5Screate_simple(large_rank, dims, NULL);
-    VRFY((mem_large_ds_process_slice_sid != FAIL), 
+    /* used by checker board tests only */
+    tv_ptr->file_large_ds_sid_1 = H5Screate_simple(tv_ptr->large_rank, tv_ptr->dims, NULL);
+    VRFY((tv_ptr->file_large_ds_sid_1 != FAIL), 
+         "H5Screate_simple() file_large_ds_sid_1 succeeded");
+
+    tv_ptr->mem_large_ds_process_slice_sid = 
+        H5Screate_simple(tv_ptr->large_rank, tv_ptr->dims, NULL);
+    VRFY((tv_ptr->mem_large_ds_process_slice_sid != FAIL), 
          "H5Screate_simple() mem_large_ds_process_slice_sid succeeded");
 
-    file_large_ds_process_slice_sid = H5Screate_simple(large_rank, dims, NULL);
-    VRFY((file_large_ds_process_slice_sid != FAIL), 
+    tv_ptr->file_large_ds_process_slice_sid = 
+        H5Screate_simple(tv_ptr->large_rank, tv_ptr->dims, NULL);
+    VRFY((tv_ptr->file_large_ds_process_slice_sid != FAIL), 
          "H5Screate_simple() file_large_ds_process_slice_sid succeeded");
 
 
-    large_ds_slice_sid = H5Screate_simple(large_rank - 1, &(dims[1]), NULL);
-    VRFY((large_ds_slice_sid != 0), 
+    tv_ptr->large_ds_slice_sid = 
+        H5Screate_simple(tv_ptr->large_rank - 1, &(tv_ptr->dims[1]), NULL);
+    VRFY((tv_ptr->large_ds_slice_sid != 0), 
          "H5Screate_simple() large_ds_slice_sid succeeded");
 
 
@@ -369,10 +387,10 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
      * large data set creation property lists to specify chunked
      * datasets.
      */
-    if ( chunk_edge_size > 0 ) {
+    if ( tv_ptr->chunk_edge_size > 0 ) {
 
         /* Under Lustre (and perhaps other parallel file systems?) we get 
-	 * locking delays when two or more processes attempt to access the 
+         * locking delays when two or more processes attempt to access the 
          * same file system block.
          *
          * To minimize this problem, I have changed chunk_dims[0] 
@@ -390,14 +408,15 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
          */
         if ( express_test == 0 ) {
 
-            chunk_dims[0] = 1;
+            tv_ptr->chunk_dims[0] = 1;
 
         } else {
 
-            chunk_dims[0] = 1;
+            tv_ptr->chunk_dims[0] = 1;
         }
-        chunk_dims[1] = chunk_dims[2] = 
-                        chunk_dims[3] = chunk_dims[4] = (hsize_t)chunk_edge_size;
+        tv_ptr->chunk_dims[1] = tv_ptr->chunk_dims[2] = 
+                                tv_ptr->chunk_dims[3] = 
+                                tv_ptr->chunk_dims[4] = (hsize_t)(tv_ptr->chunk_edge_size);
 
         small_ds_dcpl_id = H5Pcreate(H5P_DATASET_CREATE);
         VRFY((ret != FAIL), "H5Pcreate() small_ds_dcpl_id succeeded");
@@ -405,7 +424,7 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
         ret = H5Pset_layout(small_ds_dcpl_id, H5D_CHUNKED);
         VRFY((ret != FAIL), "H5Pset_layout() small_ds_dcpl_id succeeded");
 
-        ret = H5Pset_chunk(small_ds_dcpl_id, small_rank, chunk_dims);
+        ret = H5Pset_chunk(small_ds_dcpl_id, tv_ptr->small_rank, tv_ptr->chunk_dims);
         VRFY((ret != FAIL), "H5Pset_chunk() small_ds_dcpl_id succeeded");
 
 
@@ -415,89 +434,88 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
         ret = H5Pset_layout(large_ds_dcpl_id, H5D_CHUNKED);
         VRFY((ret != FAIL), "H5Pset_layout() large_ds_dcpl_id succeeded");
 
-        ret = H5Pset_chunk(large_ds_dcpl_id, large_rank, chunk_dims);
+        ret = H5Pset_chunk(large_ds_dcpl_id, tv_ptr->large_rank, tv_ptr->chunk_dims);
         VRFY((ret != FAIL), "H5Pset_chunk() large_ds_dcpl_id succeeded");
     }
 
     /* create the small dataset */
-    small_dataset = H5Dcreate2(fid, "small_dataset", dset_type,
-                               file_small_ds_sid, H5P_DEFAULT,
-                               small_ds_dcpl_id, H5P_DEFAULT);
+    tv_ptr->small_dataset = H5Dcreate2(tv_ptr->fid, "small_dataset", tv_ptr->dset_type,
+                                       tv_ptr->file_small_ds_sid_0, H5P_DEFAULT,
+                                       small_ds_dcpl_id, H5P_DEFAULT);
     VRFY((ret != FAIL), "H5Dcreate2() small_dataset succeeded");
 
     /* create the large dataset */
-    large_dataset = H5Dcreate2(fid, "large_dataset", dset_type,
-                               file_large_ds_sid, H5P_DEFAULT,
-                               large_ds_dcpl_id, H5P_DEFAULT);
+    tv_ptr->large_dataset = H5Dcreate2(tv_ptr->fid, "large_dataset", tv_ptr->dset_type,
+                                       tv_ptr->file_large_ds_sid_0, H5P_DEFAULT,
+                                       large_ds_dcpl_id, H5P_DEFAULT);
     VRFY((ret != FAIL), "H5Dcreate2() large_dataset succeeded");
 
 
-
     /* setup xfer property list */
-    xfer_plist = H5Pcreate(H5P_DATASET_XFER);
-    VRFY((xfer_plist >= 0), "H5Pcreate(H5P_DATASET_XFER) succeeded");
+    tv_ptr->xfer_plist = H5Pcreate(H5P_DATASET_XFER);
+    VRFY((tv_ptr->xfer_plist >= 0), "H5Pcreate(H5P_DATASET_XFER) succeeded");
 
     if(use_collective_io) {
-        ret = H5Pset_dxpl_mpio(xfer_plist, H5FD_MPIO_COLLECTIVE);
+        ret = H5Pset_dxpl_mpio(tv_ptr->xfer_plist, H5FD_MPIO_COLLECTIVE);
         VRFY((ret >= 0), "H5Pset_dxpl_mpio succeeded");
     }
 
     /* setup selection to write initial data to the small and large data sets */
-    start[0] = (hsize_t)mpi_rank;
-    stride[0] = (hsize_t)(2 * (mpi_size + 1));
-    count[0] = 1;
-    block[0] = 1;
+    tv_ptr->start[0] = (hsize_t)(tv_ptr->mpi_rank);
+    tv_ptr->stride[0] = (hsize_t)(2 * (tv_ptr->mpi_size + 1));
+    tv_ptr->count[0] = 1;
+    tv_ptr->block[0] = 1;
 
-    for ( i = 1; i < large_rank; i++ ) {
+    for ( i = 1; i < tv_ptr->large_rank; i++ ) {
 
-        start[i] = 0;
-        stride[i] = (hsize_t)(2 * edge_size);
-        count[i] = 1;
-        block[i] = (hsize_t)edge_size;
+        tv_ptr->start[i] = 0;
+        tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size);
+        tv_ptr->count[i] = 1;
+        tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size);
     }
 
     /* setup selections for writing initial data to the small data set */
-    ret = H5Sselect_hyperslab(mem_small_ds_sid,
+    ret = H5Sselect_hyperslab(tv_ptr->mem_small_ds_sid,
                               H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
+                              tv_ptr->start,
+                              tv_ptr->stride,
+                              tv_ptr->count,
+                              tv_ptr->block);
     VRFY((ret >= 0), "H5Sselect_hyperslab(mem_small_ds_sid, set) suceeded");
 
-    ret = H5Sselect_hyperslab(file_small_ds_sid,
+    ret = H5Sselect_hyperslab(tv_ptr->file_small_ds_sid_0,
                               H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
-    VRFY((ret >= 0), "H5Sselect_hyperslab(file_small_ds_sid, set) suceeded");
+                              tv_ptr->start,
+                              tv_ptr->stride,
+                              tv_ptr->count,
+                              tv_ptr->block);
+    VRFY((ret >= 0), "H5Sselect_hyperslab(file_small_ds_sid_0, set) suceeded");
 
     if ( MAINPROCESS ) { /* add an additional slice to the selections */
 
-        start[0] = (hsize_t)mpi_size;
+        tv_ptr->start[0] = (hsize_t)(tv_ptr->mpi_size);
 
-        ret = H5Sselect_hyperslab(mem_small_ds_sid,
+        ret = H5Sselect_hyperslab(tv_ptr->mem_small_ds_sid,
                                   H5S_SELECT_OR,
-                                  start,
-                                  stride,
-                                  count,
-                                  block);
+                                  tv_ptr->start,
+                                  tv_ptr->stride,
+                                  tv_ptr->count,
+                                  tv_ptr->block);
         VRFY((ret>= 0), "H5Sselect_hyperslab(mem_small_ds_sid, or) suceeded");
 
-        ret = H5Sselect_hyperslab(file_small_ds_sid,
+        ret = H5Sselect_hyperslab(tv_ptr->file_small_ds_sid_0,
                                   H5S_SELECT_OR,
-                                  start,
-                                  stride,
-                                  count,
-                                  block);
-        VRFY((ret>= 0), "H5Sselect_hyperslab(file_small_ds_sid, or) suceeded");
+                                  tv_ptr->start,
+                                  tv_ptr->stride,
+                                  tv_ptr->count,
+                                  tv_ptr->block);
+        VRFY((ret>= 0), "H5Sselect_hyperslab(file_small_ds_sid_0, or) suceeded");
     }
 
 
     /* write the initial value of the small data set to file */
-    ret = H5Dwrite(small_dataset, dset_type, mem_small_ds_sid, file_small_ds_sid,
-                   xfer_plist, small_ds_buf_0);
+    ret = H5Dwrite(tv_ptr->small_dataset, tv_ptr->dset_type, tv_ptr->mem_small_ds_sid, 
+                   tv_ptr->file_small_ds_sid_0, tv_ptr->xfer_plist, tv_ptr->small_ds_buf_0);
 
     VRFY((ret >= 0), "H5Dwrite() small_dataset initial write succeeded");
 
@@ -511,24 +529,24 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
 
     /* read the small data set back to verify that it contains the 
      * expected data.  Note that each process reads in the entire 
-     * data set.
+     * data set and verifies it.
      */
-    ret = H5Dread(small_dataset,
+    ret = H5Dread(tv_ptr->small_dataset,
                   H5T_NATIVE_UINT32,
-                  full_mem_small_ds_sid,
-                  full_file_small_ds_sid,
-                  xfer_plist,
-                  small_ds_buf_1);
+                  tv_ptr->full_mem_small_ds_sid,
+                  tv_ptr->full_file_small_ds_sid,
+                  tv_ptr->xfer_plist,
+                  tv_ptr->small_ds_buf_1);
     VRFY((ret >= 0), "H5Dread() small_dataset initial read succeeded");
 
 
     /* verify that the correct data was written to the small data set */
     expected_value = 0;
     mis_match = FALSE;
-    ptr_1 = small_ds_buf_1;
+    ptr_1 = tv_ptr->small_ds_buf_1;
 
     i = 0;
-    for ( i = 0; i < (int)small_ds_size; i++ ) {
+    for ( i = 0; i < (int)(tv_ptr->small_ds_size); i++ ) {
 
         if ( *ptr_1 != expected_value ) {
 
@@ -540,72 +558,72 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
     VRFY( (mis_match == FALSE), "small ds init data good.");
 
 
-
     /* setup selections for writing initial data to the large data set */
 
-    start[0] = (hsize_t)mpi_rank;
+    tv_ptr->start[0] = (hsize_t)(tv_ptr->mpi_rank);
 
-    ret = H5Sselect_hyperslab(mem_large_ds_sid,
+    ret = H5Sselect_hyperslab(tv_ptr->mem_large_ds_sid,
                               H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
+                              tv_ptr->start,
+                              tv_ptr->stride,
+                              tv_ptr->count,
+                              tv_ptr->block);
     VRFY((ret >= 0), "H5Sselect_hyperslab(mem_large_ds_sid, set) suceeded");
 
-    ret = H5Sselect_hyperslab(file_large_ds_sid,
+    ret = H5Sselect_hyperslab(tv_ptr->file_large_ds_sid_0,
                               H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
-    VRFY((ret >= 0), "H5Sselect_hyperslab(file_large_ds_sid, set) suceeded");
+                              tv_ptr->start,
+                              tv_ptr->stride,
+                              tv_ptr->count,
+                              tv_ptr->block);
+    VRFY((ret >= 0), "H5Sselect_hyperslab(file_large_ds_sid_0, set) suceeded");
  
     /* In passing, setup the process slice data spaces as well */
 
-    ret = H5Sselect_hyperslab(mem_large_ds_process_slice_sid,
+    ret = H5Sselect_hyperslab(tv_ptr->mem_large_ds_process_slice_sid,
                               H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
+                              tv_ptr->start,
+                              tv_ptr->stride,
+                              tv_ptr->count,
+                              tv_ptr->block);
     VRFY((ret >= 0), 
          "H5Sselect_hyperslab(mem_large_ds_process_slice_sid, set) suceeded");
 
-    ret = H5Sselect_hyperslab(file_large_ds_process_slice_sid,
+    ret = H5Sselect_hyperslab(tv_ptr->file_large_ds_process_slice_sid,
                               H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
+                              tv_ptr->start,
+                              tv_ptr->stride,
+                              tv_ptr->count,
+                              tv_ptr->block);
     VRFY((ret >= 0), 
          "H5Sselect_hyperslab(file_large_ds_process_slice_sid, set) suceeded");
 
     if ( MAINPROCESS ) { /* add an additional slice to the selections */
 
-        start[0] = (hsize_t)mpi_size;
+        tv_ptr->start[0] = (hsize_t)(tv_ptr->mpi_size);
 
-        ret = H5Sselect_hyperslab(mem_large_ds_sid,
+        ret = H5Sselect_hyperslab(tv_ptr->mem_large_ds_sid,
                                   H5S_SELECT_OR,
-                                  start,
-                                  stride,
-                                  count,
-                                  block);
+                                  tv_ptr->start,
+                                  tv_ptr->stride,
+                                  tv_ptr->count,
+                                  tv_ptr->block);
         VRFY((ret>= 0), "H5Sselect_hyperslab(mem_large_ds_sid, or) suceeded");
 
-        ret = H5Sselect_hyperslab(file_large_ds_sid,
+        ret = H5Sselect_hyperslab(tv_ptr->file_large_ds_sid_0,
                                   H5S_SELECT_OR,
-                                  start,
-                                  stride,
-                                  count,
-                                  block);
-        VRFY((ret>= 0), "H5Sselect_hyperslab(file_large_ds_sid, or) suceeded");
+                                  tv_ptr->start,
+                                  tv_ptr->stride,
+                                  tv_ptr->count,
+                                  tv_ptr->block);
+        VRFY((ret>= 0), "H5Sselect_hyperslab(file_large_ds_sid_0, or) suceeded");
     }
 
 
     /* write the initial value of the large data set to file */
-    ret = H5Dwrite(large_dataset, dset_type, mem_large_ds_sid, file_large_ds_sid,
-                   xfer_plist, large_ds_buf_0);
+    ret = H5Dwrite(tv_ptr->large_dataset, tv_ptr->dset_type, 
+                   tv_ptr->mem_large_ds_sid, tv_ptr->file_large_ds_sid_0, 
+                   tv_ptr->xfer_plist, tv_ptr->large_ds_buf_0);
     if ( ret < 0 ) H5Eprint2(H5E_DEFAULT, stderr);
     VRFY((ret >= 0), "H5Dwrite() large_dataset initial write succeeded");
 
@@ -618,26 +636,26 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
     }
 
 
-    /* read the small data set back to verify that it contains the 
+    /* read the large data set back to verify that it contains the 
      * expected data.  Note that each process reads in the entire 
      * data set.
      */
-    ret = H5Dread(large_dataset,
+    ret = H5Dread(tv_ptr->large_dataset,
                   H5T_NATIVE_UINT32,
-                  full_mem_large_ds_sid,
-                  full_file_large_ds_sid,
-                  xfer_plist,
-                  large_ds_buf_1);
+                  tv_ptr->full_mem_large_ds_sid,
+                  tv_ptr->full_file_large_ds_sid,
+                  tv_ptr->xfer_plist,
+                  tv_ptr->large_ds_buf_1);
     VRFY((ret >= 0), "H5Dread() large_dataset initial read succeeded");
 
 
     /* verify that the correct data was written to the large data set */
     expected_value = 0;
     mis_match = FALSE;
-    ptr_1 = large_ds_buf_1;
+    ptr_1 = tv_ptr->large_ds_buf_1;
 
     i = 0;
-    for ( i = 0; i < (int)large_ds_size; i++ ) {
+    for ( i = 0; i < (int)(tv_ptr->large_ds_size); i++ ) {
 
         if ( *ptr_1 != expected_value ) {
 
@@ -657,18 +675,170 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
         VRFY((mrc==MPI_SUCCESS), "Sync initial values check");
     }
 
+    return;
+
+} /* hs_dr_pio_test__setup() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	hs_dr_pio_test__takedown()
+ *
+ * Purpose:	Do takedown after tests of I/O to/from hyperslab selections 
+ *		of different rank in the parallel case.
+ *
+ * Return:	void
+ *
+ * Programmer:	JRM -- 9/18/09
+ *
+ * Modifications:
+ *
+ *		None.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define HS_DR_PIO_TEST__TAKEDOWN__DEBUG 0
+
+static void
+hs_dr_pio_test__takedown( struct hs_dr_pio_test_vars_t * tv_ptr)
+{
+#if HS_DR_PIO_TEST__TAKEDOWN__DEBUG 
+    const char *fcnName = "hs_dr_pio_test__takedown()";
+#endif /* HS_DR_PIO_TEST__TAKEDOWN__DEBUG */
+    int		mpi_rank;       /* needed by the VRFY macro */
+    herr_t	ret;		/* Generic return value */
+
+    /* initialize the local copy of mpi_rank */
+    mpi_rank = tv_ptr->mpi_rank;
+
+    /* Close property lists */
+    if ( tv_ptr->xfer_plist != H5P_DEFAULT ) {
+        ret = H5Pclose(tv_ptr->xfer_plist);
+        VRFY((ret != FAIL), "H5Pclose(xfer_plist) succeeded");
+    }
+
+    /* Close dataspaces */
+    ret = H5Sclose(tv_ptr->full_mem_small_ds_sid);
+    VRFY((ret != FAIL), "H5Sclose(full_mem_small_ds_sid) succeeded");
+
+    ret = H5Sclose(tv_ptr->full_file_small_ds_sid);
+    VRFY((ret != FAIL), "H5Sclose(full_file_small_ds_sid) succeeded");
+
+    ret = H5Sclose(tv_ptr->mem_small_ds_sid);
+    VRFY((ret != FAIL), "H5Sclose(mem_small_ds_sid) succeeded");
+
+    ret = H5Sclose(tv_ptr->file_small_ds_sid_0);
+    VRFY((ret != FAIL), "H5Sclose(file_small_ds_sid_0) succeeded");
+
+    ret = H5Sclose(tv_ptr->file_small_ds_sid_1);
+    VRFY((ret != FAIL), "H5Sclose(file_small_ds_sid_1) succeeded");
+
+    ret = H5Sclose(tv_ptr->small_ds_slice_sid);
+    VRFY((ret != FAIL), "H5Sclose(small_ds_slice_sid) succeeded");
+
+    ret = H5Sclose(tv_ptr->full_mem_large_ds_sid);
+    VRFY((ret != FAIL), "H5Sclose(full_mem_large_ds_sid) succeeded");
+
+    ret = H5Sclose(tv_ptr->full_file_large_ds_sid);
+    VRFY((ret != FAIL), "H5Sclose(full_file_large_ds_sid) succeeded");
+
+    ret = H5Sclose(tv_ptr->mem_large_ds_sid);
+    VRFY((ret != FAIL), "H5Sclose(mem_large_ds_sid) succeeded");
+
+    ret = H5Sclose(tv_ptr->file_large_ds_sid_0);
+    VRFY((ret != FAIL), "H5Sclose(file_large_ds_sid_0) succeeded");
+
+    ret = H5Sclose(tv_ptr->file_large_ds_sid_1);
+    VRFY((ret != FAIL), "H5Sclose(file_large_ds_sid_1) succeeded");
+
+    ret = H5Sclose(tv_ptr->mem_large_ds_process_slice_sid);
+    VRFY((ret != FAIL), "H5Sclose(mem_large_ds_process_slice_sid) succeeded");
+
+    ret = H5Sclose(tv_ptr->file_large_ds_process_slice_sid);
+    VRFY((ret != FAIL), "H5Sclose(file_large_ds_process_slice_sid) succeeded");
+
+    ret = H5Sclose(tv_ptr->large_ds_slice_sid);
+    VRFY((ret != FAIL), "H5Sclose(large_ds_slice_sid) succeeded");
+
+    /* Close Datasets */
+    ret = H5Dclose(tv_ptr->small_dataset);
+    VRFY((ret != FAIL), "H5Dclose(small_dataset) succeeded");
+
+    ret = H5Dclose(tv_ptr->large_dataset);
+    VRFY((ret != FAIL), "H5Dclose(large_dataset) succeeded");
+
+    /* close the file collectively */
+    MESG("about to close file.");
+    ret = H5Fclose(tv_ptr->fid);
+    VRFY((ret != FAIL), "file close succeeded");
+
+    /* Free memory buffers */
+
+    if ( tv_ptr->small_ds_buf_0 != NULL ) HDfree(tv_ptr->small_ds_buf_0);
+    if ( tv_ptr->small_ds_buf_1 != NULL ) HDfree(tv_ptr->small_ds_buf_1);
+    if ( tv_ptr->small_ds_buf_2 != NULL ) HDfree(tv_ptr->small_ds_buf_2);
+    if ( tv_ptr->small_ds_slice_buf != NULL ) HDfree(tv_ptr->small_ds_slice_buf);
+
+    if ( tv_ptr->large_ds_buf_0 != NULL ) HDfree(tv_ptr->large_ds_buf_0);
+    if ( tv_ptr->large_ds_buf_1 != NULL ) HDfree(tv_ptr->large_ds_buf_1);
+    if ( tv_ptr->large_ds_buf_2 != NULL ) HDfree(tv_ptr->large_ds_buf_2);
+    if ( tv_ptr->large_ds_slice_buf != NULL ) HDfree(tv_ptr->large_ds_slice_buf);
+
+    return;
+
+} /* hs_dr_pio_test__takedown() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	contig_hs_dr_pio_test__d2m_l2s()
+ *
+ * Purpose:	Part one of a series of tests of I/O to/from hyperslab 
+ *		selections of different rank in the parallel.
+ *
+ *		Verify that we can read from disk correctly using 
+ *		selections of different rank that H5S_select_shape_same() 
+ *		views as being of the same shape.
+ *
+ *              In this function, we test this by reading small_rank - 1 
+ *		slices from the on disk large cube, and verifying that the 
+ *		data read is correct.  Verify that H5S_select_shape_same() 
+ *		returns true on the memory and file selections.
+ *
+ * Return:	void
+ *
+ * Programmer:	JRM -- 9/10/11
+ *
+ * Modifications:
+ *
+ *		None.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define CONTIG_HS_DR_PIO_TEST__D2M_L2S__DEBUG 0
+
+static void
+contig_hs_dr_pio_test__d2m_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
+{
+#if CONTIG_HS_DR_PIO_TEST__D2M_L2S__DEBUG 
+    const char *fcnName = "contig_hs_dr_pio_test__run_test()";
+#endif /* CONTIG_HS_DR_PIO_TEST__D2M_L2S__DEBUG */
+    hbool_t	mis_match = FALSE;
+    int		i, j, k, l;
+    size_t	n;
+    int		mpi_rank; /* needed by the VRFY macro */
+    uint32_t	expected_value;
+    uint32_t  * ptr_1;
+    htri_t      check;          /* Shape comparison return value */
+    herr_t	ret;		/* Generic return value */
+
+    /* initialize the local copy of mpi_rank */
+    mpi_rank = tv_ptr->mpi_rank;
 
-    /* first, verify that we can read from disk correctly using selections
-     * of different rank that H5S_select_shape_same() views as being of the
-     * same shape.
-     *
-     * Start by reading small_rank-D - 1 slice from the on disk large cube, 
-     * and verifying that the data read is correct.  Verify that 
-     * H5S_select_shape_same() returns true on the memory and file selections.
-     */
 
     /* We have already done a H5Sselect_all() on the data space 
-     * small_ds_slice_sid, so no need to call H5Sselect_all() again.
+     * small_ds_slice_sid in the initialization phase, so no need to 
+     * call H5Sselect_all() again.
      */
 
     /* set up start, stride, count, and block -- note that we will
@@ -676,27 +846,28 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
      */
     for ( i = 0; i < PAR_SS_DR_MAX_RANK; i++ ) {
 
-        start[i] = 0;
-        stride[i] = (hsize_t)(2 * edge_size);
-        count[i] = 1;
-        if ( (PAR_SS_DR_MAX_RANK - i) > (small_rank - 1) ) {
+        tv_ptr->start[i] = 0;
+        tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size);
+        tv_ptr->count[i] = 1;
+        if ( (PAR_SS_DR_MAX_RANK - i) > (tv_ptr->small_rank - 1) ) {
 
-            block[i] = 1;
+            tv_ptr->block[i] = 1;
 
         } else {
 
-            block[i] = (hsize_t)edge_size;
+            tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size);
         }
     }
 
     /* zero out the buffer we will be reading into */
-    HDmemset(small_ds_slice_buf, 0, sizeof(uint32_t) * small_ds_slice_size);
+    HDmemset(tv_ptr->small_ds_slice_buf, 0, sizeof(uint32_t) * tv_ptr->small_ds_slice_size);
 
-#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
+#if CONTIG_HS_DR_PIO_TEST__D2M_L2S__DEBUG 
     HDfprintf(stdout, 
               "%s reading slices from big cube on disk into small cube slice.\n",
               fcnName);
-#endif 
+#endif /* CONTIG_HS_DR_PIO_TEST__D2M_L2S__DEBUG */
+
     /* in serial versions of this test, we loop through all the dimensions
      * of the large data set.  However, in the parallel version, each 
      * process only works with that slice of the large cube indicated
@@ -704,9 +875,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
      * mpi_rank, and don't itterate over it.
      */
 
-    if ( PAR_SS_DR_MAX_RANK - large_rank == 0 ) {
+    if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 0 ) {
 
-        i = mpi_rank;
+        i = tv_ptr->mpi_rank;
 
     } else {
 
@@ -719,9 +890,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
      * test.
      */
 
-    if ( PAR_SS_DR_MAX_RANK - large_rank == 1 ) {
+    if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 1 ) {
 
-        j = mpi_rank;
+        j = tv_ptr->mpi_rank;
 
     } else {
 
@@ -729,9 +900,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
     }
 
     do {
-        if ( PAR_SS_DR_MAX_RANK - large_rank == 2 ) {
+        if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 2 ) {
 
-            k = mpi_rank;
+            k = tv_ptr->mpi_rank;
 
         } else {
 
@@ -751,145 +922,213 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
 
             l = 0;
             do {
-                /* we know that small_rank - 1 >= 1 and that 
-                 * large_rank > small_rank by the assertions at the head 
-                 * of this function.  Thus no need for another inner loop.
-                 */
-                start[0] = (hsize_t)i;
-                start[1] = (hsize_t)j;
-                start[2] = (hsize_t)k;
-                start[3] = (hsize_t)l;
-                start[4] = 0;
-
-                ret = H5Sselect_hyperslab(file_large_ds_sid,
-                                          H5S_SELECT_SET,
-                                          start_ptr,
-                                          stride_ptr,
-                                          count_ptr,
-                                          block_ptr);
-                VRFY((ret != FAIL), 
-                     "H5Sselect_hyperslab(file_large_cube_sid) succeeded");
-
-
-                /* verify that H5S_select_shape_same() reports the two
-                 * selections as having the same shape.
-                 */
-                check = H5S_select_shape_same_test(small_ds_slice_sid,
-                                                   file_large_ds_sid);
-                VRFY((check == TRUE), "H5S_select_shape_same_test passed");
-
-
-                /* Read selection from disk */
-#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
-                HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", 
-                          fcnName, (int)mpi_rank, 
-                          (int)start[0], (int)start[1], (int)start[2], 
-                          (int)start[3], (int)start[4]);
-                HDfprintf(stdout, "%s slice/file extent dims = %d/%d.\n",
-                          fcnName,
-                          H5Sget_simple_extent_ndims(small_ds_slice_sid),
-                          H5Sget_simple_extent_ndims(file_large_ds_sid));
-#endif 
-                ret = H5Dread(large_dataset,
-                              H5T_NATIVE_UINT32,
-                              small_ds_slice_sid,
-                              file_large_ds_sid,
-                              xfer_plist,
-                              small_ds_slice_buf);
-                VRFY((ret >= 0), "H5Dread() slice from large ds succeeded.");
+                if ( (tv_ptr->skips)++ < tv_ptr->max_skips ) { /* skip the test */
 
+ 		    (tv_ptr->tests_skipped)++;
 
-                /* verify that expected data is retrieved */
+                } else { /* run the test */
 
-                mis_match = FALSE;
-                ptr_1 = small_ds_slice_buf;
-                expected_value = (uint32_t)(
-			(i * edge_size * edge_size * edge_size * edge_size) +
-                        (j * edge_size * edge_size * edge_size) +
-                        (k * edge_size * edge_size) +
-                        (l * edge_size));
+                    tv_ptr->skips = 0; /* reset the skips counter */
 
-                for ( n = 0; n < small_ds_slice_size; n++ ) {
+                    /* we know that small_rank - 1 >= 1 and that 
+                     * large_rank > small_rank by the assertions at the head 
+                     * of this function.  Thus no need for another inner loop.
+                     */
+                    tv_ptr->start[0] = (hsize_t)i;
+                    tv_ptr->start[1] = (hsize_t)j;
+                    tv_ptr->start[2] = (hsize_t)k;
+                    tv_ptr->start[3] = (hsize_t)l;
+                    tv_ptr->start[4] = 0;
+
+                    ret = H5Sselect_hyperslab(tv_ptr->file_large_ds_sid_0,
+                                              H5S_SELECT_SET,
+                                              tv_ptr->start_ptr,
+                                              tv_ptr->stride_ptr,
+                                              tv_ptr->count_ptr,
+                                              tv_ptr->block_ptr);
+                    VRFY((ret != FAIL), 
+                         "H5Sselect_hyperslab(file_large_cube_sid) succeeded");
+
+
+                    /* verify that H5S_select_shape_same() reports the two
+                     * selections as having the same shape.
+                     */
+                    check = H5S_select_shape_same_test(tv_ptr->small_ds_slice_sid,
+                                                       tv_ptr->file_large_ds_sid_0);
+                    VRFY((check == TRUE), "H5S_select_shape_same_test passed");
+
+
+                    /* Read selection from disk */
+#if CONTIG_HS_DR_PIO_TEST__D2M_L2S__DEBUG 
+                    HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", 
+                              fcnName, (int)(tv_ptr->mpi_rank), 
+                              (int)(tv_ptr->start[0]), (int)(tv_ptr->start[1]), 
+                              (int)(tv_ptr->start[2]), (int)(tv_ptr->start[3]), 
+                              (int)(tv_ptr->start[4]));
+                    HDfprintf(stdout, "%s slice/file extent dims = %d/%d.\n",
+                              fcnName,
+                              H5Sget_simple_extent_ndims(tv_ptr->small_ds_slice_sid),
+                              H5Sget_simple_extent_ndims(tv_ptr->file_large_ds_sid_0));
+#endif /* CONTIG_HS_DR_PIO_TEST__D2M_L2S__DEBUG */
+                    ret = H5Dread(tv_ptr->large_dataset,
+                                  H5T_NATIVE_UINT32,
+                                  tv_ptr->small_ds_slice_sid,
+                                  tv_ptr->file_large_ds_sid_0,
+                                  tv_ptr->xfer_plist,
+                                  tv_ptr->small_ds_slice_buf);
+                    VRFY((ret >= 0), "H5Dread() slice from large ds succeeded.");
+
+
+                    /* verify that expected data is retrieved */
+
+                    mis_match = FALSE;
+                    ptr_1 = tv_ptr->small_ds_slice_buf;
+                    expected_value = (uint32_t)(
+                        (i * tv_ptr->edge_size * tv_ptr->edge_size * 
+                             tv_ptr->edge_size * tv_ptr->edge_size) +
+                        (j * tv_ptr->edge_size * tv_ptr->edge_size * tv_ptr->edge_size) +
+                        (k * tv_ptr->edge_size * tv_ptr->edge_size) +
+                        (l * tv_ptr->edge_size));
+
+                    for ( n = 0; n < tv_ptr->small_ds_slice_size; n++ ) {
+
+                        if ( *ptr_1 != expected_value ) {
+
+                            mis_match = TRUE;
+                        }
 
-                    if ( *ptr_1 != expected_value ) {
+                        *ptr_1 = 0; /* zero data for next use */
 
-                        mis_match = TRUE;
+                        ptr_1++;
+                        expected_value++;
                     }
 
-                    *ptr_1 = 0; /* zero data for next use */
+                    VRFY((mis_match == FALSE), 
+                         "small slice read from large ds data good.");
 
-                    ptr_1++;
-                    expected_value++;
+ 		    (tv_ptr->tests_run)++;
                 }
 
-                VRFY((mis_match == FALSE), 
-                     "small slice read from large ds data good.");
                 l++;
 
-            } while ( ( large_rank > 2 ) &&
-                      ( (small_rank - 1) <= 1 ) &&
-                      ( l < edge_size ) );
+                (tv_ptr->total_tests)++;
+
+            } while ( ( tv_ptr->large_rank > 2 ) &&
+                      ( (tv_ptr->small_rank - 1) <= 1 ) &&
+                      ( l < tv_ptr->edge_size ) );
             k++;
-        } while ( ( large_rank > 3 ) &&
-                  ( (small_rank - 1) <= 2 ) &&
-                  ( k < edge_size ) );
+        } while ( ( tv_ptr->large_rank > 3 ) &&
+                  ( (tv_ptr->small_rank - 1) <= 2 ) &&
+                  ( k < tv_ptr->edge_size ) );
         j++;
-    } while ( ( large_rank > 4 ) &&
-              ( (small_rank - 1) <= 3 ) &&
-              ( j < edge_size ) );
+    } while ( ( tv_ptr->large_rank > 4 ) &&
+              ( (tv_ptr->small_rank - 1) <= 3 ) &&
+              ( j < tv_ptr->edge_size ) );
+
+    return;
 
+} /* contig_hs_dr_pio_test__d2m_l2s() */
 
-    /* similarly, read slices of the on disk small data set into slices 
+
+/*-------------------------------------------------------------------------
+ * Function:	contig_hs_dr_pio_test__d2m_s2l()
+ *
+ * Purpose:	Part two of a series of tests of I/O to/from hyperslab 
+ *		selections of different rank in the parallel.
+ *
+ *		Verify that we can read from disk correctly using 
+ *		selections of different rank that H5S_select_shape_same() 
+ *		views as being of the same shape.
+ *
+ *		In this function, we test this by reading slices of the 
+ *		on disk small data set into slices through the in memory 
+ *		large data set, and verify that the correct data (and 
+ *		only the correct data) is read.
+ *
+ * Return:	void
+ *
+ * Programmer:	JRM -- 8/10/11
+ *
+ * Modifications:
+ *
+ *		None.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define CONTIG_HS_DR_PIO_TEST__D2M_S2L__DEBUG 0
+
+static void
+contig_hs_dr_pio_test__d2m_s2l(struct hs_dr_pio_test_vars_t * tv_ptr)
+{
+#if CONTIG_HS_DR_PIO_TEST__D2M_S2L__DEBUG 
+    const char *fcnName = "contig_hs_dr_pio_test__d2m_s2l()";
+#endif /* CONTIG_HS_DR_PIO_TEST__D2M_S2L__DEBUG */
+    hbool_t	mis_match = FALSE;
+    int		i, j, k, l;
+    size_t	n;
+    int		mpi_rank; /* needed by the VRFY macro */
+    size_t      start_index;
+    size_t      stop_index;
+    uint32_t	expected_value;
+    uint32_t  * ptr_1;
+    htri_t      check;          /* Shape comparison return value */
+    herr_t	ret;		/* Generic return value */
+
+    /* initialize the local copy of mpi_rank */
+    mpi_rank = tv_ptr->mpi_rank;
+
+    /* Read slices of the on disk small data set into slices 
      * through the in memory large data set, and verify that the correct 
      * data (and only the correct data) is read.
      */
 
-    start[0] = (hsize_t)mpi_rank;
-    stride[0] = (hsize_t)(2 * (mpi_size + 1));
-    count[0] = 1;
-    block[0] = 1;
+    tv_ptr->start[0] = (hsize_t)(tv_ptr->mpi_rank);
+    tv_ptr->stride[0] = (hsize_t)(2 * (tv_ptr->mpi_size + 1));
+    tv_ptr->count[0] = 1;
+    tv_ptr->block[0] = 1;
 
-    for ( i = 1; i < large_rank; i++ ) {
+    for ( i = 1; i < tv_ptr->large_rank; i++ ) {
 
-        start[i] = 0;
-        stride[i] = (hsize_t)(2 * edge_size);
-        count[i] = 1;
-        block[i] = (hsize_t)edge_size;
+        tv_ptr->start[i] = 0;
+        tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size);
+        tv_ptr->count[i] = 1;
+        tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size);
     }
 
-    ret = H5Sselect_hyperslab(file_small_ds_sid,
+    ret = H5Sselect_hyperslab(tv_ptr->file_small_ds_sid_0,
                               H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
-    VRFY((ret >= 0), "H5Sselect_hyperslab(file_small_ds_sid, set) suceeded");
+                              tv_ptr->start,
+                              tv_ptr->stride,
+                              tv_ptr->count,
+                              tv_ptr->block);
+    VRFY((ret >= 0), "H5Sselect_hyperslab(file_small_ds_sid_0, set) suceeded");
 
 
-#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
+#if CONTIG_HS_DR_PIO_TEST__D2M_S2L__DEBUG 
     HDfprintf(stdout, 
       "%s reading slices of on disk small data set into slices of big data set.\n",
               fcnName);
-#endif 
+#endif /* CONTIG_HS_DR_PIO_TEST__D2M_S2L__DEBUG */
 
     /* zero out the in memory large ds */
-    HDmemset(large_ds_buf_1, 0, sizeof(uint32_t) * large_ds_size);
+    HDmemset(tv_ptr->large_ds_buf_1, 0, sizeof(uint32_t) * tv_ptr->large_ds_size);
 
     /* set up start, stride, count, and block -- note that we will
      * change start[] so as to read slices of the large cube.
      */
     for ( i = 0; i < PAR_SS_DR_MAX_RANK; i++ ) {
 
-        start[i] = 0;
-        stride[i] = (hsize_t)(2 * edge_size);
-        count[i] = 1;
-        if ( (PAR_SS_DR_MAX_RANK - i) > (small_rank - 1) ) {
+        tv_ptr->start[i] = 0;
+        tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size);
+        tv_ptr->count[i] = 1;
+        if ( (PAR_SS_DR_MAX_RANK - i) > (tv_ptr->small_rank - 1) ) {
 
-            block[i] = 1;
+            tv_ptr->block[i] = 1;
 
         } else {
 
-            block[i] = (hsize_t)edge_size;
+            tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size);
         }
     }
 
@@ -904,9 +1143,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
      */
 
 
-    if ( PAR_SS_DR_MAX_RANK - large_rank == 0 ) {
+    if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 0 ) {
 
-        i = mpi_rank;
+        i = tv_ptr->mpi_rank;
 
     } else {
 
@@ -919,9 +1158,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
      * test.
      */
 
-    if ( PAR_SS_DR_MAX_RANK - large_rank == 1 ) {
+    if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 1 ) {
 
-        j = mpi_rank;
+        j = tv_ptr->mpi_rank;
 
     } else {
 
@@ -929,9 +1168,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
     }
 
     do {
-        if ( PAR_SS_DR_MAX_RANK - large_rank == 2 ) {
+        if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 2 ) {
 
-            k = mpi_rank;
+            k = tv_ptr->mpi_rank;
 
         } else {
 
@@ -951,147 +1190,218 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
 
             l = 0;
             do {
-                /* we know that small_rank >= 1 and that large_rank > small_rank
-                 * by the assertions at the head of this function.  Thus no
-                 * need for another inner loop.
-                 */
-                start[0] = (hsize_t)i;
-                start[1] = (hsize_t)j;
-                start[2] = (hsize_t)k;
-                start[3] = (hsize_t)l;
-                start[4] = 0;
-
-                ret = H5Sselect_hyperslab(mem_large_ds_sid,
-                                          H5S_SELECT_SET,
-                                          start_ptr,
-                                          stride_ptr,
-                                          count_ptr,
-                                          block_ptr);
-                VRFY((ret != FAIL), 
-                     "H5Sselect_hyperslab(mem_large_ds_sid) succeeded");
-
-
-                /* verify that H5S_select_shape_same() reports the two
-                 * selections as having the same shape.
-                 */
-                check = H5S_select_shape_same_test(file_small_ds_sid,
-                                                   mem_large_ds_sid);
-                VRFY((check == TRUE), "H5S_select_shape_same_test passed");
-
-
-                /* Read selection from disk */
-#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
-                HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", 
-                          fcnName, (int)mpi_rank, 
-                          (int)start[0], (int)start[1], (int)start[2], 
-                          (int)start[3], (int)start[4]);
-                HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n",
-                          fcnName, mpi_rank,
-                          H5Sget_simple_extent_ndims(mem_large_ds_sid),
-                          H5Sget_simple_extent_ndims(file_small_ds_sid));
-#endif 
-                ret = H5Dread(small_dataset,
-                              H5T_NATIVE_UINT32,
-                              mem_large_ds_sid,
-                              file_small_ds_sid,
-                              xfer_plist,
-                              large_ds_buf_1);
-                VRFY((ret >= 0), "H5Dread() slice from small ds succeeded.");
-
-                /* verify that the expected data and only the
-                 * expected data was read.
-                 */
-                ptr_1 = large_ds_buf_1;
-                expected_value = (uint32_t)((size_t)mpi_rank * small_ds_slice_size);
-                start_index = (size_t)(
-                        (i * edge_size * edge_size * edge_size * edge_size) +
-                        (j * edge_size * edge_size * edge_size) +
-                        (k * edge_size * edge_size) +
-                        (l * edge_size));
-                stop_index = start_index + small_ds_slice_size - 1;
-
-                HDassert( start_index < stop_index );
-                HDassert( stop_index <= large_ds_size );
-
-                for ( n = 0; n < large_ds_size; n++ ) {
-
-                    if ( ( n >= start_index ) && ( n <= stop_index ) ) {
+                if ( (tv_ptr->skips)++ < tv_ptr->max_skips ) { /* skip the test */
 
-                        if ( *ptr_1 != expected_value ) {
+                    (tv_ptr->tests_skipped)++;
 
-                            mis_match = TRUE;
-                        }
-                        expected_value++;
+                } else { /* run the test */
 
-                    } else {
+                    tv_ptr->skips = 0; /* reset the skips counter */
 
-                        if ( *ptr_1 != 0 ) {
+                    /* we know that small_rank >= 1 and that large_rank > small_rank
+                     * by the assertions at the head of this function.  Thus no
+                     * need for another inner loop.
+                     */
+                    tv_ptr->start[0] = (hsize_t)i;
+                    tv_ptr->start[1] = (hsize_t)j;
+                    tv_ptr->start[2] = (hsize_t)k;
+                    tv_ptr->start[3] = (hsize_t)l;
+                    tv_ptr->start[4] = 0;
+
+                    ret = H5Sselect_hyperslab(tv_ptr->mem_large_ds_sid,
+                                              H5S_SELECT_SET,
+                                              tv_ptr->start_ptr,
+                                              tv_ptr->stride_ptr,
+                                              tv_ptr->count_ptr,
+                                              tv_ptr->block_ptr);
+                    VRFY((ret != FAIL), 
+                         "H5Sselect_hyperslab(mem_large_ds_sid) succeeded");
+
+
+                    /* verify that H5S_select_shape_same() reports the two
+                     * selections as having the same shape.
+                     */
+                    check = H5S_select_shape_same_test(tv_ptr->file_small_ds_sid_0,
+                                                       tv_ptr->mem_large_ds_sid);
+                    VRFY((check == TRUE), "H5S_select_shape_same_test passed");
+
+
+                    /* Read selection from disk */
+#if CONTIG_HS_DR_PIO_TEST__D2M_S2L__DEBUG 
+                    HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", 
+                              fcnName, (int)(tv_ptr->mpi_rank), 
+                              (int)(tv_ptr->start[0]), (int)(tv_ptr->start[1]), 
+                              (int)(tv_ptr->start[2]), (int)(tv_ptr->start[3]), 
+                              (int)(tv_ptr->start[4]));
+                    HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n",
+                              fcnName, tv_ptr->mpi_rank,
+                              H5Sget_simple_extent_ndims(tv_ptr->mem_large_ds_sid),
+                              H5Sget_simple_extent_ndims(tv_ptr->file_small_ds_sid_0));
+#endif /* CONTIG_HS_DR_PIO_TEST__D2M_S2L__DEBUG */
+                    ret = H5Dread(tv_ptr->small_dataset,
+                                  H5T_NATIVE_UINT32,
+                                  tv_ptr->mem_large_ds_sid,
+                                  tv_ptr->file_small_ds_sid_0,
+                                  tv_ptr->xfer_plist,
+                                  tv_ptr->large_ds_buf_1);
+                    VRFY((ret >= 0), "H5Dread() slice from small ds succeeded.");
+
+                    /* verify that the expected data and only the
+                     * expected data was read.
+                     */
+                    ptr_1 = tv_ptr->large_ds_buf_1;
+                    expected_value = (uint32_t)
+                        ((size_t)(tv_ptr->mpi_rank) * tv_ptr->small_ds_slice_size);
+                    start_index = (size_t)(
+                        (i * tv_ptr->edge_size * tv_ptr->edge_size * 
+                             tv_ptr->edge_size * tv_ptr->edge_size) +
+                        (j * tv_ptr->edge_size * tv_ptr->edge_size * tv_ptr->edge_size) +
+                        (k * tv_ptr->edge_size * tv_ptr->edge_size) +
+                        (l * tv_ptr->edge_size));
+                    stop_index = start_index + tv_ptr->small_ds_slice_size - 1;
 
-                            mis_match = TRUE;
+                    HDassert( start_index < stop_index );
+                    HDassert( stop_index <= tv_ptr->large_ds_size );
+
+                    for ( n = 0; n < tv_ptr->large_ds_size; n++ ) {
+
+                        if ( ( n >= start_index ) && ( n <= stop_index ) ) {
+
+                            if ( *ptr_1 != expected_value ) {
+
+                                mis_match = TRUE;
+                            }
+                            expected_value++;
+
+                        } else {
+
+                            if ( *ptr_1 != 0 ) {
+
+                                mis_match = TRUE;
+                            }
                         }
+                        /* zero out the value for the next pass */
+                        *ptr_1 = 0;
+
+                        ptr_1++;
                     }
-                    /* zero out the value for the next pass */
-                    *ptr_1 = 0;
 
-                    ptr_1++;
-                }
+                    VRFY((mis_match == FALSE), 
+                         "small slice read from large ds data good.");
 
-                VRFY((mis_match == FALSE), 
-                     "small slice read from large ds data good.");
+                    (tv_ptr->tests_run)++;
+                }
 
                 l++;
 
-            } while ( ( large_rank > 2 ) &&
-                      ( (small_rank - 1) <= 1 ) &&
-                      ( l < edge_size ) );
+                (tv_ptr->total_tests)++;
+
+            } while ( ( tv_ptr->large_rank > 2 ) &&
+                      ( (tv_ptr->small_rank - 1) <= 1 ) &&
+                      ( l < tv_ptr->edge_size ) );
             k++;
-        } while ( ( large_rank > 3 ) &&
-                  ( (small_rank - 1) <= 2 ) &&
-                  ( k < edge_size ) );
+        } while ( ( tv_ptr->large_rank > 3 ) &&
+                  ( (tv_ptr->small_rank - 1) <= 2 ) &&
+                  ( k < tv_ptr->edge_size ) );
         j++;
-    } while ( ( large_rank > 4 ) &&
-              ( (small_rank - 1) <= 3 ) &&
-              ( j < edge_size ) );
+    } while ( ( tv_ptr->large_rank > 4 ) &&
+              ( (tv_ptr->small_rank - 1) <= 3 ) &&
+              ( j < tv_ptr->edge_size ) );
+
+    return;
+
+} /* contig_hs_dr_pio_test__d2m_s2l() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	contig_hs_dr_pio_test__m2d_l2s()
+ *
+ * Purpose:	Part three of a series of tests of I/O to/from hyperslab 
+ *		selections of different rank in the parallel.
+ *
+ *		Verify that we can write from memory to file using 
+ *		selections of different rank that H5S_select_shape_same() 
+ *		views as being of the same shape.
+ *
+ *		Do this by writing small_rank - 1 dimensional slices from 
+ *		the in memory large data set to the on disk small cube 
+ *		dataset.  After each write, read the slice of the small 
+ *		dataset back from disk, and verify that it contains 
+ *              the expected data. Verify that H5S_select_shape_same() 
+ *		returns true on the memory and file selections.
+ *
+ * Return:	void
+ *
+ * Programmer:	JRM -- 8/10/11
+ *
+ * Modifications:
+ *
+ *		None.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define CONTIG_HS_DR_PIO_TEST__M2D_L2S__DEBUG 0
+
+static void
+contig_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
+{
+#if CONTIG_HS_DR_PIO_TEST__M2D_L2S__DEBUG 
+    const char *fcnName = "contig_hs_dr_pio_test__m2d_l2s()";
+#endif /* CONTIG_HS_DR_PIO_TEST__M2D_L2S__DEBUG */
+    hbool_t	mis_match = FALSE;
+    int		i, j, k, l;
+    size_t	n;
+    int		mpi_rank; /* needed by the VRFY macro */
+    size_t      start_index;
+    size_t      stop_index;
+    uint32_t	expected_value;
+    uint32_t  * ptr_1;
+    htri_t      check;          /* Shape comparison return value */
+    herr_t	ret;		/* Generic return value */
+
+    /* initialize the local copy of mpi_rank */
+    mpi_rank = tv_ptr->mpi_rank;
 
 
     /* now we go in the opposite direction, verifying that we can write
      * from memory to file using selections of different rank that
      * H5S_select_shape_same() views as being of the same shape.
      *
-     * Start by writing small_rank - 1 D slices from the in memory large data
-     * set to the on disk small cube dataset.  After each write, read the 
+     * Start by writing small_rank - 1 dimensional slices from the in memory large 
+     * data set to the on disk small cube dataset.  After each write, read the 
      * slice of the small dataset back from disk, and verify that it contains 
      * the expected data. Verify that H5S_select_shape_same() returns true on 
      * the memory and file selections.
      */
 
-    start[0] = (hsize_t)mpi_rank;
-    stride[0] = (hsize_t)(2 * (mpi_size + 1));
-    count[0] = 1;
-    block[0] = 1;
+    tv_ptr->start[0] = (hsize_t)(tv_ptr->mpi_rank);
+    tv_ptr->stride[0] = (hsize_t)(2 * (tv_ptr->mpi_size + 1));
+    tv_ptr->count[0] = 1;
+    tv_ptr->block[0] = 1;
 
-    for ( i = 1; i < large_rank; i++ ) {
+    for ( i = 1; i < tv_ptr->large_rank; i++ ) {
 
-        start[i] = 0;
-        stride[i] = (hsize_t)(2 * edge_size);
-        count[i] = 1;
-        block[i] = (hsize_t)edge_size;
+        tv_ptr->start[i] = 0;
+        tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size);
+        tv_ptr->count[i] = 1;
+        tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size);
     }
 
-    ret = H5Sselect_hyperslab(file_small_ds_sid,
+    ret = H5Sselect_hyperslab(tv_ptr->file_small_ds_sid_0,
                               H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
-    VRFY((ret >= 0), "H5Sselect_hyperslab(file_small_ds_sid, set) suceeded");
+                              tv_ptr->start,
+                              tv_ptr->stride,
+                              tv_ptr->count,
+                              tv_ptr->block);
+    VRFY((ret >= 0), "H5Sselect_hyperslab(file_small_ds_sid_0, set) suceeded");
 
-    ret = H5Sselect_hyperslab(mem_small_ds_sid,
+    ret = H5Sselect_hyperslab(tv_ptr->mem_small_ds_sid,
                               H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
+                              tv_ptr->start,
+                              tv_ptr->stride,
+                              tv_ptr->count,
+                              tv_ptr->block);
     VRFY((ret >= 0), "H5Sselect_hyperslab(mem_small_ds_sid, set) suceeded");
 
 
@@ -1100,28 +1410,28 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
      */
     for ( i = 0; i < PAR_SS_DR_MAX_RANK; i++ ) {
 
-        start[i] = 0;
-        stride[i] = (hsize_t)(2 * edge_size);
-        count[i] = 1;
-        if ( (PAR_SS_DR_MAX_RANK - i) > (small_rank - 1) ) {
+        tv_ptr->start[i] = 0;
+        tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size);
+        tv_ptr->count[i] = 1;
+        if ( (PAR_SS_DR_MAX_RANK - i) > (tv_ptr->small_rank - 1) ) {
 
-            block[i] = 1;
+            tv_ptr->block[i] = 1;
 
         } else {
 
-            block[i] = (hsize_t)edge_size;
+            tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size);
         }
     }
 
     /* zero out the in memory small ds */
-    HDmemset(small_ds_buf_1, 0, sizeof(uint32_t) * small_ds_size);
+    HDmemset(tv_ptr->small_ds_buf_1, 0, sizeof(uint32_t) * tv_ptr->small_ds_size);
 
 
-#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
+#if CONTIG_HS_DR_PIO_TEST__M2D_L2S__DEBUG 
     HDfprintf(stdout, 
               "%s writing slices from big ds to slices of small ds on disk.\n",
               fcnName);
-#endif 
+#endif /* CONTIG_HS_DR_PIO_TEST__M2D_L2S__DEBUG */
 
     /* in serial versions of this test, we loop through all the dimensions
      * of the large data set that don't appear in the small data set.  
@@ -1133,9 +1443,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
      */
 
 
-    if ( PAR_SS_DR_MAX_RANK - large_rank == 0 ) {
+    if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 0 ) {
 
-        i = mpi_rank;
+        i = tv_ptr->mpi_rank;
 
     } else {
 
@@ -1148,9 +1458,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
      * test.
      */
 
-    if ( PAR_SS_DR_MAX_RANK - large_rank == 1 ) {
+    if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 1 ) {
 
-        j = mpi_rank;
+        j = tv_ptr->mpi_rank;
 
     } else {
 
@@ -1159,9 +1469,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
 
     j = 0;
     do {
-        if ( PAR_SS_DR_MAX_RANK - large_rank == 2 ) {
+        if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 2 ) {
 
-            k = mpi_rank;
+            k = tv_ptr->mpi_rank;
 
         } else {
 
@@ -1181,136 +1491,207 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
 
             l = 0;
             do {
-                /* we know that small_rank >= 1 and that large_rank > small_rank
-                 * by the assertions at the head of this function.  Thus no
-                 * need for another inner loop.
-                 */
-
-                /* zero out this rank's slice of the on disk small data set */
-                ret = H5Dwrite(small_dataset,
-                               H5T_NATIVE_UINT32,
-                               mem_small_ds_sid,
-                               file_small_ds_sid,
-                               xfer_plist,
-                               small_ds_buf_2);
-                VRFY((ret >= 0), "H5Dwrite() zero slice to small ds succeeded.");
-
-                /* select the portion of the in memory large cube from which we
-                 * are going to write data.
-                 */
-                start[0] = (hsize_t)i;
-                start[1] = (hsize_t)j;
-                start[2] = (hsize_t)k;
-                start[3] = (hsize_t)l;
-                start[4] = 0;
-
-                ret = H5Sselect_hyperslab(mem_large_ds_sid,
-                                          H5S_SELECT_SET,
-                                          start_ptr,
-                                          stride_ptr,
-                                          count_ptr,
-                                          block_ptr);
-                VRFY((ret >= 0), 
-                     "H5Sselect_hyperslab() mem_large_ds_sid succeeded.");
-
-
-                /* verify that H5S_select_shape_same() reports the in
-                 * memory slice through the cube selection and the
-                 * on disk full square selections as having the same shape.
-                 */
-                check = H5S_select_shape_same_test(file_small_ds_sid,
-                                                   mem_large_ds_sid);
-                VRFY((check == TRUE), "H5S_select_shape_same_test passed.");
-
-
-                /* write the slice from the in memory large data set to the 
-                 * slice of the on disk small dataset. */
-#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
-                HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", 
-                          fcnName, (int)mpi_rank,
-                          (int)start[0], (int)start[1], (int)start[2], 
-                          (int)start[3], (int)start[4]);
-                HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n",
-                          fcnName, mpi_rank,
-                          H5Sget_simple_extent_ndims(mem_large_ds_sid),
-                          H5Sget_simple_extent_ndims(file_small_ds_sid));
-#endif 
-                ret = H5Dwrite(small_dataset,
-                               H5T_NATIVE_UINT32,
-                               mem_large_ds_sid,
-                               file_small_ds_sid,
-                               xfer_plist,
-                               large_ds_buf_0);
-                VRFY((ret >= 0), "H5Dwrite() slice to large ds succeeded.");
+                if ( (tv_ptr->skips)++ < tv_ptr->max_skips ) { /* skip the test */
+
+                    (tv_ptr->tests_skipped)++;
 
+                } else { /* run the test */
 
-                /* read the on disk square into memory */
-                ret = H5Dread(small_dataset,
-                              H5T_NATIVE_UINT32,
-                              mem_small_ds_sid,
-                              file_small_ds_sid,
-                              xfer_plist,
-                              small_ds_buf_1);
-                VRFY((ret >= 0), "H5Dread() slice from small ds succeeded.");
+                    tv_ptr->skips = 0; /* reset the skips counter */
 
+                    /* we know that small_rank >= 1 and that large_rank > small_rank
+                     * by the assertions at the head of this function.  Thus no
+                     * need for another inner loop.
+                     */
 
-                /* verify that expected data is retrieved */
+                    /* zero out this rank's slice of the on disk small data set */
+                    ret = H5Dwrite(tv_ptr->small_dataset,
+                                   H5T_NATIVE_UINT32,
+                                   tv_ptr->mem_small_ds_sid,
+                                   tv_ptr->file_small_ds_sid_0,
+                                   tv_ptr->xfer_plist,
+                                   tv_ptr->small_ds_buf_2);
+                    VRFY((ret >= 0), "H5Dwrite() zero slice to small ds succeeded.");
+
+                    /* select the portion of the in memory large cube from which we
+                     * are going to write data.
+                     */
+                    tv_ptr->start[0] = (hsize_t)i;
+                    tv_ptr->start[1] = (hsize_t)j;
+                    tv_ptr->start[2] = (hsize_t)k;
+                    tv_ptr->start[3] = (hsize_t)l;
+                    tv_ptr->start[4] = 0;
+
+                    ret = H5Sselect_hyperslab(tv_ptr->mem_large_ds_sid,
+                                              H5S_SELECT_SET,
+                                              tv_ptr->start_ptr,
+                                              tv_ptr->stride_ptr,
+                                              tv_ptr->count_ptr,
+                                              tv_ptr->block_ptr);
+                    VRFY((ret >= 0), 
+                         "H5Sselect_hyperslab() mem_large_ds_sid succeeded.");
+
+
+                    /* verify that H5S_select_shape_same() reports the in
+                     * memory slice through the cube selection and the
+                     * on disk full square selections as having the same shape.
+                     */
+                    check = H5S_select_shape_same_test(tv_ptr->file_small_ds_sid_0,
+                                                       tv_ptr->mem_large_ds_sid);
+                    VRFY((check == TRUE), "H5S_select_shape_same_test passed.");
+
+
+                    /* write the slice from the in memory large data set to the 
+                     * slice of the on disk small dataset. */
+#if CONTIG_HS_DR_PIO_TEST__M2D_L2S__DEBUG 
+                    HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", 
+                              fcnName, (int)(tv_ptr->mpi_rank),
+                              (int)(tv_ptr->start[0]), (int)(tv_ptr->start[1]), 
+                              (int)(tv_ptr->start[2]), (int)(tv_ptr->start[3]), 
+                              (int)(tv_ptr->start[4]));
+                    HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n",
+                              fcnName, tv_ptr->mpi_rank,
+                              H5Sget_simple_extent_ndims(tv_ptr->mem_large_ds_sid),
+                              H5Sget_simple_extent_ndims(tv_ptr->file_small_ds_sid_0));
+#endif /* CONTIG_HS_DR_PIO_TEST__M2D_L2S__DEBUG */
+                    ret = H5Dwrite(tv_ptr->small_dataset,
+                                   H5T_NATIVE_UINT32,
+                                   tv_ptr->mem_large_ds_sid,
+                                   tv_ptr->file_small_ds_sid_0,
+                                   tv_ptr->xfer_plist,
+                                   tv_ptr->large_ds_buf_0);
+                    VRFY((ret >= 0), "H5Dwrite() slice to large ds succeeded.");
+
+
+                    /* read the on disk square into memory */
+                    ret = H5Dread(tv_ptr->small_dataset,
+                                  H5T_NATIVE_UINT32,
+                                  tv_ptr->mem_small_ds_sid,
+                                  tv_ptr->file_small_ds_sid_0,
+                                  tv_ptr->xfer_plist,
+                                  tv_ptr->small_ds_buf_1);
+                    VRFY((ret >= 0), "H5Dread() slice from small ds succeeded.");
+
+
+                    /* verify that expected data is retrieved */
+
+                    mis_match = FALSE;
+                    ptr_1 = tv_ptr->small_ds_buf_1;
+
+                    expected_value = (uint32_t)(
+                        (i * tv_ptr->edge_size * tv_ptr->edge_size * 
+                             tv_ptr->edge_size * tv_ptr->edge_size) +
+                        (j * tv_ptr->edge_size * tv_ptr->edge_size * tv_ptr->edge_size) +
+                        (k * tv_ptr->edge_size * tv_ptr->edge_size) +
+                        (l * tv_ptr->edge_size));
+
+                    start_index = (size_t)(tv_ptr->mpi_rank) * tv_ptr->small_ds_slice_size;
+                    stop_index = start_index + tv_ptr->small_ds_slice_size - 1;
+
+                    HDassert( start_index < stop_index );
+                    HDassert( stop_index <= tv_ptr->small_ds_size );
+
+                    for ( n = 0; n < tv_ptr->small_ds_size; n++ ) {
+
+                        if ( ( n >= start_index ) && ( n <= stop_index ) ) {
+
+                            if ( *ptr_1 != expected_value ) {
+
+                                mis_match = TRUE;
+                            }
+                            expected_value++;
 
-                mis_match = FALSE;
-                ptr_1 = small_ds_buf_1;
+                        } else {
 
-                expected_value = (uint32_t)(
-			(i * edge_size * edge_size * edge_size * edge_size) +
-                        (j * edge_size * edge_size * edge_size) +
-                        (k * edge_size * edge_size) +
-                        (l * edge_size));
+                            if ( *ptr_1 != 0 ) {
 
-                start_index = (size_t)mpi_rank * small_ds_slice_size;
-                stop_index = start_index + small_ds_slice_size - 1;
+                                mis_match = TRUE;
+                            }
+                        }
+                        /* zero out the value for the next pass */
+                        *ptr_1 = 0;
 
-                HDassert( start_index < stop_index );
-                HDassert( stop_index <= small_ds_size );
+                        ptr_1++;
+                    }
 
-                for ( n = 0; n < small_ds_size; n++ ) {
+                    VRFY((mis_match == FALSE), 
+                         "small slice write from large ds data good.");
 
-                    if ( ( n >= start_index ) && ( n <= stop_index ) ) {
+                    (tv_ptr->tests_run)++;
+                }
 
-                        if ( *ptr_1 != expected_value ) {
+                l++;
 
-                            mis_match = TRUE;
-                        }
-                        expected_value++;
+               (tv_ptr->total_tests)++;
 
-                    } else {
+            } while ( ( tv_ptr->large_rank > 2 ) &&
+                      ( (tv_ptr->small_rank - 1) <= 1 ) &&
+                      ( l < tv_ptr->edge_size ) );
+            k++;
+        } while ( ( tv_ptr->large_rank > 3 ) &&
+                  ( (tv_ptr->small_rank - 1) <= 2 ) &&
+                  ( k < tv_ptr->edge_size ) );
+        j++;
+    } while ( ( tv_ptr->large_rank > 4 ) &&
+              ( (tv_ptr->small_rank - 1) <= 3 ) &&
+              ( j < tv_ptr->edge_size ) );
 
-                        if ( *ptr_1 != 0 ) {
+    return;
 
-                            mis_match = TRUE;
-                        }
-                    }
-                    /* zero out the value for the next pass */
-                    *ptr_1 = 0;
+} /* contig_hs_dr_pio_test__m2d_l2s() */
 
-                    ptr_1++;
-                }
 
-                VRFY((mis_match == FALSE), 
-                     "small slice write from large ds data good.");
+/*-------------------------------------------------------------------------
+ * Function:	contig_hs_dr_pio_test__m2d_s2l()
+ *
+ * Purpose:	Part four of a series of tests of I/O to/from hyperslab 
+ *		selections of different rank in the parallel.
+ *
+ *		Verify that we can write from memory to file using 
+ *		selections of different rank that H5S_select_shape_same() 
+ *		views as being of the same shape.
+ *
+ *		Do this by writing the contents of the process's slice of 
+ *		the in memory small data set to slices of the on disk 
+ *		large data set.  After each write, read the process's 
+ *		slice of the large data set back into memory, and verify 
+ *		that it contains the expected data. 
+ *
+ *		Verify that H5S_select_shape_same() returns true on the 
+ *		memory and file selections.
+ *
+ * Return:	void
+ *
+ * Programmer:	JRM -- 8/10/11
+ *
+ * Modifications:
+ *
+ *		None
+ *
+ *-------------------------------------------------------------------------
+ */
 
-                l++;
+#define CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG 0
 
-            } while ( ( large_rank > 2 ) &&
-                      ( (small_rank - 1) <= 1 ) &&
-                      ( l < edge_size ) );
-            k++;
-        } while ( ( large_rank > 3 ) &&
-                  ( (small_rank - 1) <= 2 ) &&
-                  ( k < edge_size ) );
-        j++;
-    } while ( ( large_rank > 4 ) &&
-              ( (small_rank - 1) <= 3 ) &&
-              ( j < edge_size ) );
+static void
+contig_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t * tv_ptr)
+{
+#if CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG 
+    const char *fcnName = "contig_hs_dr_pio_test__m2d_s2l()";
+#endif /* CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG */
+    hbool_t	mis_match = FALSE;
+    int		i, j, k, l;
+    size_t	n;
+    int		mpi_rank; /* needed by the VRFY macro */
+    size_t      start_index;
+    size_t      stop_index;
+    uint32_t	expected_value;
+    uint32_t  * ptr_1;
+    htri_t      check;          /* Shape comparison return value */
+    herr_t	ret;		/* Generic return value */
 
+    /* initialize the local copy of mpi_rank */
+    mpi_rank = tv_ptr->mpi_rank;
 
     /* Now write the contents of the process's slice of the in memory 
      * small data set to slices of the on disk large data set.  After 
@@ -1323,25 +1704,25 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
     /* select the slice of the in memory small data set associated with 
      * the process's mpi rank.
      */
-    start[0] = (hsize_t)mpi_rank;
-    stride[0] = (hsize_t)(2 * (mpi_size + 1));
-    count[0] = 1;
-    block[0] = 1;
+    tv_ptr->start[0] = (hsize_t)(tv_ptr->mpi_rank);
+    tv_ptr->stride[0] = (hsize_t)(2 * (tv_ptr->mpi_size + 1));
+    tv_ptr->count[0] = 1;
+    tv_ptr->block[0] = 1;
 
-    for ( i = 1; i < large_rank; i++ ) {
+    for ( i = 1; i < tv_ptr->large_rank; i++ ) {
 
-        start[i] = 0;
-        stride[i] = (hsize_t)(2 * edge_size);
-        count[i] = 1;
-        block[i] = (hsize_t)edge_size;
+        tv_ptr->start[i] = 0;
+        tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size);
+        tv_ptr->count[i] = 1;
+        tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size);
     }
 
-    ret = H5Sselect_hyperslab(mem_small_ds_sid,
+    ret = H5Sselect_hyperslab(tv_ptr->mem_small_ds_sid,
                               H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
+                              tv_ptr->start,
+                              tv_ptr->stride,
+                              tv_ptr->count,
+                              tv_ptr->block);
     VRFY((ret >= 0), "H5Sselect_hyperslab(mem_small_ds_sid, set) suceeded");
 
 
@@ -1351,31 +1732,31 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
      */
     for ( i = 0; i < PAR_SS_DR_MAX_RANK; i++ ) {
 
-        start[i] = 0;
-        stride[i] = (hsize_t)(2 * edge_size);
-        count[i] = 1;
-        if ( (PAR_SS_DR_MAX_RANK - i) > (small_rank - 1) ) {
+        tv_ptr->start[i] = 0;
+        tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size);
+        tv_ptr->count[i] = 1;
+        if ( (PAR_SS_DR_MAX_RANK - i) > (tv_ptr->small_rank - 1) ) {
 
-            block[i] = 1;
+            tv_ptr->block[i] = 1;
 
         } else {
 
-            block[i] = (hsize_t)edge_size;
+            tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size);
         }
     }
 
     /* zero out the in memory large ds */
-    HDmemset(large_ds_buf_1, 0, sizeof(uint32_t) * large_ds_size);
+    HDmemset(tv_ptr->large_ds_buf_1, 0, sizeof(uint32_t) * tv_ptr->large_ds_size);
 
-#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
+#if CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG 
     HDfprintf(stdout, 
          "%s writing process slices of small ds to slices of large ds on disk.\n",
          fcnName);
-#endif 
+#endif /* CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG */
 
-    if ( PAR_SS_DR_MAX_RANK - large_rank == 0 ) {
+    if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 0 ) {
 
-        i = mpi_rank;
+        i = tv_ptr->mpi_rank;
 
     } else {
 
@@ -1388,9 +1769,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
      * test.
      */
 
-    if ( PAR_SS_DR_MAX_RANK - large_rank == 1 ) {
+    if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 1 ) {
 
-        j = mpi_rank;
+        j = tv_ptr->mpi_rank;
 
     } else {
 
@@ -1398,9 +1779,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
     }
 
     do {
-        if ( PAR_SS_DR_MAX_RANK - large_rank == 2 ) {
+        if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 2 ) {
 
-            k = mpi_rank;
+            k = tv_ptr->mpi_rank;
 
         } else {
 
@@ -1420,216 +1801,410 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
 
             l = 0;
             do {
-                /* we know that small_rank >= 1 and that large_rank > small_rank
-                 * by the assertions at the head of this function.  Thus no
-                 * need for another inner loop.
-                 */
-
-                /* Zero out this processes slice of the on disk large data set.
-                 * Note that this will leave one slice with its original data
-                 * as there is one more slice than processes.
-                  */
-                ret = H5Dwrite(large_dataset,
-                               H5T_NATIVE_UINT32,
-                               large_ds_slice_sid,
-                               file_large_ds_process_slice_sid,
-                               xfer_plist,
-                               large_ds_buf_2);
-		VRFY((ret != FAIL), "H5Dwrite() to zero large ds suceeded");
-
-
-                /* select the portion of the in memory large cube to which we
-                 * are going to write data.
-                 */
-                start[0] = (hsize_t)i;
-                start[1] = (hsize_t)j;
-                start[2] = (hsize_t)k;
-                start[3] = (hsize_t)l;
-                start[4] = 0;
-
-                ret = H5Sselect_hyperslab(file_large_ds_sid,
-                                          H5S_SELECT_SET,
-                                          start_ptr,
-                                          stride_ptr,
-                                          count_ptr,
-                                          block_ptr);
-		VRFY((ret != FAIL), 
-                     "H5Sselect_hyperslab() target large ds slice succeeded");
-
-
-                /* verify that H5S_select_shape_same() reports the in
-                 * memory small data set slice selection and the
-                 * on disk slice through the large data set selection
-                 * as having the same shape.
-                 */
-                check = H5S_select_shape_same_test(mem_small_ds_sid,
-                                                   file_large_ds_sid);
-		VRFY((check == TRUE), "H5S_select_shape_same_test passed");
-
-
-                /* write the small data set slice from memory to the 
-                 * target slice of the disk data set 
-                 */
-#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
-                HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", 
-                          fcnName, (int)mpi_rank,
-                          (int)start[0], (int)start[1], (int)start[2], 
-                          (int)start[3], (int)start[4]);
-                HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n",
-                          fcnName, mpi_rank,
-                          H5Sget_simple_extent_ndims(mem_small_ds_sid),
-                          H5Sget_simple_extent_ndims(file_large_ds_sid));
-#endif 
-                ret = H5Dwrite(large_dataset,
-                               H5T_NATIVE_UINT32,
-                               mem_small_ds_sid,
-                               file_large_ds_sid,
-                               xfer_plist,
-                               small_ds_buf_0);
-		VRFY((ret != FAIL), 
-                      "H5Dwrite of small ds slice to large ds succeeded");
+                if ( (tv_ptr->skips)++ < tv_ptr->max_skips ) { /* skip the test */
+
+                    (tv_ptr->tests_skipped)++;
+
+#if CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG 
+                    tv_ptr->start[0] = (hsize_t)i;
+                    tv_ptr->start[1] = (hsize_t)j;
+                    tv_ptr->start[2] = (hsize_t)k;
+                    tv_ptr->start[3] = (hsize_t)l;
+                    tv_ptr->start[4] = 0;
+
+                    HDfprintf(stdout, 
+                              "%s:%d: skipping test with start = %d %d %d %d %d.\n", 
+                              fcnName, (int)(tv_ptr->mpi_rank),
+                              (int)(tv_ptr->start[0]), (int)(tv_ptr->start[1]), 
+                              (int)(tv_ptr->start[2]), (int)(tv_ptr->start[3]), 
+                              (int)(tv_ptr->start[4]));
+                    HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n",
+                              fcnName, tv_ptr->mpi_rank,
+                              H5Sget_simple_extent_ndims(tv_ptr->mem_small_ds_sid),
+                              H5Sget_simple_extent_ndims(tv_ptr->file_large_ds_sid_0));
+#endif /* CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG */
+                } else { /* run the test */
+
+                    tv_ptr->skips = 0; /* reset the skips counter */
+
+                    /* we know that small_rank >= 1 and that large_rank > small_rank
+                     * by the assertions at the head of this function.  Thus no
+                     * need for another inner loop.
+                     */
 
+                    /* Zero out this processes slice of the on disk large data set.
+                     * Note that this will leave one slice with its original data
+                     * as there is one more slice than processes.
+                     */
+                    ret = H5Dwrite(tv_ptr->large_dataset,
+                                   H5T_NATIVE_UINT32,
+                                   tv_ptr->large_ds_slice_sid,
+                                   tv_ptr->file_large_ds_process_slice_sid,
+                                   tv_ptr->xfer_plist,
+                                   tv_ptr->large_ds_buf_2);
+                    VRFY((ret != FAIL), "H5Dwrite() to zero large ds suceeded");
 
-                /* read this processes slice on the on disk large 
-                 * data set into memory.
-                 */
 
-                ret = H5Dread(large_dataset,
-                              H5T_NATIVE_UINT32,
-                              mem_large_ds_process_slice_sid,
-                              file_large_ds_process_slice_sid,
-                              xfer_plist,
-                              large_ds_buf_1);
-                VRFY((ret != FAIL), 
-                     "H5Dread() of process slice of large ds succeeded");
+                    /* select the portion of the in memory large cube to which we
+                     * are going to write data.
+                     */
+                    tv_ptr->start[0] = (hsize_t)i;
+                    tv_ptr->start[1] = (hsize_t)j;
+                    tv_ptr->start[2] = (hsize_t)k;
+                    tv_ptr->start[3] = (hsize_t)l;
+                    tv_ptr->start[4] = 0;
+
+                    ret = H5Sselect_hyperslab(tv_ptr->file_large_ds_sid_0,
+                                              H5S_SELECT_SET,
+                                              tv_ptr->start_ptr,
+                                              tv_ptr->stride_ptr,
+                                              tv_ptr->count_ptr,
+                                              tv_ptr->block_ptr);
+                    VRFY((ret != FAIL), 
+                         "H5Sselect_hyperslab() target large ds slice succeeded");
+
+
+                    /* verify that H5S_select_shape_same() reports the in
+                     * memory small data set slice selection and the
+                     * on disk slice through the large data set selection
+                     * as having the same shape.
+                     */
+                    check = H5S_select_shape_same_test(tv_ptr->mem_small_ds_sid,
+                                                       tv_ptr->file_large_ds_sid_0);
+                    VRFY((check == TRUE), "H5S_select_shape_same_test passed");
 
 
-                /* verify that the expected data and only the
-                 * expected data was read.
-                 */
-                ptr_1 = large_ds_buf_1;
-                expected_value = (uint32_t)((size_t)mpi_rank * small_ds_slice_size);
+                    /* write the small data set slice from memory to the 
+                     * target slice of the disk data set 
+                     */
+#if CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG 
+                    HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", 
+                              fcnName, (int)(tv_ptr->mpi_rank),
+                              (int)(tv_ptr->start[0]), (int)(tv_ptr->start[1]), 
+                              (int)(tv_ptr->start[2]), (int)(tv_ptr->start[3]), 
+                              (int)(tv_ptr->start[4]));
+                    HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n",
+                              fcnName, tv_ptr->mpi_rank,
+                              H5Sget_simple_extent_ndims(tv_ptr->mem_small_ds_sid),
+                              H5Sget_simple_extent_ndims(tv_ptr->file_large_ds_sid_0));
+#endif /* CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG */
+                    ret = H5Dwrite(tv_ptr->large_dataset,
+                                   H5T_NATIVE_UINT32,
+                                   tv_ptr->mem_small_ds_sid,
+                                   tv_ptr->file_large_ds_sid_0,
+                                   tv_ptr->xfer_plist,
+                                   tv_ptr->small_ds_buf_0);
+                    VRFY((ret != FAIL), 
+                          "H5Dwrite of small ds slice to large ds succeeded");
+
+
+                    /* read this processes slice on the on disk large 
+                     * data set into memory.
+                     */
 
-                start_index = (size_t)((i * edge_size * edge_size * edge_size * edge_size) +
-                              (j * edge_size * edge_size * edge_size) +
-                              (k * edge_size * edge_size) +
-                              (l * edge_size));
-                stop_index = start_index + small_ds_slice_size - 1;
+                    ret = H5Dread(tv_ptr->large_dataset,
+                                  H5T_NATIVE_UINT32,
+                                  tv_ptr->mem_large_ds_process_slice_sid,
+                                  tv_ptr->file_large_ds_process_slice_sid,
+                                  tv_ptr->xfer_plist,
+                                  tv_ptr->large_ds_buf_1);
+                    VRFY((ret != FAIL), 
+                         "H5Dread() of process slice of large ds succeeded");
 
-                HDassert( start_index < stop_index );
-                HDassert( stop_index < large_ds_size );
 
-                for ( n = 0; n < large_ds_size; n++ ) {
+                    /* verify that the expected data and only the
+                     * expected data was read.
+                     */
+                    ptr_1 = tv_ptr->large_ds_buf_1;
+                    expected_value = (uint32_t)
+                	    ((size_t)(tv_ptr->mpi_rank) * tv_ptr->small_ds_slice_size);
 
-                    if ( ( n >= start_index ) && ( n <= stop_index ) ) {
+                    start_index = (size_t)
+                                  ((i * tv_ptr->edge_size * tv_ptr->edge_size * 
+                                        tv_ptr->edge_size * tv_ptr->edge_size) +
+                                   (j * tv_ptr->edge_size * tv_ptr->edge_size * 
+                                        tv_ptr->edge_size) +
+                                   (k * tv_ptr->edge_size * tv_ptr->edge_size) +
+                                   (l * tv_ptr->edge_size));
+                    stop_index = start_index + tv_ptr->small_ds_slice_size - 1;
 
-                        if ( *ptr_1 != expected_value ) {
+                    HDassert( start_index < stop_index );
+                    HDassert( stop_index < tv_ptr->large_ds_size );
 
-                            mis_match = TRUE;
-                        }
+                    for ( n = 0; n < tv_ptr->large_ds_size; n++ ) {
 
-                        expected_value++;
+                        if ( ( n >= start_index ) && ( n <= stop_index ) ) {
 
-                    } else {
+                            if ( *ptr_1 != expected_value ) {
 
-                        if ( *ptr_1 != 0 ) {
+                                mis_match = TRUE;
+                            }
 
-                            mis_match = TRUE;
+                            expected_value++;
+
+                        } else {
+
+                            if ( *ptr_1 != 0 ) {
+
+                                mis_match = TRUE;
+                            }
                         }
+                        /* zero out buffer for next test */
+                        *ptr_1 = 0;
+                        ptr_1++;
                     }
-                    /* zero out buffer for next test */
-                    *ptr_1 = 0;
-                    ptr_1++;
-                }
 
-                VRFY((mis_match == FALSE), 
-                     "small ds slice write to large ds slice data good.");
+                    VRFY((mis_match == FALSE), 
+                         "small ds slice write to large ds slice data good.");
+
+                    (tv_ptr->tests_run)++;
+                }
 
                 l++;
 
-            } while ( ( large_rank > 2 ) &&
-                      ( (small_rank - 1) <= 1 ) &&
-                      ( l < edge_size ) );
+                (tv_ptr->total_tests)++;
+
+            } while ( ( tv_ptr->large_rank > 2 ) &&
+                      ( (tv_ptr->small_rank - 1) <= 1 ) &&
+                      ( l < tv_ptr->edge_size ) );
             k++;
-        } while ( ( large_rank > 3 ) &&
-                  ( (small_rank - 1) <= 2 ) &&
-                  ( k < edge_size ) );
+        } while ( ( tv_ptr->large_rank > 3 ) &&
+                  ( (tv_ptr->small_rank - 1) <= 2 ) &&
+                  ( k < tv_ptr->edge_size ) );
         j++;
-    } while ( ( large_rank > 4 ) &&
-              ( (small_rank - 1) <= 3 ) &&
-              ( j < edge_size ) );
+    } while ( ( tv_ptr->large_rank > 4 ) &&
+              ( (tv_ptr->small_rank - 1) <= 3 ) &&
+              ( j < tv_ptr->edge_size ) );
 
+    return;
 
-    /* Close dataspaces */
-    ret = H5Sclose(full_mem_small_ds_sid);
-    VRFY((ret != FAIL), "H5Sclose(full_mem_small_ds_sid) succeeded");
+} /* contig_hs_dr_pio_test__m2d_s2l() */
 
-    ret = H5Sclose(full_file_small_ds_sid);
-    VRFY((ret != FAIL), "H5Sclose(full_file_small_ds_sid) succeeded");
 
-    ret = H5Sclose(mem_small_ds_sid);
-    VRFY((ret != FAIL), "H5Sclose(mem_small_ds_sid) succeeded");
+/*-------------------------------------------------------------------------
+ * Function:	contig_hs_dr_pio_test__run_test()
+ *
+ * Purpose:	Test I/O to/from hyperslab selections of different rank in
+ *		the parallel.
+ *
+ * Return:	void
+ *
+ * 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.
+ *
+ *-------------------------------------------------------------------------
+ */
 
-    ret = H5Sclose(file_small_ds_sid);
-    VRFY((ret != FAIL), "H5Sclose(file_small_ds_sid) succeeded");
+#define CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG 0
 
-    ret = H5Sclose(small_ds_slice_sid);
-    VRFY((ret != FAIL), "H5Sclose(small_ds_slice_sid) succeeded");
+static void
+contig_hs_dr_pio_test__run_test(const int test_num,
+                                const int edge_size,
+                                const int chunk_edge_size,
+                                const int small_rank,
+                                const int large_rank,
+                                const hbool_t use_collective_io,
+                                const hid_t dset_type,
+                                int express_test,
+                                int * skips_ptr,
+                                int max_skips,
+                                int64_t * total_tests_ptr,
+                                int64_t * tests_run_ptr,
+                                int64_t * tests_skipped_ptr)
+{
+#if CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG 
+    const char *fcnName = "contig_hs_dr_pio_test__run_test()";
+#endif /* CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG */
+    int		mpi_rank;
+    struct hs_dr_pio_test_vars_t test_vars = 
+    {
+        /* int	       mpi_size                        = */ -1,
+        /* int         mpi_rank                        = */ -1,
+        /* MPI_Comm    mpi_comm                        = */ MPI_COMM_NULL,
+        /* MPI_Inf     mpi_info                        = */ MPI_INFO_NULL,
+        /* int         test_num                        = */ -1,
+        /* int         edge_size                       = */ -1,
+        /* int         checker_edge_size               = */ -1,
+        /* int         chunk_edge_size                 = */ -1,
+        /* int         small_rank                      = */ -1,
+        /* int         large_rank                      = */ -1,
+        /* hid_t       dset_type                       = */ -1,
+        /* uint32_t  * small_ds_buf_0                  = */ NULL,
+        /* uint32_t  * small_ds_buf_1                  = */ NULL,
+        /* uint32_t  * small_ds_buf_2                  = */ NULL,
+        /* uint32_t  * small_ds_slice_buf              = */ NULL,
+        /* uint32_t  * large_ds_buf_0                  = */ NULL,
+        /* uint32_t  * large_ds_buf_1                  = */ NULL, 
+        /* uint32_t  * large_ds_buf_2                  = */ NULL,
+        /* uint32_t  * large_ds_slice_buf              = */ NULL,
+        /* int         small_ds_offset                 = */ -1,
+        /* int         large_ds_offset                 = */ -1,
+        /* hid_t       fid                             = */ -1,  /* HDF5 file ID */
+        /* hid_t       xfer_plist                      = */ H5P_DEFAULT,
+        /* hid_t       full_mem_small_ds_sid           = */ -1,
+        /* hid_t       full_file_small_ds_sid          = */ -1,
+        /* hid_t       mem_small_ds_sid                = */ -1,
+        /* hid_t       file_small_ds_sid_0             = */ -1,
+        /* hid_t       file_small_ds_sid_1             = */ -1,
+        /* hid_t       small_ds_slice_sid              = */ -1,
+        /* hid_t       full_mem_large_ds_sid           = */ -1,
+        /* hid_t       full_file_large_ds_sid          = */ -1,
+        /* hid_t       mem_large_ds_sid                = */ -1,
+        /* hid_t       file_large_ds_sid_0             = */ -1,
+        /* hid_t       file_large_ds_sid_1             = */ -1,
+        /* hid_t       file_large_ds_process_slice_sid = */ -1,
+        /* hid_t       mem_large_ds_process_slice_sid  = */ -1,
+        /* hid_t       large_ds_slice_sid              = */ -1,
+        /* hid_t       small_dataset                   = */ -1,     /* Dataset ID */
+        /* hid_t       large_dataset                   = */ -1,     /* Dataset ID */
+        /* size_t      small_ds_size                   = */ 1,
+        /* size_t      small_ds_slice_size             = */ 1,
+        /* size_t      large_ds_size                   = */ 1,
+        /* size_t      large_ds_slice_size             = */ 1,
+        /* hsize_t     dims[PAR_SS_DR_MAX_RANK]        = */ {0,0,0,0,0},
+        /* hsize_t     chunk_dims[PAR_SS_DR_MAX_RANK]  = */ {0,0,0,0,0},
+        /* hsize_t     start[PAR_SS_DR_MAX_RANK]       = */ {0,0,0,0,0},
+        /* hsize_t     stride[PAR_SS_DR_MAX_RANK]      = */ {0,0,0,0,0},
+        /* hsize_t     count[PAR_SS_DR_MAX_RANK]       = */ {0,0,0,0,0},
+        /* hsize_t     block[PAR_SS_DR_MAX_RANK]       = */ {0,0,0,0,0},
+        /* hsize_t   * start_ptr                       = */ NULL,
+        /* hsize_t   * stride_ptr                      = */ NULL,
+        /* hsize_t   * count_ptr                       = */ NULL,
+        /* hsize_t   * block_ptr                       = */ NULL,
+        /* int 	       skips                           = */ 0,
+        /* int 	       max_skips                       = */ 0,
+        /* int64_t     total_tests                     = */ 0,
+        /* int64_t     tests_run                       = */ 0,
+        /* int64_t     tests_skipped                   = */ 0
+    };
+    struct hs_dr_pio_test_vars_t * tv_ptr = &test_vars;
 
-    ret = H5Sclose(full_mem_large_ds_sid);
-    VRFY((ret != FAIL), "H5Sclose(full_mem_large_ds_sid) succeeded");
+    hs_dr_pio_test__setup(test_num, edge_size, -1, chunk_edge_size,
+                          small_rank, large_rank, use_collective_io,
+                          dset_type, express_test, tv_ptr);
 
-    ret = H5Sclose(full_file_large_ds_sid);
-    VRFY((ret != FAIL), "H5Sclose(full_file_large_ds_sid) succeeded");
+    /* initialize the local copy of mpi_rank */
+    mpi_rank = tv_ptr->mpi_rank;
 
-    ret = H5Sclose(mem_large_ds_sid);
-    VRFY((ret != FAIL), "H5Sclose(mem_large_ds_sid) succeeded");
+    /* initialize skips & max_skips */
+    tv_ptr->skips = *skips_ptr;
+    tv_ptr->max_skips = max_skips;
 
-    ret = H5Sclose(file_large_ds_sid);
-    VRFY((ret != FAIL), "H5Sclose(mem_large_ds_sid) succeeded");
+#if CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG 
+    if ( MAINPROCESS ) {
+        HDfprintf(stdout, "test %d: small rank = %d, large rank = %d.\n",
+                  test_num, small_rank, large_rank);
+        HDfprintf(stdout, "test %d: Initialization complete.\n", test_num);
+    }
+#endif /* CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG */
 
-    ret = H5Sclose(mem_large_ds_process_slice_sid);
-    VRFY((ret != FAIL), "H5Sclose(mem_large_ds_process_slice_sid) succeeded");
+    /* first, verify that we can read from disk correctly using selections
+     * of different rank that H5S_select_shape_same() views as being of the
+     * same shape.
+     *
+     * Start by reading small_rank - 1 dimensional slice from the on disk 
+     * large cube, and verifying that the data read is correct.  Verify that 
+     * H5S_select_shape_same() returns true on the memory and file selections.
+     */
 
-    ret = H5Sclose(file_large_ds_process_slice_sid);
-    VRFY((ret != FAIL), "H5Sclose(file_large_ds_process_slice_sid) succeeded");
+#if CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG 
+    if ( MAINPROCESS ) {
+        HDfprintf(stdout, "test %d: running contig_hs_dr_pio_test__d2m_l2s.\n", test_num);
+    }
+#endif /* CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG */
+    contig_hs_dr_pio_test__d2m_l2s(tv_ptr);
 
-    ret = H5Sclose(large_ds_slice_sid);
-    VRFY((ret != FAIL), "H5Sclose(large_ds_slice_sid) succeeded");
 
+    /* Second, read slices of the on disk small data set into slices 
+     * through the in memory large data set, and verify that the correct 
+     * data (and only the correct data) is read.
+     */
 
-    /* Close Datasets */
-    ret = H5Dclose(small_dataset);
-    VRFY((ret != FAIL), "H5Dclose(small_dataset) succeeded");
+#if CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG 
+    if ( MAINPROCESS ) {
+        HDfprintf(stdout, "test %d: running contig_hs_dr_pio_test__d2m_s2l.\n", test_num);
+    }
+#endif /* CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG */
+    contig_hs_dr_pio_test__d2m_s2l(tv_ptr);
 
-    ret = H5Dclose(large_dataset);
-    VRFY((ret != FAIL), "H5Dclose(large_dataset) succeeded");
 
+    /* now we go in the opposite direction, verifying that we can write
+     * from memory to file using selections of different rank that
+     * H5S_select_shape_same() views as being of the same shape.
+     *
+     * Start by writing small_rank - 1 D slices from the in memory large data
+     * set to the on disk small cube dataset.  After each write, read the 
+     * slice of the small dataset back from disk, and verify that it contains 
+     * the expected data. Verify that H5S_select_shape_same() returns true on 
+     * the memory and file selections.
+     */
 
-    /* close the file collectively */
-    MESG("about to close file.");
-    ret = H5Fclose(fid);
-    VRFY((ret != FAIL), "file close succeeded");
+#if CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG 
+    if ( MAINPROCESS ) {
+        HDfprintf(stdout, "test %d: running contig_hs_dr_pio_test__m2d_l2s.\n", test_num);
+    }
+#endif /* CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG */
+    contig_hs_dr_pio_test__m2d_l2s(tv_ptr);
 
-    /* Free memory buffers */
 
-    if ( small_ds_buf_0 != NULL ) HDfree(small_ds_buf_0);
-    if ( small_ds_buf_1 != NULL ) HDfree(small_ds_buf_1);
-    if ( small_ds_buf_2 != NULL ) HDfree(small_ds_buf_2);
-    if ( small_ds_slice_buf != NULL ) HDfree(small_ds_slice_buf);
+    /* Now write the contents of the process's slice of the in memory 
+     * small data set to slices of the on disk large data set.  After 
+     * each write, read the process's slice of the large data set back
+     * into memory, and verify that it contains the expected data. 
+     * Verify that H5S_select_shape_same() returns true on the memory 
+     * and file selections.
+     */
+
+#if CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG 
+    if ( MAINPROCESS ) {
+        HDfprintf(stdout, "test %d: running contig_hs_dr_pio_test__m2d_s2l.\n", test_num);
+    }
+#endif /* CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG */
+    contig_hs_dr_pio_test__m2d_s2l(tv_ptr);
+
+#if CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG 
+    if ( MAINPROCESS ) {
+        HDfprintf(stdout, 
+            "test %d: Subtests complete -- tests run/skipped/total = %lld/%lld/%lld.\n", 
+             test_num, (long long)(tv_ptr->tests_run), (long long)(tv_ptr->tests_skipped),
+             (long long)(tv_ptr->total_tests));
+    }
+#endif /* CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG */
+
+    hs_dr_pio_test__takedown(tv_ptr);
+
+#if CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG 
+    if ( MAINPROCESS ) {
+        HDfprintf(stdout, "test %d: Takedown complete.\n", test_num);
+    }
+#endif /* CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG */
 
-    if ( large_ds_buf_0 != NULL ) HDfree(large_ds_buf_0);
-    if ( large_ds_buf_1 != NULL ) HDfree(large_ds_buf_1);
-    if ( large_ds_buf_2 != NULL ) HDfree(large_ds_buf_2);
-    if ( large_ds_slice_buf != NULL ) HDfree(large_ds_slice_buf);
+    *skips_ptr = tv_ptr->skips;
+    *total_tests_ptr += tv_ptr->total_tests;
+    *tests_run_ptr += tv_ptr->tests_run;
+    *tests_skipped_ptr += tv_ptr->tests_skipped;
 
     return;
 
-} /* contig_hyperslab_dr_pio_test__run_test() */
+} /* contig_hs_dr_pio_test__run_test() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	contig_hyperslab_dr_pio_test(ShapeSameTestMethods sstest_type)
+ * Function:	contig_hs_dr_pio_test(ShapeSameTestMethods sstest_type)
  *
  * Purpose:	Test I/O to/from hyperslab selections of different rank in
  *		the parallel case.
@@ -1655,43 +2230,37 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
  *-------------------------------------------------------------------------
  */
 
+#define CONTIG_HS_DR_PIO_TEST__DEBUG 0
+
 void
-contig_hyperslab_dr_pio_test(ShapeSameTestMethods sstest_type)
+contig_hs_dr_pio_test(ShapeSameTestMethods sstest_type)
 {
+    int         express_test;
+    int         local_express_test;
+    int         mpi_rank = -1;
     int	        test_num = 0;
     int		edge_size = 10;
     int		chunk_edge_size = 0;
     int	        small_rank;
     int	        large_rank;
-    int		skips[4] = {0, 0, 0, 0};
-    int		skip_counters[4] = {0, 0, 0, 0};
-    int		tests_skiped[4] = {0, 0, 0, 0};
     int		mpi_result;
+    int		skips = 0;
+    int		max_skips = 0;
+    /* The following table list the number of sub-tests skipped between 
+     * each test that is actually executed as a function of the express 
+     * test level.  Note that any value in excess of 4880 will cause all
+     * sub tests to be skipped.
+     */
+    int         max_skips_tbl[4] = {0, 4, 16, 64};
     hid_t	dset_type = H5T_NATIVE_UINT;
-#ifdef H5_HAVE_GETTIMEOFDAY
-    hbool_t	time_tests = TRUE;
-    hbool_t	display_skips = FALSE;
-    int		local_express_test;
-    int		express_test;
-    int		i;
-    int		samples = 0;
-    int		sample_size = 1;
-    int		mpi_size = -1;
-    int         mpi_rank = -1;
-    int		local_skips[4];
-    const int	ind_contig_idx = 0;
-    const int	col_contig_idx = 1;
-    const int	ind_chunked_idx = 2;
-    const int	col_chunked_idx = 3;
-    const int	test_types = 4;
-    long long   max_test_time = 3000000; /* for one test */
-    long long	sample_times[4] = {0, 0, 0, 0};
-    struct timeval timeval_a;
-    struct timeval timeval_b;
-#endif /* H5_HAVE_GETTIMEOFDAY */
+    int64_t	total_tests = 0;
+    int64_t	tests_run = 0;
+    int64_t     tests_skipped = 0;
 
     HDcompile_assert(sizeof(uint32_t) == sizeof(unsigned));
 
+    MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
+
     local_express_test = GetTestExpress();
 
     mpi_result = MPI_Allreduce((void *)&local_express_test,
@@ -1703,198 +2272,130 @@ contig_hyperslab_dr_pio_test(ShapeSameTestMethods sstest_type)
 
     VRFY((mpi_result == MPI_SUCCESS ), "MPI_Allreduce(0) succeeded");
 
+    if ( local_express_test < 0 ) {
+        max_skips = max_skips_tbl[0];
+    } else if ( local_express_test > 3 ) {
+        max_skips = max_skips_tbl[3];
+    } else {
+        max_skips = max_skips_tbl[local_express_test];
+    }
+
     for ( large_rank = 3; large_rank <= PAR_SS_DR_MAX_RANK; large_rank++ ) {
 
         for ( small_rank = 2; small_rank < large_rank; small_rank++ ) {
-	  switch(sstest_type){
-	  case IND_CONTIG:
-	    /* contiguous data set, independent I/O */
-            chunk_edge_size = 0;
-            if ( skip_counters[ind_contig_idx] < skips[ind_contig_idx] ) {
-
-                skip_counters[ind_contig_idx]++;
-                tests_skiped[ind_contig_idx]++;
-		printf("Test skipped\n");
-            } else {
-                skip_counters[ind_contig_idx] = 0;
-                START_TIMER(time_tests, timeval_a, "HDgettimeofday(0) succeeds.");
-                contig_hyperslab_dr_pio_test__run_test(test_num,
+
+            switch(sstest_type){
+                case IND_CONTIG:
+                    /* contiguous data set, independent I/O */
+                    chunk_edge_size = 0;
+
+                    contig_hs_dr_pio_test__run_test(test_num,
                                                    edge_size,
                                                    chunk_edge_size,
                                                    small_rank,
                                                    large_rank,
                                                    FALSE,  
                                                    dset_type,
-                                                   express_test);
-                STOP_TIMER_AND_UPDATE(time_tests, timeval_b, \
-                                      "HDgettimeofday(1) succeeds.", \
-                                      sample_times[col_contig_idx]);
-            }
-            test_num++;
-	    break;
-	    /* end of case IND_CONTIG */
-
-	  case COL_CONTIG:
-	    /* contiguous data set, collective I/O */
-            chunk_edge_size = 0;
-            if ( skip_counters[col_contig_idx] < skips[col_contig_idx] ) {
-
-                skip_counters[col_contig_idx]++;
-                tests_skiped[col_contig_idx]++;
-		printf("Test skipped\n");
-            } else {
-                skip_counters[col_contig_idx] = 0;
-                START_TIMER(time_tests, timeval_a, "HDgettimeofday(2) succeeds.");
-                contig_hyperslab_dr_pio_test__run_test(test_num,
+                                                   express_test,
+                                                   &skips,
+                                                   max_skips,
+                                                   &total_tests,
+                                                   &tests_run,
+                                                   &tests_skipped);
+                    test_num++;
+                    break;
+                    /* end of case IND_CONTIG */
+
+                case COL_CONTIG:
+                    /* contiguous data set, collective I/O */
+                    chunk_edge_size = 0;
+
+                    contig_hs_dr_pio_test__run_test(test_num,
                                                    edge_size,
                                                    chunk_edge_size,
                                                    small_rank,
                                                    large_rank,
                                                    TRUE,  
                                                    dset_type,
-                                                   express_test);
-                STOP_TIMER_AND_UPDATE(time_tests, timeval_b, \
-                                      "HDgettimeofday(3) succeeds.", \
-                                      sample_times[ind_contig_idx]);
-            }
-            test_num++;
-	    break;
-	    /* end of case COL_CONTIG */
-
-	  case IND_CHUNKED:
-	    /* chunked data set, independent I/O */
-            chunk_edge_size = 5;
-            if ( skip_counters[ind_chunked_idx] < skips[ind_chunked_idx] ) {
-
-                skip_counters[ind_chunked_idx]++;
-                tests_skiped[ind_chunked_idx]++;
-		printf("Test skipped\n");
-            } else {
-                skip_counters[ind_chunked_idx] = 0;
-                START_TIMER(time_tests, timeval_a, "HDgettimeofday(4) succeeds.");
-                contig_hyperslab_dr_pio_test__run_test(test_num,
+                                                   express_test,
+                                                   &skips,
+                                                   max_skips,
+                                                   &total_tests,
+                                                   &tests_run,
+                                                   &tests_skipped);
+                    test_num++;
+                    break;
+                    /* end of case COL_CONTIG */
+
+                case IND_CHUNKED:
+                    /* chunked data set, independent I/O */
+                    chunk_edge_size = 5;
+
+                    contig_hs_dr_pio_test__run_test(test_num,
                                                    edge_size,
                                                    chunk_edge_size,
                                                    small_rank,
                                                    large_rank,
                                                    FALSE,  
                                                    dset_type,
-                                                   express_test);
-                STOP_TIMER_AND_UPDATE(time_tests, timeval_b, \
-                                      "HDgettimeofday(5) succeeds.", \
-                                      sample_times[col_chunked_idx]);
-            }
-            test_num++;
-	    break;
-	    /* end of case IND_CHUNKED */
-
-	  case COL_CHUNKED:
-	    /* chunked data set, collective I/O */
-            chunk_edge_size = 5;
-            if ( skip_counters[col_chunked_idx] < skips[col_chunked_idx] ) {
-
-                skip_counters[col_chunked_idx]++;
-                tests_skiped[col_chunked_idx]++;
-		printf("Test skipped\n");
-            } else {
-                skip_counters[col_chunked_idx] = 0;
-                START_TIMER(time_tests, timeval_a, "HDgettimeofday(6) succeeds.");
-                contig_hyperslab_dr_pio_test__run_test(test_num,
+                                                   express_test,
+                                                   &skips,
+                                                   max_skips,
+                                                   &total_tests,
+                                                   &tests_run,
+                                                   &tests_skipped);
+                    test_num++;
+                    break;
+                    /* end of case IND_CHUNKED */
+
+                case COL_CHUNKED:
+                    /* chunked data set, collective I/O */
+                    chunk_edge_size = 5;
+
+                    contig_hs_dr_pio_test__run_test(test_num,
                                                    edge_size,
                                                    chunk_edge_size,
                                                    small_rank,
                                                    large_rank,
                                                    TRUE,  
                                                    dset_type,
-                                                   express_test);
-                STOP_TIMER_AND_UPDATE(time_tests, timeval_b, \
-                                      "HDgettimeofday(7) succeeds.", \
-                                      sample_times[ind_chunked_idx]);
-            }
-            test_num++;
-	    break;
-	    /* end of case COL_CHUNKED */
-	  } /* end of switch(sstest_type) */
-
-#ifdef H5_HAVE_GETTIMEOFDAY
-            if ( time_tests ) {
-            
-                samples++;
-
-                if ( samples >= sample_size ) {
-
-                    int result;
-
-                    time_tests = FALSE;
-
-                    max_test_time = ((long long)sample_size) * max_test_time;
-
-                    for ( i = 0; i < test_types; i++ ) {
-
-                        if ( ( express_test == 0 ) ||
-                             ( sample_times[i] <= max_test_time ) ) {
-
-                            local_skips[i] = 0;
-
-                        } else {
-
-                            local_skips[i] = (int)(sample_times[i] / max_test_time);
-                        }
-                    }
-
-                    /* do an MPI_Allreduce() with the skips vector to ensure that 
-                     * all processes agree on its contents.
-                     */
-                    result = MPI_Allreduce((void *)local_skips,
-                                           (void *)skips,
-                                           test_types,
-                                           MPI_INT,
-                                           MPI_MAX,
-                                           MPI_COMM_WORLD);
-                    VRFY((result == MPI_SUCCESS ), \
-                         "MPI_Allreduce(1) succeeded");
-                }
+                                                   express_test,
+                                                   &skips,
+                                                   max_skips,
+                                                   &total_tests,
+                                                   &tests_run,
+                                                   &tests_skipped);
+                    test_num++;
+                    break;
+                    /* end of case COL_CHUNKED */
+
+                default:
+                    VRFY((FALSE), "unknown test type");
+                    break;
+
+            } /* end of switch(sstest_type) */
+#if CONTIG_HS_DR_PIO_TEST__DEBUG
+            if ( ( MAINPROCESS ) && ( tests_skipped > 0 ) ) {
+                HDfprintf(stdout, "	run/skipped/total = %lld/%lld/%lld.\n",
+                          tests_run, tests_skipped, total_tests);
             }
-#endif /* H5_HAVE_GETTIMEOFDAY */
-
+#endif /* CONTIG_HS_DR_PIO_TEST__DEBUG */
         }
     }
 
-#ifdef H5_HAVE_GETTIMEOFDAY
-    if ( ( MAINPROCESS ) && ( display_skips ) ) {
-
-        HDfprintf(stdout, "***********************************\n");
-        HDfprintf(stdout, "express_test = %d.\n", express_test);
-        HDfprintf(stdout, "sample_size = %d, max_test_time = %lld.\n",
-                  sample_size, max_test_time);
-        HDfprintf(stdout, "sample_times[]  = %lld, %lld, %lld, %lld.\n", 
-                  sample_times[ind_contig_idx],
-                  sample_times[col_contig_idx],
-                  sample_times[ind_chunked_idx],
-                  sample_times[col_chunked_idx]);
-        HDfprintf(stdout, "skips[]  = %d, %d, %d, %d.\n", 
-                  skips[ind_contig_idx],
-                  skips[col_contig_idx],
-                  skips[ind_chunked_idx],
-                  skips[col_chunked_idx]);
-        HDfprintf(stdout, "tests_skiped[]  = %d, %d, %d, %d.\n", 
-                  tests_skiped[ind_contig_idx],
-                  tests_skiped[col_contig_idx],
-                  tests_skiped[ind_chunked_idx],
-                  tests_skiped[col_chunked_idx]);
-        HDfprintf(stdout, "test_num          = %d.\n", test_num);
-        HDfprintf(stdout, "***********************************\n");
+    if ( ( MAINPROCESS ) && ( tests_skipped > 0 ) ) {
+        HDfprintf(stdout, "	%lld of %lld subtests skipped to expedite testing.\n",
+                  tests_skipped, total_tests);
     }
-#endif /* H5_HAVE_GETTIMEOFDAY */
 
     return;
 
-} /* contig_hyperslab_dr_pio_test() */
+} /* contig_hs_dr_pio_test() */
 
 
 /****************************************************************
 **
-**  checker_board_hyperslab_dr_pio_test__select_checker_board():  
+**  ckrbrd_hs_dr_pio_test__slct_ckrbrd():  
 **	Given a data space of tgt_rank, and dimensions:
 **
 **		(mpi_size + 1), edge_size, ... , edge_size
@@ -1915,21 +2416,19 @@ contig_hyperslab_dr_pio_test(ShapeSameTestMethods sstest_type)
 **
 ****************************************************************/
 
-#define CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG 0
+#define CKRBRD_HS_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG 0
 
 static void
-checker_board_hyperslab_dr_pio_test__select_checker_board(
-                                 const int mpi_rank,
-                                 const hid_t tgt_sid,
-                                 const int tgt_rank,
-                                 const int edge_size,
-                                 const int checker_edge_size,
-                                 const int sel_rank,
-                                 hsize_t sel_start[])
+ckrbrd_hs_dr_pio_test__slct_ckrbrd(const int mpi_rank,
+                                   const hid_t tgt_sid,
+                                   const int tgt_rank,
+                                   const int edge_size,
+                                   const int checker_edge_size,
+                                   const int sel_rank,
+                                   hsize_t sel_start[])
 {
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG 
-    const char *	fcnName = 
-			"checker_board_hyperslab_dr_pio_test__select_checker_board():";
+#if CKRBRD_HS_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG 
+    const char *	fcnName = "ckrbrd_hs_dr_pio_test__slct_ckrbrd():";
 #endif 
     hbool_t		first_selection = TRUE;
     int                 i, j, k, l, m;
@@ -1960,14 +2459,14 @@ checker_board_hyperslab_dr_pio_test__select_checker_board(
     HDassert( n_cube_offset >= 0 );
     HDassert( n_cube_offset <= sel_offset );
 
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG 
+#if CKRBRD_HS_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG 
     HDfprintf(stdout, "%s:%d: edge_size/checker_edge_size = %d/%d\n",
               fcnName, mpi_rank, edge_size, checker_edge_size);
     HDfprintf(stdout, "%s:%d: sel_rank/sel_offset = %d/%d.\n", 
               fcnName, mpi_rank, sel_rank, sel_offset);
     HDfprintf(stdout, "%s:%d: tgt_rank/n_cube_offset = %d/%d.\n", 
               fcnName, mpi_rank, tgt_rank, n_cube_offset);
-#endif /* CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG */ 
+#endif /* CKRBRD_HS_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG */ 
 
     /* First, compute the base count (which assumes start == 0
      * for the associated offset) and offset_count (which
@@ -2117,7 +2616,7 @@ checker_board_hyperslab_dr_pio_test__select_checker_board(
 
                         if ( ((i + j + k + l + m) % 2) == 0 ) {
 
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG 
+#if CKRBRD_HS_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG 
                             HDfprintf(stdout, "%s%d: *** first_selection = %d ***\n", 
                                       fcnName, mpi_rank, (int)first_selection);
                             HDfprintf(stdout, "%s:%d: i/j/k/l/m = %d/%d/%d/%d/%d\n",
@@ -2204,10 +2703,10 @@ checker_board_hyperslab_dr_pio_test__select_checker_board(
     } while ( ( i <= 1 ) &&
               ( 0 >= sel_offset ) );
 
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG 
+#if CKRBRD_HS_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG 
     HDfprintf(stdout, "%s%d: H5Sget_select_npoints(tgt_sid) = %d.\n",
               fcnName, mpi_rank, (int)H5Sget_select_npoints(tgt_sid));
-#endif /* CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG */
+#endif /* CKRBRD_HS_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG */
 
     /* Clip the selection back to the data space proper. */
 
@@ -2224,20 +2723,20 @@ checker_board_hyperslab_dr_pio_test__select_checker_board(
 
     VRFY((ret != FAIL), "H5Sselect_hyperslab(AND) succeeded");
 
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG 
+#if CKRBRD_HS_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG 
     HDfprintf(stdout, "%s%d: H5Sget_select_npoints(tgt_sid) = %d.\n",
               fcnName, mpi_rank, (int)H5Sget_select_npoints(tgt_sid));
     HDfprintf(stdout, "%s%d: done.\n", fcnName, mpi_rank);
-#endif /* CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG */
+#endif /* CKRBRD_HS_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG */
 
     return;
 
-} /* checker_board_hyperslab_dr_pio_test__select_checker_board() */
+} /* ckrbrd_hs_dr_pio_test__slct_ckrbrd() */
 
 
 /****************************************************************
 **
-**  checker_board_hyperslab_dr_pio_test__verify_data(): 
+**  ckrbrd_hs_dr_pio_test__verify_data(): 
 **
 **	Examine the supplied buffer to see if it contains the 
 **	expected data.  Return TRUE if it does, and FALSE 
@@ -2291,19 +2790,18 @@ checker_board_hyperslab_dr_pio_test__select_checker_board(
 **
 ****************************************************************/
 
-#define CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__VERIFY_DATA__DEBUG 0
+#define CKRBRD_HS_DR_PIO_TEST__VERIFY_DATA__DEBUG 0
 
 static hbool_t
-checker_board_hyperslab_dr_pio_test__verify_data(uint32_t * buf_ptr,
-                                                 const int rank,
-                                                 const int edge_size,
-                                                 const int checker_edge_size,
-                                                 uint32_t first_expected_val,
-                                                 hbool_t buf_starts_in_checker)
+ckrbrd_hs_dr_pio_test__verify_data(uint32_t * buf_ptr,
+                                   const int rank,
+                                   const int edge_size,
+                                   const int checker_edge_size,
+                                   uint32_t first_expected_val,
+                                   hbool_t buf_starts_in_checker)
 {
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__VERIFY_DATA__DEBUG
-    const char *	fcnName = 
-			"checker_board_hyperslab_dr_pio_test__verify_data():";
+#if CKRBRD_HS_DR_PIO_TEST__VERIFY_DATA__DEBUG
+    const char *	fcnName = "ckrbrd_hs_dr_pio_test__verify_data():";
 #endif
     hbool_t good_data = TRUE;
     hbool_t in_checker;
@@ -2322,7 +2820,7 @@ checker_board_hyperslab_dr_pio_test__verify_data(uint32_t * buf_ptr,
     HDassert( checker_edge_size <= edge_size );
     HDassert( test_max_rank <= PAR_SS_DR_MAX_RANK );
 
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__VERIFY_DATA__DEBUG 
+#if CKRBRD_HS_DR_PIO_TEST__VERIFY_DATA__DEBUG 
 
     int		mpi_rank;
 
@@ -2385,13 +2883,13 @@ checker_board_hyperslab_dr_pio_test__verify_data(uint32_t * buf_ptr,
 
                     m = 0;
                     z = 0;
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__VERIFY_DATA__DEBUG 
+#if CKRBRD_HS_DR_PIO_TEST__VERIFY_DATA__DEBUG 
                     HDfprintf(stdout, "%d, %d, %d, %d, %d:", i, j, k, l, m);
 #endif
                     in_checker = start_in_checker[3];
                     do
                     {
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__VERIFY_DATA__DEBUG 
+#if CKRBRD_HS_DR_PIO_TEST__VERIFY_DATA__DEBUG 
                         HDfprintf(stdout, " %d", (int)(*val_ptr));
 #endif
                         if ( z >= checker_edge_size ) {
@@ -2426,7 +2924,7 @@ checker_board_hyperslab_dr_pio_test__verify_data(uint32_t * buf_ptr,
  
                     } while ( ( rank >= (test_max_rank - 4) ) &&
                               ( m < edge_size ) );
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__VERIFY_DATA__DEBUG 
+#if CKRBRD_HS_DR_PIO_TEST__VERIFY_DATA__DEBUG 
                     HDfprintf(stdout, "\n");
 #endif
                     l++;
@@ -2448,668 +2946,118 @@ checker_board_hyperslab_dr_pio_test__verify_data(uint32_t * buf_ptr,
 
     return(good_data);
 
-} /* checker_board_hyperslab_dr_pio_test__verify_data() */
+} /* ckrbrd_hs_dr_pio_test__verify_data() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	checker_board_hyperslab_dr_pio_test__run_test()
+ * Function:	ckrbrd_hs_dr_pio_test__d2m_l2s()
  *
- * Purpose:	Test I/O to/from checkerboard selections of hyperslabs of 
- *		different rank in the parallel.
+ * Purpose:	Part one of a series of tests of I/O to/from hyperslab 
+ *		selections of different rank in the parallel.
+ *
+ *		Verify that we can read from disk correctly using checker
+ *		board selections of different rank that 
+ *              H5S_select_shape_same() views as being of the same shape.
+ *
+ *              In this function, we test this by reading small_rank - 1 
+ *		checker board slices from the on disk large cube, and 
+ *		verifying that the data read is correct.  Verify that 
+ *		H5S_select_shape_same() returns true on the memory and 
+ *		file selections.
  *
  * Return:	void
  *
- * Programmer:	JRM -- 10/10/09
+ * Programmer:	JRM -- 9/15/11
  *
  * 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.
+ *		None.
  *
  *-------------------------------------------------------------------------
  */
 
-#define PAR_SS_DR_MAX_RANK	5
-#define CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 0
+#define CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG 0
 
 static void
-checker_board_hyperslab_dr_pio_test__run_test(const int test_num,
-                                              const int edge_size,
-                                              const int checker_edge_size,
-                                              const int chunk_edge_size,
-                                              const int small_rank,
-                                              const int large_rank,
-                                              const hbool_t use_collective_io,
-                                              const hid_t dset_type,
-                                              const int express_test)
+ckrbrd_hs_dr_pio_test__d2m_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
 {
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG
-    const char *fcnName = "checker_board_hyperslab_dr_pio_test__run_test()";
-#endif /* CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG */
-    const char *filename;
-    hbool_t	use_gpfs = FALSE;   /* Use GPFS hints */
+#if CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG 
+    const char *fcnName = "ckrbrd_hs_dr_pio_test__d2m_l2s()";
+    uint32_t  * ptr_0;
+#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG */
     hbool_t	data_ok = FALSE;
-    hbool_t	mis_match = FALSE;
     int		i, j, k, l;
-    size_t      u;
-    int         mrc;
-    size_t      start_index;
-    size_t      stop_index;
-    int		small_ds_offset;
-    int         large_ds_offset;
-    const int   test_max_rank = 5;  /* must update code if this changes */
     uint32_t	expected_value;
-    uint32_t  * small_ds_buf_0 = NULL;
-    uint32_t  * small_ds_buf_1 = NULL;
-    uint32_t  * small_ds_buf_2 = NULL;
-    uint32_t  * small_ds_slice_buf = NULL;
-    uint32_t  * large_ds_buf_0 = NULL;
-    uint32_t  * large_ds_buf_1 = NULL;
-    uint32_t  * large_ds_buf_2 = NULL;
-    uint32_t  * large_ds_slice_buf = NULL;
-    uint32_t  * ptr_0;
-    uint32_t  * ptr_1;
-    int		mpi_rank;
-    int		mpi_size;
-    MPI_Comm    mpi_comm = MPI_COMM_NULL;
-    MPI_Info	mpi_info = MPI_INFO_NULL;
-    hid_t       fid;			/* HDF5 file ID */
-    hid_t	acc_tpl;		/* File access templates */
-    hid_t	xfer_plist = H5P_DEFAULT;
-    hid_t       full_mem_small_ds_sid;
-    hid_t       full_file_small_ds_sid;
-    hid_t       mem_small_ds_sid;
-    hid_t       file_small_ds_sid_0;
-    hid_t       file_small_ds_sid_1;
-    hid_t	small_ds_slice_sid;
-    hid_t       full_mem_large_ds_sid;
-    hid_t       full_file_large_ds_sid;
-    hid_t       mem_large_ds_sid;
-    hid_t       file_large_ds_sid_0;
-    hid_t       file_large_ds_sid_1;
-    hid_t       file_large_ds_process_slice_sid;
-    hid_t       mem_large_ds_process_slice_sid;
-    hid_t	large_ds_slice_sid;
-    hid_t       small_ds_dcpl_id = H5P_DEFAULT;
-    hid_t       large_ds_dcpl_id = H5P_DEFAULT;
-    hid_t       small_dataset;     /* Dataset ID                   */
-    hid_t       large_dataset;     /* Dataset ID                   */
-    size_t      small_ds_size = 1;
-    size_t      small_ds_slice_size = 1;
-    size_t      large_ds_size = 1;
-    size_t      large_ds_slice_size = 1;
-    hsize_t     dims[PAR_SS_DR_MAX_RANK];
-    hsize_t     chunk_dims[PAR_SS_DR_MAX_RANK];
-    hsize_t     start[PAR_SS_DR_MAX_RANK];
-    hsize_t     stride[PAR_SS_DR_MAX_RANK];
-    hsize_t     count[PAR_SS_DR_MAX_RANK];
-    hsize_t     block[PAR_SS_DR_MAX_RANK];
+    int		mpi_rank; /* needed by VRFY */
     hsize_t     sel_start[PAR_SS_DR_MAX_RANK];
     htri_t      check;          /* Shape comparison return value */
     herr_t	ret;		/* Generic return value */
 
-    HDassert( edge_size >= 6 );
-    HDassert( edge_size >= chunk_edge_size );
-    HDassert( ( chunk_edge_size == 0 ) || ( chunk_edge_size >= 3 ) );
-    HDassert( 1 < small_rank );
-    HDassert( small_rank < large_rank );
-    HDassert( large_rank <= test_max_rank );
-    HDassert( test_max_rank <= PAR_SS_DR_MAX_RANK );
-
-    MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
-    MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
-
-    HDassert( mpi_size >= 1 );
-
-    mpi_comm = MPI_COMM_WORLD;
-    mpi_info = MPI_INFO_NULL;
-
-    for ( i = 0; i < small_rank - 1; i++ )
-    {
-        small_ds_size *= (size_t)edge_size;
-        small_ds_slice_size *= (size_t)edge_size;
-    }
-    small_ds_size *= (size_t)(mpi_size + 1);
-
-    small_ds_offset = PAR_SS_DR_MAX_RANK - small_rank;
-
-    HDassert( 0 < small_ds_offset );
-    HDassert( small_ds_offset < PAR_SS_DR_MAX_RANK );
-
-
-    for ( i = 0; i < large_rank - 1; i++ ) {
-
-        large_ds_size *= (size_t)edge_size;
-        large_ds_slice_size *= (size_t)edge_size;
-    }
-    large_ds_size *= (size_t)(mpi_size + 1);
-
-    large_ds_offset = PAR_SS_DR_MAX_RANK - large_rank;
-
-    HDassert( 0 <= large_ds_offset );
-    HDassert( large_ds_offset < PAR_SS_DR_MAX_RANK );
-
-
-    /* Allocate buffers */
-    small_ds_buf_0 = (uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_size);
-    VRFY((small_ds_buf_0 != NULL), "malloc of small_ds_buf_0 succeeded");
-
-    small_ds_buf_1 = (uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_size);
-    VRFY((small_ds_buf_1 != NULL), "malloc of small_ds_buf_1 succeeded");
-
-    small_ds_buf_2 = (uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_size);
-    VRFY((small_ds_buf_2 != NULL), "malloc of small_ds_buf_2 succeeded");
-
-    small_ds_slice_buf = 
-	(uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_slice_size);
-    VRFY((small_ds_slice_buf != NULL), "malloc of small_ds_slice_buf succeeded");
-
-    large_ds_buf_0 = (uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_size);
-    VRFY((large_ds_buf_0 != NULL), "malloc of large_ds_buf_0 succeeded");
-
-    large_ds_buf_1 = (uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_size);
-    VRFY((large_ds_buf_1 != NULL), "malloc of large_ds_buf_1 succeeded");
-
-    large_ds_buf_2 = (uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_size);
-    VRFY((large_ds_buf_2 != NULL), "malloc of large_ds_buf_2 succeeded");
-
-    large_ds_slice_buf = 
-	(uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_slice_size);
-    VRFY((large_ds_slice_buf != NULL), "malloc of large_ds_slice_buf succeeded");
-
-    /* initialize the buffers */
-
-    ptr_0 = small_ds_buf_0;
-    for(i = 0; i < (int)small_ds_size; i++)
-        *ptr_0++ = (uint32_t)i;
-    HDmemset(small_ds_buf_1, 0, sizeof(uint32_t) * small_ds_size);
-    HDmemset(small_ds_buf_2, 0, sizeof(uint32_t) * small_ds_size);
-
-    HDmemset(small_ds_slice_buf, 0, sizeof(uint32_t) * small_ds_slice_size);
-
-    ptr_0 = large_ds_buf_0;
-    for(i = 0; i < (int)large_ds_size; i++)
-        *ptr_0++ = (uint32_t)i;
-    HDmemset(large_ds_buf_1, 0, sizeof(uint32_t) * large_ds_size);
-    HDmemset(large_ds_buf_2, 0, sizeof(uint32_t) * large_ds_size);
-
-    HDmemset(large_ds_slice_buf, 0, sizeof(uint32_t) * large_ds_slice_size);
-
-    filename = (const char *)GetTestParameters();
-    HDassert( filename != NULL );
-
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG
-    if ( MAINPROCESS ) {
-
-        HDfprintf(stdout, "%s:%d: test num = %d.\n", fcnName, mpi_rank, test_num);
-        HDfprintf(stdout, "%s:%d: mpi_size = %d.\n", fcnName, mpi_rank, mpi_size);
-        HDfprintf(stdout, 
-                  "%s:%d: small/large rank = %d/%d, use_collective_io = %d.\n",
-                  fcnName, mpi_rank, small_rank, large_rank, (int)use_collective_io);
-        HDfprintf(stdout, "%s:%d: edge_size = %d, chunk_edge_size = %d.\n",
-                  fcnName, mpi_rank, edge_size, chunk_edge_size);
-        HDfprintf(stdout, "%s:%d: checker_edge_size = %d.\n", 
-                  fcnName, mpi_rank, checker_edge_size);
-        HDfprintf(stdout, "%s:%d: small_ds_size = %d, large_ds_size = %d.\n",
-                  fcnName, mpi_rank, (int)small_ds_size, (int)large_ds_size);
-        HDfprintf(stdout, "%s:%d: filename = %s.\n", fcnName, mpi_rank, filename);
-    }
-#endif /* CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG */
-
-    /* ----------------------------------------
-     * CREATE AN HDF5 FILE WITH PARALLEL ACCESS
-     * ---------------------------------------*/
-    /* setup file access template */
-    acc_tpl = create_faccess_plist(mpi_comm, mpi_info, facc_type, use_gpfs);
-    VRFY((acc_tpl >= 0), "create_faccess_plist() succeeded");
-
-    /* set the alignment -- need it large so that we aren't always hitting the
-     * the same file system block.  Do this only if express_test is greater
-     * than zero.
-     */
-    if ( express_test > 0 ) {
-
-        ret = H5Pset_alignment(acc_tpl, (hsize_t)0, SHAPE_SAME_TEST_ALIGNMENT);
-        VRFY((ret != FAIL), "H5Pset_alignment() succeeded");
-    }
-
-    /* create the file collectively */
-    fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, acc_tpl);
-    VRFY((fid >= 0), "H5Fcreate succeeded");
-
-    MESG("File opened.");
-
-    /* Release file-access template */
-    ret = H5Pclose(acc_tpl);
-    VRFY((ret >= 0), "H5Pclose(acc_tpl) succeeded");
-
-
-    /* setup dims: */
-    dims[0] = (hsize_t)(mpi_size + 1);
-    dims[1] = dims[2] = dims[3] = dims[4] = (hsize_t)edge_size;
-
-
-    /* Create small ds dataspaces */
-    full_mem_small_ds_sid = H5Screate_simple(small_rank, dims, NULL);
-    VRFY((full_mem_small_ds_sid != 0), 
-         "H5Screate_simple() full_mem_small_ds_sid succeeded");
-
-    full_file_small_ds_sid = H5Screate_simple(small_rank, dims, NULL);
-    VRFY((full_file_small_ds_sid != 0), 
-         "H5Screate_simple() full_file_small_ds_sid succeeded");
-
-    mem_small_ds_sid = H5Screate_simple(small_rank, dims, NULL);
-    VRFY((mem_small_ds_sid != 0), 
-	 "H5Screate_simple() mem_small_ds_sid succeeded");
-
-    file_small_ds_sid_0 = H5Screate_simple(small_rank, dims, NULL);
-    VRFY((file_small_ds_sid_0 != 0), 
-         "H5Screate_simple() file_small_ds_sid_0 succeeded");
-
-    file_small_ds_sid_1 = H5Screate_simple(small_rank, dims, NULL);
-    VRFY((file_small_ds_sid_1 != 0), 
-         "H5Screate_simple() file_small_ds_sid_1 succeeded");
-
-    small_ds_slice_sid = H5Screate_simple(small_rank - 1, &(dims[1]), NULL);
-    VRFY((small_ds_slice_sid != 0), 
-         "H5Screate_simple() small_ds_slice_sid succeeded");
-
-
-    /* Create large ds dataspaces */
-    full_mem_large_ds_sid = H5Screate_simple(large_rank, dims, NULL);
-    VRFY((full_mem_large_ds_sid != 0), 
-         "H5Screate_simple() full_mem_large_ds_sid succeeded");
-
-    full_file_large_ds_sid = H5Screate_simple(large_rank, dims, NULL);
-    VRFY((full_file_large_ds_sid != FAIL), 
-         "H5Screate_simple() full_file_large_ds_sid succeeded");
-
-    mem_large_ds_sid = H5Screate_simple(large_rank, dims, NULL);
-    VRFY((mem_large_ds_sid != FAIL), 
-         "H5Screate_simple() mem_large_ds_sid succeeded");
-
-    file_large_ds_sid_0 = H5Screate_simple(large_rank, dims, NULL);
-    VRFY((file_large_ds_sid_0 != FAIL), 
-         "H5Screate_simple() file_large_ds_sid_0 succeeded");
-
-    file_large_ds_sid_1 = H5Screate_simple(large_rank, dims, NULL);
-    VRFY((file_large_ds_sid_1 != FAIL), 
-         "H5Screate_simple() file_large_ds_sid_1 succeeded");
-
-    mem_large_ds_process_slice_sid = H5Screate_simple(large_rank, dims, NULL);
-    VRFY((mem_large_ds_process_slice_sid != FAIL), 
-         "H5Screate_simple() mem_large_ds_process_slice_sid succeeded");
-
-    file_large_ds_process_slice_sid = H5Screate_simple(large_rank, dims, NULL);
-    VRFY((file_large_ds_process_slice_sid != FAIL), 
-         "H5Screate_simple() file_large_ds_process_slice_sid succeeded");
-
-
-    large_ds_slice_sid = H5Screate_simple(large_rank - 1, &(dims[1]), NULL);
-    VRFY((large_ds_slice_sid != 0), 
-         "H5Screate_simple() large_ds_slice_sid succeeded");
-
-
-    /* if chunk edge size is greater than zero, set up the small and
-     * large data set creation property lists to specify chunked
-     * datasets.
-     */
-    if ( chunk_edge_size > 0 ) {
-
-        /* Under Lustre (and perhaps other parallel file systems?) we get 
-	 * locking delays when two or more processes attempt to access the 
-         * same file system block.
-         *
-         * To minimize this problem, I have changed chunk_dims[0] 
-         * from (mpi_size + 1) to just when any sort of express test is
-         * selected.  Given the structure of the test, and assuming we 
-         * set the alignment large enough, this avoids the contention 
-         * issue by seeing to it that each chunk is only accessed by one 
-         * process.
-         *
-         * One can argue as to whether this is a good thing to do in our 
-         * tests, but for now it is necessary if we want the test to complete
-         * in a reasonable amount of time.
-         *
-         *                                         JRM -- 9/16/10
-         */
-        if ( express_test == 0 ) {
-
-            chunk_dims[0] = 1;
-
-        } else {
-
-            chunk_dims[0] = 1;
-        }
-
-        chunk_dims[1] = chunk_dims[2] = 
-                        chunk_dims[3] = chunk_dims[4] = (hsize_t)chunk_edge_size;
-
-        small_ds_dcpl_id = H5Pcreate(H5P_DATASET_CREATE);
-        VRFY((ret != FAIL), "H5Pcreate() small_ds_dcpl_id succeeded");
-
-        ret = H5Pset_layout(small_ds_dcpl_id, H5D_CHUNKED);
-        VRFY((ret != FAIL), "H5Pset_layout() small_ds_dcpl_id succeeded");
-
-        ret = H5Pset_chunk(small_ds_dcpl_id, small_rank, chunk_dims);
-        VRFY((ret != FAIL), "H5Pset_chunk() small_ds_dcpl_id succeeded");
-
-
-        large_ds_dcpl_id = H5Pcreate(H5P_DATASET_CREATE);
-        VRFY((ret != FAIL), "H5Pcreate() large_ds_dcpl_id succeeded");
-
-        ret = H5Pset_layout(large_ds_dcpl_id, H5D_CHUNKED);
-        VRFY((ret != FAIL), "H5Pset_layout() large_ds_dcpl_id succeeded");
-
-        ret = H5Pset_chunk(large_ds_dcpl_id, large_rank, chunk_dims);
-        VRFY((ret != FAIL), "H5Pset_chunk() large_ds_dcpl_id succeeded");
-    }
-
-    /* create the small dataset */
-    small_dataset = H5Dcreate2(fid, "small_dataset", dset_type,
-                               file_small_ds_sid_0, H5P_DEFAULT,
-                               small_ds_dcpl_id, H5P_DEFAULT);
-    VRFY((ret != FAIL), "H5Dcreate2() small_dataset succeeded");
-
-    /* create the large dataset */
-    large_dataset = H5Dcreate2(fid, "large_dataset", dset_type,
-                               file_large_ds_sid_0, H5P_DEFAULT,
-                               large_ds_dcpl_id, H5P_DEFAULT);
-    VRFY((ret != FAIL), "H5Dcreate2() large_dataset succeeded");
-
-
-    /* setup xfer property list */
-    xfer_plist = H5Pcreate(H5P_DATASET_XFER);
-    VRFY((xfer_plist >= 0), "H5Pcreate(H5P_DATASET_XFER) succeeded");
-
-    if(use_collective_io) {
-        ret = H5Pset_dxpl_mpio(xfer_plist, H5FD_MPIO_COLLECTIVE);
-        VRFY((ret >= 0), "H5Pset_dxpl_mpio succeeded");
-    }
-
-
-    /* setup selection to write initial data to the small and large data sets */
-    start[0] = (hsize_t)mpi_rank;
-    stride[0] = (hsize_t)(2 * (mpi_size + 1));
-    count[0] = 1;
-    block[0] = 1;
-
-    for ( i = 1; i < large_rank; i++ ) {
-
-        start[i] = 0;
-        stride[i] = (hsize_t)(2 * edge_size);
-        count[i] = 1;
-        block[i] = (hsize_t)edge_size;
-    }
-
-    /* setup selections for writing initial data to the small data set */
-    ret = H5Sselect_hyperslab(mem_small_ds_sid,
-                              H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
-    VRFY((ret >= 0), "H5Sselect_hyperslab(mem_small_ds_sid, set) suceeded");
-
-    ret = H5Sselect_hyperslab(file_small_ds_sid_0,
-                              H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
-    VRFY((ret >= 0), "H5Sselect_hyperslab(file_small_ds_sid_0, set) suceeded");
-
-    if ( MAINPROCESS ) { /* add an additional slice to the selections */
-
-        start[0] = (hsize_t)mpi_size;
-
-        ret = H5Sselect_hyperslab(mem_small_ds_sid,
-                                  H5S_SELECT_OR,
-                                  start,
-                                  stride,
-                                  count,
-                                  block);
-        VRFY((ret>= 0), "H5Sselect_hyperslab(mem_small_ds_sid, or) suceeded");
-
-        ret = H5Sselect_hyperslab(file_small_ds_sid_0,
-                                  H5S_SELECT_OR,
-                                  start,
-                                  stride,
-                                  count,
-                                  block);
-        VRFY((ret>= 0), "H5Sselect_hyperslab(file_small_ds_sid_0, or) suceeded");
-    }
-
-
-    /* write the initial value of the small data set to file */
-    ret = H5Dwrite(small_dataset, dset_type, mem_small_ds_sid, file_small_ds_sid_0,
-                   xfer_plist, small_ds_buf_0);
-    VRFY((ret >= 0), "H5Dwrite() small_dataset initial write succeeded");
-
-
-    /* sync with the other processes before checking data */
-    if ( ! use_collective_io ) {
-
-        mrc = MPI_Barrier(MPI_COMM_WORLD);
-        VRFY((mrc==MPI_SUCCESS), "Sync after small dataset writes");
-    }
-
-    /* read the small data set back to verify that it contains the 
-     * expected data.  Note that each process reads in the entire 
-     * data set and verifies it.
-     */
-    ret = H5Dread(small_dataset,
-                  H5T_NATIVE_UINT32,
-                  full_mem_small_ds_sid,
-                  full_file_small_ds_sid,
-                  xfer_plist,
-                  small_ds_buf_1);
-    VRFY((ret >= 0), "H5Dread() small_dataset initial read succeeded");
-
-
-    /* verify that the correct data was written to the small data set */
-    expected_value = 0;
-    mis_match = FALSE;
-    ptr_1 = small_ds_buf_1;
-
-    i = 0;
-    for ( i = 0; i < (int)small_ds_size; i++ ) {
-
-        if ( *ptr_1 != expected_value ) {
-
-            mis_match = TRUE;
-        }
-        ptr_1++;
-        expected_value++;
-    }
-    VRFY( (mis_match == FALSE), "small ds init data good.");
-
-
-
-    /* setup selections for writing initial data to the large data set */
-
-    start[0] = (hsize_t)mpi_rank;
-
-    ret = H5Sselect_hyperslab(mem_large_ds_sid,
-                              H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
-    VRFY((ret >= 0), "H5Sselect_hyperslab(mem_large_ds_sid, set) suceeded");
-
-    ret = H5Sselect_hyperslab(file_large_ds_sid_0,
-                              H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
-    VRFY((ret >= 0), "H5Sselect_hyperslab(file_large_ds_sid_0, set) suceeded");
- 
-    /* In passing, setup the process slice data spaces as well */
-
-    ret = H5Sselect_hyperslab(mem_large_ds_process_slice_sid,
-                              H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
-    VRFY((ret >= 0), 
-         "H5Sselect_hyperslab(mem_large_ds_process_slice_sid, set) suceeded");
-
-    ret = H5Sselect_hyperslab(file_large_ds_process_slice_sid,
-                              H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
-    VRFY((ret >= 0), 
-         "H5Sselect_hyperslab(file_large_ds_process_slice_sid, set) suceeded");
-
-    if ( MAINPROCESS ) { /* add an additional slice to the selections */
-
-        start[0] = (hsize_t)mpi_size;
-
-        ret = H5Sselect_hyperslab(mem_large_ds_sid,
-                                  H5S_SELECT_OR,
-                                  start,
-                                  stride,
-                                  count,
-                                  block);
-        VRFY((ret>= 0), "H5Sselect_hyperslab(mem_large_ds_sid, or) suceeded");
-
-        ret = H5Sselect_hyperslab(file_large_ds_sid_0,
-                                  H5S_SELECT_OR,
-                                  start,
-                                  stride,
-                                  count,
-                                  block);
-        VRFY((ret>= 0), "H5Sselect_hyperslab(file_large_ds_sid_0, or) suceeded");
-    }
-
-
-    /* write the initial value of the large data set to file */
-    ret = H5Dwrite(large_dataset, dset_type, mem_large_ds_sid, file_large_ds_sid_0,
-                   xfer_plist, large_ds_buf_0);
-    if ( ret < 0 ) H5Eprint2(H5E_DEFAULT, stderr);
-    VRFY((ret >= 0), "H5Dwrite() large_dataset initial write succeeded");
-
-
-    /* sync with the other processes before checking data */
-    if ( ! use_collective_io ) {
-
-        mrc = MPI_Barrier(MPI_COMM_WORLD);
-        VRFY((mrc==MPI_SUCCESS), "Sync after large dataset writes");
-    }
-
-
-    /* read the small data set back to verify that it contains the 
-     * expected data.  Note that each process reads in the entire 
-     * data set.
-     */
-    ret = H5Dread(large_dataset,
-                  H5T_NATIVE_UINT32,
-                  full_mem_large_ds_sid,
-                  full_file_large_ds_sid,
-                  xfer_plist,
-                  large_ds_buf_1);
-    VRFY((ret >= 0), "H5Dread() large_dataset initial read succeeded");
-
+    /* initialize the local copy of mpi_rank */
+    mpi_rank = tv_ptr->mpi_rank;
 
-    /* verify that the correct data was written to the small data set */
-    expected_value = 0;
-    mis_match = FALSE;
-    ptr_1 = large_ds_buf_1;
-
-    i = 0;
-    for ( i = 0; i < (int)large_ds_size; i++ ) {
-
-        if ( *ptr_1 != expected_value ) {
-
-            mis_match = TRUE;
-        }
-        ptr_1++;
-        expected_value++;
-    }
-    VRFY( (mis_match == FALSE), "large ds init data good.");
- 
-    /* sync with the other processes before changing data */
-
-    if ( ! use_collective_io ) {
-
-        mrc = MPI_Barrier(MPI_COMM_WORLD);
-        VRFY((mrc==MPI_SUCCESS), "Sync after initial values check");
-    }
-
-
-    /***********************************/
-    /***** INITIALIZATION COMPLETE *****/
-    /***********************************/
 
     /* first, verify that we can read from disk correctly using selections
      * of different rank that H5S_select_shape_same() views as being of the
      * same shape.
      *
-     * Start by reading a (small_rank - 1)-D slice from this processes slice 
-     * of the on disk large data set, and verifying that the data read is 
-     * correct.  Verify that H5S_select_shape_same() returns true on the 
-     * memory and file selections.
+     * Start by reading a (small_rank - 1)-D checker board slice from this 
+     * processes slice of the on disk large data set, and verifying that the 
+     * data read is correct.  Verify that H5S_select_shape_same() returns 
+     * true on the memory and file selections.
      *
      * The first step is to set up the needed checker board selection in the
      * in memory small small cube
      */
 
     sel_start[0] = sel_start[1] = sel_start[2] = sel_start[3] = sel_start[4] = 0;
-    sel_start[small_ds_offset] = (hsize_t)mpi_rank;
+    sel_start[tv_ptr->small_ds_offset] = (hsize_t)(tv_ptr->mpi_rank);
 
-    checker_board_hyperslab_dr_pio_test__select_checker_board(mpi_rank,
-                                                              small_ds_slice_sid,
-                                                              small_rank - 1,
-                                                              edge_size,
-                                                              checker_edge_size,
-                                                              small_rank - 1,
-                                                              sel_start);
+    ckrbrd_hs_dr_pio_test__slct_ckrbrd(tv_ptr->mpi_rank,
+                                       tv_ptr->small_ds_slice_sid,
+                                       tv_ptr->small_rank - 1,
+                                       tv_ptr->edge_size,
+                                       tv_ptr->checker_edge_size,
+                                       tv_ptr->small_rank - 1,
+                                       sel_start);
 
     /* zero out the buffer we will be reading into */
-    HDmemset(small_ds_slice_buf, 0, sizeof(uint32_t) * small_ds_slice_size);
+    HDmemset(tv_ptr->small_ds_slice_buf, 0, sizeof(uint32_t) * tv_ptr->small_ds_slice_size);
 
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
+#if CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG 
     HDfprintf(stdout, "%s:%d: initial small_ds_slice_buf = ",
-              fcnName, mpi_rank);
-    ptr_0 = small_ds_slice_buf;
-    for ( i = 0; i < (int)small_ds_slice_size; i++ ) {
-	HDfprintf(stdout, "%d ", (int)(*ptr_0));
+              fcnName, tv_ptr->mpi_rank);
+    ptr_0 = tv_ptr->small_ds_slice_buf;
+    for ( i = 0; i < (int)(tv_ptr->small_ds_slice_size); i++ ) {
+        HDfprintf(stdout, "%d ", (int)(*ptr_0));
         ptr_0++;
     }
     HDfprintf(stdout, "\n");
-#endif /* CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG */ 
+#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG */ 
 
     /* set up start, stride, count, and block -- note that we will
      * change start[] so as to read slices of the large cube.
      */
     for ( i = 0; i < PAR_SS_DR_MAX_RANK; i++ ) {
 
-        start[i] = 0;
-        stride[i] = (hsize_t)(2 * edge_size);
-        count[i] = 1;
-        if ( (PAR_SS_DR_MAX_RANK - i) > (small_rank - 1) ) {
+        tv_ptr->start[i] = 0;
+        tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size);
+        tv_ptr->count[i] = 1;
+        if ( (PAR_SS_DR_MAX_RANK - i) > (tv_ptr->small_rank - 1) ) {
 
-            block[i] = 1;
+            tv_ptr->block[i] = 1;
 
         } else {
 
-            block[i] = (hsize_t)edge_size;
+            tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size);
         }
     }
 
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
+#if CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG 
     HDfprintf(stdout, 
               "%s:%d: reading slice from big ds on disk into small ds slice.\n",
-              fcnName, mpi_rank);
-#endif /* CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG */ 
+              fcnName, tv_ptr->mpi_rank);
+#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG */ 
     /* in serial versions of this test, we loop through all the dimensions
      * of the large data set.  However, in the parallel version, each 
      * process only works with that slice of the large cube indicated
@@ -3117,9 +3065,9 @@ checker_board_hyperslab_dr_pio_test__run_test(const int test_num,
      * mpi_rank, and don't itterate over it.
      */
 
-    if ( PAR_SS_DR_MAX_RANK - large_rank == 0 ) {
+    if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 0 ) {
 
-        i = mpi_rank;
+        i = tv_ptr->mpi_rank;
 
     } else {
 
@@ -3132,9 +3080,9 @@ checker_board_hyperslab_dr_pio_test__run_test(const int test_num,
      * test.
      */
 
-    if ( PAR_SS_DR_MAX_RANK - large_rank == 1 ) {
+    if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 1 ) {
 
-        j = mpi_rank;
+        j = tv_ptr->mpi_rank;
 
     } else {
 
@@ -3142,9 +3090,9 @@ checker_board_hyperslab_dr_pio_test__run_test(const int test_num,
     }
 
     do {
-        if ( PAR_SS_DR_MAX_RANK - large_rank == 2 ) {
+        if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 2 ) {
 
-            k = mpi_rank;
+            k = tv_ptr->mpi_rank;
 
         } else {
 
@@ -3164,98 +3112,167 @@ checker_board_hyperslab_dr_pio_test__run_test(const int test_num,
 
             l = 0;
             do {
-                /* we know that small_rank - 1 >= 1 and that 
-                 * large_rank > small_rank by the assertions at the head 
-                 * of this function.  Thus no need for another inner loop.
-                 */
-                start[0] = (hsize_t)i;
-                start[1] = (hsize_t)j;
-                start[2] = (hsize_t)k;
-                start[3] = (hsize_t)l;
-                start[4] = 0;
-
-                HDassert( ( start[0] == 0 ) || ( 0 < small_ds_offset + 1 ) );
-                HDassert( ( start[1] == 0 ) || ( 1 < small_ds_offset + 1 ) );
-                HDassert( ( start[2] == 0 ) || ( 2 < small_ds_offset + 1 ) );
-                HDassert( ( start[3] == 0 ) || ( 3 < small_ds_offset + 1 ) );
-                HDassert( ( start[4] == 0 ) || ( 4 < small_ds_offset + 1 ) );
-
-                checker_board_hyperslab_dr_pio_test__select_checker_board
-                (
-                  mpi_rank,
-                  file_large_ds_sid_0,
-                  large_rank,
-                  edge_size,
-                  checker_edge_size,
-                  small_rank - 1,
-                  start
-                );
-
-                /* verify that H5S_select_shape_same() reports the two
-                 * selections as having the same shape.
-                 */
-                check = H5S_select_shape_same_test(small_ds_slice_sid,
-                                                   file_large_ds_sid_0);
-                VRFY((check == TRUE), "H5S_select_shape_same_test passed");
-
-
-                /* Read selection from disk */
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
-                HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", fcnName,
-                          mpi_rank, start[0], start[1], start[2], start[3], 
-                          start[4]);
-                HDfprintf(stdout, "%s slice/file extent dims = %d/%d.\n",
-                          fcnName,
-                          H5Sget_simple_extent_ndims(small_ds_slice_sid),
-                          H5Sget_simple_extent_ndims(file_large_ds_sid_0));
-#endif /* CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG */ 
-
-                ret = H5Dread(large_dataset,
-                              H5T_NATIVE_UINT32,
-                              small_ds_slice_sid,
-                              file_large_ds_sid_0,
-                              xfer_plist,
-                              small_ds_slice_buf);
-                VRFY((ret >= 0), "H5Dread() slice from large ds succeeded.");
-
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
-		HDfprintf(stdout, "%s:%d: H5Dread() returns.\n", 
-                          fcnName, mpi_rank);
-#endif 
+                if ( (tv_ptr->skips)++ < tv_ptr->max_skips ) { /* skip the test */
+
+                    (tv_ptr->tests_skipped)++;
+
+                } else { /* run the test */
+
+                    tv_ptr->skips = 0; /* reset the skips counter */
+
+                    /* we know that small_rank - 1 >= 1 and that 
+                     * large_rank > small_rank by the assertions at the head 
+                     * of this function.  Thus no need for another inner loop.
+                     */
+                    tv_ptr->start[0] = (hsize_t)i;
+                    tv_ptr->start[1] = (hsize_t)j;
+                    tv_ptr->start[2] = (hsize_t)k;
+                    tv_ptr->start[3] = (hsize_t)l;
+                    tv_ptr->start[4] = 0;
+
+                    HDassert((tv_ptr->start[0] == 0)||(0 < tv_ptr->small_ds_offset + 1));
+                    HDassert((tv_ptr->start[1] == 0)||(1 < tv_ptr->small_ds_offset + 1));
+                    HDassert((tv_ptr->start[2] == 0)||(2 < tv_ptr->small_ds_offset + 1));
+                    HDassert((tv_ptr->start[3] == 0)||(3 < tv_ptr->small_ds_offset + 1));
+                    HDassert((tv_ptr->start[4] == 0)||(4 < tv_ptr->small_ds_offset + 1));
+
+                    ckrbrd_hs_dr_pio_test__slct_ckrbrd
+                    (
+                      tv_ptr->mpi_rank,
+                      tv_ptr->file_large_ds_sid_0,
+                      tv_ptr->large_rank,
+                      tv_ptr->edge_size,
+                      tv_ptr->checker_edge_size,
+                      tv_ptr->small_rank - 1,
+                      tv_ptr->start
+                    );
+
+                    /* verify that H5S_select_shape_same() reports the two
+                     * selections as having the same shape.
+                     */
+                    check = H5S_select_shape_same_test(tv_ptr->small_ds_slice_sid,
+                                                       tv_ptr->file_large_ds_sid_0);
+                    VRFY((check == TRUE), "H5S_select_shape_same_test passed");
+
+
+                    /* Read selection from disk */
+#if CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG 
+                    HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", fcnName,
+                              tv_ptr->mpi_rank, tv_ptr->start[0], tv_ptr->start[1], 
+                              tv_ptr->start[2], tv_ptr->start[3], tv_ptr->start[4]);
+                    HDfprintf(stdout, "%s slice/file extent dims = %d/%d.\n",
+                              fcnName,
+                              H5Sget_simple_extent_ndims(tv_ptr->small_ds_slice_sid),
+                              H5Sget_simple_extent_ndims(tv_ptr->file_large_ds_sid_0));
+#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG */ 
+
+                    ret = H5Dread(tv_ptr->large_dataset,
+                                  H5T_NATIVE_UINT32,
+                                  tv_ptr->small_ds_slice_sid,
+                                  tv_ptr->file_large_ds_sid_0,
+                                  tv_ptr->xfer_plist,
+                                  tv_ptr->small_ds_slice_buf);
+                    VRFY((ret >= 0), "H5Dread() slice from large ds succeeded.");
+
+#if CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG 
+                    HDfprintf(stdout, "%s:%d: H5Dread() returns.\n", 
+                              fcnName, tv_ptr->mpi_rank);
+#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG */
+
+                    /* verify that expected data is retrieved */
+
+                    expected_value = (uint32_t)
+                        ((i * tv_ptr->edge_size * tv_ptr->edge_size * 
+                              tv_ptr->edge_size * tv_ptr->edge_size) +
+                         (j * tv_ptr->edge_size * tv_ptr->edge_size * tv_ptr->edge_size) +
+                         (k * tv_ptr->edge_size * tv_ptr->edge_size) +
+                         (l * tv_ptr->edge_size));
+
+                    data_ok = ckrbrd_hs_dr_pio_test__verify_data
+                              (
+                                tv_ptr->small_ds_slice_buf,
+                                tv_ptr->small_rank - 1,
+                                tv_ptr->edge_size,
+                                tv_ptr->checker_edge_size,
+                                expected_value,
+                                (hbool_t)TRUE
+                              );
+
+                    VRFY((data_ok == TRUE), 
+                         "small slice read from large ds data good.");
+
+                    (tv_ptr->tests_run)++;
+                }
 
-                /* verify that expected data is retrieved */
-
-                expected_value = (uint32_t)
-			((i * edge_size * edge_size * edge_size * edge_size) +
-                         (j * edge_size * edge_size * edge_size) +
-                         (k * edge_size * edge_size) +
-                         (l * edge_size));
-
-                data_ok = checker_board_hyperslab_dr_pio_test__verify_data
-                          (
-                            small_ds_slice_buf,
-                            small_rank - 1,
-                            edge_size,
-                            checker_edge_size,
-                            expected_value,
-                            (hbool_t)TRUE
-                          );
-
-                VRFY((data_ok == TRUE), 
-                     "small slice read from large ds data good.");
                 l++;
 
-            } while ( ( large_rank > 2 ) &&
-                      ( (small_rank - 1) <= 1 ) &&
-                      ( l < edge_size ) );
+                (tv_ptr->total_tests)++;
+
+            } while ( ( tv_ptr->large_rank > 2 ) &&
+                      ( (tv_ptr->small_rank - 1) <= 1 ) &&
+                      ( l < tv_ptr->edge_size ) );
             k++;
-        } while ( ( large_rank > 3 ) &&
-                  ( (small_rank - 1) <= 2 ) &&
-                  ( k < edge_size ) );
+        } while ( ( tv_ptr->large_rank > 3 ) &&
+                  ( (tv_ptr->small_rank - 1) <= 2 ) &&
+                  ( k < tv_ptr->edge_size ) );
         j++;
-    } while ( ( large_rank > 4 ) &&
-              ( (small_rank - 1) <= 3 ) &&
-              ( j < edge_size ) );
+    } while ( ( tv_ptr->large_rank > 4 ) &&
+              ( (tv_ptr->small_rank - 1) <= 3 ) &&
+              ( j < tv_ptr->edge_size ) );
+
+    return;
+
+} /* ckrbrd_hs_dr_pio_test__d2m_l2s() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	ckrbrd_hs_dr_pio_test__d2m_s2l()
+ *
+ * Purpose:	Part two of a series of tests of I/O to/from hyperslab 
+ *		selections of different rank in the parallel.
+ *
+ *		Verify that we can read from disk correctly using 
+ *		selections of different rank that H5S_select_shape_same() 
+ *		views as being of the same shape.
+ *
+ *		In this function, we test this by reading checker board
+ *		slices of the on disk small data set into slices through 
+ *		the in memory large data set, and verify that the correct 
+ *		data (and only the correct data) is read.
+ *
+ * Return:	void
+ *
+ * Programmer:	JRM -- 8/15/11
+ *
+ * Modifications:
+ *
+ *		None.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define CHECKER_BOARD_HS_DR_PIO_TEST__D2M_S2L__DEBUG 0
+
+static void
+ckrbrd_hs_dr_pio_test__d2m_s2l(struct hs_dr_pio_test_vars_t * tv_ptr)
+{
+#if CHECKER_BOARD_HS_DR_PIO_TEST__D2M_S2L__DEBUG 
+    const char *fcnName = "ckrbrd_hs_dr_pio_test__d2m_s2l()";
+#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__D2M_S2L__DEBUG */
+    hbool_t	data_ok = FALSE;
+    int		i, j, k, l;
+    size_t      u;
+    size_t      start_index;
+    size_t      stop_index;
+    uint32_t	expected_value;
+    uint32_t  * ptr_1;
+    int		mpi_rank; /* needed by VRFY */
+    hsize_t     sel_start[PAR_SS_DR_MAX_RANK];
+    htri_t      check;          /* Shape comparison return value */
+    herr_t	ret;		/* Generic return value */
+
+    /* initialize the local copy of mpi_rank */
+    mpi_rank = tv_ptr->mpi_rank;
 
 
     /* similarly, read slices of the on disk small data set into slices 
@@ -3264,24 +3281,24 @@ checker_board_hyperslab_dr_pio_test__run_test(const int test_num,
      */
 
     sel_start[0] = sel_start[1] = sel_start[2] = sel_start[3] = sel_start[4] = 0;
-    sel_start[small_ds_offset] = (hsize_t)mpi_rank;
+    sel_start[tv_ptr->small_ds_offset] = (hsize_t)(tv_ptr->mpi_rank);
 
-    checker_board_hyperslab_dr_pio_test__select_checker_board(mpi_rank,
-                                                              file_small_ds_sid_0,
-                                                              small_rank,
-                                                              edge_size,
-                                                              checker_edge_size,
-                                                              small_rank - 1,
-                                                              sel_start);
+    ckrbrd_hs_dr_pio_test__slct_ckrbrd(tv_ptr->mpi_rank,
+                                       tv_ptr->file_small_ds_sid_0,
+                                       tv_ptr->small_rank,
+                                       tv_ptr->edge_size,
+                                       tv_ptr->checker_edge_size,
+                                       tv_ptr->small_rank - 1,
+                                       sel_start);
 
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
+#if CHECKER_BOARD_HS_DR_PIO_TEST__D2M_S2L__DEBUG 
     HDfprintf(stdout, 
       "%s reading slices of on disk small data set into slices of big data set.\n",
               fcnName);
-#endif 
+#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__D2M_S2L__DEBUG */
 
     /* zero out the buffer we will be reading into */
-    HDmemset(large_ds_buf_1, 0, sizeof(uint32_t) * large_ds_size);
+    HDmemset(tv_ptr->large_ds_buf_1, 0, sizeof(uint32_t) * tv_ptr->large_ds_size);
 
     /* set up start, stride, count, and block -- note that we will
      * change start[] so as to read the slice of the small data set
@@ -3290,20 +3307,19 @@ checker_board_hyperslab_dr_pio_test__run_test(const int test_num,
      */
     for ( i = 0; i < PAR_SS_DR_MAX_RANK; i++ ) {
 
-        start[i] = 0;
-        stride[i] = (hsize_t)(2 * edge_size);
-        count[i] = 1;
-        if ( (PAR_SS_DR_MAX_RANK - i) > (small_rank - 1) ) {
+        tv_ptr->start[i] = 0;
+        tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size);
+        tv_ptr->count[i] = 1;
+        if ( (PAR_SS_DR_MAX_RANK - i) > (tv_ptr->small_rank - 1) ) {
 
-            block[i] = 1;
+            tv_ptr->block[i] = 1;
 
         } else {
 
-            block[i] = (hsize_t)edge_size;
+            tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size);
         }
     }
 
-
     /* in serial versions of this test, we loop through all the dimensions
      * of the large data set that don't appear in the small data set.  
      *
@@ -3314,9 +3330,9 @@ checker_board_hyperslab_dr_pio_test__run_test(const int test_num,
      */
 
 
-    if ( PAR_SS_DR_MAX_RANK - large_rank == 0 ) {
+    if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 0 ) {
 
-        i = mpi_rank;
+        i = tv_ptr->mpi_rank;
 
     } else {
 
@@ -3329,9 +3345,9 @@ checker_board_hyperslab_dr_pio_test__run_test(const int test_num,
      * test.
      */
 
-    if ( PAR_SS_DR_MAX_RANK - large_rank == 1 ) {
+    if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 1 ) {
 
-        j = mpi_rank;
+        j = tv_ptr->mpi_rank;
 
     } else {
 
@@ -3339,9 +3355,9 @@ checker_board_hyperslab_dr_pio_test__run_test(const int test_num,
     }
 
     do {
-        if ( PAR_SS_DR_MAX_RANK - large_rank == 2 ) {
+        if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 2 ) {
 
-            k = mpi_rank;
+            k = tv_ptr->mpi_rank;
 
         } else {
 
@@ -3361,161 +3377,235 @@ checker_board_hyperslab_dr_pio_test__run_test(const int test_num,
 
             l = 0;
             do {
-                /* we know that small_rank >= 1 and that large_rank > small_rank
-                 * by the assertions at the head of this function.  Thus no
-                 * need for another inner loop.
-                 */
-                start[0] = (hsize_t)i;
-                start[1] = (hsize_t)j;
-                start[2] = (hsize_t)k;
-                start[3] = (hsize_t)l;
-                start[4] = 0;
-
-                HDassert( ( start[0] == 0 ) || ( 0 < small_ds_offset + 1 ) );
-                HDassert( ( start[1] == 0 ) || ( 1 < small_ds_offset + 1 ) );
-                HDassert( ( start[2] == 0 ) || ( 2 < small_ds_offset + 1 ) );
-                HDassert( ( start[3] == 0 ) || ( 3 < small_ds_offset + 1 ) );
-                HDassert( ( start[4] == 0 ) || ( 4 < small_ds_offset + 1 ) );
-
-                checker_board_hyperslab_dr_pio_test__select_checker_board
-                (
-                  mpi_rank,
-                  mem_large_ds_sid,
-                  large_rank,
-                  edge_size,
-                  checker_edge_size,
-                  small_rank - 1,
-                  start
-                );
-
-
-                /* verify that H5S_select_shape_same() reports the two
-                 * selections as having the same shape.
-                 */
-                check = H5S_select_shape_same_test(file_small_ds_sid_0,
-                                                   mem_large_ds_sid);
-                VRFY((check == TRUE), "H5S_select_shape_same_test passed");
-
-
-                /* Read selection from disk */
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
-                HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", 
-                          fcnName, mpi_rank, 
-                          start[0], start[1], start[2], start[3], start[4]);
-                HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n",
-                          fcnName, mpi_rank,
-                          H5Sget_simple_extent_ndims(large_ds_slice_sid),
-                          H5Sget_simple_extent_ndims(file_small_ds_sid_0));
-#endif 
-                ret = H5Dread(small_dataset,
-                              H5T_NATIVE_UINT32,
-                              mem_large_ds_sid,
-                              file_small_ds_sid_0,
-                              xfer_plist,
-                              large_ds_buf_1);
-                VRFY((ret >= 0), "H5Dread() slice from small ds succeeded.");
-
-                /* verify that the expected data and only the
-                 * expected data was read.
-                 */
-                data_ok = TRUE;
-                ptr_1 = large_ds_buf_1;
-                expected_value = (uint32_t)((size_t)mpi_rank * small_ds_slice_size);
-                start_index = (size_t)(
-                        (i * edge_size * edge_size * edge_size * edge_size) +
-                        (j * edge_size * edge_size * edge_size) +
-                        (k * edge_size * edge_size) +
-                        (l * edge_size));
-                stop_index = start_index + small_ds_slice_size - 1;
-
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
-{
-int		m, n;
-
-		HDfprintf(stdout, "%s:%d: expected_value = %d.\n", 
-                          fcnName, mpi_rank, expected_value);
-		HDfprintf(stdout, "%s:%d: start/stop index = %d/%d.\n",
-                          fcnName, mpi_rank, start_index, stop_index);
-                n = 0;
-                for ( m = 0; m < large_ds_size; m ++ ) {
-                    HDfprintf(stdout, "%d ", (int)(*ptr_1));
-                    ptr_1++;
-                    n++;
-                    if ( n >= edge_size ) {
-                        HDfprintf(stdout, "\n");
+                if ( (tv_ptr->skips)++ < tv_ptr->max_skips ) { /* skip the test */
+
+                    (tv_ptr->tests_skipped)++;
+
+                } else { /* run the test */
+
+                    tv_ptr->skips = 0; /* reset the skips counter */
+
+                    /* we know that small_rank >= 1 and that large_rank > small_rank
+                     * by the assertions at the head of this function.  Thus no
+                     * need for another inner loop.
+                     */
+                    tv_ptr->start[0] = (hsize_t)i;
+                    tv_ptr->start[1] = (hsize_t)j;
+                    tv_ptr->start[2] = (hsize_t)k;
+                    tv_ptr->start[3] = (hsize_t)l;
+                    tv_ptr->start[4] = 0;
+
+                    HDassert((tv_ptr->start[0] == 0)||(0 < tv_ptr->small_ds_offset + 1));
+                    HDassert((tv_ptr->start[1] == 0)||(1 < tv_ptr->small_ds_offset + 1));
+                    HDassert((tv_ptr->start[2] == 0)||(2 < tv_ptr->small_ds_offset + 1));
+                    HDassert((tv_ptr->start[3] == 0)||(3 < tv_ptr->small_ds_offset + 1));
+                    HDassert((tv_ptr->start[4] == 0)||(4 < tv_ptr->small_ds_offset + 1));
+
+                    ckrbrd_hs_dr_pio_test__slct_ckrbrd
+                    (
+                      tv_ptr->mpi_rank,
+                      tv_ptr->mem_large_ds_sid,
+                      tv_ptr->large_rank,
+                      tv_ptr->edge_size,
+                      tv_ptr->checker_edge_size,
+                      tv_ptr->small_rank - 1,
+                      tv_ptr->start
+                    );
+
+
+                    /* verify that H5S_select_shape_same() reports the two
+                     * selections as having the same shape.
+                     */
+                    check = H5S_select_shape_same_test(tv_ptr->file_small_ds_sid_0,
+                                                       tv_ptr->mem_large_ds_sid);
+                    VRFY((check == TRUE), "H5S_select_shape_same_test passed");
+
+
+                    /* Read selection from disk */
+#if CHECKER_BOARD_HS_DR_PIO_TEST__D2M_S2L__DEBUG 
+                    HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", 
+                              fcnName, tv_ptr->mpi_rank, 
+                              tv_ptr->start[0], tv_ptr->start[1], tv_ptr->start[2], 
+                              tv_ptr->start[3], tv_ptr->start[4]); 
+                    HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n",
+                              fcnName, tv_ptr->mpi_rank,
+                              H5Sget_simple_extent_ndims(tv_ptr->large_ds_slice_sid),
+                              H5Sget_simple_extent_ndims(tv_ptr->file_small_ds_sid_0));
+#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__D2M_S2L__DEBUG */
+                    ret = H5Dread(tv_ptr->small_dataset,
+                                  H5T_NATIVE_UINT32,
+                                  tv_ptr->mem_large_ds_sid,
+                                  tv_ptr->file_small_ds_sid_0,
+                                  tv_ptr->xfer_plist,
+                                  tv_ptr->large_ds_buf_1);
+                    VRFY((ret >= 0), "H5Dread() slice from small ds succeeded.");
+
+                    /* verify that the expected data and only the
+                     * expected data was read.
+                     */
+                    data_ok = TRUE;
+                    ptr_1 = tv_ptr->large_ds_buf_1;
+                    expected_value = 
+                       (uint32_t)((size_t)(tv_ptr->mpi_rank) * tv_ptr->small_ds_slice_size);
+                    start_index = (size_t)(
+                        (i * tv_ptr->edge_size * tv_ptr->edge_size * 
+                             tv_ptr->edge_size * tv_ptr->edge_size) +
+                        (j * tv_ptr->edge_size * tv_ptr->edge_size * tv_ptr->edge_size) +
+                        (k * tv_ptr->edge_size * tv_ptr->edge_size) +
+                        (l * tv_ptr->edge_size));
+                    stop_index = start_index + tv_ptr->small_ds_slice_size - 1;
+
+#if CHECKER_BOARD_HS_DR_PIO_TEST__D2M_S2L__DEBUG 
+                    {
+                        int m, n;
+
+                        HDfprintf(stdout, "%s:%d: expected_value = %d.\n", 
+                                  fcnName, tv_ptr->mpi_rank, expected_value);
+                        HDfprintf(stdout, "%s:%d: start/stop index = %d/%d.\n",
+                                  fcnName, tv_ptr->mpi_rank, start_index, stop_index);
                         n = 0;
+                        for ( m = 0; (unsigned)m < tv_ptr->large_ds_size; m ++ ) {
+                            HDfprintf(stdout, "%d ", (int)(*ptr_1));
+                            ptr_1++;
+                            n++;
+                            if ( n >= tv_ptr->edge_size ) {
+                                HDfprintf(stdout, "\n");
+                                n = 0;
+                            }
+                        }
+                        HDfprintf(stdout, "\n");
+                        ptr_1 = tv_ptr->large_ds_buf_1;
                     }
-                }
-                HDfprintf(stdout, "\n");
-                fsync(stdout);
-                ptr_1 = large_ds_buf_1;
-}
-#endif 
+#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__D2M_S2L__DEBUG */
 
-                HDassert( start_index < stop_index );
-                HDassert( stop_index <= large_ds_size );
+                    HDassert( start_index < stop_index );
+                    HDassert( stop_index <= tv_ptr->large_ds_size );
 
-                for ( u = 0; u < start_index; u++ ) {
+                    for ( u = 0; u < start_index; u++ ) {
 
-                    if ( *ptr_1 != 0 ) {
+                        if ( *ptr_1 != 0 ) {
 
-			data_ok = FALSE;
-		    }
+                            data_ok = FALSE;
+                        }
 
-                    /* zero out the value for the next pass */
-                    *ptr_1 = 0;
+                        /* zero out the value for the next pass */
+                        *ptr_1 = 0;
 
-                    ptr_1++;
-                }
+                        ptr_1++;
+                    }
 
-                VRFY((data_ok == TRUE), 
-                     "slice read from small to large ds data good(1).");
+                    VRFY((data_ok == TRUE), 
+                         "slice read from small to large ds data good(1).");
 
-                data_ok = checker_board_hyperslab_dr_pio_test__verify_data
-                          (
-                            ptr_1,
-                            small_rank - 1,
-                            edge_size,
-                            checker_edge_size,
-                            expected_value,
-                            (hbool_t)TRUE
-                          );
+                    data_ok = ckrbrd_hs_dr_pio_test__verify_data
+                              (
+                                ptr_1,
+                                tv_ptr->small_rank - 1,
+                                tv_ptr->edge_size,
+                                tv_ptr->checker_edge_size,
+                                expected_value,
+                                (hbool_t)TRUE
+                              );
 
-                VRFY((data_ok == TRUE), 
-                     "slice read from small to large ds data good(2).");
+                    VRFY((data_ok == TRUE), 
+                         "slice read from small to large ds data good(2).");
 
 
-                ptr_1 = large_ds_buf_1 + stop_index + 1;
+                    ptr_1 = tv_ptr->large_ds_buf_1 + stop_index + 1;
 
-                for ( u = stop_index + 1; u < large_ds_size; u++ ) {
+                    for ( u = stop_index + 1; u < tv_ptr->large_ds_size; u++ ) {
 
-                    if ( *ptr_1 != 0 ) {
+                        if ( *ptr_1 != 0 ) {
 
-			data_ok = FALSE;
-		    }
+                            data_ok = FALSE;
+                        }
 
-                    /* zero out the value for the next pass */
-                    *ptr_1 = 0;
+                        /* zero out the value for the next pass */
+                        *ptr_1 = 0;
 
-                    *ptr_1++;
-                }
+                        ptr_1++;
+                    }
+
+                    VRFY((data_ok == TRUE), 
+                         "slice read from small to large ds data good(3).");
 
-                VRFY((data_ok == TRUE), 
-                     "slice read from small to large ds data good(3).");
+                    (tv_ptr->tests_run)++;
+                }
 
                 l++;
 
-            } while ( ( large_rank > 2 ) &&
-                      ( (small_rank - 1) <= 1 ) &&
-                      ( l < edge_size ) );
+                (tv_ptr->total_tests)++;
+
+            } while ( ( tv_ptr->large_rank > 2 ) &&
+                      ( (tv_ptr->small_rank - 1) <= 1 ) &&
+                      ( l < tv_ptr->edge_size ) );
             k++;
-        } while ( ( large_rank > 3 ) &&
-                  ( (small_rank - 1) <= 2 ) &&
-                  ( k < edge_size ) );
+        } while ( ( tv_ptr->large_rank > 3 ) &&
+                  ( (tv_ptr->small_rank - 1) <= 2 ) &&
+                  ( k < tv_ptr->edge_size ) );
         j++;
-    } while ( ( large_rank > 4 ) &&
-              ( (small_rank - 1) <= 3 ) &&
-              ( j < edge_size ) );
+    } while ( ( tv_ptr->large_rank > 4 ) &&
+              ( (tv_ptr->small_rank - 1) <= 3 ) &&
+              ( j < tv_ptr->edge_size ) );
+
+    return;
+
+} /* ckrbrd_hs_dr_pio_test__d2m_s2l() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	ckrbrd_hs_dr_pio_test__m2d_l2s()
+ *
+ * Purpose:	Part three of a series of tests of I/O to/from checker
+ *		board hyperslab selections of different rank in the 
+ *		parallel.
+ *
+ *		Verify that we can write from memory to file using checker
+ *		board selections of different rank that 
+ *		H5S_select_shape_same() views as being of the same shape.
+ *
+ *		Do this by writing small_rank - 1 dimensional checker 
+ *		board slices from the in memory large data set to the on 
+ *		disk small cube dataset.  After each write, read the 
+ *		slice of the small dataset back from disk, and verify 
+ *		that it contains the expected data. Verify that 
+ *		H5S_select_shape_same() returns true on the memory and 
+ *		file selections.
+ *
+ * Return:	void
+ *
+ * Programmer:	JRM -- 8/15/11
+ *
+ * Modifications:
+ *
+ *		None.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define CHECKER_BOARD_HS_DR_PIO_TEST__M2D_L2S__DEBUG 0
+
+static void
+ckrbrd_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
+{
+#if CHECKER_BOARD_HS_DR_PIO_TEST__M2D_L2S__DEBUG 
+    const char *fcnName = "ckrbrd_hs_dr_pio_test__m2d_l2s()";
+#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__M2D_L2S__DEBUG */
+    hbool_t	data_ok = FALSE;
+    hbool_t	mis_match = FALSE;
+    int		i, j, k, l;
+    size_t      u;
+    size_t      start_index;
+    size_t      stop_index;
+    uint32_t	expected_value;
+    uint32_t  * ptr_1;
+    int		mpi_rank; /* needed by VRFY */
+    hsize_t     sel_start[PAR_SS_DR_MAX_RANK];
+    htri_t      check;          /* Shape comparison return value */
+    herr_t	ret;		/* Generic return value */
+
+    /* initialize the local copy of mpi_rank */
+    mpi_rank = tv_ptr->mpi_rank;
 
 
     /* now we go in the opposite direction, verifying that we can write
@@ -3529,46 +3619,46 @@ int		m, n;
      * the memory and file selections.
      */
 
-    start[0] = (hsize_t)mpi_rank;
-    stride[0] = (hsize_t)(2 * (mpi_size + 1));
-    count[0] = 1;
-    block[0] = 1;
+    tv_ptr->start[0] = (hsize_t)(tv_ptr->mpi_rank);
+    tv_ptr->stride[0] = (hsize_t)(2 * (tv_ptr->mpi_size + 1));
+    tv_ptr->count[0] = 1;
+    tv_ptr->block[0] = 1;
 
-    for ( i = 1; i < large_rank; i++ ) {
+    for ( i = 1; i < tv_ptr->large_rank; i++ ) {
 
-        start[i] = 0;
-        stride[i] = (hsize_t)(2 * edge_size);
-        count[i] = 1;
-        block[i] = (hsize_t)edge_size;
+        tv_ptr->start[i] = 0;
+        tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size);
+        tv_ptr->count[i] = 1;
+        tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size);
     }
 
-    ret = H5Sselect_hyperslab(file_small_ds_sid_0,
+    ret = H5Sselect_hyperslab(tv_ptr->file_small_ds_sid_0,
                               H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
+                              tv_ptr->start,
+                              tv_ptr->stride,
+                              tv_ptr->count,
+                              tv_ptr->block);
     VRFY((ret >= 0), "H5Sselect_hyperslab(file_small_ds_sid_0, set) suceeded");
 
-    ret = H5Sselect_hyperslab(mem_small_ds_sid,
+    ret = H5Sselect_hyperslab(tv_ptr->mem_small_ds_sid,
                               H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
+                              tv_ptr->start,
+                              tv_ptr->stride,
+                              tv_ptr->count,
+                              tv_ptr->block);
     VRFY((ret >= 0), "H5Sselect_hyperslab(mem_small_ds_sid, set) suceeded");
 
 
     sel_start[0] = sel_start[1] = sel_start[2] = sel_start[3] = sel_start[4] = 0;
-    sel_start[small_ds_offset] = (hsize_t)mpi_rank;
+    sel_start[tv_ptr->small_ds_offset] = (hsize_t)(tv_ptr->mpi_rank);
 
-    checker_board_hyperslab_dr_pio_test__select_checker_board(mpi_rank,
-                                                              file_small_ds_sid_1,
-                                                              small_rank,
-                                                              edge_size,
-                                                              checker_edge_size,
-                                                              small_rank - 1,
-                                                              sel_start);
+    ckrbrd_hs_dr_pio_test__slct_ckrbrd(tv_ptr->mpi_rank,
+                                       tv_ptr->file_small_ds_sid_1,
+                                       tv_ptr->small_rank,
+                                       tv_ptr->edge_size,
+                                       tv_ptr->checker_edge_size,
+                                       tv_ptr->small_rank - 1,
+                                       sel_start);
 
 
     /* set up start, stride, count, and block -- note that we will
@@ -3576,28 +3666,28 @@ int		m, n;
      */
     for ( i = 0; i < PAR_SS_DR_MAX_RANK; i++ ) {
 
-        start[i] = 0;
-        stride[i] = (hsize_t)(2 * edge_size);
-        count[i] = 1;
-        if ( (PAR_SS_DR_MAX_RANK - i) > (small_rank - 1) ) {
+        tv_ptr->start[i] = 0;
+        tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size);
+        tv_ptr->count[i] = 1;
+        if ( (PAR_SS_DR_MAX_RANK - i) > (tv_ptr->small_rank - 1) ) {
 
-            block[i] = 1;
+            tv_ptr->block[i] = 1;
 
         } else {
 
-            block[i] = (hsize_t)edge_size;
+            tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size);
         }
     }
 
     /* zero out the in memory small ds */
-    HDmemset(small_ds_buf_1, 0, sizeof(uint32_t) * small_ds_size);
+    HDmemset(tv_ptr->small_ds_buf_1, 0, sizeof(uint32_t) * tv_ptr->small_ds_size);
 
 
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
+#if CHECKER_BOARD_HS_DR_PIO_TEST__M2D_L2S__DEBUG 
     HDfprintf(stdout, 
     "%s writing checker boards selections of slices from big ds to slices of small ds on disk.\n",
     fcnName);
-#endif 
+#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__M2D_L2S__DEBUG */
 
     /* in serial versions of this test, we loop through all the dimensions
      * of the large data set that don't appear in the small data set.  
@@ -3609,9 +3699,9 @@ int		m, n;
      */
 
 
-    if ( PAR_SS_DR_MAX_RANK - large_rank == 0 ) {
+    if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 0 ) {
 
-        i = mpi_rank;
+        i = tv_ptr->mpi_rank;
 
     } else {
 
@@ -3624,9 +3714,9 @@ int		m, n;
      * test.
      */
 
-    if ( PAR_SS_DR_MAX_RANK - large_rank == 1 ) {
+    if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 1 ) {
 
-        j = mpi_rank;
+        j = tv_ptr->mpi_rank;
 
     } else {
 
@@ -3635,9 +3725,9 @@ int		m, n;
 
     j = 0;
     do {
-        if ( PAR_SS_DR_MAX_RANK - large_rank == 2 ) {
+        if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 2 ) {
 
-            k = mpi_rank;
+            k = tv_ptr->mpi_rank;
 
         } else {
 
@@ -3657,154 +3747,228 @@ int		m, n;
 
             l = 0;
             do {
-                /* we know that small_rank >= 1 and that large_rank > small_rank
-                 * by the assertions at the head of this function.  Thus no
-                 * need for another inner loop.
-                 */
-
-                /* zero out this rank's slice of the on disk small data set */
-                ret = H5Dwrite(small_dataset,
-                               H5T_NATIVE_UINT32,
-                               mem_small_ds_sid,
-                               file_small_ds_sid_0,
-                               xfer_plist,
-                               small_ds_buf_2);
-                VRFY((ret >= 0), "H5Dwrite() zero slice to small ds succeeded.");
-
-                /* select the portion of the in memory large cube from which we
-                 * are going to write data.
-                 */
-                start[0] = (hsize_t)i;
-                start[1] = (hsize_t)j;
-                start[2] = (hsize_t)k;
-                start[3] = (hsize_t)l;
-                start[4] = 0;
-
-                HDassert( ( start[0] == 0 ) || ( 0 < small_ds_offset + 1 ) );
-                HDassert( ( start[1] == 0 ) || ( 1 < small_ds_offset + 1 ) );
-                HDassert( ( start[2] == 0 ) || ( 2 < small_ds_offset + 1 ) );
-                HDassert( ( start[3] == 0 ) || ( 3 < small_ds_offset + 1 ) );
-                HDassert( ( start[4] == 0 ) || ( 4 < small_ds_offset + 1 ) );
-
-                checker_board_hyperslab_dr_pio_test__select_checker_board
-                (
-                  mpi_rank,
-                  mem_large_ds_sid,
-                  large_rank,
-                  edge_size,
-                  checker_edge_size,
-                  small_rank - 1,
-                  start
-                );
-
-
-                /* verify that H5S_select_shape_same() reports the in
-                 * memory checkerboard selection of the slice through the 
-                 * large dataset and the checkerboard selection of the process
-                 * slice of the small data set as having the same shape.
-                 */
-                check = H5S_select_shape_same_test(file_small_ds_sid_1,
-                                                   mem_large_ds_sid);
-                VRFY((check == TRUE), "H5S_select_shape_same_test passed.");
-
-
-                /* write the checker board selection of the slice from the in 
-                 * memory large data set to the slice of the on disk small 
-                 * dataset. 
-                 */
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
-                HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", 
-                          fcnName, mpi_rank,
-                          start[0], start[1], start[2], start[3], start[4]);
-                HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n",
-                          fcnName, mpi_rank,
-                          H5Sget_simple_extent_ndims(mem_large_ds_sid),
-                          H5Sget_simple_extent_ndims(file_small_ds_sid_1));
-#endif 
-                ret = H5Dwrite(small_dataset,
-                               H5T_NATIVE_UINT32,
-                               mem_large_ds_sid,
-                               file_small_ds_sid_1,
-                               xfer_plist,
-                               large_ds_buf_0);
-                VRFY((ret >= 0), "H5Dwrite() slice to large ds succeeded.");
+                if ( (tv_ptr->skips)++ < tv_ptr->max_skips ) { /* skip the test */
 
+                    (tv_ptr->tests_skipped)++;
 
-                /* read the on disk process slice of the small dataset into memory */
-                ret = H5Dread(small_dataset,
-                              H5T_NATIVE_UINT32,
-                              mem_small_ds_sid,
-                              file_small_ds_sid_0,
-                              xfer_plist,
-                              small_ds_buf_1);
-                VRFY((ret >= 0), "H5Dread() slice from small ds succeeded.");
+                } else { /* run the test */
 
+                    tv_ptr->skips = 0; /* reset the skips counter */
 
-                /* verify that expected data is retrieved */
+                    /* we know that small_rank >= 1 and that large_rank > small_rank
+                     * by the assertions at the head of this function.  Thus no
+                     * need for another inner loop.
+                     */
+    
+                    /* zero out this rank's slice of the on disk small data set */
+                    ret = H5Dwrite(tv_ptr->small_dataset,
+                                   H5T_NATIVE_UINT32,
+                                   tv_ptr->mem_small_ds_sid,
+                                   tv_ptr->file_small_ds_sid_0,
+                                   tv_ptr->xfer_plist,
+                                   tv_ptr->small_ds_buf_2);
+                    VRFY((ret >= 0), "H5Dwrite() zero slice to small ds succeeded.");
+    
+                    /* select the portion of the in memory large cube from which we
+                     * are going to write data.
+                     */
+                    tv_ptr->start[0] = (hsize_t)i;
+                    tv_ptr->start[1] = (hsize_t)j;
+                    tv_ptr->start[2] = (hsize_t)k;
+                    tv_ptr->start[3] = (hsize_t)l;
+                    tv_ptr->start[4] = 0;
+    
+                    HDassert((tv_ptr->start[0] == 0)||(0 < tv_ptr->small_ds_offset + 1));
+                    HDassert((tv_ptr->start[1] == 0)||(1 < tv_ptr->small_ds_offset + 1));
+                    HDassert((tv_ptr->start[2] == 0)||(2 < tv_ptr->small_ds_offset + 1));
+                    HDassert((tv_ptr->start[3] == 0)||(3 < tv_ptr->small_ds_offset + 1));
+                    HDassert((tv_ptr->start[4] == 0)||(4 < tv_ptr->small_ds_offset + 1));
+    
+                    ckrbrd_hs_dr_pio_test__slct_ckrbrd
+                    (
+                      tv_ptr->mpi_rank,
+                      tv_ptr->mem_large_ds_sid,
+                      tv_ptr->large_rank,
+                      tv_ptr->edge_size,
+                      tv_ptr->checker_edge_size,
+                      tv_ptr->small_rank - 1,
+                      tv_ptr->start
+                    );
+    
+    
+                    /* verify that H5S_select_shape_same() reports the in
+                     * memory checkerboard selection of the slice through the 
+                     * large dataset and the checkerboard selection of the process
+                     * slice of the small data set as having the same shape.
+                     */
+                    check = H5S_select_shape_same_test(tv_ptr->file_small_ds_sid_1,
+                                                       tv_ptr->mem_large_ds_sid);
+                    VRFY((check == TRUE), "H5S_select_shape_same_test passed.");
+    
+    
+                    /* write the checker board selection of the slice from the in 
+                     * memory large data set to the slice of the on disk small 
+                     * dataset. 
+                     */
+#if CHECKER_BOARD_HS_DR_PIO_TEST__M2D_L2S__DEBUG 
+                    HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", 
+                              fcnName, tv_ptr->mpi_rank,
+                              tv_ptr->start[0], tv_ptr->start[1], tv_ptr->start[2], 
+                              tv_ptr->start[3], tv_ptr->start[4]);
+                    HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n",
+                              fcnName, tv_ptr->mpi_rank,
+                              H5Sget_simple_extent_ndims(tv_ptr->mem_large_ds_sid),
+                              H5Sget_simple_extent_ndims(tv_ptr->file_small_ds_sid_1));
+#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__M2D_L2S__DEBUG */
+                    ret = H5Dwrite(tv_ptr->small_dataset,
+                                   H5T_NATIVE_UINT32,
+                                   tv_ptr->mem_large_ds_sid,
+                                   tv_ptr->file_small_ds_sid_1,
+                                   tv_ptr->xfer_plist,
+                                   tv_ptr->large_ds_buf_0);
+                    VRFY((ret >= 0), "H5Dwrite() slice to large ds succeeded.");
+    
+    
+                    /* read the on disk process slice of the small dataset into memory */
+                    ret = H5Dread(tv_ptr->small_dataset,
+                                  H5T_NATIVE_UINT32,
+                                  tv_ptr->mem_small_ds_sid,
+                                  tv_ptr->file_small_ds_sid_0,
+                                  tv_ptr->xfer_plist,
+                                  tv_ptr->small_ds_buf_1);
+                    VRFY((ret >= 0), "H5Dread() slice from small ds succeeded.");
+    
+    
+                    /* verify that expected data is retrieved */
+    
+                    mis_match = FALSE;
+    
+                    expected_value = (uint32_t)(
+    			(i * tv_ptr->edge_size * tv_ptr->edge_size * 
+                                 tv_ptr->edge_size * tv_ptr->edge_size) +
+                        (j * tv_ptr->edge_size * tv_ptr->edge_size * tv_ptr->edge_size) +
+                        (k * tv_ptr->edge_size * tv_ptr->edge_size) +
+                        (l * tv_ptr->edge_size));
+    
+                    start_index = (size_t)(tv_ptr->mpi_rank) * tv_ptr->small_ds_slice_size;
+                    stop_index = start_index + tv_ptr->small_ds_slice_size - 1;
+    
+                    HDassert( start_index < stop_index );
+                    HDassert( stop_index <= tv_ptr->small_ds_size );
+    
+                    data_ok = TRUE;
+    
+                    ptr_1 = tv_ptr->small_ds_buf_1;
+                    for ( u = 0; u < start_index; u++, ptr_1++ ) {
+    
+                        if ( *ptr_1 != 0 ) {
 
-                mis_match = FALSE;
+                            data_ok = FALSE;
+                            *ptr_1 = 0;
+                        }
+                    }
 
-                expected_value = (uint32_t)(
-			(i * edge_size * edge_size * edge_size * edge_size) +
-                        (j * edge_size * edge_size * edge_size) +
-                        (k * edge_size * edge_size) +
-                        (l * edge_size));
+                    data_ok &= ckrbrd_hs_dr_pio_test__verify_data
+                               (
+                                 tv_ptr->small_ds_buf_1 + start_index,
+                                 tv_ptr->small_rank - 1,
+                                 tv_ptr->edge_size,
+                                 tv_ptr->checker_edge_size,
+                                 expected_value,
+                                 (hbool_t)TRUE
+                               );
 
-                start_index = (size_t)mpi_rank * small_ds_slice_size;
-                stop_index = start_index + small_ds_slice_size - 1;
 
-                HDassert( start_index < stop_index );
-                HDassert( stop_index <= small_ds_size );
+                    ptr_1 = tv_ptr->small_ds_buf_1;
+                    for ( u = stop_index; u < tv_ptr->small_ds_size; u++, ptr_1++ ) {
 
-                data_ok = TRUE;
+                        if ( *ptr_1 != 0 ) {
 
-                ptr_1 = small_ds_buf_1;
-                for ( u = 0; u < start_index; u++, ptr_1++ ) {
+                            data_ok = FALSE;
+                            *ptr_1 = 0;
+                        }
+                    }
 
-                    if ( *ptr_1 != 0 ) {
+                    VRFY((data_ok == TRUE), 
+                         "large slice write slice to small slice data good.");
 
-                        data_ok = FALSE;
-                        *ptr_1 = 0;
-                    }
+                    (tv_ptr->tests_run)++;
                 }
 
-                data_ok &= checker_board_hyperslab_dr_pio_test__verify_data
-                           (
-                             small_ds_buf_1 + start_index,
-                             small_rank - 1,
-                             edge_size,
-                             checker_edge_size,
-                             expected_value,
-                             (hbool_t)TRUE
-                           );
+                l++;
 
+                (tv_ptr->total_tests)++;
 
-                ptr_1 = small_ds_buf_1;
-                for ( u = stop_index; u < small_ds_size; u++, ptr_1++ ) {
+            } while ( ( tv_ptr->large_rank > 2 ) &&
+                      ( (tv_ptr->small_rank - 1) <= 1 ) &&
+                      ( l < tv_ptr->edge_size ) );
+            k++;
+        } while ( ( tv_ptr->large_rank > 3 ) &&
+                  ( (tv_ptr->small_rank - 1) <= 2 ) &&
+                  ( k < tv_ptr->edge_size ) );
+        j++;
+    } while ( ( tv_ptr->large_rank > 4 ) &&
+              ( (tv_ptr->small_rank - 1) <= 3 ) &&
+              ( j < tv_ptr->edge_size ) );
 
-                    if ( *ptr_1 != 0 ) {
+    return;
 
-                        data_ok = FALSE;
-                        *ptr_1 = 0;
-                    }
-                }
+} /* ckrbrd_hs_dr_pio_test__m2d_l2s() */
 
-                VRFY((data_ok == TRUE), 
-                     "large slice write slice to small slice data good.");
 
-                l++;
+/*-------------------------------------------------------------------------
+ * Function:	ckrbrd_hs_dr_pio_test__m2d_s2l()
+ *
+ * Purpose:	Part four of a series of tests of I/O to/from checker
+ *		board hyperslab selections of different rank in the parallel.
+ *
+ *		Verify that we can write from memory to file using 
+ *		selections of different rank that H5S_select_shape_same() 
+ *		views as being of the same shape.
+ *
+ *		Do this by writing checker board selections of the contents 
+ *		of the process's slice of the in memory small data set to 
+ *		slices of the on disk large data set.  After each write, 
+ *		read the process's slice of the large data set back into 
+ *		memory, and verify that it contains the expected data. 
+ *
+ *		Verify that H5S_select_shape_same() returns true on the 
+ *		memory and file selections.
+ *
+ * Return:	void
+ *
+ * Programmer:	JRM -- 8/15/11
+ *
+ * Modifications:
+ *
+ *		None
+ *
+ *-------------------------------------------------------------------------
+ */
 
-            } while ( ( large_rank > 2 ) &&
-                      ( (small_rank - 1) <= 1 ) &&
-                      ( l < edge_size ) );
-            k++;
-        } while ( ( large_rank > 3 ) &&
-                  ( (small_rank - 1) <= 2 ) &&
-                  ( k < edge_size ) );
-        j++;
-    } while ( ( large_rank > 4 ) &&
-              ( (small_rank - 1) <= 3 ) &&
-              ( j < edge_size ) );
+#define CHECKER_BOARD_HS_DR_PIO_TEST__M2D_S2L__DEBUG 0
+
+static void
+ckrbrd_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t * tv_ptr)
+{
+#if CHECKER_BOARD_HS_DR_PIO_TEST__M2D_S2L__DEBUG 
+    const char *fcnName = "ckrbrd_hs_dr_pio_test__m2d_s2l()";
+#endif /* CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG */
+    hbool_t	data_ok = FALSE;
+    hbool_t	mis_match = FALSE;
+    int		i, j, k, l;
+    size_t      u;
+    size_t      start_index;
+    size_t      stop_index;
+    uint32_t	expected_value;
+    uint32_t  * ptr_1;
+    int		mpi_rank; /* needed by VRFY */
+    hsize_t     sel_start[PAR_SS_DR_MAX_RANK];
+    htri_t      check;          /* Shape comparison return value */
+    herr_t	ret;		/* Generic return value */
+
+    /* initialize the local copy of mpi_rank */
+    mpi_rank = tv_ptr->mpi_rank;
 
 
     /* Now write the contents of the process's slice of the in memory 
@@ -3815,49 +3979,49 @@ int		m, n;
      * and file selections.
      */
 
-    start[0] = (hsize_t)mpi_rank;
-    stride[0] = (hsize_t)(2 * (mpi_size + 1));
-    count[0] = 1;
-    block[0] = 1;
+    tv_ptr->start[0] = (hsize_t)(tv_ptr->mpi_rank);
+    tv_ptr->stride[0] = (hsize_t)(2 * (tv_ptr->mpi_size + 1));
+    tv_ptr->count[0] = 1;
+    tv_ptr->block[0] = 1;
 
-    for ( i = 1; i < large_rank; i++ ) {
+    for ( i = 1; i < tv_ptr->large_rank; i++ ) {
 
-        start[i] = 0;
-        stride[i] = (hsize_t)(2 * edge_size);
-        count[i] = 1;
-        block[i] = (hsize_t)edge_size;
+        tv_ptr->start[i] = 0;
+        tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size);
+        tv_ptr->count[i] = 1;
+        tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size);
     }
 
-    ret = H5Sselect_hyperslab(file_large_ds_sid_0,
+    ret = H5Sselect_hyperslab(tv_ptr->file_large_ds_sid_0,
                               H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
+                              tv_ptr->start,
+                              tv_ptr->stride,
+                              tv_ptr->count,
+                              tv_ptr->block);
     VRFY((ret >= 0), "H5Sselect_hyperslab(file_large_ds_sid_0, set) suceeded");
 
-    ret = H5Sselect_hyperslab(mem_large_ds_sid,
+    ret = H5Sselect_hyperslab(tv_ptr->mem_large_ds_sid,
                               H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
-    VRFY((ret >= 0), "H5Sselect_hyperslab(mem_small_ds_sid, set) suceeded");
+                              tv_ptr->start,
+                              tv_ptr->stride,
+                              tv_ptr->count,
+                              tv_ptr->block);
+    VRFY((ret >= 0), "H5Sselect_hyperslab(tv_ptr->mem_large_ds_sid, set) suceeded");
 
     /* setup a checkerboard selection of the slice of the in memory small 
      * data set associated with the process's mpi rank.
      */
 
     sel_start[0] = sel_start[1] = sel_start[2] = sel_start[3] = sel_start[4] = 0;
-    sel_start[small_ds_offset] = (hsize_t)mpi_rank;
+    sel_start[tv_ptr->small_ds_offset] = (hsize_t)(tv_ptr->mpi_rank);
 
-    checker_board_hyperslab_dr_pio_test__select_checker_board(mpi_rank,
-                                                              mem_small_ds_sid,
-                                                              small_rank,
-                                                              edge_size,
-                                                              checker_edge_size,
-                                                              small_rank - 1,
-                                                              sel_start);
+    ckrbrd_hs_dr_pio_test__slct_ckrbrd(tv_ptr->mpi_rank,
+                                       tv_ptr->mem_small_ds_sid,
+                                       tv_ptr->small_rank,
+                                       tv_ptr->edge_size,
+                                       tv_ptr->checker_edge_size,
+                                       tv_ptr->small_rank - 1,
+                                       sel_start);
 
     /* set up start, stride, count, and block -- note that we will
      * change start[] so as to write checkerboard selections of slices 
@@ -3865,31 +4029,31 @@ int		m, n;
      */
     for ( i = 0; i < PAR_SS_DR_MAX_RANK; i++ ) {
 
-        start[i] = 0;
-        stride[i] = (hsize_t)(2 * edge_size);
-        count[i] = 1;
-        if ( (PAR_SS_DR_MAX_RANK - i) > (small_rank - 1) ) {
+        tv_ptr->start[i] = 0;
+        tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size);
+        tv_ptr->count[i] = 1;
+        if ( (PAR_SS_DR_MAX_RANK - i) > (tv_ptr->small_rank - 1) ) {
 
-            block[i] = 1;
+            tv_ptr->block[i] = 1;
 
         } else {
 
-            block[i] = (hsize_t)edge_size;
+            tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size);
         }
     }
 
     /* zero out the in memory large ds */
-    HDmemset(large_ds_buf_1, 0, sizeof(uint32_t) * large_ds_size);
+    HDmemset(tv_ptr->large_ds_buf_1, 0, sizeof(uint32_t) * tv_ptr->large_ds_size);
 
-#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG
+#if CHECKER_BOARD_HS_DR_PIO_TEST__M2D_S2L__DEBUG
     HDfprintf(stdout, 
          "%s writing process checkerboard selections of slices of small ds to process slices of large ds on disk.\n",
          fcnName);
-#endif 
+#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__M2D_S2L__DEBUG */
 
-    if ( PAR_SS_DR_MAX_RANK - large_rank == 0 ) {
+    if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 0 ) {
 
-        i = mpi_rank;
+        i = tv_ptr->mpi_rank;
 
     } else {
 
@@ -3902,9 +4066,9 @@ int		m, n;
      * test.
      */
 
-    if ( PAR_SS_DR_MAX_RANK - large_rank == 1 ) {
+    if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 1 ) {
 
-        j = mpi_rank;
+        j = tv_ptr->mpi_rank;
 
     } else {
 
@@ -3912,9 +4076,9 @@ int		m, n;
     }
 
     do {
-        if ( PAR_SS_DR_MAX_RANK - large_rank == 2 ) {
+        if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 2 ) {
 
-            k = mpi_rank;
+            k = tv_ptr->mpi_rank;
 
         } else {
 
@@ -3934,240 +4098,395 @@ int		m, n;
 
             l = 0;
             do {
-                /* we know that small_rank >= 1 and that large_rank > small_rank
-                 * by the assertions at the head of this function.  Thus no
-                 * need for another inner loop.
-                 */
-
-                /* Zero out this processes slice of the on disk large data set.
-                 * Note that this will leave one slice with its original data
-                 * as there is one more slice than processes.
-                  */
-                ret = H5Dwrite(large_dataset,
-                               H5T_NATIVE_UINT32,
-                               mem_large_ds_sid,
-                               file_large_ds_sid_0,
-                               xfer_plist,
-                               large_ds_buf_2);
-		VRFY((ret != FAIL), "H5Dwrite() to zero large ds suceeded");
-
-
-                /* select the portion of the in memory large cube to which we
-                 * are going to write data.
-                 */
-                start[0] = (hsize_t)i;
-                start[1] = (hsize_t)j;
-                start[2] = (hsize_t)k;
-                start[3] = (hsize_t)l;
-                start[4] = 0;
-
-                HDassert( ( start[0] == 0 ) || ( 0 < small_ds_offset + 1 ) );
-                HDassert( ( start[1] == 0 ) || ( 1 < small_ds_offset + 1 ) );
-                HDassert( ( start[2] == 0 ) || ( 2 < small_ds_offset + 1 ) );
-                HDassert( ( start[3] == 0 ) || ( 3 < small_ds_offset + 1 ) );
-                HDassert( ( start[4] == 0 ) || ( 4 < small_ds_offset + 1 ) );
-
-                checker_board_hyperslab_dr_pio_test__select_checker_board
-                (
-                  mpi_rank,
-                  file_large_ds_sid_1,
-                  large_rank,
-                  edge_size,
-                  checker_edge_size,
-                  small_rank - 1,
-                  start
-                );
-
-
-                /* verify that H5S_select_shape_same() reports the in
-                 * memory small data set slice selection and the
-                 * on disk slice through the large data set selection
-                 * as having the same shape.
-                 */
-                check = H5S_select_shape_same_test(mem_small_ds_sid,
-                                                   file_large_ds_sid_1);
-		VRFY((check == TRUE), "H5S_select_shape_same_test passed");
-
-
-                /* write the small data set slice from memory to the 
-                 * target slice of the disk data set 
-                 */
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
-                HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", 
-                          fcnName, mpi_rank,
-                          start[0], start[1], start[2], start[3], start[4]);
-                HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n",
-                          fcnName, mpi_rank,
-                          H5Sget_simple_extent_ndims(mem_small_ds_sid),
-                          H5Sget_simple_extent_ndims(file_large_ds_sid_1));
-#endif 
-                ret = H5Dwrite(large_dataset,
-                               H5T_NATIVE_UINT32,
-                               mem_small_ds_sid,
-                               file_large_ds_sid_1,
-                               xfer_plist,
-                               small_ds_buf_0);
-		VRFY((ret != FAIL), 
-                      "H5Dwrite of small ds slice to large ds succeeded");
+                if ( (tv_ptr->skips)++ < tv_ptr->max_skips ) { /* skip the test */
 
+                    (tv_ptr->tests_skipped)++;
 
-                /* read this processes slice on the on disk large 
-                 * data set into memory.
-                 */
+                } else { /* run the test */
 
-                ret = H5Dread(large_dataset,
-                              H5T_NATIVE_UINT32,
-                              mem_large_ds_sid,
-                              file_large_ds_sid_0,
-                              xfer_plist,
-                              large_ds_buf_1);
-                VRFY((ret != FAIL), 
-                     "H5Dread() of process slice of large ds succeeded");
+                    tv_ptr->skips = 0; /* reset the skips counter */
 
+                    /* we know that small_rank >= 1 and that large_rank > small_rank
+                     * by the assertions at the head of this function.  Thus no
+                     * need for another inner loop.
+                     */
 
-                /* verify that the expected data and only the
-                 * expected data was read.
-                 */
-                expected_value = (uint32_t)((size_t)mpi_rank * small_ds_slice_size);
+                    /* Zero out this processes slice of the on disk large data set.
+                     * Note that this will leave one slice with its original data
+                     * as there is one more slice than processes.
+                     */
+                    ret = H5Dwrite(tv_ptr->large_dataset,
+                                   H5T_NATIVE_UINT32,
+                                   tv_ptr->mem_large_ds_sid,
+                                   tv_ptr->file_large_ds_sid_0,
+                                   tv_ptr->xfer_plist,
+                                   tv_ptr->large_ds_buf_2);
+                    VRFY((ret != FAIL), "H5Dwrite() to zero large ds suceeded");
 
-                start_index = (size_t)((i * edge_size * edge_size * edge_size * edge_size) +
-                              (j * edge_size * edge_size * edge_size) +
-                              (k * edge_size * edge_size) +
-                              (l * edge_size));
-                stop_index = start_index + small_ds_slice_size - 1;
 
-                HDassert( start_index < stop_index );
-                HDassert( stop_index < large_ds_size );
+                    /* select the portion of the in memory large cube to which we
+                     * are going to write data.
+                     */
+                    tv_ptr->start[0] = (hsize_t)i;
+                    tv_ptr->start[1] = (hsize_t)j;
+                    tv_ptr->start[2] = (hsize_t)k;
+                    tv_ptr->start[3] = (hsize_t)l;
+                    tv_ptr->start[4] = 0;
+
+                    HDassert((tv_ptr->start[0] == 0)||(0 < tv_ptr->small_ds_offset + 1));
+                    HDassert((tv_ptr->start[1] == 0)||(1 < tv_ptr->small_ds_offset + 1));
+                    HDassert((tv_ptr->start[2] == 0)||(2 < tv_ptr->small_ds_offset + 1));
+                    HDassert((tv_ptr->start[3] == 0)||(3 < tv_ptr->small_ds_offset + 1));
+                    HDassert((tv_ptr->start[4] == 0)||(4 < tv_ptr->small_ds_offset + 1));
+
+                    ckrbrd_hs_dr_pio_test__slct_ckrbrd
+                    (
+                      tv_ptr->mpi_rank,
+                      tv_ptr->file_large_ds_sid_1,
+                      tv_ptr->large_rank,
+                      tv_ptr->edge_size,
+                      tv_ptr->checker_edge_size,
+                      tv_ptr->small_rank - 1,
+                      tv_ptr->start
+                    );
+
+
+                    /* verify that H5S_select_shape_same() reports the in
+                     * memory small data set slice selection and the
+                     * on disk slice through the large data set selection
+                     * as having the same shape.
+                     */
+                    check = H5S_select_shape_same_test(tv_ptr->mem_small_ds_sid,
+                                                       tv_ptr->file_large_ds_sid_1);
+                    VRFY((check == TRUE), "H5S_select_shape_same_test passed");
 
 
-                mis_match = FALSE;
+                    /* write the small data set slice from memory to the 
+                     * target slice of the disk data set 
+                     */
+#if CHECKER_BOARD_HS_DR_PIO_TEST__M2D_S2L__DEBUG 
+                    HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", 
+                              fcnName, tv_ptr->mpi_rank,
+                              tv_ptr->start[0], tv_ptr->start[1], tv_ptr->start[2], 
+                              tv_ptr->start[3], tv_ptr->start[4]);
+                    HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n",
+                              fcnName, tv_ptr->mpi_rank,
+                              H5Sget_simple_extent_ndims(tv_ptr->mem_small_ds_sid),
+                              H5Sget_simple_extent_ndims(tv_ptr->file_large_ds_sid_1));
+#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__M2D_S2L__DEBUG */
+                    ret = H5Dwrite(tv_ptr->large_dataset,
+                                   H5T_NATIVE_UINT32,
+                                   tv_ptr->mem_small_ds_sid,
+                                   tv_ptr->file_large_ds_sid_1,
+                                   tv_ptr->xfer_plist,
+                                   tv_ptr->small_ds_buf_0);
+                    VRFY((ret != FAIL), 
+                         "H5Dwrite of small ds slice to large ds succeeded");
+
+
+                    /* read this processes slice on the on disk large 
+                     * data set into memory.
+                     */
 
-                data_ok = TRUE;
+                    ret = H5Dread(tv_ptr->large_dataset,
+                                  H5T_NATIVE_UINT32,
+                                  tv_ptr->mem_large_ds_sid,
+                                  tv_ptr->file_large_ds_sid_0,
+                                  tv_ptr->xfer_plist,
+                                  tv_ptr->large_ds_buf_1);
+                    VRFY((ret != FAIL), 
+                         "H5Dread() of process slice of large ds succeeded");
 
-                ptr_1 = large_ds_buf_1;
-                for ( u = 0; u < start_index; u++, ptr_1++ ) {
 
-                    if ( *ptr_1 != 0 ) {
+                    /* verify that the expected data and only the
+                     * expected data was read.
+                     */
+                    expected_value = 
+                       (uint32_t)((size_t)(tv_ptr->mpi_rank) * tv_ptr->small_ds_slice_size);
 
-                        data_ok = FALSE;
-                        *ptr_1 = 0;
+                    start_index = (size_t)
+                        ((i * tv_ptr->edge_size * tv_ptr->edge_size * 
+                              tv_ptr->edge_size * tv_ptr->edge_size) +
+                         (j * tv_ptr->edge_size * tv_ptr->edge_size * tv_ptr->edge_size) +
+                         (k * tv_ptr->edge_size * tv_ptr->edge_size) +
+                         (l * tv_ptr->edge_size));
+                    stop_index = start_index + tv_ptr->small_ds_slice_size - 1;
+
+                    HDassert( start_index < stop_index );
+                    HDassert( stop_index < tv_ptr->large_ds_size );
+
+
+                    mis_match = FALSE;
+
+                    data_ok = TRUE;
+
+                    ptr_1 = tv_ptr->large_ds_buf_1;
+                    for ( u = 0; u < start_index; u++, ptr_1++ ) {
+
+                        if ( *ptr_1 != 0 ) {
+
+                            data_ok = FALSE;
+                            *ptr_1 = 0;
+                        }
                     }
-                }
 
-                data_ok &= checker_board_hyperslab_dr_pio_test__verify_data
-                           (
-                             large_ds_buf_1 + start_index,
-                             small_rank - 1,
-                             edge_size,
-                             checker_edge_size,
-                             expected_value,
-                             (hbool_t)TRUE
-                           );
+                    data_ok &= ckrbrd_hs_dr_pio_test__verify_data
+                               (
+                                 tv_ptr->large_ds_buf_1 + start_index,
+                                 tv_ptr->small_rank - 1,
+                                 tv_ptr->edge_size,
+                                 tv_ptr->checker_edge_size,
+                                 expected_value,
+                                 (hbool_t)TRUE
+                               );
 
 
-                ptr_1 = large_ds_buf_1;
-                for ( u = stop_index; u < small_ds_size; u++, ptr_1++ ) {
+                    ptr_1 = tv_ptr->large_ds_buf_1;
+                    for ( u = stop_index; u < tv_ptr->small_ds_size; u++, ptr_1++ ) {
 
-                    if ( *ptr_1 != 0 ) {
+                        if ( *ptr_1 != 0 ) {
 
-                        data_ok = FALSE;
-                        *ptr_1 = 0;
+                            data_ok = FALSE;
+                            *ptr_1 = 0;
+                        }
                     }
-                }
 
-                VRFY((data_ok == TRUE), 
-                     "small ds cb slice write to large ds slice data good.");
+                    VRFY((data_ok == TRUE), 
+                         "small ds cb slice write to large ds slice data good.");
+
+                    (tv_ptr->tests_run)++;
+                }
 
                 l++;
 
-            } while ( ( large_rank > 2 ) &&
-                      ( (small_rank - 1) <= 1 ) &&
-                      ( l < edge_size ) );
+                (tv_ptr->total_tests)++;
+
+            } while ( ( tv_ptr->large_rank > 2 ) &&
+                      ( (tv_ptr->small_rank - 1) <= 1 ) &&
+                      ( l < tv_ptr->edge_size ) );
             k++;
-        } while ( ( large_rank > 3 ) &&
-                  ( (small_rank - 1) <= 2 ) &&
-                  ( k < edge_size ) );
+        } while ( ( tv_ptr->large_rank > 3 ) &&
+                  ( (tv_ptr->small_rank - 1) <= 2 ) &&
+                  ( k < tv_ptr->edge_size ) );
         j++;
-    } while ( ( large_rank > 4 ) &&
-              ( (small_rank - 1) <= 3 ) &&
-              ( j < edge_size ) );
+    } while ( ( tv_ptr->large_rank > 4 ) &&
+              ( (tv_ptr->small_rank - 1) <= 3 ) &&
+              ( j < tv_ptr->edge_size ) );
 
+    return;
 
-    /* Close dataspaces */
-    ret = H5Sclose(full_mem_small_ds_sid);
-    VRFY((ret != FAIL), "H5Sclose(full_mem_small_ds_sid) succeeded");
+} /* ckrbrd_hs_dr_pio_test__m2d_s2l() */
 
-    ret = H5Sclose(full_file_small_ds_sid);
-    VRFY((ret != FAIL), "H5Sclose(full_file_small_ds_sid) succeeded");
 
-    ret = H5Sclose(mem_small_ds_sid);
-    VRFY((ret != FAIL), "H5Sclose(mem_small_ds_sid) succeeded");
+/*-------------------------------------------------------------------------
+ * Function:	ckrbrd_hs_dr_pio_test__run_test()
+ *
+ * Purpose:	Test I/O to/from checkerboard selections of hyperslabs of 
+ *		different rank in the parallel.
+ *
+ * Return:	void
+ *
+ * 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.
+ *
+ *-------------------------------------------------------------------------
+ */
 
-    ret = H5Sclose(file_small_ds_sid_0);
-    VRFY((ret != FAIL), "H5Sclose(file_small_ds_sid_0) succeeded");
+#define CKRBRD_HS_DR_PIO_TEST__RUN_TEST__DEBUG 0
 
-    ret = H5Sclose(file_small_ds_sid_1);
-    VRFY((ret != FAIL), "H5Sclose(file_small_ds_sid_1) succeeded");
+static void
+ckrbrd_hs_dr_pio_test__run_test(const int test_num,
+                                const int edge_size,
+                                const int checker_edge_size,
+                                const int chunk_edge_size,
+                                const int small_rank,
+                                const int large_rank,
+                                const hbool_t use_collective_io,
+                                const hid_t dset_type,
+                                const int express_test,
+                                int * skips_ptr,
+                                int max_skips,
+                                int64_t * total_tests_ptr,
+                                int64_t * tests_run_ptr,
+                                int64_t * tests_skipped_ptr)
 
-    ret = H5Sclose(small_ds_slice_sid);
-    VRFY((ret != FAIL), "H5Sclose(small_ds_slice_sid) succeeded");
+{
+#if CKRBRD_HS_DR_PIO_TEST__RUN_TEST__DEBUG
+    const char *fcnName = "ckrbrd_hs_dr_pio_test__run_test()";
+#endif /* CKRBRD_HS_DR_PIO_TEST__RUN_TEST__DEBUG */
+    int		mpi_rank; /* needed by VRFY */
+    struct hs_dr_pio_test_vars_t test_vars = 
+    {
+        /* int	       mpi_size                        = */ -1,
+        /* int         mpi_rank                        = */ -1,
+        /* MPI_Comm    mpi_comm                        = */ MPI_COMM_NULL,
+        /* MPI_Inf     mpi_info                        = */ MPI_INFO_NULL,
+        /* int         test_num                        = */ -1,
+        /* int         edge_size                       = */ -1,
+        /* int         checker_edge_size               = */ -1,
+        /* int         chunk_edge_size                 = */ -1,
+        /* int         small_rank                      = */ -1,
+        /* int         large_rank                      = */ -1,
+        /* hid_t       dset_type                       = */ -1,
+        /* uint32_t  * small_ds_buf_0                  = */ NULL,
+        /* uint32_t  * small_ds_buf_1                  = */ NULL,
+        /* uint32_t  * small_ds_buf_2                  = */ NULL,
+        /* uint32_t  * small_ds_slice_buf              = */ NULL,
+        /* uint32_t  * large_ds_buf_0                  = */ NULL,
+        /* uint32_t  * large_ds_buf_1                  = */ NULL, 
+        /* uint32_t  * large_ds_buf_2                  = */ NULL,
+        /* uint32_t  * large_ds_slice_buf              = */ NULL,
+        /* int         small_ds_offset                 = */ -1,
+        /* int         large_ds_offset                 = */ -1,
+        /* hid_t       fid                             = */ -1,  /* HDF5 file ID */
+        /* hid_t       xfer_plist                      = */ H5P_DEFAULT,
+        /* hid_t       full_mem_small_ds_sid           = */ -1,
+        /* hid_t       full_file_small_ds_sid          = */ -1,
+        /* hid_t       mem_small_ds_sid                = */ -1,
+        /* hid_t       file_small_ds_sid_0             = */ -1,
+        /* hid_t       file_small_ds_sid_1             = */ -1,
+        /* hid_t       small_ds_slice_sid              = */ -1,
+        /* hid_t       full_mem_large_ds_sid           = */ -1,
+        /* hid_t       full_file_large_ds_sid          = */ -1,
+        /* hid_t       mem_large_ds_sid                = */ -1,
+        /* hid_t       file_large_ds_sid_0             = */ -1,
+        /* hid_t       file_large_ds_sid_1             = */ -1,
+        /* hid_t       file_large_ds_process_slice_sid = */ -1,
+        /* hid_t       mem_large_ds_process_slice_sid  = */ -1,
+        /* hid_t       large_ds_slice_sid              = */ -1,
+        /* hid_t       small_dataset                   = */ -1,     /* Dataset ID */
+        /* hid_t       large_dataset                   = */ -1,     /* Dataset ID */
+        /* size_t      small_ds_size                   = */ 1,
+        /* size_t      small_ds_slice_size             = */ 1,
+        /* size_t      large_ds_size                   = */ 1,
+        /* size_t      large_ds_slice_size             = */ 1,
+        /* hsize_t     dims[PAR_SS_DR_MAX_RANK]        = */ {0,0,0,0,0},
+        /* hsize_t     chunk_dims[PAR_SS_DR_MAX_RANK]  = */ {0,0,0,0,0},
+        /* hsize_t     start[PAR_SS_DR_MAX_RANK]       = */ {0,0,0,0,0},
+        /* hsize_t     stride[PAR_SS_DR_MAX_RANK]      = */ {0,0,0,0,0},
+        /* hsize_t     count[PAR_SS_DR_MAX_RANK]       = */ {0,0,0,0,0},
+        /* hsize_t     block[PAR_SS_DR_MAX_RANK]       = */ {0,0,0,0,0},
+        /* hsize_t   * start_ptr                       = */ NULL,
+        /* hsize_t   * stride_ptr                      = */ NULL,
+        /* hsize_t   * count_ptr                       = */ NULL,
+        /* hsize_t   * block_ptr                       = */ NULL,
+        /* int 	       skips                           = */ 0,
+        /* int 	       max_skips                       = */ 0,
+        /* int64_t     total_tests                     = */ 0,
+        /* int64_t     tests_run                       = */ 0,
+        /* int64_t     tests_skipped                   = */ 0
+    };
+    struct hs_dr_pio_test_vars_t * tv_ptr = &test_vars;
 
-    ret = H5Sclose(full_mem_large_ds_sid);
-    VRFY((ret != FAIL), "H5Sclose(full_mem_large_ds_sid) succeeded");
+    hs_dr_pio_test__setup(test_num, edge_size, checker_edge_size, 
+                          chunk_edge_size, small_rank, large_rank, 
+                          use_collective_io, dset_type, express_test, 
+                          tv_ptr);
 
-    ret = H5Sclose(full_file_large_ds_sid);
-    VRFY((ret != FAIL), "H5Sclose(full_file_large_ds_sid) succeeded");
 
-    ret = H5Sclose(mem_large_ds_sid);
-    VRFY((ret != FAIL), "H5Sclose(mem_large_ds_sid) succeeded");
+    /* initialize the local copy of mpi_rank */
+    mpi_rank = tv_ptr->mpi_rank;
 
-    ret = H5Sclose(file_large_ds_sid_0);
-    VRFY((ret != FAIL), "H5Sclose(mem_large_ds_sid) succeeded");
 
-    ret = H5Sclose(file_large_ds_sid_1);
-    VRFY((ret != FAIL), "H5Sclose(mem_large_ds_sid) succeeded");
+    /* initialize skips & max_skips */
+    tv_ptr->skips = *skips_ptr;
+    tv_ptr->max_skips = max_skips;
 
-    ret = H5Sclose(mem_large_ds_process_slice_sid);
-    VRFY((ret != FAIL), "H5Sclose(mem_large_ds_process_slice_sid) succeeded");
 
-    ret = H5Sclose(file_large_ds_process_slice_sid);
-    VRFY((ret != FAIL), "H5Sclose(file_large_ds_process_slice_sid) succeeded");
+#if CKRBRD_HS_DR_PIO_TEST__RUN_TEST__DEBUG
+    if ( MAINPROCESS ) {
+        HDfprintf(stdout, "test %d: small rank = %d, large rank = %d.\n",
+                  test_num, small_rank, large_rank);
+        HDfprintf(stdout, "test %d: Initialization complete.\n", test_num);
+    }
+#endif /* CKRBRD_HS_DR_PIO_TEST__RUN_TEST__DEBUG */
 
-    ret = H5Sclose(large_ds_slice_sid);
-    VRFY((ret != FAIL), "H5Sclose(large_ds_slice_sid) succeeded");
 
+    /* first, verify that we can read from disk correctly using selections
+     * of different rank that H5S_select_shape_same() views as being of the
+     * same shape.
+     *
+     * Start by reading a (small_rank - 1)-D slice from this processes slice 
+     * of the on disk large data set, and verifying that the data read is 
+     * correct.  Verify that H5S_select_shape_same() returns true on the 
+     * memory and file selections.
+     *
+     * The first step is to set up the needed checker board selection in the
+     * in memory small small cube
+     */
 
-    /* Close Datasets */
-    ret = H5Dclose(small_dataset);
-    VRFY((ret != FAIL), "H5Dclose(small_dataset) succeeded");
+    ckrbrd_hs_dr_pio_test__d2m_l2s(tv_ptr);
 
-    ret = H5Dclose(large_dataset);
-    VRFY((ret != FAIL), "H5Dclose(large_dataset) succeeded");
 
+    /* similarly, read slices of the on disk small data set into slices 
+     * through the in memory large data set, and verify that the correct 
+     * data (and only the correct data) is read.
+     */
 
-    /* close the file collectively */
-    MESG("about to close file.");
-    ret = H5Fclose(fid);
-    VRFY((ret != FAIL), "file close succeeded");
+    ckrbrd_hs_dr_pio_test__d2m_s2l(tv_ptr);
 
-    /* Free memory buffers */
-    if ( small_ds_buf_0 != NULL ) HDfree(small_ds_buf_0);
-    if ( small_ds_buf_1 != NULL ) HDfree(small_ds_buf_1);
-    if ( small_ds_buf_2 != NULL ) HDfree(small_ds_buf_2);
-    if ( small_ds_slice_buf != NULL ) HDfree(small_ds_slice_buf);
 
-    if ( large_ds_buf_0 != NULL ) HDfree(large_ds_buf_0);
-    if ( large_ds_buf_1 != NULL ) HDfree(large_ds_buf_1);
-    if ( large_ds_buf_2 != NULL ) HDfree(large_ds_buf_2);
-    if ( large_ds_slice_buf != NULL ) HDfree(large_ds_slice_buf);
+    /* now we go in the opposite direction, verifying that we can write
+     * from memory to file using selections of different rank that
+     * H5S_select_shape_same() views as being of the same shape.
+     *
+     * Start by writing small_rank - 1 D slices from the in memory large data
+     * set to the on disk small dataset.  After each write, read the slice of 
+     * the small dataset back from disk, and verify that it contains the 
+     * expected data. Verify that H5S_select_shape_same() returns true on 
+     * the memory and file selections.
+     */
+
+    ckrbrd_hs_dr_pio_test__m2d_l2s(tv_ptr);
+
+
+    /* Now write the contents of the process's slice of the in memory 
+     * small data set to slices of the on disk large data set.  After 
+     * each write, read the process's slice of the large data set back
+     * into memory, and verify that it contains the expected data. 
+     * Verify that H5S_select_shape_same() returns true on the memory 
+     * and file selections.
+     */
+
+    ckrbrd_hs_dr_pio_test__m2d_s2l(tv_ptr);
+
+
+#if CKRBRD_HS_DR_PIO_TEST__RUN_TEST__DEBUG
+    if ( MAINPROCESS ) {
+        HDfprintf(stdout, 
+            "test %d: Subtests complete -- tests run/skipped/total = %lld/%lld/%lld.\n", 
+             test_num, (long long)(tv_ptr->tests_run), (long long)(tv_ptr->tests_skipped),
+             (long long)(tv_ptr->total_tests));
+    }
+#endif /* CKRBRD_HS_DR_PIO_TEST__RUN_TEST__DEBUG */
+
+    hs_dr_pio_test__takedown(tv_ptr);
+
+#if CKRBRD_HS_DR_PIO_TEST__RUN_TEST__DEBUG
+    if ( MAINPROCESS ) {
+        HDfprintf(stdout, "test %d: Takedown complete.\n", test_num);
+    }
+#endif /* CKRBRD_HS_DR_PIO_TEST__RUN_TEST__DEBUG */
+
+    *skips_ptr = tv_ptr->skips;
+    *total_tests_ptr += tv_ptr->total_tests;
+    *tests_run_ptr += tv_ptr->tests_run;
+    *tests_skipped_ptr += tv_ptr->tests_skipped;
 
     return;
 
-} /* checker_board_hyperslab_dr_pio_test__run_test() */
+} /* ckrbrd_hs_dr_pio_test__run_test() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	checker_board_hyperslab_dr_pio_test()
+ * Function:	ckrbrd_hs_dr_pio_test()
  *
  * Purpose:	Test I/O to/from hyperslab selections of different rank in
  *		the parallel case.
@@ -4193,44 +4512,35 @@ int		m, n;
  *-------------------------------------------------------------------------
  */
 
-void
-checker_board_hyperslab_dr_pio_test(ShapeSameTestMethods sstest_type)
+static void
+ckrbrd_hs_dr_pio_test(ShapeSameTestMethods sstest_type)
 {
+    int         express_test;
+    int         local_express_test;
+    int	        mpi_size = -1;
+    int         mpi_rank = -1;
     int	        test_num = 0;
     int		edge_size = 10;
     int         checker_edge_size = 3;
     int		chunk_edge_size = 0;
     int	        small_rank = 3;
     int	        large_rank = 4;
-    int         skips[4] = {0, 0, 0, 0};
-    int         skip_counters[4] = {0, 0, 0, 0};
-    int         tests_skiped[4] = {0, 0, 0, 0};
     int		mpi_result;
     hid_t	dset_type = H5T_NATIVE_UINT;
-#ifdef H5_HAVE_GETTIMEOFDAY
-    hbool_t     time_tests = TRUE;
-    hbool_t	display_skips = FALSE;
-    int         local_express_test;
-    int         express_test;
-    int         i;
-    int         samples = 0;
-    int         sample_size = 1;
-    int         mpi_size = -1;
-    int         mpi_rank = -1;
-    int         local_skips[4];
-    const int   ind_contig_idx = 0;
-    const int   col_contig_idx = 1;
-    const int   ind_chunked_idx = 2;
-    const int   col_chunked_idx = 3;
-    const int   test_types = 4;
-    long long   max_test_time = 3000000; /* for one test */
-    long long   sample_times[4] = {0, 0, 0, 0};
-    struct timeval timeval_a;
-    struct timeval timeval_b;
+    int         skips = 0;
+    int         max_skips = 0;
+    /* The following table list the number of sub-tests skipped between
+     * each test that is actually executed as a function of the express
+     * test level.  Note that any value in excess of 4880 will cause all
+     * sub tests to be skipped.
+     */
+    int         max_skips_tbl[4] = {0, 4, 16, 64};
+    int64_t     total_tests = 0;
+    int64_t     tests_run = 0;
+    int64_t     tests_skipped = 0;
 
     MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
     MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
-#endif /* H5_HAVE_GETTIMEOFDAY */
 
     local_express_test = GetTestExpress();
 
@@ -4245,6 +4555,14 @@ checker_board_hyperslab_dr_pio_test(ShapeSameTestMethods sstest_type)
 
     VRFY((mpi_result == MPI_SUCCESS ), "MPI_Allreduce(0) succeeded");
 
+    if ( local_express_test < 0 ) {
+        max_skips = max_skips_tbl[0];
+    } else if ( local_express_test > 3 ) {
+        max_skips = max_skips_tbl[3];
+    } else {
+        max_skips = max_skips_tbl[local_express_test];
+    }
+
 #if 0 
     {
         int DebugWait = 1;
@@ -4256,201 +4574,113 @@ checker_board_hyperslab_dr_pio_test(ShapeSameTestMethods sstest_type)
     for ( large_rank = 3; large_rank <= PAR_SS_DR_MAX_RANK; large_rank++ ) {
 
         for ( small_rank = 2; small_rank < large_rank; small_rank++ ) {
-	  switch(sstest_type){
-	  case IND_CONTIG:
-            /* contiguous data set, independent I/O */
-            chunk_edge_size = 0;
-            if ( skip_counters[ind_contig_idx] < skips[ind_contig_idx] ) {
-
-                skip_counters[ind_contig_idx]++;
-                tests_skiped[ind_contig_idx]++;
-		printf("Test skipped\n");
-            } else {
-                skip_counters[ind_contig_idx] = 0;
-                START_TIMER(time_tests, timeval_a, "HDgettimeofday(0) succeeds.");
-
-                checker_board_hyperslab_dr_pio_test__run_test(test_num,
-                                                  edge_size,
-                                                  checker_edge_size,
-                                                  chunk_edge_size,
-                                                  small_rank,
-                                                  large_rank,
-                                                  FALSE,
-                                                  dset_type,
-                                                  express_test);
-                STOP_TIMER_AND_UPDATE(time_tests, timeval_b, \
-                                      "HDgettimeofday(1) succeeds.", \
-                                      sample_times[ind_contig_idx]);
-
+            switch(sstest_type){
+                case IND_CONTIG:
+                    /* contiguous data set, independent I/O */
+                    chunk_edge_size = 0;
+                    ckrbrd_hs_dr_pio_test__run_test(test_num,
+                                                    edge_size,
+                                                    checker_edge_size,
+                                                    chunk_edge_size,
+                                                    small_rank,
+                                                    large_rank,
+                                                    FALSE,
+                                                    dset_type,
+                                                    express_test,
+                                                    &skips,
+                                                    max_skips,
+                                                    &total_tests,
+                                                    &tests_run,
+                                                    &tests_skipped);
+                    test_num++;
+                    break;
+                    /* end of case IND_CONTIG */
+
+                 case COL_CONTIG:
+                    /* contiguous data set, collective I/O */
+                    chunk_edge_size = 0;
+                    ckrbrd_hs_dr_pio_test__run_test(test_num,
+                                                    edge_size,
+                                                    checker_edge_size,
+                                                    chunk_edge_size,
+                                                    small_rank,
+                                                    large_rank,
+                                                    TRUE,
+                                                    dset_type,
+                                                    express_test,
+                                                    &skips,
+                                                    max_skips,
+                                                    &total_tests,
+                                                    &tests_run,
+                                                    &tests_skipped);
+                    test_num++;
+                    break;
+                    /* end of case COL_CONTIG */
+
+                case IND_CHUNKED:
+                    /* chunked data set, independent I/O */
+                    chunk_edge_size = 5;
+                    ckrbrd_hs_dr_pio_test__run_test(test_num,
+                                                    edge_size,
+                                                    checker_edge_size,
+                                                    chunk_edge_size,
+                                                    small_rank,
+                                                    large_rank,
+                                                    FALSE,
+                                                    dset_type,
+                                                    express_test,
+                                                    &skips,
+                                                    max_skips,
+                                                    &total_tests,
+                                                    &tests_run,
+                                                    &tests_skipped);
+                    test_num++;
+                    break;
+                    /* end of case IND_CHUNKED */
+
+                case COL_CHUNKED:
+                    /* chunked data set, collective I/O */
+                    chunk_edge_size = 5;
+                    ckrbrd_hs_dr_pio_test__run_test(test_num,
+                                                    edge_size,
+                                                    checker_edge_size,
+                                                    chunk_edge_size,
+                                                    small_rank,
+                                                    large_rank,
+                                                    TRUE,
+                                                    dset_type,
+                                                    express_test,
+                                                    &skips,
+                                                    max_skips,
+                                                    &total_tests,
+                                                    &tests_run,
+                                                    &tests_skipped);
+                    test_num++;
+                    break;
+                    /* end of case COL_CHUNKED */
+
+                default:
+                    VRFY((FALSE), "unknown test type");
+                    break;
+
+            } /* end of switch(sstest_type) */
+#if CONTIG_HS_DR_PIO_TEST__DEBUG
+            if ( ( MAINPROCESS ) && ( tests_skipped > 0 ) ) {
+                HDfprintf(stdout, "     run/skipped/total = %lld/%lld/%lld.\n",
+                          tests_run, tests_skipped, total_tests);
             }
-            test_num++;
-	    break;
-	    /* end of case IND_CONTIG */
-
-	  case COL_CONTIG:
-            /* contiguous data set, collective I/O */
-            chunk_edge_size = 0;
-            if ( skip_counters[col_contig_idx] < skips[col_contig_idx] ) {
-
-                skip_counters[col_contig_idx]++;
-                tests_skiped[col_contig_idx]++;
-		printf("Test skipped\n");
-            } else {
-                skip_counters[col_contig_idx] = 0;
-                START_TIMER(time_tests, timeval_a, "HDgettimeofday(2) succeeds.");
-
-                checker_board_hyperslab_dr_pio_test__run_test(test_num,
-                                                  edge_size,
-                                                  checker_edge_size,
-                                                  chunk_edge_size,
-                                                  small_rank,
-                                                  large_rank,
-                                                  TRUE,
-                                                  dset_type,
-                                                  express_test);
-                STOP_TIMER_AND_UPDATE(time_tests, timeval_b, \
-                                      "HDgettimeofday(3) succeeds.", \
-                                      sample_times[col_contig_idx]);
-
-            }
-            test_num++;
-	    break;
-	    /* end of case COL_CONTIG */
-
-	  case IND_CHUNKED:
-            /* chunked data set, independent I/O */
-            chunk_edge_size = 5;
-            if ( skip_counters[ind_chunked_idx] < skips[ind_chunked_idx] ) {
-
-                skip_counters[ind_chunked_idx]++;
-                tests_skiped[ind_chunked_idx]++;
-		printf("Test skipped\n");
-            } else {
-                skip_counters[ind_chunked_idx] = 0;
-                START_TIMER(time_tests, timeval_a, "HDgettimeofday(4) succeeds.");
-
-                checker_board_hyperslab_dr_pio_test__run_test(test_num,
-                                                  edge_size,
-                                                  checker_edge_size,
-                                                  chunk_edge_size,
-                                                  small_rank,
-                                                  large_rank,
-                                                  FALSE,
-                                                  dset_type,
-                                                  express_test);
-                STOP_TIMER_AND_UPDATE(time_tests, timeval_b, \
-                                      "HDgettimeofday(5) succeeds.", \
-                                      sample_times[ind_chunked_idx]);
-
-            }
-            test_num++;
-	    break;
-	    /* end of case IND_CHUNKED */
-
-	  case COL_CHUNKED:
-            /* chunked data set, collective I/O */
-            chunk_edge_size = 5;
-            if ( skip_counters[col_chunked_idx] < skips[col_chunked_idx] ) {
-
-                skip_counters[col_chunked_idx]++;
-                tests_skiped[col_chunked_idx]++;
-		printf("Test skipped\n");
-            } else {
-                skip_counters[col_chunked_idx] = 0;
-                START_TIMER(time_tests, timeval_a, "HDgettimeofday(6) succeeds.");
-
-                checker_board_hyperslab_dr_pio_test__run_test(test_num,
-                                                  edge_size,
-                                                  checker_edge_size,
-                                                  chunk_edge_size,
-                                                  small_rank,
-                                                  large_rank,
-                                                  TRUE,
-                                                  dset_type,
-                                                  express_test);
-                STOP_TIMER_AND_UPDATE(time_tests, timeval_b, \
-                                      "HDgettimeofday(7) succeeds.", \
-                                      sample_times[col_chunked_idx]);
-
-            }
-            test_num++;
-	    break;
-	    /* end of case COL_CHUNKED */
-	  } /* end of switch(sstest_type) */
-
-#ifdef H5_HAVE_GETTIMEOFDAY
-            if ( time_tests ) {
-
-                samples++;
-
-                if ( samples >= sample_size ) {
-
-                    int result;
-
-                    time_tests = FALSE;
-
-                    max_test_time = ((long long)sample_size) * max_test_time;
-
-                    for ( i = 0; i < test_types; i++ ) {
-
-                        if ( ( express_test == 0 ) ||
-                             ( sample_times[i] <= max_test_time ) ) {
-
-                            local_skips[i] = 0;
-
-                        } else {
-
-                            local_skips[i] = (int)(sample_times[i] / max_test_time);
-                        }
-                    }
-
-                    /* do an MPI_Allreduce() with the skips vector to ensure that
-                     * all processes agree on its contents.
-                     */
-                    result = MPI_Allreduce((void *)local_skips,
-                                           (void *)skips,
-                                           test_types,
-                                           MPI_INT,
-                                           MPI_MAX,
-                                           MPI_COMM_WORLD);
-                    VRFY((result == MPI_SUCCESS ), "MPI_Allreduce() succeeded");
-                }
-            }
-#endif /* H5_HAVE_GETTIMEOFDAY */
-
+#endif /* CONTIG_HS_DR_PIO_TEST__DEBUG */
         }
     }
 
-#ifdef H5_HAVE_GETTIMEOFDAY
-    if ( ( MAINPROCESS ) && ( display_skips ) ) {
-
-        HDfprintf(stdout, "***********************************\n");
-        HDfprintf(stdout, "express test = %d.\n", express_test);
-        HDfprintf(stdout, "sample_size = %d, max_test_time = %lld.\n",
-                  sample_size, max_test_time);
-        HDfprintf(stdout, "sample_times[]  = %lld, %lld, %lld, %lld.\n",
-                  sample_times[ind_contig_idx],
-                  sample_times[col_contig_idx],
-                  sample_times[ind_chunked_idx],
-                  sample_times[col_chunked_idx]);
-        HDfprintf(stdout, "skips[]  = %d, %d, %d, %d.\n",
-                  skips[ind_contig_idx],
-                  skips[col_contig_idx],
-                  skips[ind_chunked_idx],
-                  skips[col_chunked_idx]);
-        HDfprintf(stdout, "tests_skiped[]  = %d, %d, %d, %d.\n",
-                  tests_skiped[ind_contig_idx],
-                  tests_skiped[col_contig_idx],
-                  tests_skiped[ind_chunked_idx],
-                  tests_skiped[col_chunked_idx]);
-        HDfprintf(stdout, "test_num          = %d.\n", test_num);
-        HDfprintf(stdout, "***********************************\n");
+    if ( ( MAINPROCESS ) && ( tests_skipped > 0 ) ) {
+        HDfprintf(stdout, "     %lld of %lld subtests skipped to expedite testing.\n",
+                  tests_skipped, total_tests);
     }
-#endif /* H5_HAVE_GETTIMEOFDAY */
 
     return;
 
-} /* checker_board_hyperslab_dr_pio_test() */
+} /* ckrbrd_hs_dr_pio_test() */
 
 /* Main Body. Here for now, may have to move them to a separated file later. */
 
@@ -4756,28 +4986,28 @@ create_faccess_plist(MPI_Comm comm, MPI_Info info, int l_facc_type,
 static void
 sscontig1(void)
 {
-    contig_hyperslab_dr_pio_test(IND_CONTIG);
+    contig_hs_dr_pio_test(IND_CONTIG);
 }
 
 /* Shape Same test using contigous hyperslab using collective IO on contigous datasets */
 static void
 sscontig2(void)
 {
-    contig_hyperslab_dr_pio_test(COL_CONTIG);
+    contig_hs_dr_pio_test(COL_CONTIG);
 }
 
 /* Shape Same test using contigous hyperslab using independent IO on chunked datasets */
 static void
 sscontig3(void)
 {
-    contig_hyperslab_dr_pio_test(IND_CHUNKED);
+    contig_hs_dr_pio_test(IND_CHUNKED);
 }
 
 /* Shape Same test using contigous hyperslab using collective IO on chunked datasets */
 static void
 sscontig4(void)
 {
-    contig_hyperslab_dr_pio_test(COL_CHUNKED);
+    contig_hs_dr_pio_test(COL_CHUNKED);
 }
 
 
@@ -4785,38 +5015,34 @@ sscontig4(void)
 static void
 sschecker1(void)
 {
-    checker_board_hyperslab_dr_pio_test(IND_CONTIG);
+    ckrbrd_hs_dr_pio_test(IND_CONTIG);
 }
 
 /* Shape Same test using checker hyperslab using collective IO on contigous datasets */
 static void
 sschecker2(void)
 {
-    checker_board_hyperslab_dr_pio_test(COL_CONTIG);
+    ckrbrd_hs_dr_pio_test(COL_CONTIG);
 }
 
 /* Shape Same test using checker hyperslab using independent IO on chunked datasets */
 static void
 sschecker3(void)
 {
-    checker_board_hyperslab_dr_pio_test(IND_CHUNKED);
+    ckrbrd_hs_dr_pio_test(IND_CHUNKED);
 }
 
 /* Shape Same test using checker hyperslab using collective IO on chunked datasets */
 static void
 sschecker4(void)
 {
-    checker_board_hyperslab_dr_pio_test(COL_CHUNKED);
+    ckrbrd_hs_dr_pio_test(COL_CHUNKED);
 }
 
 
 int main(int argc, char **argv)
 {
     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;
-    H5Ptest_param_t rr_obj_flush_confusion_params;
 
     /* Un-buffer the stdout and stderr */
     setbuf(stderr, NULL);
@@ -4832,6 +5058,7 @@ int main(int argc, char **argv)
     if (MAINPROCESS){
 	printf("===================================\n");
 	printf("Shape Same Tests Start\n");
+        printf("	express_test = %d.\n", GetTestExpress());
 	printf("===================================\n");
     }
 
@@ -4841,7 +5068,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("%d: Failed to turn off atexit processing. Continue.\n", mpi_rank);
     };
     H5open();
     h5_show_hostname();
@@ -4850,6 +5077,7 @@ int main(int argc, char **argv)
     TestInit(argv[0], usage, parse_options);
 
     /* Shape Same tests using contigous hyperslab */
+#if 1
     AddTest("sscontig1", sscontig1, NULL,
 	"Shape Same, contigous hyperslab, ind IO, contig datasets", PARATESTFILE);
     AddTest("sscontig2", sscontig2, NULL,
@@ -4858,6 +5086,7 @@ int main(int argc, char **argv)
 	"Shape Same, contigous hyperslab, ind IO, chunked datasets", PARATESTFILE);
     AddTest("sscontig4", sscontig4, NULL,
 	"Shape Same, contigous hyperslab, col IO, chunked datasets", PARATESTFILE);
+#endif
 
     /* Shape Same tests using checker board hyperslab */
     AddTest("sschecker1", sschecker1, NULL,
@@ -4919,9 +5148,9 @@ int main(int argc, char **argv)
     if (MAINPROCESS){		/* only process 0 reports */
 	printf("===================================\n");
 	if (nerrors)
-	    printf("***PHDF5 tests detected %d errors***\n", nerrors);
+	    printf("***Shape Same tests detected %d errors***\n", nerrors);
 	else
-	    printf("PHDF5 tests finished with no errors\n");
+	    printf("Shape Same tests finished with no errors\n");
 	printf("===================================\n");
     }
     /* close HDF5 library */