[svn-r21380]

Ported shape same test express test mods from trunk to 1.8 branch.

This was mostly a matter of copying testpar/t_shapesame.c from trunk
to the 1.8 branch, as the root versions of the files were almost 
identical.

Tested parallel on Jam only, as changes have been well tested on the 
trunk.

1 files changed, 3033 insertions, 2804 deletions

diff --git a/testpar/t_shapesame.c b/testpar/t_shapesame.c
index 459fcf8..b76b481 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
@@ -78,212 +37,252 @@
  * the chunked dataset case.
  */
 
-#define SHAPE_SAME_TEST_ALIGNMENT  ((hsize_t)(4 * 1024 * 1024))
+#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
+ * 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;
+    hbool_t	use_gpfs = FALSE;   /* Use GPFS hints */
+    hbool_t	mis_match = FALSE;
+    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 */
-    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;
+    int		mpi_rank; /* needed by the VRFY macro */
+    uint32_t	expected_value;
     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	acc_tpl;		/* File access templates */
     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 */
+    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 );
+    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");
 
-    small_ds_slice_sid = H5Screate_simple(small_rank - 1, &(dims[1]), NULL);
-    VRFY((small_ds_slice_sid != 0), 
+    /* 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");
+
+    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");
+
+    /* 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");
 
-    mem_large_ds_process_slice_sid = H5Screate_simple(large_rank, dims, NULL);
-    VRFY((mem_large_ds_process_slice_sid != FAIL), 
+    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)++;
 
+                } else { /* run the test */
 
-                /* verify that expected data is retrieved */
+                    tv_ptr->skips = 0; /* reset the skips counter */
 
-                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));
+                    /* 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++ ) {
 
-                for ( n = 0; n < small_ds_slice_size; n++ ) {
+                        if ( *ptr_1 != expected_value ) {
 
-                    if ( *ptr_1 != expected_value ) {
+                            mis_match = TRUE;
+                        }
 
-                        mis_match = TRUE;
+                        *ptr_1 = 0; /* zero data for next use */
+
+                        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)++;
 
-                /* 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.");
+                } 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.
+                     */
 
-                mis_match = FALSE;
-                ptr_1 = small_ds_buf_1;
+                    /* 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++;
 
-                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));
+                        } else {
 
-                start_index = (size_t)mpi_rank * small_ds_slice_size;
-                stop_index = start_index + small_ds_slice_size - 1;
+                            if ( *ptr_1 != 0 ) {
 
-                HDassert( start_index < stop_index );
-                HDassert( stop_index <= small_ds_size );
+                                mis_match = TRUE;
+                            }
+                        }
+                        /* zero out the value for the next pass */
+                        *ptr_1 = 0;
 
-                for ( n = 0; n < small_ds_size; n++ ) {
+                        ptr_1++;
+                    }
 
-                    if ( ( n >= start_index ) && ( n <= stop_index ) ) {
+                    VRFY((mis_match == FALSE), 
+                         "small slice write from large ds data good.");
 
-                        if ( *ptr_1 != expected_value ) {
+                    (tv_ptr->tests_run)++;
+                }
 
-                            mis_match = TRUE;
-                        }
-                        expected_value++;
+                l++;
 
-                    } else {
+               (tv_ptr->total_tests)++;
 
-                        if ( *ptr_1 != 0 ) {
+            } 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 ) );
 
-                            mis_match = TRUE;
-                        }
-                    }
-                    /* zero out the value for the next pass */
-                    *ptr_1 = 0;
+    return;
 
-                    ptr_1++;
-                }
+} /* contig_hs_dr_pio_test__m2d_l2s() */
 
-                VRFY((mis_match == FALSE), 
-                     "small slice write from large ds data good.");
 
-                l++;
+/*-------------------------------------------------------------------------
+ * 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
+ *
+ *-------------------------------------------------------------------------
+ */
 
-            } 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 CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG 0
 
+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,278 +1801,466 @@ 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.
+     */
+
+#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);
 
-    /* Close Datasets */
-    ret = H5Dclose(small_dataset);
-    VRFY((ret != FAIL), "H5Dclose(small_dataset) succeeded");
 
-    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.
+     */
+
+#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);
 
 
-    /* close the file collectively */
-    MESG("about to close file.");
-    ret = H5Fclose(fid);
-    VRFY((ret != FAIL), "file close succeeded");
+    /* 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.
+     */
 
-    /* Free memory buffers */
+#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 ( 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 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 */
 
-    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);
+    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 */
+
+    *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.
+ * Purpose:	Test I/O to/from hyperslab selections of different rank in
+ *		the parallel case.
  *
- * Return:  void
+ * Return:	void
  *
- * Programmer:  JRM -- 9/18/09
+ * Programmer:	JRM -- 9/18/09
  *
  * Modifications:
  *
- *      Modified function to take a sample of the run times
- *    of the different tests, and skip some of them if 
- *    run times are too long.  
+ *  		Modified function to take a sample of the run times
+ *		of the different tests, and skip some of them if 
+ *		run times are too long.  
  *
- *    We need to do this because Lustre runns very slowly
- *    if two or more processes are banging on the same 
- *    block of memory.
- *            JRM -- 9/10/10
+ *		We need to do this because Lustre runns very slowly
+ *		if two or more processes are banging on the same 
+ *		block of memory.
+ *						JRM -- 9/10/10
  *              Break this one big test into 4 smaller tests according
  *              to {independent,collective}x{contigous,chunked} datasets.
- *    AKC -- 2010/01/14
+ *		AKC -- 2010/01/14
  *
  *-------------------------------------------------------------------------
  */
 
+#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          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;
-    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         express_test;
+    int         local_express_test;
     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 */
+    int	        test_num = 0;
+    int		edge_size = 10;
+    int		chunk_edge_size = 0;
+    int	        small_rank;
+    int	        large_rank;
+    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, 32, 256};
+    hid_t	dset_type = H5T_NATIVE_UINT;
+    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,247 +2272,177 @@ 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():  
-**  Given a data space of tgt_rank, and dimensions:
+**  ckrbrd_hs_dr_pio_test__slct_ckrbrd():  
+**	Given a data space of tgt_rank, and dimensions:
 **
-**    (mpi_size + 1), edge_size, ... , edge_size
+**		(mpi_size + 1), edge_size, ... , edge_size
 **
-**  edge_size, and a checker_edge_size, select a checker
-**  board selection of a sel_rank (sel_rank < tgt_rank) 
-**  dimensional slice through the data space parallel to the 
+**	edge_size, and a checker_edge_size, select a checker
+**	board selection of a sel_rank (sel_rank < tgt_rank) 
+**	dimensional slice through the data space parallel to the 
 **      sel_rank fastest changing indicies, with origin (in the
-**  higher indicies) as indicated by the start array.
+**	higher indicies) as indicated by the start array.
 **
-**  Note that this function, like all its relatives, is
-**  hard coded to presume a maximum data space rank of 5.
-**  While this maximum is declared as a constant, increasing
-**  it will require extensive coding in addition to changing
+**	Note that this function, like all its relatives, is
+**	hard coded to presume a maximum data space rank of 5.
+**	While this maximum is declared as a constant, increasing
+**	it will require extensive coding in addition to changing
 **      the value of the constant.
 **
-**          JRM -- 10/8/09
+**					JRM -- 10/8/09
 **
 ****************************************************************/
 
-#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;
+    hbool_t		first_selection = TRUE;
     int                 i, j, k, l, m;
-    int      n_cube_offset;
-    int      sel_offset;
-    const int    test_max_rank = PAR_SS_DR_MAX_RANK;  /* must update code if */
+    int			n_cube_offset;
+    int			sel_offset;
+    const int		test_max_rank = PAR_SS_DR_MAX_RANK;  /* must update code if */
                                                              /* this changes        */
-    hsize_t    base_count;
+    hsize_t		base_count;
     hsize_t             offset_count;
-    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];
-    herr_t        ret;            /* Generic return value */
+    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];
+    herr_t      	ret;            /* Generic return value */
 
     HDassert( edge_size >= 6 );
     HDassert( 0 < checker_edge_size );
@@ -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,86 +2723,85 @@ 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 
+**	Examine the supplied buffer to see if it contains the 
+**	expected data.  Return TRUE if it does, and FALSE 
 **      otherwise.
 **
-**  The supplied buffer is presumed to this process's slice 
-**  of the target data set.  Each such slice will be an
-**  n-cube of rank (rank -1) and the supplied edge_size with
-**  origin (mpi_rank, 0, ... , 0) in the target data set.
+**	The supplied buffer is presumed to this process's slice 
+**	of the target data set.  Each such slice will be an
+**	n-cube of rank (rank -1) and the supplied edge_size with
+**	origin (mpi_rank, 0, ... , 0) in the target data set.
 **
-**  Further, the buffer is presumed to be the result of reading
-**  or writing a checker board selection of an m (1 <= m < 
+**	Further, the buffer is presumed to be the result of reading
+**	or writing a checker board selection of an m (1 <= m < 
 **      rank) dimensional slice through this processes slice
-**  of the target data set.  Also, this slice must be parallel
-**  to the fastest changing indicies.  
+**	of the target data set.  Also, this slice must be parallel
+**	to the fastest changing indicies.  
 **
-**  It is further presumed that the buffer was zeroed before
-**  the read/write, and that the full target data set (i.e.
-**  the buffer/data set for all processes) was initialized
+**	It is further presumed that the buffer was zeroed before
+**	the read/write, and that the full target data set (i.e.
+**	the buffer/data set for all processes) was initialized
 **      with the natural numbers listed in order from the origin 
-**  along the fastest changing axis.
+**	along the fastest changing axis.
 **
 **      Thus for a 20x10x10 dataset, the value stored in location
-**  (x, y, z) (assuming that z is the fastest changing index
-**  and x the slowest) is assumed to be:
+**	(x, y, z) (assuming that z is the fastest changing index
+**	and x the slowest) is assumed to be:
 **
-**    (10 * 10 * x) + (10 * y) + z
+**		(10 * 10 * x) + (10 * y) + z
 **
-**  Further, supposing that this is process 10, this process's 
-**  slice of the dataset would be a 10 x 10 2-cube with origin
-**  (10, 0, 0) in the data set, and would be initialize (prior
-**  to the checkerboard selection) as follows:
+**	Further, supposing that this is process 10, this process's 
+**	slice of the dataset would be a 10 x 10 2-cube with origin
+**	(10, 0, 0) in the data set, and would be initialize (prior
+**	to the checkerboard selection) as follows:
 **
-**    1000, 1001, 1002, ... 1008, 1009
-**    1010, 1011, 1012, ... 1018, 1019
-**      .     .     .         .     .
-**      .     .     .         .     .
-**      .     .     .         .     .
-**    1090, 1091, 1092, ... 1098, 1099
+**		1000, 1001, 1002, ... 1008, 1009
+**		1010, 1011, 1012, ... 1018, 1019
+**		  .     .     .         .     .
+**		  .     .     .         .     .
+**		  .     .     .         .     .
+**		1090, 1091, 1092, ... 1098, 1099
 **
-**  In the case of a read from the processors slice of another
-**  data set of different rank, the values expected will have
-**  to be adjusted accordingly.  This is done via the 
-**  first_expected_val parameter.
+**	In the case of a read from the processors slice of another
+**	data set of different rank, the values expected will have
+**	to be adjusted accordingly.  This is done via the 
+**	first_expected_val parameter.
 **
-**  Finally, the function presumes that the first element 
-**  of the buffer resides either at the origin of either
-**  a selected or an unselected checker.  (Translation:
-**  if partial checkers appear in the buffer, they will
-**  intersect the edges of the n-cube oposite the origin.)
+**	Finally, the function presumes that the first element 
+**	of the buffer resides either at the origin of either
+**	a selected or an unselected checker.  (Translation:
+**	if partial checkers appear in the buffer, they will
+**	intersect the edges of the n-cube oposite the origin.)
 **
 ****************************************************************/
 
-#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,9 +2820,9 @@ 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;
+    int		mpi_rank;
 
     MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
     HDfprintf(stdout, "%s mpi_rank = %d.\n", fcnName, 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:	Part one of a series of tests of I/O to/from hyperslab 
+ *		selections of different rank in the parallel.
  *
- * Purpose:  Test I/O to/from checkerboard selections of hyperslabs 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.
  *
- * Return:  void
+ *              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.
  *
- * Programmer:  JRM -- 10/10/09
+ * Return:	void
+ *
+ * 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 */
-    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;
+#if CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG 
+    const char *fcnName = "ckrbrd_hs_dr_pio_test__d2m_l2s()";
     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];
+#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG */
+    hbool_t	data_ok = FALSE;
+    int		i, j, k, l;
+    uint32_t	expected_value;
+    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 */
+    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);
+    /* initialize the local copy of mpi_rank */
+    mpi_rank = tv_ptr->mpi_rank;
 
-    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");
-
-
-    /* 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 = 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
+                              );
 
-                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
-                          );
+                    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 = tv_ptr->large_ds_buf_1 + stop_index + 1;
 
-                ptr_1 = large_ds_buf_1 + stop_index + 1;
+                    for ( u = stop_index + 1; u < tv_ptr->large_ds_size; u++ ) {
 
-                for ( u = stop_index + 1; u < 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,303 +4098,449 @@ 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.
+                     */
+
+                    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");
 
-                data_ok = TRUE;
 
-                ptr_1 = large_ds_buf_1;
-                for ( u = 0; u < start_index; u++, ptr_1++ ) {
+                    /* 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);
 
-                    if ( *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;
 
-                        data_ok = FALSE;
-                        *ptr_1 = 0;
+                    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.
+ * Purpose:	Test I/O to/from hyperslab selections of different rank in
+ *		the parallel case.
  *
- * Return:  void
+ * Return:	void
  *
- * Programmer:  JRM -- 9/18/09
+ * Programmer:	JRM -- 9/18/09
  *
  * Modifications:
  *
- *      Modified function to take a sample of the run times
- *    of the different tests, and skip some of them if 
- *    run times are too long.  
+ *  		Modified function to take a sample of the run times
+ *		of the different tests, and skip some of them if 
+ *		run times are too long.  
  *
- *    We need to do this because Lustre runns very slowly
- *    if two or more processes are banging on the same 
- *    block of memory.
- *            JRM -- 9/10/10
- *        Break this one big test into 4 smaller tests according
- *        to {independent,collective}x{contigous,chunked} datasets.
- *    AKC -- 2010/01/17
+ *		We need to do this because Lustre runns very slowly
+ *		if two or more processes are banging on the same 
+ *		block of memory.
+ *						JRM -- 9/10/10
+ *      	Break this one big test into 4 smaller tests according
+ *      	to {independent,collective}x{contigous,chunked} datasets.
+ *		AKC -- 2010/01/17
  *
  *-------------------------------------------------------------------------
  */
 
-void
-checker_board_hyperslab_dr_pio_test(ShapeSameTestMethods sstest_type)
+static void
+ckrbrd_hs_dr_pio_test(ShapeSameTestMethods sstest_type)
 {
-    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         local_express_test;
+    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	        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		mpi_result;
+    hid_t	dset_type = H5T_NATIVE_UINT;
+    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, 32, 256};
+    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]);
-
-            }
-            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]);
-
+            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 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. */
 
@@ -4469,15 +4699,15 @@ int dim0;
 int dim1;
 int chunkdim0;
 int chunkdim1;
-int nerrors = 0;      /* errors count */
-int ndatasets = 300;      /* number of datasets to create*/
+int nerrors = 0;			/* errors count */
+int ndatasets = 300;			/* number of datasets to create*/
 int ngroups = 512;                      /* number of groups to create in root
                                          * group. */
-int facc_type = FACC_MPIO;    /*Test file access type */
+int facc_type = FACC_MPIO;		/*Test file access type */
 int dxfer_coll_type = DXFER_COLLECTIVE_IO;
 
-H5E_auto2_t old_func;            /* previous error handler */
-void *old_client_data;      /* previous error handler arg.*/
+H5E_auto2_t old_func;		        /* previous error handler */
+void *old_client_data;			/* previous error handler arg.*/
 
 /* other option flags */
 
@@ -4489,10 +4719,10 @@ void *old_client_data;      /* previous error handler arg.*/
 #define NFILENAME 2
 #define PARATESTFILE filenames[0]
 const char *FILENAME[NFILENAME]={
-      "ShapeSameTest",
-      NULL};
-char  filenames[NFILENAME][PATH_MAX];
-hid_t  fapl;        /* file access property list */
+	    "ShapeSameTest",
+	    NULL};
+char	filenames[NFILENAME][PATH_MAX];
+hid_t	fapl;				/* file access property list */
 
 #ifdef USE_PAUSE
 /* pause the process for a moment to allow debugger to attach if desired. */
@@ -4505,7 +4735,7 @@ void pause_proc(void)
 {
 
     int pid;
-    h5_stat_t  statbuf;
+    h5_stat_t	statbuf;
     char greenlight[] = "go";
     int maxloop = 10;
     int loops = 0;
@@ -4522,15 +4752,15 @@ void pause_proc(void)
     MPI_Get_processor_name(mpi_name, &mpi_namelen);
 
     if (MAINPROCESS)
-  while ((HDstat(greenlight, &statbuf) == -1) && loops < maxloop){
-      if (!loops++){
-    printf("Proc %d (%*s, %d): to debug, attach %d\n",
-        mpi_rank, mpi_namelen, mpi_name, pid, pid);
-      }
-      printf("waiting(%ds) for file %s ...\n", time_int, greenlight);
-      fflush(stdout);
-      sleep(time_int);
-  }
+	while ((HDstat(greenlight, &statbuf) == -1) && loops < maxloop){
+	    if (!loops++){
+		printf("Proc %d (%*s, %d): to debug, attach %d\n",
+		    mpi_rank, mpi_namelen, mpi_name, pid, pid);
+	    }
+	    printf("waiting(%ds) for file %s ...\n", time_int, greenlight);
+	    fflush(stdout);
+	    sleep(time_int);
+	}
     MPI_Barrier(MPI_COMM_WORLD);
 }
 
@@ -4542,7 +4772,7 @@ int MPI_Init(int *argc, char ***argv)
     pause_proc();
     return (ret_code);
 }
-#endif  /* USE_PAUSE */
+#endif	/* USE_PAUSE */
 
 
 /*
@@ -4552,16 +4782,16 @@ static void
 usage(void)
 {
     printf("    [-r] [-w] [-m<n_datasets>] [-n<n_groups>] "
-  "[-o] [-f <prefix>] [-d <dim0> <dim1>]\n");
+	"[-o] [-f <prefix>] [-d <dim0> <dim1>]\n");
     printf("\t-m<n_datasets>"
-  "\tset number of datasets for the multiple dataset test\n");
+	"\tset number of datasets for the multiple dataset test\n");
     printf("\t-n<n_groups>"
         "\tset number of groups for the multiple group test\n");
     printf("\t-f <prefix>\tfilename prefix\n");
     printf("\t-2\t\tuse Split-file together with MPIO\n");
     printf("\t-p\t\tuse combo MPI-POSIX driver\n");
     printf("\t-d <factor0> <factor1>\tdataset dimensions factors. Defaults (%d,%d)\n",
-  ROW_FACTOR, COL_FACTOR);
+	ROW_FACTOR, COL_FACTOR);
     printf("\t-c <dim0> <dim1>\tdataset chunk dimensions. Defaults (dim0/10,dim1/10)\n");
     printf("\n");
 }
@@ -4573,7 +4803,7 @@ usage(void)
 static int
 parse_options(int argc, char **argv)
 {
-    int mpi_size, mpi_rank;        /* mpi variables */
+    int mpi_size, mpi_rank;				/* mpi variables */
 
     MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
     MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
@@ -4584,110 +4814,110 @@ parse_options(int argc, char **argv)
     chunkdim1 = (dim1+9)/10;
 
     while (--argc){
-  if (**(++argv) != '-'){
-      break;
-  }else{
-      switch(*(*argv+1)){
-    case 'm':   ndatasets = atoi((*argv+1)+1);
-          if (ndatasets < 0){
-        nerrors++;
-        return(1);
-          }
-          break;
-          case 'n':   ngroups = atoi((*argv+1)+1);
-                if (ngroups < 0){
+	if (**(++argv) != '-'){
+	    break;
+	}else{
+	    switch(*(*argv+1)){
+		case 'm':   ndatasets = atoi((*argv+1)+1);
+			    if (ndatasets < 0){
+				nerrors++;
+				return(1);
+			    }
+			    break;
+	        case 'n':   ngroups = atoi((*argv+1)+1);
+		            if (ngroups < 0){
                                 nerrors++;
                                 return(1);
-          }
+			    }
                             break;
-    case 'f':   if (--argc < 1) {
-        nerrors++;
-        return(1);
-          }
-          if (**(++argv) == '-') {
-        nerrors++;
-        return(1);
-          }
-          paraprefix = *argv;
-          break;
-    case 'p':   /* Use the MPI-POSIX driver access */
-          facc_type = FACC_MPIPOSIX;
-          break;
-    case 'i':   /* Collective MPI-IO access with independent IO  */
-          dxfer_coll_type = DXFER_INDEPENDENT_IO;
-          break;
-    case '2':   /* Use the split-file driver with MPIO access */
-          /* Can use $HDF5_METAPREFIX to define the */
-          /* meta-file-prefix. */
-          facc_type = FACC_MPIO | FACC_SPLIT;
-          break;
-    case 'd':   /* dimensizes */
-          if (--argc < 2){
-        nerrors++;
-        return(1);
-          }
-          dim0 = atoi(*(++argv))*mpi_size;
-          argc--;
-          dim1 = atoi(*(++argv))*mpi_size;
-          /* set default chunkdim sizes too */
-          chunkdim0 = (dim0+9)/10;
-          chunkdim1 = (dim1+9)/10;
-          break;
-    case 'c':   /* chunk dimensions */
-          if (--argc < 2){
-        nerrors++;
-        return(1);
-          }
-          chunkdim0 = atoi(*(++argv));
-          argc--;
-          chunkdim1 = atoi(*(++argv));
-          break;
-    case 'h':   /* print help message--return with nerrors set */
-          return(1);
-    default:    printf("Illegal option(%s)\n", *argv);
-          nerrors++;
-          return(1);
-      }
-  }
+		case 'f':   if (--argc < 1) {
+				nerrors++;
+				return(1);
+			    }
+			    if (**(++argv) == '-') {
+				nerrors++;
+				return(1);
+			    }
+			    paraprefix = *argv;
+			    break;
+		case 'p':   /* Use the MPI-POSIX driver access */
+			    facc_type = FACC_MPIPOSIX;
+			    break;
+		case 'i':   /* Collective MPI-IO access with independent IO  */
+			    dxfer_coll_type = DXFER_INDEPENDENT_IO;
+			    break;
+		case '2':   /* Use the split-file driver with MPIO access */
+			    /* Can use $HDF5_METAPREFIX to define the */
+			    /* meta-file-prefix. */
+			    facc_type = FACC_MPIO | FACC_SPLIT;
+			    break;
+		case 'd':   /* dimensizes */
+			    if (--argc < 2){
+				nerrors++;
+				return(1);
+			    }
+			    dim0 = atoi(*(++argv))*mpi_size;
+			    argc--;
+			    dim1 = atoi(*(++argv))*mpi_size;
+			    /* set default chunkdim sizes too */
+			    chunkdim0 = (dim0+9)/10;
+			    chunkdim1 = (dim1+9)/10;
+			    break;
+		case 'c':   /* chunk dimensions */
+			    if (--argc < 2){
+				nerrors++;
+				return(1);
+			    }
+			    chunkdim0 = atoi(*(++argv));
+			    argc--;
+			    chunkdim1 = atoi(*(++argv));
+			    break;
+		case 'h':   /* print help message--return with nerrors set */
+			    return(1);
+		default:    printf("Illegal option(%s)\n", *argv);
+			    nerrors++;
+			    return(1);
+	    }
+	}
     } /*while*/
 
     /* check validity of dimension and chunk sizes */
     if (dim0 <= 0 || dim1 <= 0){
-  printf("Illegal dim sizes (%d, %d)\n", dim0, dim1);
-  nerrors++;
-  return(1);
+	printf("Illegal dim sizes (%d, %d)\n", dim0, dim1);
+	nerrors++;
+	return(1);
     }
     if (chunkdim0 <= 0 || chunkdim1 <= 0){
-  printf("Illegal chunkdim sizes (%d, %d)\n", chunkdim0, chunkdim1);
-  nerrors++;
-  return(1);
+	printf("Illegal chunkdim sizes (%d, %d)\n", chunkdim0, chunkdim1);
+	nerrors++;
+	return(1);
     }
 
     /* Make sure datasets can be divided into equal portions by the processes */
     if ((dim0 % mpi_size) || (dim1 % mpi_size)){
-  if (MAINPROCESS)
-      printf("dim0(%d) and dim1(%d) must be multiples of processes(%d)\n",
-        dim0, dim1, mpi_size);
-  nerrors++;
-  return(1);
+	if (MAINPROCESS)
+	    printf("dim0(%d) and dim1(%d) must be multiples of processes(%d)\n",
+		    dim0, dim1, mpi_size);
+	nerrors++;
+	return(1);
     }
 
     /* compose the test filenames */
     {
-  int i, n;
-
-  n = sizeof(FILENAME)/sizeof(FILENAME[0]) - 1;  /* exclude the NULL */
-
-  for (i=0; i < n; i++)
-      if (h5_fixname(FILENAME[i],fapl,filenames[i],sizeof(filenames[i]))
-    == NULL){
-    printf("h5_fixname failed\n");
-    nerrors++;
-    return(1);
-      }
-  printf("Test filenames are:\n");
-  for (i=0; i < n; i++)
-      printf("    %s\n", filenames[i]);
+	int i, n;
+
+	n = sizeof(FILENAME)/sizeof(FILENAME[0]) - 1;	/* exclude the NULL */
+
+	for (i=0; i < n; i++)
+	    if (h5_fixname(FILENAME[i],fapl,filenames[i],sizeof(filenames[i]))
+		== NULL){
+		printf("h5_fixname failed\n");
+		nerrors++;
+		return(1);
+	    }
+	printf("Test filenames are:\n");
+	for (i=0; i < n; i++)
+	    printf("    %s\n", filenames[i]);
     }
 
     return(0);
@@ -4703,7 +4933,7 @@ create_faccess_plist(MPI_Comm comm, MPI_Info info, int l_facc_type,
 {
     hid_t ret_pl = -1;
     herr_t ret;                 /* generic return value */
-    int mpi_rank;    /* mpi variables */
+    int mpi_rank;		/* mpi variables */
 
     /* need the rank for error checking macros */
     MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
@@ -4712,39 +4942,39 @@ create_faccess_plist(MPI_Comm comm, MPI_Info info, int l_facc_type,
     VRFY((ret_pl >= 0), "H5P_FILE_ACCESS");
 
     if (l_facc_type == FACC_DEFAULT)
-  return (ret_pl);
+	return (ret_pl);
 
     if (l_facc_type == FACC_MPIO){
-  /* set Parallel access with communicator */
-  ret = H5Pset_fapl_mpio(ret_pl, comm, info);
-  VRFY((ret >= 0), "");
-  return(ret_pl);
+	/* set Parallel access with communicator */
+	ret = H5Pset_fapl_mpio(ret_pl, comm, info);
+	VRFY((ret >= 0), "");
+	return(ret_pl);
     }
 
     if (l_facc_type == (FACC_MPIO | FACC_SPLIT)){
-  hid_t mpio_pl;
-
-  mpio_pl = H5Pcreate (H5P_FILE_ACCESS);
-  VRFY((mpio_pl >= 0), "");
-  /* set Parallel access with communicator */
-  ret = H5Pset_fapl_mpio(mpio_pl, comm, info);
-  VRFY((ret >= 0), "");
-
-  /* setup file access template */
-  ret_pl = H5Pcreate (H5P_FILE_ACCESS);
-  VRFY((ret_pl >= 0), "");
-  /* set Parallel access with communicator */
-  ret = H5Pset_fapl_split(ret_pl, ".meta", mpio_pl, ".raw", mpio_pl);
-  VRFY((ret >= 0), "H5Pset_fapl_split succeeded");
-  H5Pclose(mpio_pl);
-  return(ret_pl);
+	hid_t mpio_pl;
+
+	mpio_pl = H5Pcreate (H5P_FILE_ACCESS);
+	VRFY((mpio_pl >= 0), "");
+	/* set Parallel access with communicator */
+	ret = H5Pset_fapl_mpio(mpio_pl, comm, info);
+	VRFY((ret >= 0), "");
+
+	/* setup file access template */
+	ret_pl = H5Pcreate (H5P_FILE_ACCESS);
+	VRFY((ret_pl >= 0), "");
+	/* set Parallel access with communicator */
+	ret = H5Pset_fapl_split(ret_pl, ".meta", mpio_pl, ".raw", mpio_pl);
+	VRFY((ret >= 0), "H5Pset_fapl_split succeeded");
+	H5Pclose(mpio_pl);
+	return(ret_pl);
     }
 
     if (l_facc_type == FACC_MPIPOSIX) {
-  /* set Parallel access with communicator */
-  ret = H5Pset_fapl_mpiposix(ret_pl, comm, use_gpfs);
-  VRFY((ret >= 0), "H5Pset_fapl_mpiposix succeeded");
-  return(ret_pl);
+	/* set Parallel access with communicator */
+	ret = H5Pset_fapl_mpiposix(ret_pl, comm, use_gpfs);
+	VRFY((ret >= 0), "H5Pset_fapl_mpiposix succeeded");
+	return(ret_pl);
     }
 
     /* unknown file access types */
@@ -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;
+    int mpi_size, mpi_rank;				/* mpi variables */
 
     /* Un-buffer the stdout and stderr */
     setbuf(stderr, NULL);
@@ -4830,9 +5056,10 @@ int main(int argc, char **argv)
     dim1 = COL_FACTOR*mpi_size;
 
     if (MAINPROCESS){
-  printf("===================================\n");
-  printf("Shape Same Tests Start\n");
-  printf("===================================\n");
+	printf("===================================\n");
+	printf("Shape Same Tests Start\n");
+        printf("	express_test = %d.\n", GetTestExpress());
+	printf("===================================\n");
     }
 
     /* Attempt to turn off atexit post processing so that in case errors
@@ -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,24 +5077,26 @@ 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);
+	"Shape Same, contigous hyperslab, ind IO, contig datasets", PARATESTFILE);
     AddTest("sscontig2", sscontig2, NULL,
-  "Shape Same, contigous hyperslab, col IO, contig datasets", PARATESTFILE);
+	"Shape Same, contigous hyperslab, col IO, contig datasets", PARATESTFILE);
     AddTest("sscontig3", sscontig3, NULL,
-  "Shape Same, contigous hyperslab, ind IO, chunked datasets", PARATESTFILE);
+	"Shape Same, contigous hyperslab, ind IO, chunked datasets", PARATESTFILE);
     AddTest("sscontig4", sscontig4, NULL,
-  "Shape Same, contigous hyperslab, col IO, chunked datasets", PARATESTFILE);
+	"Shape Same, contigous hyperslab, col IO, chunked datasets", PARATESTFILE);
+#endif
 
     /* Shape Same tests using checker board hyperslab */
     AddTest("sschecker1", sschecker1, NULL,
-  "Shape Same, checker hyperslab, ind IO, contig datasets", PARATESTFILE);
+	"Shape Same, checker hyperslab, ind IO, contig datasets", PARATESTFILE);
     AddTest("sschecker2", sschecker2, NULL,
-  "Shape Same, checker hyperslab, col IO, contig datasets", PARATESTFILE);
+	"Shape Same, checker hyperslab, col IO, contig datasets", PARATESTFILE);
     AddTest("sschecker3", sschecker3, NULL,
-  "Shape Same, checker hyperslab, ind IO, chunked datasets", PARATESTFILE);
+	"Shape Same, checker hyperslab, ind IO, chunked datasets", PARATESTFILE);
     AddTest("sschecker4", sschecker4, NULL,
-  "Shape Same, checker hyperslab, col IO, chunked datasets", PARATESTFILE);
+	"Shape Same, checker hyperslab, col IO, chunked datasets", PARATESTFILE);
 
     /* Display testing information */
     TestInfo(argv[0]);
@@ -4880,15 +5109,15 @@ int main(int argc, char **argv)
     TestParseCmdLine(argc, argv);
 
     if (facc_type == FACC_MPIPOSIX && MAINPROCESS){
-  printf("===================================\n"
-         "   Using MPIPOSIX driver\n"
-         "===================================\n");
+	printf("===================================\n"
+	       "   Using MPIPOSIX driver\n"
+	       "===================================\n");
     }
 
     if (dxfer_coll_type == DXFER_INDEPENDENT_IO && MAINPROCESS){
-  printf("===================================\n"
-         "   Using Independent I/O with file set view to replace collective I/O \n"
-         "===================================\n");
+	printf("===================================\n"
+	       "   Using Independent I/O with file set view to replace collective I/O \n"
+	       "===================================\n");
     }
 
 
@@ -4913,16 +5142,16 @@ int main(int argc, char **argv)
     {
         int temp;
         MPI_Allreduce(&nerrors, &temp, 1, MPI_INT, MPI_MAX, MPI_COMM_WORLD);
-  nerrors=temp;
+	nerrors=temp;
     }
 
-    if (MAINPROCESS){    /* only process 0 reports */
-  printf("===================================\n");
-  if (nerrors)
-      printf("***PHDF5 tests detected %d errors***\n", nerrors);
-  else
-      printf("PHDF5 tests finished with no errors\n");
-  printf("===================================\n");
+    if (MAINPROCESS){		/* only process 0 reports */
+	printf("===================================\n");
+	if (nerrors)
+	    printf("***Shape Same tests detected %d errors***\n", nerrors);
+	else
+	    printf("Shape Same tests finished with no errors\n");
+	printf("===================================\n");
     }
     /* close HDF5 library */
     H5close();