[svn-r19092] Description:

	Bring "shape same" changes from LBL branch to trunk.  These changes
allow shapes that are the same, but projected into dataspaces with different
ranks to be detected correctly, and also contains code to project a dataspace
into greater/lesser number of dimensions, so the I/O can proceed in a faster
way.

	These changes also contain several bug fixes and _lots_ of code
cleanups to the MPI datatype creation code.

	Many other misc. code cleanup are included as well...

Tested on:
        FreeBSD/32 6.3 (duty) in debug mode
        FreeBSD/64 6.3 (liberty) w/C++ & FORTRAN, in debug mode
        Linux/32 2.6 (jam) w/PGI compilers, w/default API=1.8.x,
                w/C++ & FORTRAN, w/threadsafe, in debug mode
        Linux/64-amd64 2.6 (amani) w/Intel compilers, w/default API=1.6.x,
                w/C++ & FORTRAN, in production mode
        Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
                w/szip filter, in production mode
        Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
                in production mode
        Linux/64-amd64 2.6 (abe) w/parallel, w/FORTRAN, in debug mode
        Mac OS X/32 10.6.3 (amazon) in debug mode
        Mac OS X/32 10.6.3 (amazon) w/C++ & FORTRAN, w/threadsafe,
                in production mode

1 files changed, 5066 insertions, 178 deletions

diff --git a/test/tselect.c b/test/tselect.c
index b8c59d8..89cd9e5 100644
--- a/test/tselect.c
+++ b/test/tselect.c
@@ -159,6 +159,9 @@
 #define SPACERE5_DIM3            12
 #define SPACERE5_DIM4            8
 
+/* #defines for shape same / different rank tests */
+#define SS_DR_MAX_RANK		5
+
 
 
 /* Location comparison function */
@@ -1585,6 +1588,2031 @@ test_select_hyper_contig3(hid_t dset_type, hid_t xfer_plist)
     HDfree(rbuf);
 }   /* test_select_hyper_contig3() */
 
+
+/****************************************************************
+**
+**  verify_select_hyper_contig_dr__run_test(): Verify data from
+**      test_select_hyper_contig_dr__run_test()
+**
+****************************************************************/
+static void
+verify_select_hyper_contig_dr__run_test(const uint16_t *cube_buf,
+    size_t cube_size, unsigned edge_size, unsigned cube_rank)
+{
+    const uint16_t     *cube_ptr;           /* Pointer into the cube buffer */
+    uint16_t		expected_value;     /* Expected value in dataset */
+    unsigned            i, j, k, l, m;      /* Local index variables */
+    size_t              s;                  /* Local index variable */
+    hbool_t		mis_match;          /* Flag to indicate mis-match in expected value */
+
+    HDassert(cube_buf);
+    HDassert(cube_size > 0);
+
+    expected_value = 0;
+    mis_match = FALSE;
+    cube_ptr = cube_buf;
+    s = 0;
+    i = 0;
+    do {
+        j = 0;
+        do {
+            k = 0;
+            do {
+                l = 0;
+                do {
+                    m = 0;
+                    do {
+                        /* Sanity check */
+                        HDassert(s < cube_size);
+
+                        /* Check for correct value */
+                        if(*cube_ptr != expected_value)
+                            mis_match = TRUE;
+
+                        /* Advance to next element */
+                        cube_ptr++;
+                        expected_value++;
+                        s++;       
+                        m++;       
+                    } while((cube_rank > 0) && (m < edge_size));
+                    l++;
+                } while((cube_rank > 1) && (l < edge_size));
+                k++;
+            } while((cube_rank > 2) && (k < edge_size));
+            j++;
+        } while((cube_rank > 3) && (j < edge_size));
+        i++;
+    } while((cube_rank > 4) && (i < edge_size));
+    if(mis_match)
+        TestErrPrintf("Initial cube data don't match! Line = %d\n", __LINE__);
+}   /* verify_select_hyper_contig_dr__run_test() */
+
+
+/****************************************************************
+**
+**  test_select_hyper_contig_dr__run_test(): Test H5S (dataspace) 
+**	selection code with contiguous source and target having 
+**	different ranks but the same shape.  We have already
+**	tested H5S_shape_same in isolation, so now we try to do 
+**	I/O.
+**
+****************************************************************/
+static void
+test_select_hyper_contig_dr__run_test(int test_num, const uint16_t *cube_buf,
+    const uint16_t *zero_buf, unsigned edge_size, unsigned chunk_edge_size,
+    unsigned small_rank, unsigned large_rank, hid_t dset_type, hid_t xfer_plist)
+{
+    hbool_t		mis_match;              /* Flag indicating a value read in wasn't what was expected */
+    hid_t               fapl;                   /* File access property list */
+    hid_t		fid1;		        /* File ID */
+    hid_t		small_cube_sid;         /* Dataspace ID for small cube in memory & file */
+    hid_t		mem_large_cube_sid;     /* Dataspace ID for large cube in memory */
+    hid_t		file_large_cube_sid;    /* Dataspace ID for large cube in file */
+    hid_t		small_cube_dcpl_id = H5P_DEFAULT;   /* DCPL for small cube dataset */
+    hid_t		large_cube_dcpl_id = H5P_DEFAULT;   /* DCPL for large cube dataset */
+    hid_t		small_cube_dataset;	/* Dataset ID */
+    hid_t		large_cube_dataset;	/* Dataset ID */
+    size_t              start_index;            /* Offset within buffer to begin inspecting */
+    size_t              stop_index;             /* Offset within buffer to end inspecting */
+    uint16_t		expected_value;         /* Expected value in dataset */
+    uint16_t	      * small_cube_buf_1;       /* Buffer for small cube data */
+    uint16_t	      * large_cube_buf_1;       /* Buffer for large cube data */
+    uint16_t	      * ptr_1;                  /* Temporary pointer into cube data */
+    hsize_t		dims[SS_DR_MAX_RANK];   /* Dataspace dimensions */
+    hsize_t     	start[SS_DR_MAX_RANK];  /* Shared hyperslab start offset */
+    hsize_t     	stride[SS_DR_MAX_RANK]; /* Shared hyperslab stride */
+    hsize_t     	count[SS_DR_MAX_RANK];  /* Shared hyperslab count */
+    hsize_t     	block[SS_DR_MAX_RANK];  /* Shared hyperslab block size */
+    hsize_t	      * start_ptr;          /* Actual hyperslab start offset */
+    hsize_t	      * stride_ptr;         /* Actual hyperslab stride */
+    hsize_t	      * count_ptr;          /* Actual hyperslab count */
+    hsize_t	      * block_ptr;          /* Actual hyperslab block size */
+    size_t              small_cube_size;    /* Number of elements in small cube */
+    size_t              large_cube_size;    /* Number of elements in large cube */
+    unsigned            u, v, w, x;     /* Local index variables */
+    size_t              s;              /* Local index variable */
+    htri_t      	check;          /* Shape comparison return value */
+    herr_t      	ret;            /* Generic return value */
+
+    MESSAGE(7, ("\tn-cube slice through m-cube I/O test %d.\n", test_num));
+    MESSAGE(7, ("\tranks = %u/%u, edge_size = %u, chunk_edge_size = %u.\n", small_rank, large_rank, edge_size, chunk_edge_size));
+
+    HDassert(edge_size >= 6);
+    HDassert(edge_size >= chunk_edge_size);
+    HDassert((chunk_edge_size == 0) || (chunk_edge_size >= 3));
+    HDassert(small_rank > 0);
+    HDassert(small_rank < large_rank);
+    HDassert(large_rank <= SS_DR_MAX_RANK);
+
+    /* Compute cube sizes */
+    small_cube_size = large_cube_size = (size_t)1;
+    for(u = 0; u < large_rank; u++) {
+        if(u < small_rank)
+            small_cube_size *= (size_t)edge_size;
+
+        large_cube_size *= (size_t)edge_size;
+    } /* end for */
+
+    HDassert(large_cube_size < (size_t)UINT_MAX);
+
+    /* set up the start, stride, count, and block pointers */
+    start_ptr  = &(start[SS_DR_MAX_RANK - large_rank]);
+    stride_ptr = &(stride[SS_DR_MAX_RANK - large_rank]);
+    count_ptr  = &(count[SS_DR_MAX_RANK - large_rank]);
+    block_ptr  = &(block[SS_DR_MAX_RANK - large_rank]);
+
+    /* Allocate buffers */
+    small_cube_buf_1 = (uint16_t *)HDcalloc(sizeof(uint16_t), small_cube_size);
+    CHECK(small_cube_buf_1, NULL, "HDcalloc");
+    large_cube_buf_1 = (uint16_t *)HDcalloc(sizeof(uint16_t), large_cube_size);
+    CHECK(large_cube_buf_1, NULL, "HDcalloc");
+
+    /* Create a dataset transfer property list */
+    fapl = H5Pcreate(H5P_FILE_ACCESS);
+    CHECK(fapl, FAIL, "H5Pcreate");
+
+    /* Use the 'core' VFD for this test */
+    ret = H5Pset_fapl_core(fapl, (size_t)(1024 * 1024), FALSE);
+    CHECK(ret, FAIL, "H5Pset_fapl_core");
+
+    /* Create file */
+    fid1 = H5Fcreate(FILENAME, H5F_ACC_TRUNC, H5P_DEFAULT, fapl);
+    CHECK(fid1, FAIL, "H5Fcreate");
+
+    /* Close file access property list */
+    ret = H5Pclose(fapl);
+    CHECK(ret, FAIL, "H5Pclose");
+
+    /* setup dims: */
+    dims[0] = dims[1] = dims[2] = dims[3] = dims[4] = (hsize_t)edge_size;
+
+    /* Create small cube dataspaces */
+    small_cube_sid = H5Screate_simple((int)small_rank, dims, NULL);
+    CHECK(small_cube_sid, FAIL, "H5Screate_simple");
+
+    /* Create large cube dataspace */
+    mem_large_cube_sid = H5Screate_simple((int)large_rank, dims, NULL);
+    CHECK(mem_large_cube_sid, FAIL, "H5Screate_simple");
+    file_large_cube_sid = H5Screate_simple((int)large_rank, dims, NULL);
+    CHECK(file_large_cube_sid, FAIL, "H5Screate_simple");
+
+    /* 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) {
+        hsize_t		chunk_dims[SS_DR_MAX_RANK];     /* Chunk dimensions */
+
+        chunk_dims[0] = chunk_dims[1] = 
+		chunk_dims[2] = chunk_dims[3] = chunk_dims[4] = (hsize_t)chunk_edge_size;
+
+        small_cube_dcpl_id = H5Pcreate(H5P_DATASET_CREATE);
+        CHECK(small_cube_dcpl_id, FAIL, "H5Pcreate");
+
+        ret = H5Pset_layout(small_cube_dcpl_id, H5D_CHUNKED);
+        CHECK(ret, FAIL, "H5Pset_layout");
+
+        ret = H5Pset_chunk(small_cube_dcpl_id, (int)small_rank, chunk_dims);
+        CHECK(ret, FAIL, "H5Pset_chunk");
+
+
+        large_cube_dcpl_id = H5Pcreate(H5P_DATASET_CREATE);
+        CHECK(large_cube_dcpl_id, FAIL, "H5Pcreate");
+
+        ret = H5Pset_layout(large_cube_dcpl_id, H5D_CHUNKED);
+        CHECK(ret, FAIL, "H5Pset_layout");
+
+        ret = H5Pset_chunk(large_cube_dcpl_id, (int)large_rank, chunk_dims);
+        CHECK(ret, FAIL, "H5Pset_chunk");
+    } /* end if */
+
+    /* create the small cube dataset */
+    small_cube_dataset = H5Dcreate2(fid1, "small_cube_dataset", dset_type, 
+            small_cube_sid, H5P_DEFAULT, small_cube_dcpl_id, H5P_DEFAULT);
+    CHECK(small_cube_dataset, FAIL, "H5Dcreate2");
+
+    /* Close non-default small dataset DCPL */
+    if(small_cube_dcpl_id != H5P_DEFAULT) {
+        ret = H5Pclose(small_cube_dcpl_id);
+        CHECK(ret, FAIL, "H5Pclose");
+    } /* end if */
+
+    /* create the large cube dataset */
+    large_cube_dataset = H5Dcreate2(fid1, "large_cube_dataset", dset_type, 
+            file_large_cube_sid, H5P_DEFAULT, large_cube_dcpl_id, H5P_DEFAULT);
+    CHECK(large_cube_dataset, FAIL, "H5Dcreate2");
+
+    /* Close non-default large dataset DCPL */
+    if(large_cube_dcpl_id != H5P_DEFAULT) {
+        ret = H5Pclose(large_cube_dcpl_id);
+        CHECK(ret, FAIL, "H5Pclose");
+    } /* end if */
+
+
+    /* write initial data to the on disk datasets */
+    ret = H5Dwrite(small_cube_dataset, H5T_NATIVE_UINT16, small_cube_sid, 
+            small_cube_sid, xfer_plist, cube_buf);
+    CHECK(ret, FAIL, "H5Dwrite");
+
+    ret = H5Dwrite(large_cube_dataset, H5T_NATIVE_UINT16, mem_large_cube_sid, 
+            file_large_cube_sid, xfer_plist, cube_buf);
+    CHECK(ret, FAIL, "H5Dwrite");
+
+    /* read initial data from disk and verify that it is as expected. */
+    ret = H5Dread(small_cube_dataset, H5T_NATIVE_UINT16, small_cube_sid, 
+        small_cube_sid, xfer_plist, small_cube_buf_1);
+    CHECK(ret, FAIL, "H5Dread");
+
+    /* Check that the data is valid */
+    verify_select_hyper_contig_dr__run_test(small_cube_buf_1, small_cube_size,
+        edge_size, small_rank);
+
+    ret = H5Dread(large_cube_dataset, H5T_NATIVE_UINT16, mem_large_cube_sid, 
+        file_large_cube_sid, xfer_plist, large_cube_buf_1);
+    CHECK(ret, FAIL, "H5Dread");
+
+    /* Check that the data is valid */
+    verify_select_hyper_contig_dr__run_test(large_cube_buf_1, large_cube_size,
+        edge_size, large_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 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.
+     */
+
+    
+    /* set up start, stride, count, and block -- note that we will
+     * change start[] so as to read slices of the large cube.
+     */
+    for(u = 0; u < SS_DR_MAX_RANK; u++) {
+        start[u] = 0;
+        stride[u] = 1;
+        count[u] = 1;
+        if((SS_DR_MAX_RANK - u) > small_rank)
+            block[u] = 1;
+        else
+            block[u] = (hsize_t)edge_size;
+    } /* end for */
+
+    u = 0;
+    do {
+        v = 0;
+        do {
+            w = 0;
+            do {
+                x = 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)u;
+                    start[1] = (hsize_t)v;
+                    start[2] = (hsize_t)w;
+                    start[3] = (hsize_t)x;
+                    start[4] = (hsize_t)0;
+
+                    ret = H5Sselect_hyperslab(file_large_cube_sid, 
+                                              H5S_SELECT_SET,
+                                              start_ptr, 
+                                              stride_ptr, 
+                                              count_ptr, 
+                                              block_ptr);
+                    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+                    /* verify that H5S_select_shape_same() reports the two 
+                     * selections as having the same shape.
+                     */
+                    check = H5S_select_shape_same_test(small_cube_sid, 
+                                                       file_large_cube_sid);
+                    VERIFY(check, TRUE, "H5S_select_shape_same_test");
+
+                    /* Read selection from disk */
+                    ret = H5Dread(large_cube_dataset,
+                                  H5T_NATIVE_UINT16,
+                                  small_cube_sid,
+                                  file_large_cube_sid,
+                                  xfer_plist,
+                                  small_cube_buf_1);
+                    CHECK(ret, FAIL, "H5Dread");
+
+                    /* verify that expected data is retrieved */
+                    mis_match = FALSE;
+                    ptr_1 = small_cube_buf_1;
+                    expected_value = (uint16_t)((u * edge_size * edge_size * edge_size * edge_size) +
+                                     (v * edge_size * edge_size * edge_size) +
+                                     (w * edge_size * edge_size) +
+                                     (x * edge_size));
+                    for(s = 0; s < small_cube_size; s++ ) {
+                        if(*ptr_1 != expected_value )
+                            mis_match = TRUE;
+                        ptr_1++;
+                        expected_value++;
+                    } /* end for */
+                    if(mis_match)
+                        TestErrPrintf("small cube read from largecube has bad data! Line=%d\n",__LINE__);
+
+                    x++;
+                } while((large_rank >= 2) && (small_rank <= 1) && (x < edge_size));
+                w++;
+            } while((large_rank >= 3) && (small_rank <= 2) && (w < edge_size));
+            v++;
+        } while((large_rank >= 4) && (small_rank <= 3) && (v < edge_size));
+        u++;
+    } while((large_rank >= 5) && (small_rank <= 4) && (u < edge_size));
+        
+
+    /* similarly, read the on disk small cube into slices through the in memory
+     * large cube, and verify that the correct data (and only the correct data)
+     * is read.
+     */
+
+    /* zero out the in-memory large cube */
+    HDmemset(large_cube_buf_1, 0, large_cube_size * sizeof(uint16_t));
+
+    u = 0;
+    do {
+        v = 0;
+        do {
+            w = 0;
+            do {
+                x = 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)u;
+                    start[1] = (hsize_t)v;
+                    start[2] = (hsize_t)w;
+                    start[3] = (hsize_t)x;
+                    start[4] = (hsize_t)0;
+
+                    ret = H5Sselect_hyperslab(mem_large_cube_sid, 
+                                              H5S_SELECT_SET,
+                                              start_ptr, 
+                                              stride_ptr, 
+                                              count_ptr, 
+                                              block_ptr);
+                    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+
+                    /* verify that H5S_select_shape_same() reports the two 
+                     * selections as having the same shape.
+                     */
+                    check = H5S_select_shape_same_test(small_cube_sid, 
+                                                       mem_large_cube_sid);
+                    VERIFY(check, TRUE, "H5S_select_shape_same_test");
+
+
+                    /* Read selection from disk */
+                    ret = H5Dread(small_cube_dataset,
+                                  H5T_NATIVE_UINT16,
+                                  mem_large_cube_sid,
+                                  small_cube_sid,
+                                  xfer_plist,
+                                  large_cube_buf_1);
+                    CHECK(ret, FAIL, "H5Dread");
+
+
+                    /* verify that the expected data and only the 
+                     * expected data was read.
+                     */
+                    start_index = (u * edge_size * edge_size * edge_size * edge_size) +
+                                  (v * edge_size * edge_size * edge_size) +
+                                  (w * edge_size * edge_size) +
+                                  (x * edge_size);
+                    stop_index = start_index + small_cube_size - 1;
+
+                    HDassert(start_index < stop_index);
+                    HDassert(stop_index <= large_cube_size);
+
+                    mis_match = FALSE;
+                    ptr_1 = large_cube_buf_1;
+                    expected_value = 0;
+                    for(s = 0; s < start_index; s++) {
+                        if(*ptr_1 != 0)
+                            mis_match = TRUE;
+                        ptr_1++;
+                    } /* end for */
+                    for(; s <= stop_index; s++) {
+                        if(*ptr_1 != expected_value)
+                            mis_match = TRUE;
+                        expected_value++;
+                        ptr_1++;
+                    } /* end for */
+                    for(; s < large_cube_size; s++) {
+                        if(*ptr_1 != 0)
+                            mis_match = TRUE;
+                        ptr_1++;
+                    } /* end for */
+                    if(mis_match)
+                        TestErrPrintf("large cube read from small cube has bad data! Line=%u\n", __LINE__);
+
+                    /* Zero out the buffer for the next pass */
+                    HDmemset(large_cube_buf_1 + start_index, 0, small_cube_size * sizeof(uint16_t));
+                    
+                    x++;
+                } while((large_rank >= 2) && (small_rank <= 1) && (x < edge_size));
+                w++;
+            } while((large_rank >= 3) && (small_rank <= 2) && (w < edge_size));
+            v++;
+        } while((large_rank >= 4) && (small_rank <= 3) && (v < edge_size));
+        u++;
+    } while((large_rank >= 5) && (small_rank <= 4) && (u < edge_size));
+
+
+    /* 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 D slices from the in memory large cube, to 
+     * the the on disk small cube dataset.  After each write, read the small
+     * cube 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.
+     */ 
+
+    u = 0;
+    do {
+        v = 0;
+        do {
+            w = 0;
+            do {
+                x = 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 the on disk small cube */
+                    ret = H5Dwrite(small_cube_dataset, 
+                                   H5T_NATIVE_UINT16, 
+                                   small_cube_sid, 
+                                   small_cube_sid, 
+                                   xfer_plist, 
+                                   zero_buf);
+                    CHECK(ret, FAIL, "H5Dwrite");
+
+                    /* select the portion of the in memory large cube from which we 
+                     * are going to write data.
+                     */
+                    start[0] = (hsize_t)u;
+                    start[1] = (hsize_t)v;
+                    start[2] = (hsize_t)w;
+                    start[3] = (hsize_t)x;
+                    start[4] = (hsize_t)0;
+
+                    ret = H5Sselect_hyperslab(mem_large_cube_sid, 
+                                              H5S_SELECT_SET,
+                                              start_ptr, 
+                                              stride_ptr, 
+                                              count_ptr, 
+                                              block_ptr);
+                    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+
+                    /* verify that H5S_select_shape_same() reports the in 
+                     * memory slice through the cube selection and the 
+                     * on disk full small cube selections as having the same shape.
+                     */
+                    check = H5S_select_shape_same_test(small_cube_sid, 
+                                                       mem_large_cube_sid);
+                    VERIFY(check, TRUE, "H5S_select_shape_same_test");
+
+
+	            /* write the slice from the in memory large cube to the on disk small cube */
+                    ret = H5Dwrite(small_cube_dataset, 
+                                   H5T_NATIVE_UINT16, 
+                                   mem_large_cube_sid, 
+                                   small_cube_sid, 
+                                   xfer_plist, 
+                                   cube_buf);
+                    CHECK(ret, FAIL, "H5Dwrite");
+
+
+                    /* read the on disk small cube into memory */
+                    ret = H5Dread(small_cube_dataset, 
+                                  H5T_NATIVE_UINT16,
+                                  small_cube_sid,
+                                  small_cube_sid, 
+                                  xfer_plist, 
+                                  small_cube_buf_1);
+                    CHECK(ret, FAIL, "H5Dread");
+
+
+                    /* verify that expected data is retrieved */
+                    mis_match = FALSE;
+                    ptr_1 = small_cube_buf_1;
+                    expected_value = (uint16_t)((u * edge_size * edge_size * edge_size * edge_size) +
+                                     (v * edge_size * edge_size * edge_size) +
+                                     (w * edge_size * edge_size) +
+                                     (x * edge_size));
+                    for(s = 0; s < small_cube_size; s++) {
+                        if(*ptr_1 != expected_value)
+                            mis_match = TRUE;
+                        expected_value++;
+                        ptr_1++;
+                    } /* end for */
+                    if(mis_match )
+                        TestErrPrintf("small cube data don't match! Line=%d\n",__LINE__);
+                    
+                    x++;
+                } while((large_rank >= 2) && (small_rank <= 1) && (x < edge_size));
+                w++;
+            } while((large_rank >= 3) && (small_rank <= 2) && (w < edge_size));
+            v++;
+        } while((large_rank >= 4) && (small_rank <= 3) && (v < edge_size));
+        u++;
+    } while((large_rank >= 5) && (small_rank <= 4) && (u < edge_size));
+
+
+    /* Now write the contents of the in memory small cube to slices of 
+     * the on disk cube.  After each write, read the on disk cube
+     * into memeory, and verify that it contains the expected 
+     * data.  Verify that H5S_select_shape_same() returns true on 
+     * the memory and file selections.
+     */
+
+    /* select the entire memory and file cube dataspaces */
+    ret = H5Sselect_all(mem_large_cube_sid);
+    CHECK(ret, FAIL, "H5Sselect_all");
+
+    ret = H5Sselect_all(file_large_cube_sid);
+    CHECK(ret, FAIL, "H5Sselect_all");
+
+    u = 0;
+    do {
+        v = 0;
+        do {
+            w = 0;
+            do {
+                x = 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 the on disk cube */
+                    ret = H5Dwrite(large_cube_dataset, 
+                                   H5T_NATIVE_USHORT, 
+                                   mem_large_cube_sid, 
+                                   file_large_cube_sid, 
+                                   xfer_plist, 
+                                   zero_buf);
+                    CHECK(ret, FAIL, "H5Dwrite");
+
+
+                    /* select the portion of the in memory large cube to which we 
+                     * are going to write data.
+                     */
+                    start[0] = (hsize_t)u;
+                    start[1] = (hsize_t)v;
+                    start[2] = (hsize_t)w;
+                    start[3] = (hsize_t)x;
+                    start[4] = (hsize_t)0;
+
+                    ret = H5Sselect_hyperslab(file_large_cube_sid, 
+                                              H5S_SELECT_SET,
+                                              start_ptr, 
+                                              stride_ptr, 
+                                              count_ptr, 
+                                              block_ptr);
+                    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+
+                    /* verify that H5S_select_shape_same() reports the in 
+                     * memory full selection of the small cube and the 
+                     * on disk slice through the large cube selection 
+                     * as having the same shape.
+                     */
+                    check = H5S_select_shape_same_test(small_cube_sid, 
+                                                       file_large_cube_sid);
+                    VERIFY(check, TRUE, "H5S_select_shape_same_test");
+
+
+	            /* write the cube from memory to the target slice of the disk cube */
+                    ret = H5Dwrite(large_cube_dataset, 
+                                   H5T_NATIVE_UINT16, 
+                                   small_cube_sid, 
+                                   file_large_cube_sid, 
+                                   xfer_plist, 
+                                   cube_buf);
+                    CHECK(ret, FAIL, "H5Dwrite");
+
+
+                    /* read the on disk cube into memory */
+                    ret = H5Sselect_all(file_large_cube_sid);
+                    CHECK(ret, FAIL, "H5Sselect_all");
+
+                    ret = H5Dread(large_cube_dataset, 
+                                  H5T_NATIVE_UINT16,
+                                  mem_large_cube_sid,
+                                  file_large_cube_sid, 
+                                  xfer_plist, 
+                                  large_cube_buf_1);
+                    CHECK(ret, FAIL, "H5Dread");
+
+
+                    /* verify that the expected data and only the 
+                     * expected data was read.
+                     */
+                    start_index = (u * edge_size * edge_size * edge_size * edge_size) +
+                                  (v * edge_size * edge_size * edge_size) +
+                                  (w * edge_size * edge_size) +
+                                  (x * edge_size);
+                    stop_index = start_index + small_cube_size - 1;
+
+                    HDassert(start_index < stop_index);
+                    HDassert(stop_index <= large_cube_size);
+
+                    mis_match = FALSE;
+                    ptr_1 = large_cube_buf_1;
+                    expected_value = 0;
+                    for(s = 0; s < start_index; s++) {
+                        if(*ptr_1 != 0)
+                            mis_match = TRUE;
+                        ptr_1++;
+                    } /* end for */
+                    for(; s <= stop_index; s++) {
+                        if(*ptr_1 != expected_value)
+                            mis_match = TRUE;
+                        expected_value++;
+                        ptr_1++;
+                    } /* end for */
+                    for(; s < large_cube_size; s++) {
+                        if(*ptr_1 != 0)
+                            mis_match = TRUE;
+                        ptr_1++;
+                    } /* end for */
+                    if(mis_match)
+                        TestErrPrintf("large cube written from small cube has bad data! Line=%d\n", __LINE__);
+                    
+                    x++;
+                } while((large_rank >= 2) && (small_rank <= 1) && (x < edge_size));
+                w++;
+            } while((large_rank >= 3) && (small_rank <= 2) && (w < edge_size));
+            v++;
+        } while((large_rank >= 4) && (small_rank <= 3) && (v < edge_size));
+        u++;
+    } while((large_rank >= 5) && (small_rank <= 4) && (u < edge_size));
+
+    /* Close memory dataspaces */
+    ret = H5Sclose(small_cube_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(mem_large_cube_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+
+    /* Close disk dataspace */
+    ret = H5Sclose(file_large_cube_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+
+    /* Close Datasets */
+    ret = H5Dclose(small_cube_dataset);
+    CHECK(ret, FAIL, "H5Dclose");
+
+    ret = H5Dclose(large_cube_dataset);
+    CHECK(ret, FAIL, "H5Dclose");
+
+    /* Close file */
+    ret = H5Fclose(fid1);
+    CHECK(ret, FAIL, "H5Fclose");
+
+    /* Free memory buffers */
+    HDfree(small_cube_buf_1);
+    HDfree(large_cube_buf_1);
+
+}   /* test_select_hyper_contig_dr__run_test() */
+
+
+/****************************************************************
+**
+**  test_select_hyper_contig_dr(): Test H5S (dataspace) 
+**	selection code with contiguous source and target having 
+**	different ranks but the same shape.  We have already
+**	tested H5S_shape_same in isolation, so now we try to do 
+**	I/O.
+**
+****************************************************************/
+static void
+test_select_hyper_contig_dr(hid_t dset_type, hid_t xfer_plist)
+{
+    int test_num = 0;
+    unsigned chunk_edge_size;   /* Size of chunk's dataspace dimensions */
+    unsigned edge_size = 6;     /* Size of dataset's dataspace dimensions */
+    unsigned small_rank;        /* Current rank of small dataset */
+    unsigned large_rank;        /* Current rank of large dataset */
+    uint16_t *cube_buf;         /* Buffer for writing cube data */
+    uint16_t *zero_buf;         /* Buffer for writing zeroed cube data */
+    uint16_t *cube_ptr;         /* Temporary pointer into cube data */
+    unsigned max_rank = 5;      /* Max. rank to use */
+    size_t max_cube_size;       /* Max. number of elements in largest cube */
+    size_t s;                   /* Local index variable */
+    unsigned u;                 /* Local index variable */
+
+    /* Output message about test being performed */
+    MESSAGE(5, ("Testing Contiguous Hyperslabs With Different Rank I/O Functionality\n"));
+
+    /* Compute max. cube size */
+    max_cube_size = (size_t)1;
+    for(u = 0; u < max_rank; u++)
+        max_cube_size *= (size_t)edge_size;
+
+    /* Allocate cube buffer for writing values */
+    cube_buf = (uint16_t *)HDmalloc(sizeof(uint16_t) * max_cube_size);
+    CHECK(cube_buf, NULL, "HDmalloc");
+
+    /* Initialize the cube buffer */
+    cube_ptr = cube_buf;
+    for(s = 0; s < max_cube_size; s++)
+        *cube_ptr++ = (uint16_t)s;
+
+    /* Allocate cube buffer for zeroing values on disk */
+    zero_buf = (uint16_t *)HDcalloc(sizeof(uint16_t), max_cube_size);
+    CHECK(zero_buf, NULL, "HDcalloc");
+
+    for(large_rank = 1; large_rank <= max_rank; large_rank++) {
+        for(small_rank = 1; small_rank < large_rank; small_rank++) {
+            chunk_edge_size = 0;
+            test_select_hyper_contig_dr__run_test(test_num, cube_buf, zero_buf,
+                    edge_size, chunk_edge_size, small_rank, large_rank,
+                    dset_type, xfer_plist);
+            test_num++;
+
+            chunk_edge_size = 3;
+            test_select_hyper_contig_dr__run_test(test_num, cube_buf, zero_buf,
+                    edge_size, chunk_edge_size, small_rank, large_rank,
+                    dset_type, xfer_plist);
+            test_num++;
+        } /* for loop on small rank */
+    } /* for loop on large rank */
+
+    HDfree(cube_buf);
+    HDfree(zero_buf);
+
+}   /* test_select_hyper_contig_dr() */
+
+
+/****************************************************************
+**
+**  test_select_hyper_checker_board_dr__select_checker_board():  
+**	Given an n-cube data space with each edge of length 
+**	edge_size, and a checker_edge_size either select a checker
+**	board selection of the entire cube(if sel_rank == n),
+**	or select a checker board selection of a
+**	sel_rank dimensional slice through n-cube parallel to the 
+**      sel_rank fastest changing indices, with origin (in the
+**	higher indices) as indicated by the start array.
+**
+**	Note that this function, like all its relatives, is
+**	hard coded to presume a maximum n-cube 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 -- 9/9/09
+**
+****************************************************************/
+static void
+test_select_hyper_checker_board_dr__select_checker_board(hid_t tgt_n_cube_sid,
+    unsigned tgt_n_cube_rank, unsigned edge_size, unsigned checker_edge_size,
+    unsigned sel_rank, hsize_t sel_start[])
+{
+    hbool_t		first_selection = TRUE;
+    unsigned		n_cube_offset;
+    unsigned		sel_offset;
+    hsize_t		base_count;
+    hsize_t             offset_count;
+    hsize_t     	start[SS_DR_MAX_RANK];  /* Offset of hyperslab selection */
+    hsize_t     	stride[SS_DR_MAX_RANK]; /* Stride of hyperslab selection */
+    hsize_t     	count[SS_DR_MAX_RANK];  /* Count of hyperslab selection */
+    hsize_t     	block[SS_DR_MAX_RANK];  /* Block size of hyperslab selection */
+    unsigned            i, j, k, l, m;  /* Local index variable */
+    unsigned            u;              /* Local index variables */
+    herr_t      	ret;            /* Generic return value */
+
+    HDassert(edge_size >= 6);
+    HDassert(0 < checker_edge_size);
+    HDassert(checker_edge_size <= edge_size);
+    HDassert(0 < sel_rank);
+    HDassert(sel_rank <= tgt_n_cube_rank);
+    HDassert(tgt_n_cube_rank <= SS_DR_MAX_RANK);
+
+    sel_offset = SS_DR_MAX_RANK - sel_rank;
+    n_cube_offset = SS_DR_MAX_RANK - tgt_n_cube_rank;
+    HDassert(n_cube_offset <= sel_offset);
+
+    /* First, compute the base count (which assumes start == 0
+     * for the associated offset) and offset_count (which
+     * assumes start == checker_edge_size for the associated
+     * offset).
+     */
+    base_count = edge_size / (checker_edge_size * 2);
+    if((edge_size % (checker_edge_size * 2)) > 0)
+        base_count++;
+
+    offset_count = (edge_size - checker_edge_size) / (checker_edge_size * 2);
+    if(((edge_size - checker_edge_size) % (checker_edge_size * 2)) > 0)
+        offset_count++;
+
+    /* Now set up the stride and block arrays, and portions of the start
+     * and count arrays that will not be altered during the selection of 
+     * the checker board.
+     */
+    u = 0;
+    while(u < n_cube_offset) {
+        /* these values should never be used */
+        start[u] = 0;
+        stride[u] = 0;
+        count[u] = 0;
+        block[u] = 0;
+
+        u++;
+    } /* end while */
+
+    while(u < sel_offset) {
+        start[u] = sel_start[u];
+        stride[u] = 2 * edge_size;
+        count[u] = 1;
+        block[u] = 1;
+
+        u++;
+    } /* end while */
+
+    while(u < SS_DR_MAX_RANK) {
+        stride[u] = 2 * checker_edge_size;
+        block[u] = checker_edge_size;
+
+        u++;
+    } /* end while */
+   
+    i = 0;
+    do {
+        if(0 >= sel_offset) {
+            if(i == 0) {
+                start[0] = 0;
+                count[0] = base_count;
+            } /* end if */
+            else {
+                start[0] = checker_edge_size;
+                count[0] = offset_count;
+            } /* end else */
+        } /* end if */
+
+        j = 0;
+        do { 
+            if(1 >= sel_offset) {
+                if(j == 0 ) {
+                    start[1] = 0;
+                    count[1] = base_count;
+                } /* end if */
+                else {
+                    start[1] = checker_edge_size;
+                    count[1] = offset_count;
+                } /* end else */
+            } /* end if */
+
+            k = 0;
+            do {
+                if(2 >= sel_offset) {
+                    if(k == 0) {
+                        start[2] = 0;
+                        count[2] = base_count;
+                    } /* end if */
+                    else {
+                        start[2] = checker_edge_size;
+                        count[2] = offset_count;
+                    } /* end else */
+                } /* end if */
+
+                l = 0;
+                do {
+                    if(3 >= sel_offset) {
+                        if(l == 0) {
+                            start[3] = 0;
+                            count[3] = base_count;
+                        } /* end if */
+                        else {
+                            start[3] = checker_edge_size;
+                            count[3] = offset_count;
+                        } /* end else */
+                    } /* end if */
+
+                    m = 0;
+                    do {
+                        if(4 >= sel_offset) {
+                            if(m == 0) {
+                                start[4] = 0;
+                                count[4] = base_count;
+                            } /* end if */
+                            else {
+                                start[4] = checker_edge_size;
+                                count[4] = offset_count;
+                            } /* end else */
+                        } /* end if */
+
+                        if(((i + j + k + l + m) % 2) == 0) {
+                            if(first_selection) {
+                                first_selection = FALSE; 
+
+                                ret = H5Sselect_hyperslab(tgt_n_cube_sid, 
+                                        H5S_SELECT_SET,
+                                        &(start[n_cube_offset]), 
+                                        &(stride[n_cube_offset]), 
+                                        &(count[n_cube_offset]), 
+                                        &(block[n_cube_offset]));
+                                CHECK(ret, FAIL, "H5Sselect_hyperslab");
+                            } /* end if */
+                            else {
+                                ret = H5Sselect_hyperslab(tgt_n_cube_sid, 
+                                        H5S_SELECT_OR,
+                                        &(start[n_cube_offset]), 
+                                        &(stride[n_cube_offset]), 
+                                        &(count[n_cube_offset]), 
+                                        &(block[n_cube_offset]));
+                                CHECK(ret, FAIL, "H5Sselect_hyperslab");
+                            } /* end else */
+                        } /* end if */
+
+                        m++;
+                    } while((m <= 1) && (4 >= sel_offset));
+                    l++;
+                } while((l <= 1) && (3 >= sel_offset));
+                k++;
+            } while((k <= 1) && (2 >= sel_offset));
+            j++;
+        } while((j <= 1) && (1 >= sel_offset));
+        i++;
+    } while((i <= 1) && (0 >= sel_offset));
+
+    /* Wierdness alert:
+     *
+     * Some how, it seems that selections can extend beyond the
+     * boundaries of the target data space -- hence the following
+     * code to manually clip the selection back to the data space
+     * proper.
+     */
+    for(u = 0; u < SS_DR_MAX_RANK; u++) {
+        start[u]  = 0;
+        stride[u] = edge_size;
+        count[u]  = 1;
+        block[u]  = edge_size;
+    } /* end for */
+
+    ret = H5Sselect_hyperslab(tgt_n_cube_sid, H5S_SELECT_AND, start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+} /* test_select_hyper_checker_board_dr__select_checker_board() */
+
+
+/****************************************************************
+**
+**  test_select_hyper_checker_board_dr__verify_data(): 
+**
+**	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 contain the results
+**	of read or writing a checkerboard selection of an 
+**	n-cube, or a checkerboard selection of an m (1 <= m < n)
+**	dimensional slice through an n-cube parallel to the 
+**      fastest changing indices.  
+**
+**	It is further presumed that the buffer was zeroed before
+**	the read, and that the n-cube was initialize with the 
+**      natural numbers listed in order from the origin along 
+**      the fastest changing axis.
+**
+**      Thus for a 10x10x10 3-cube, the value stored in location
+**	(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
+**
+**	Thus, if the buffer contains the result of reading a 
+**	checker board selection of a 10x10x10 3-cube, location
+**	(x, y, z) will contain zero if it is not in a checker,
+**	and 100x + 10y + z if (x, y, z) is in a checker.
+**
+**	If the buffer contains the result of reading a 3 
+**	dimensional slice (parallel to the three fastest changing
+**	indices) through an n cube (n > 3), then the expected 
+**	values in the buffer will be the same, save that we will
+**	add a constant determined by the origin of the 3-cube 
+**	in the n-cube.
+**
+**	Finally, the function presumes that the first element 
+**	of the buffer resides either at the origin of either
+**	a selected or an unselected checker.
+**
+****************************************************************/
+static hbool_t
+test_select_hyper_checker_board_dr__verify_data(uint16_t * buf_ptr,
+    unsigned rank, unsigned edge_size, unsigned checker_edge_size,
+    uint16_t first_expected_val, hbool_t buf_starts_in_checker)
+{
+    hbool_t good_data = TRUE;
+    hbool_t in_checker;
+    hbool_t start_in_checker[5];
+    uint16_t expected_value;
+    uint16_t * val_ptr;
+    unsigned i, j, k, l, m;              /* to track position in n-cube */
+    unsigned v, w, x, y, z;              /* to track position in checker */
+    const unsigned test_max_rank = 5;    /* code changes needed if this is increased */
+
+    HDassert(buf_ptr != NULL);
+    HDassert(0 < rank);
+    HDassert(rank <= test_max_rank);
+    HDassert(edge_size >= 6);
+    HDassert(0 < checker_edge_size);
+    HDassert(checker_edge_size <= edge_size);
+    HDassert(test_max_rank <= SS_DR_MAX_RANK);
+
+    val_ptr = buf_ptr;
+    expected_value = first_expected_val;
+
+    i = 0;
+    v = 0;
+    start_in_checker[0] = buf_starts_in_checker;
+    do {
+        if(v >= checker_edge_size) {
+            start_in_checker[0] = !start_in_checker[0];
+            v = 0;
+        } /* end if */
+
+        j = 0;
+        w = 0;
+        start_in_checker[1] = start_in_checker[0];
+        do {
+            if(w >= checker_edge_size) {
+                start_in_checker[1] = !start_in_checker[1];
+                w = 0;
+            } /* end if */
+
+            k = 0;
+            x = 0;
+            start_in_checker[2] = start_in_checker[1];
+            do {
+                if(x >= checker_edge_size) {
+                    start_in_checker[2] = !start_in_checker[2];
+                    x = 0;
+                } /* end if */
+
+                l = 0;
+                y = 0;
+                start_in_checker[3] = start_in_checker[2];
+                do { 
+                    if(y >= checker_edge_size) {
+                        start_in_checker[3] = ! start_in_checker[3];
+                        y = 0;
+                    } /* end if */
+
+                    m = 0;
+                    z = 0;
+                    in_checker = start_in_checker[3];
+                    do {
+                        if(z >= checker_edge_size) {
+                            in_checker = ! in_checker;
+                            z = 0;
+                        } /* end if */
+         
+                        if(in_checker) {
+                            if(*val_ptr != expected_value)
+                                good_data = FALSE;
+                        } /* end if */
+                        else {
+                            if(*val_ptr != 0)
+                                good_data = FALSE;
+                        } /* end else */
+ 
+                        val_ptr++;
+                        expected_value++;
+ 
+                        m++;
+                        z++;
+                    } while((rank >= (test_max_rank - 4)) && (m < edge_size));
+                    l++;
+                    y++;
+                } while((rank >= (test_max_rank - 3)) && (l < edge_size));
+                k++;
+                x++;
+            } while((rank >= (test_max_rank - 2)) && (k < edge_size));
+            j++;
+            w++;
+        } while((rank >= (test_max_rank - 1)) && (j < edge_size));
+        i++;
+        v++;
+    } while((rank >= test_max_rank) && (i < edge_size));
+
+    return(good_data);
+} /* test_select_hyper_checker_board_dr__verify_data() */
+
+
+/****************************************************************
+**
+**  test_select_hyper_checker_board_dr__run_test(): Test H5S 
+**      (dataspace) selection code with checker board source and 
+**	target selections having different ranks but the same 
+**	shape.  We have already tested H5S_shape_same in 
+**	isolation, so now we try to do I/O.
+**
+****************************************************************/
+static void
+test_select_hyper_checker_board_dr__run_test(int test_num, const uint16_t *cube_buf,
+    const uint16_t *zero_buf, unsigned edge_size, unsigned checker_edge_size,
+    unsigned chunk_edge_size, unsigned small_rank, unsigned large_rank,
+    hid_t dset_type, hid_t xfer_plist)
+{
+    hbool_t		data_ok;
+    hbool_t		start_in_checker[5];
+    hid_t               fapl;                   /* File access property list */
+    hid_t		fid;			/* HDF5 File IDs		*/
+    hid_t		full_small_cube_sid;    /* Dataspace for small cube w/all selection */
+    hid_t		mem_small_cube_sid;
+    hid_t		file_small_cube_sid;
+    hid_t		full_large_cube_sid;    /* Dataspace for large cube w/all selection */
+    hid_t		mem_large_cube_sid;
+    hid_t		file_large_cube_sid;
+    hid_t		small_cube_dcpl_id = H5P_DEFAULT;   /* DCPL for small cube dataset */
+    hid_t		large_cube_dcpl_id = H5P_DEFAULT;   /* DCPL for large cube dataset */
+    hid_t		small_cube_dataset;	/* Dataset ID			*/
+    hid_t		large_cube_dataset;	/* Dataset ID			*/
+    unsigned		small_rank_offset;      /* Rank offset of slice */
+    const unsigned	test_max_rank = 5;  /* must update code if this changes */
+    size_t              start_index;            /* Offset within buffer to begin inspecting */
+    size_t              stop_index;             /* Offset within buffer to end inspecting */
+    uint16_t		expected_value;
+    uint16_t	      * small_cube_buf_1;
+    uint16_t	      * large_cube_buf_1;
+    uint16_t	      * ptr_1;
+    size_t              small_cube_size;    /* Number of elements in small cube */
+    size_t              large_cube_size;    /* Number of elements in large cube */
+    hsize_t		dims[SS_DR_MAX_RANK];
+    hsize_t		chunk_dims[SS_DR_MAX_RANK];
+    hsize_t     	sel_start[SS_DR_MAX_RANK];
+    unsigned            u, v, w, x;     /* Local index variables */
+    size_t              s;              /* Local index variable */
+    htri_t      	check;          /* Shape comparison return value */
+    herr_t      	ret;            /* Generic return value */
+
+    MESSAGE(7, ("\tn-cube slice through m-cube I/O test %d.\n", test_num));
+    MESSAGE(7, ("\tranks = %d/%d, edge_size = %d, checker_edge_size = %d, chunk_edge_size = %d.\n", small_rank, large_rank, edge_size, checker_edge_size, chunk_edge_size));
+
+    HDassert(edge_size >= 6);
+    HDassert(checker_edge_size > 0);
+    HDassert(checker_edge_size <= edge_size);
+    HDassert(edge_size >= chunk_edge_size);
+    HDassert((chunk_edge_size == 0) || (chunk_edge_size >= 3));
+    HDassert(small_rank > 0);
+    HDassert(small_rank < large_rank);
+    HDassert(large_rank <= test_max_rank);
+    HDassert(test_max_rank <= SS_DR_MAX_RANK);
+
+    /* Compute cube sizes */
+    small_cube_size = large_cube_size = (size_t)1;
+    for(u = 0; u < large_rank; u++) {
+        if(u < small_rank)
+            small_cube_size *= (size_t)edge_size;
+
+        large_cube_size *= (size_t)edge_size;
+    } /* end for */
+    HDassert(large_cube_size < (size_t)(UINT_MAX));
+
+    small_rank_offset = test_max_rank - small_rank;
+    HDassert(small_rank_offset >= 1);
+
+    /* also, at present, we use 16 bit values in this test --
+     * hence the following assertion.  Delete it if we convert
+     * to 32 bit values.
+     */
+    HDassert(large_cube_size < (size_t)(UINT16_MAX));
+
+
+    /* Allocate & initialize buffers */
+    small_cube_buf_1 = (uint16_t *)HDcalloc(sizeof(uint16_t), small_cube_size);
+    CHECK(small_cube_buf_1, NULL, "HDcalloc");
+    large_cube_buf_1 = (uint16_t *)HDcalloc(sizeof(uint16_t), large_cube_size);
+    CHECK(large_cube_buf_1, NULL, "HDcalloc");
+
+
+    /* Create a dataset transfer property list */
+    fapl = H5Pcreate(H5P_FILE_ACCESS);
+    CHECK(fapl, FAIL, "H5Pcreate");
+
+    /* Use the 'core' VFD for this test */
+    ret = H5Pset_fapl_core(fapl, (size_t)(1024 * 1024), FALSE);
+    CHECK(ret, FAIL, "H5Pset_fapl_core");
+
+    /* Create file */
+    fid = H5Fcreate(FILENAME, H5F_ACC_TRUNC, H5P_DEFAULT, fapl);
+    CHECK(fid, FAIL, "H5Fcreate");
+
+    /* Close file access property list */
+    ret = H5Pclose(fapl);
+    CHECK(ret, FAIL, "H5Pclose");
+
+
+    /* setup dims: */
+    dims[0] = dims[1] = dims[2] = dims[3] = dims[4] = edge_size;
+
+
+    /* Create small cube dataspaces */
+    full_small_cube_sid = H5Screate_simple((int)small_rank, dims, NULL);
+    CHECK(full_small_cube_sid, FAIL, "H5Screate_simple");
+
+    mem_small_cube_sid = H5Screate_simple((int)small_rank, dims, NULL);
+    CHECK(mem_small_cube_sid, FAIL, "H5Screate_simple");
+
+    file_small_cube_sid = H5Screate_simple((int)small_rank, dims, NULL);
+    CHECK(file_small_cube_sid, FAIL, "H5Screate_simple");
+
+
+    /* Create large cube dataspace */
+    full_large_cube_sid = H5Screate_simple((int)large_rank, dims, NULL);
+    CHECK(full_large_cube_sid, FAIL, "H5Screate_simple");
+
+    mem_large_cube_sid = H5Screate_simple((int)large_rank, dims, NULL);
+    CHECK(mem_large_cube_sid, FAIL, "H5Screate_simple");
+
+    file_large_cube_sid = H5Screate_simple((int)large_rank, dims, NULL);
+    CHECK(file_large_cube_sid, FAIL, "H5Screate_simple");
+
+
+    /* 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) {
+        chunk_dims[0] = chunk_dims[1] = 
+		chunk_dims[2] = chunk_dims[3] = chunk_dims[4] = chunk_edge_size;
+
+        small_cube_dcpl_id = H5Pcreate(H5P_DATASET_CREATE);
+        CHECK(small_cube_dcpl_id, FAIL, "H5Pcreate");
+
+        ret = H5Pset_layout(small_cube_dcpl_id, H5D_CHUNKED);
+        CHECK(ret, FAIL, "H5Pset_layout");
+
+        ret = H5Pset_chunk(small_cube_dcpl_id, (int)small_rank, chunk_dims);
+        CHECK(ret, FAIL, "H5Pset_chunk");
+
+
+        large_cube_dcpl_id = H5Pcreate(H5P_DATASET_CREATE);
+        CHECK(large_cube_dcpl_id, FAIL, "H5Pcreate");
+
+        ret = H5Pset_layout(large_cube_dcpl_id, H5D_CHUNKED);
+        CHECK(ret, FAIL, "H5Pset_layout");
+
+        ret = H5Pset_chunk(large_cube_dcpl_id, (int)large_rank, chunk_dims);
+        CHECK(ret, FAIL, "H5Pset_chunk");
+    } /* end if */
+
+
+    /* create the small cube dataset */
+    small_cube_dataset = H5Dcreate2(fid, "small_cube_dataset", dset_type, 
+            file_small_cube_sid, H5P_DEFAULT, small_cube_dcpl_id, H5P_DEFAULT);
+    CHECK(small_cube_dataset, FAIL, "H5Dcreate2");
+
+    /* Close non-default small dataset DCPL */
+    if(small_cube_dcpl_id != H5P_DEFAULT) {
+        ret = H5Pclose(small_cube_dcpl_id);
+        CHECK(ret, FAIL, "H5Pclose");
+    } /* end if */
+
+    /* create the large cube dataset */
+    large_cube_dataset = H5Dcreate2(fid, "large_cube_dataset", dset_type, 
+            file_large_cube_sid, H5P_DEFAULT, large_cube_dcpl_id, H5P_DEFAULT);
+    CHECK(large_cube_dataset, FAIL, "H5Dcreate2");
+
+    /* Close non-default large dataset DCPL */
+    if(large_cube_dcpl_id != H5P_DEFAULT) {
+        ret = H5Pclose(large_cube_dcpl_id);
+        CHECK(ret, FAIL, "H5Pclose");
+    } /* end if */
+
+
+    /* write initial data to the on disk datasets */
+    ret = H5Dwrite(small_cube_dataset, H5T_NATIVE_UINT16, full_small_cube_sid, 
+            full_small_cube_sid, xfer_plist, cube_buf);
+    CHECK(ret, FAIL, "H5Dwrite");
+
+    ret = H5Dwrite(large_cube_dataset, H5T_NATIVE_UINT16, full_large_cube_sid, 
+            full_large_cube_sid, xfer_plist, cube_buf);
+    CHECK(ret, FAIL, "H5Dwrite");
+
+
+    /* read initial small cube data from disk and verify that it is as expected. */
+    ret = H5Dread(small_cube_dataset, H5T_NATIVE_UINT16, full_small_cube_sid, 
+            full_small_cube_sid, xfer_plist, small_cube_buf_1);
+    CHECK(ret, FAIL, "H5Dread");
+
+    /* Check that the data is valid */
+    verify_select_hyper_contig_dr__run_test(small_cube_buf_1, small_cube_size,
+        edge_size, small_rank);
+
+    /* read initial large cube data from disk and verify that it is as expected. */
+    ret = H5Dread(large_cube_dataset, H5T_NATIVE_UINT16, full_large_cube_sid, 
+            full_large_cube_sid, xfer_plist, large_cube_buf_1);
+    CHECK(ret, FAIL, "H5Dread");
+
+    /* Check that the data is valid */
+    verify_select_hyper_contig_dr__run_test(large_cube_buf_1, large_cube_size,
+        edge_size, large_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 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.
+     *
+     * 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;
+
+    test_select_hyper_checker_board_dr__select_checker_board(mem_small_cube_sid,
+                                                             small_rank,
+                                                             edge_size,
+                                                             checker_edge_size,
+                                                             small_rank,
+                                                             sel_start);
+
+    /* now read slices from the large, on-disk cube into the small cube. 
+     * Note how we adjust sel_start only in the dimensions peculiar to the 
+     * large cube.
+     */
+
+    start_in_checker[0] = TRUE;
+    u = 0;
+    do {
+        if(small_rank_offset > 0)
+            sel_start[0] = u;
+
+        v = 0;
+        do {
+            if(small_rank_offset > 1)
+                sel_start[1] = v;
+
+            w = 0;
+            do {
+                if(small_rank_offset > 2)
+                    sel_start[2] = w;
+
+                x = 0;
+                do {
+                    if(small_rank_offset > 3)
+                        sel_start[3] = x;
+
+                    /* 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.
+                     */
+
+                    HDassert((sel_start[0] == 0) || (0 < small_rank_offset));
+                    HDassert((sel_start[1] == 0) || (1 < small_rank_offset));
+                    HDassert((sel_start[2] == 0) || (2 < small_rank_offset));
+                    HDassert((sel_start[3] == 0) || (3 < small_rank_offset));
+                    HDassert((sel_start[4] == 0) || (4 < small_rank_offset));
+
+                    test_select_hyper_checker_board_dr__select_checker_board
+                    (
+                      file_large_cube_sid,
+                      large_rank,
+                      edge_size,
+                      checker_edge_size,
+                      small_rank,
+                      sel_start
+                    );
+
+                    /* verify that H5S_select_shape_same() reports the two 
+                     * selections as having the same shape.
+                     */
+                    check = H5S_select_shape_same_test(mem_small_cube_sid, 
+                                                       file_large_cube_sid);
+                    VERIFY(check, TRUE, "H5S_select_shape_same_test");
+
+                    /* zero the buffer that we will be using for reading */
+                    HDmemset(small_cube_buf_1, 0, sizeof(*small_cube_buf_1) * small_cube_size);
+
+                    /* Read selection from disk */
+                    ret = H5Dread(large_cube_dataset,
+                                  H5T_NATIVE_UINT16,
+                                  mem_small_cube_sid,
+                                  file_large_cube_sid,
+                                  xfer_plist,
+                                  small_cube_buf_1);
+                    CHECK(ret, FAIL, "H5Dread");
+
+                    expected_value = (uint16_t)
+                                     ((u * edge_size * edge_size * edge_size * edge_size) +
+                                      (v * edge_size * edge_size * edge_size) +
+                                      (w * edge_size * edge_size) +
+                                      (x * edge_size));
+
+                    data_ok = test_select_hyper_checker_board_dr__verify_data
+                              (
+                                small_cube_buf_1,
+                                small_rank,
+                                edge_size,
+                                checker_edge_size,
+                                expected_value,
+                                (hbool_t)TRUE
+                              );
+                    if(!data_ok)
+                        TestErrPrintf("small cube read from largecube has bad data! Line=%d\n",__LINE__);
+
+                    x++;
+                } while((large_rank >= (test_max_rank - 3)) && 
+                        (small_rank <= (test_max_rank - 4)) && (x < edge_size));
+                w++;
+            } while((large_rank >= (test_max_rank - 2)) && 
+                    (small_rank <= (test_max_rank - 3)) && (w < edge_size));
+            v++;
+        } while((large_rank >= (test_max_rank - 1)) && 
+                (small_rank <= (test_max_rank - 2)) && (v < edge_size));
+        u++;
+    } while((large_rank >= test_max_rank) && 
+            (small_rank <= (test_max_rank - 1)) && (u < edge_size));
+        
+
+    /* similarly, read the on disk small cube into slices through the in memory
+     * large cube, and verify that the correct data (and only the correct data)
+     * is read.
+     */
+
+    /* select a checker board in the file small cube dataspace */
+    sel_start[0] = sel_start[1] = sel_start[2] = sel_start[3] = sel_start[4] = 0;
+    test_select_hyper_checker_board_dr__select_checker_board(file_small_cube_sid,
+                                                             small_rank,
+                                                             edge_size,
+                                                             checker_edge_size,
+                                                             small_rank,
+                                                             sel_start);
+
+
+    start_in_checker[0] = TRUE;
+    u = 0;
+    do {
+        if(0 < small_rank_offset)
+            sel_start[0] = u;
+
+        v = 0;
+        do {
+            if(1 < small_rank_offset)
+                sel_start[1] = v;
+
+            w = 0;
+            do {
+                if(2 < small_rank_offset)
+                    sel_start[2] = w;
+
+                x = 0;
+                do {
+                    if(3 < small_rank_offset)
+                        sel_start[3] = x;
+
+                    /* 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.
+                     */
+
+                    HDassert((sel_start[0] == 0) || (0 < small_rank_offset));
+                    HDassert((sel_start[1] == 0) || (1 < small_rank_offset));
+                    HDassert((sel_start[2] == 0) || (2 < small_rank_offset));
+                    HDassert((sel_start[3] == 0) || (3 < small_rank_offset));
+                    HDassert((sel_start[4] == 0) || (4 < small_rank_offset));
+
+                    test_select_hyper_checker_board_dr__select_checker_board
+                    (
+                      mem_large_cube_sid,
+                      large_rank,
+                      edge_size,
+                      checker_edge_size,
+                      small_rank,
+                      sel_start
+                    );
+
+                    /* verify that H5S_select_shape_same() reports the two 
+                     * selections as having the same shape.
+                     */
+                    check = H5S_select_shape_same_test(file_small_cube_sid, 
+                                                       mem_large_cube_sid);
+                    VERIFY(check, TRUE, "H5S_select_shape_same_test");
+
+
+                    /* zero out the in memory large cube */
+                    HDmemset(large_cube_buf_1, 0, sizeof(*large_cube_buf_1) * large_cube_size);
+
+                    /* Read selection from disk */
+                    ret = H5Dread(small_cube_dataset,
+                                  H5T_NATIVE_UINT16,
+                                  mem_large_cube_sid,
+                                  file_small_cube_sid,
+                                  xfer_plist,
+                                  large_cube_buf_1);
+                    CHECK(ret, FAIL, "H5Dread");
+
+
+                    /* verify that the expected data and only the 
+                     * expected data was read.
+                     */
+                    data_ok = TRUE;
+                    ptr_1 = large_cube_buf_1;
+                    expected_value = 0;
+                    start_index = (u * edge_size * edge_size * edge_size * edge_size) +
+                                  (v * edge_size * edge_size * edge_size) +
+                                  (w * edge_size * edge_size) +
+                                  (x * edge_size);
+                    stop_index = start_index + small_cube_size - 1;
+
+                    HDassert( start_index < stop_index );
+                    HDassert( stop_index <= large_cube_size );
+
+                    /* verify that the large cube contains only zeros before the slice */
+                    for(s = 0; s < start_index; s++) {
+                        if(*ptr_1 != 0)
+                            data_ok = FALSE;
+                        ptr_1++;
+                    } /* end for */
+                    HDassert(s == start_index);
+
+                    data_ok &= test_select_hyper_checker_board_dr__verify_data
+                               (
+                                 ptr_1,
+                                 small_rank,
+                                 edge_size,
+                                 checker_edge_size,
+                                 (uint16_t)0,
+                                 (hbool_t)TRUE
+                              );
+
+                    ptr_1 += small_cube_size;
+                    s += small_cube_size;
+
+                    HDassert(s == stop_index + 1);
+
+                    /* verify that the large cube contains only zeros after the slice */
+                    for(s = stop_index + 1; s < large_cube_size; s++) {
+                        if(*ptr_1 != 0)
+                            data_ok = FALSE;
+                        ptr_1++;
+                    } /* end for */
+                    if(!data_ok)
+                        TestErrPrintf("large cube read from small cube has bad data! Line=%d\n",__LINE__);
+
+                    x++;
+                } while((large_rank >= (test_max_rank - 3)) && 
+                        (small_rank <= (test_max_rank - 4)) && (x < edge_size));
+                w++;
+            } while((large_rank >= (test_max_rank - 2)) && 
+                    (small_rank <= (test_max_rank - 3)) && (w < edge_size));
+            v++;
+        } while((large_rank >= (test_max_rank - 1)) && 
+                (small_rank <= (test_max_rank - 2)) && (v < edge_size));
+        u++;
+    } while((large_rank >= test_max_rank) && 
+            (small_rank <= (test_max_rank - 1)) && (u < edge_size));
+
+
+    /* 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 D slices from the in memory large cube, to 
+     * the the on disk small cube dataset.  After each write, read the small
+     * cube 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.
+     */ 
+
+    /* select a checker board in the file small cube dataspace */
+    sel_start[0] = sel_start[1] = sel_start[2] = sel_start[3] = sel_start[4] = 0;
+    test_select_hyper_checker_board_dr__select_checker_board(file_small_cube_sid,
+                                                             small_rank,
+                                                             edge_size,
+                                                             checker_edge_size,
+                                                             small_rank,
+                                                             sel_start);
+
+    start_in_checker[0] = TRUE;
+    u = 0;
+    do {
+        if(small_rank_offset > 0)
+            sel_start[0] = u;
+
+        v = 0;
+        do {
+            if(small_rank_offset > 1)
+                sel_start[1] = v;
+
+            w = 0;
+            do {
+                if(small_rank_offset > 2)
+                    sel_start[2] = w;
+
+                x = 0;
+                do {
+                    if(small_rank_offset > 3)
+                        sel_start[3] = x;
+
+                    /* zero out the on disk small cube */
+                    ret = H5Dwrite(small_cube_dataset, 
+                                   H5T_NATIVE_UINT16, 
+                                   full_small_cube_sid, 
+                                   full_small_cube_sid, 
+                                   xfer_plist, 
+                                   zero_buf);
+                    CHECK(ret, FAIL, "H5Dwrite");
+
+
+                    /* 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.
+                     */
+
+                    HDassert((sel_start[0] == 0) || (0 < small_rank_offset));
+                    HDassert((sel_start[1] == 0) || (1 < small_rank_offset));
+                    HDassert((sel_start[2] == 0) || (2 < small_rank_offset));
+                    HDassert((sel_start[3] == 0) || (3 < small_rank_offset));
+                    HDassert((sel_start[4] == 0) || (4 < small_rank_offset));
+
+                    test_select_hyper_checker_board_dr__select_checker_board
+                    (
+                      mem_large_cube_sid,
+                      large_rank,
+                      edge_size,
+                      checker_edge_size,
+                      small_rank,
+                      sel_start
+                    );
+
+                    /* verify that H5S_select_shape_same() reports the two 
+                     * selections as having the same shape.
+                     */
+                    check = H5S_select_shape_same_test(file_small_cube_sid, 
+                                                       mem_large_cube_sid);
+                    VERIFY(check, TRUE, "H5S_select_shape_same_test");
+
+
+	            /* write the slice from the in memory large cube to the 
+                     * on disk small cube 
+                     */
+                    ret = H5Dwrite(small_cube_dataset, 
+                                   H5T_NATIVE_UINT16, 
+                                   mem_large_cube_sid, 
+                                   file_small_cube_sid, 
+                                   xfer_plist, 
+                                   cube_buf);
+                    CHECK(ret, FAIL, "H5Dwrite");
+
+
+                    /* zero the buffer that we will be using for reading */
+                    HDmemset(small_cube_buf_1, 0, sizeof(*small_cube_buf_1) * small_cube_size);
+
+                    /* read the on disk small cube into memory */
+                    ret = H5Dread(small_cube_dataset, 
+                                  H5T_NATIVE_UINT16,
+                                  full_small_cube_sid,
+                                  full_small_cube_sid, 
+                                  xfer_plist, 
+                                  small_cube_buf_1);
+                    CHECK(ret, FAIL, "H5Dread");
+
+                    expected_value = (uint16_t)
+                                     ((u * edge_size * edge_size * edge_size * edge_size) +
+                                      (v * edge_size * edge_size * edge_size) +
+                                      (w * edge_size * edge_size) +
+                                      (x * edge_size));
+
+                    data_ok = test_select_hyper_checker_board_dr__verify_data
+                              (
+                                small_cube_buf_1,
+                                small_rank,
+                                edge_size,
+                                checker_edge_size,
+                                expected_value,
+                                (hbool_t)TRUE
+                              );
+                    if(!data_ok)
+                        TestErrPrintf("small cube read from largecube has bad data! Line=%d\n",__LINE__);
+
+                    x++;
+                } while((large_rank >= (test_max_rank - 3)) && 
+                        (small_rank <= (test_max_rank - 4)) && (x < edge_size));
+                w++;
+            } while((large_rank >= (test_max_rank - 2)) && 
+                    (small_rank <= (test_max_rank - 3)) && (w < edge_size));
+            v++;
+        } while((large_rank >= (test_max_rank - 1)) && 
+                (small_rank <= (test_max_rank - 2)) && (v < edge_size));
+        u++;
+    } while((large_rank >= test_max_rank) && 
+            (small_rank <= (test_max_rank - 1)) && (u < edge_size));
+
+
+    /* Now write checker board selections of the entries in memory 
+     * small cube to slices of the on disk cube.  After each write, 
+     * read the on disk large cube * into memeory, and verify that 
+     * it contains the expected * data.  Verify that 
+     * H5S_select_shape_same() returns true on the memory and file 
+     * selections.
+     */
+
+    /* select a checker board in the in memory small cube dataspace */
+    sel_start[0] = sel_start[1] = sel_start[2] = sel_start[3] = sel_start[4] = 0;
+    test_select_hyper_checker_board_dr__select_checker_board(mem_small_cube_sid,
+                                                             small_rank,
+                                                             edge_size,
+                                                             checker_edge_size,
+                                                             small_rank,
+                                                             sel_start);
+
+    start_in_checker[0] = TRUE;
+    u = 0;
+    do {
+        if(small_rank_offset > 0)
+            sel_start[0] = u;
+
+        v = 0;
+        do {
+            if(small_rank_offset > 1)
+                sel_start[1] = v;
+
+            w = 0;
+            do {
+                if(small_rank_offset > 2)
+                    sel_start[2] = w;
+
+                x = 0;
+                do {
+                    if(small_rank_offset > 3)
+                        sel_start[3] = x;
+
+                    /* zero out the on disk cube */
+                    ret = H5Dwrite(large_cube_dataset, 
+                                   H5T_NATIVE_USHORT, 
+                                   full_large_cube_sid, 
+                                   full_large_cube_sid, 
+                                   xfer_plist, 
+                                   zero_buf);
+                    CHECK(ret, FAIL, "H5Dwrite");
+
+                    /* 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.
+                     */
+
+                    HDassert((sel_start[0] == 0) || (0 < small_rank_offset));
+                    HDassert((sel_start[1] == 0) || (1 < small_rank_offset));
+                    HDassert((sel_start[2] == 0) || (2 < small_rank_offset));
+                    HDassert((sel_start[3] == 0) || (3 < small_rank_offset));
+                    HDassert((sel_start[4] == 0) || (4 < small_rank_offset));
+
+
+                    test_select_hyper_checker_board_dr__select_checker_board
+                    (
+                      file_large_cube_sid,
+                      large_rank,
+                      edge_size,
+                      checker_edge_size,
+                      small_rank,
+                      sel_start
+                    );
+
+                    /* verify that H5S_select_shape_same() reports the two 
+                     * selections as having the same shape.
+                     */
+                    check = H5S_select_shape_same_test(file_large_cube_sid, 
+                                                       mem_small_cube_sid);
+                    VERIFY(check, TRUE, "H5S_select_shape_same_test");
+
+
+	            /* write the checker board selection of the in memory
+                     * small cube to a slice through the on disk large
+                     * cube.
+                     */
+                    ret = H5Dwrite(large_cube_dataset, 
+                                   H5T_NATIVE_UINT16, 
+                                   mem_small_cube_sid, 
+                                   file_large_cube_sid, 
+                                   xfer_plist, 
+                                   cube_buf);
+                    CHECK(ret, FAIL, "H5Dwrite");
+
+
+                    /* zero out the in memory large cube */
+                    HDmemset(large_cube_buf_1, 0, sizeof(*large_cube_buf_1) * large_cube_size);
+
+                    /* read the on disk large cube into memory */
+                    ret = H5Dread(large_cube_dataset, 
+                                  H5T_NATIVE_UINT16,
+                                  full_large_cube_sid,
+                                  full_large_cube_sid, 
+                                  xfer_plist, 
+                                  large_cube_buf_1);
+                    CHECK(ret, FAIL, "H5Dread");
+
+
+                    /* verify that the expected data and only the 
+                     * expected data was written to the on disk large
+                     * cube.
+                     */
+                    data_ok = TRUE;
+                    ptr_1 = large_cube_buf_1;
+                    expected_value = 0;
+                    start_index = (u * edge_size * edge_size * edge_size * edge_size) +
+                                  (v * edge_size * edge_size * edge_size) +
+                                  (w * edge_size * edge_size) +
+                                  (x * edge_size);
+                    stop_index = start_index + small_cube_size - 1;
+
+                    HDassert( start_index < stop_index );
+                    HDassert( stop_index <= large_cube_size );
+
+                    /* verify that the large cube contains only zeros before the slice */
+                    for(s = 0; s < start_index; s++) {
+                        if(*ptr_1 != 0)
+                            data_ok = FALSE;
+                        ptr_1++;
+                    } /* end for */
+                    HDassert(s == start_index);
+
+                    /* verify that the slice contains the expected data */
+                    data_ok &= test_select_hyper_checker_board_dr__verify_data
+                               (
+                                 ptr_1,
+                                 small_rank,
+                                 edge_size,
+                                 checker_edge_size,
+                                 (uint16_t)0,
+                                 (hbool_t)TRUE
+                              );
+
+                    ptr_1 += small_cube_size;
+                    s += small_cube_size;
+
+                    HDassert(s == stop_index + 1);
+
+                    /* verify that the large cube contains only zeros after the slice */
+                    for(s = stop_index + 1; s < large_cube_size; s++) {
+                        if(*ptr_1 != 0)
+                            data_ok = FALSE;
+                        ptr_1++;
+                    } /* end for */
+                    if(!data_ok)
+                        TestErrPrintf("large cube written from small cube has bad data! Line=%d\n",__LINE__);
+
+                    x++;
+                } while((large_rank >= (test_max_rank - 3)) && 
+                        (small_rank <= (test_max_rank - 4)) && (x < edge_size));
+                w++;
+            } while((large_rank >= (test_max_rank - 2)) && 
+                    (small_rank <= (test_max_rank - 3)) && (w < edge_size));
+            v++;
+        } while((large_rank >= (test_max_rank - 1)) && 
+                (small_rank <= (test_max_rank - 2)) && (v < edge_size));
+        u++;
+    } while((large_rank >= test_max_rank) && 
+            (small_rank <= (test_max_rank - 1)) && (u < edge_size));
+                    
+
+    /* Close memory dataspaces */
+    ret = H5Sclose(full_small_cube_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(full_large_cube_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(mem_small_cube_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(mem_large_cube_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+
+    /* Close disk dataspace */
+    ret = H5Sclose(file_small_cube_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(file_large_cube_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    /* Close Datasets */
+    ret = H5Dclose(small_cube_dataset);
+    CHECK(ret, FAIL, "H5Dclose");
+
+    ret = H5Dclose(large_cube_dataset);
+    CHECK(ret, FAIL, "H5Dclose");
+
+    /* Close file */
+    ret = H5Fclose(fid);
+    CHECK(ret, FAIL, "H5Fclose");
+
+    /* Free memory buffers */
+    HDfree(small_cube_buf_1);
+    HDfree(large_cube_buf_1);
+
+}   /* test_select_hyper_checker_board_dr__run_test() */
+
+
+/****************************************************************
+**
+**  test_select_hyper_checker_board_dr(): Test H5S (dataspace) 
+**	selection code with checkerboard source and target having 
+**	different ranks but the same shape.  We have already
+**	tested H5S_shape_same in isolation, so now we try to do 
+**	I/O.
+**
+**	This is just an initial smoke check, so we will work 
+**	with a slice through a cube only.
+**
+****************************************************************/
+static void
+test_select_hyper_checker_board_dr(hid_t dset_type, hid_t xfer_plist)
+{
+    uint16_t *cube_buf;         /* Buffer for writing cube data */
+    uint16_t *cube_ptr;         /* Temporary pointer into cube data */
+    uint16_t *zero_buf;         /* Buffer for writing zeroed cube data */
+    int test_num = 0;
+    unsigned checker_edge_size = 2; /* Size of checkerboard dimension */
+    unsigned chunk_edge_size;   /* Size of chunk's dataspace dimensions */
+    unsigned edge_size = 6;     /* Size of dataset's dataspace dimensions */
+    unsigned small_rank;        /* Current rank of small dataset */
+    unsigned large_rank;        /* Current rank of large dataset */
+    unsigned max_rank = 5;      /* Max. rank to use */
+    size_t max_cube_size;       /* Max. number of elements in largest cube */
+    size_t s;                   /* Local index variable */
+    unsigned u;                 /* Local index variable */
+
+    /* Output message about test being performed */
+    MESSAGE(5, ("Testing Checker Board Hyperslabs With Different Rank I/O Functionality\n"));
+
+    /* Compute max. cube size */
+    max_cube_size = (size_t)1;
+    for(u = 0; u < max_rank; u++)
+        max_cube_size *= (size_t)(edge_size + 1);
+
+    /* Allocate cube buffer for writing values */
+    cube_buf = (uint16_t *)HDmalloc(sizeof(uint16_t) * max_cube_size);
+    CHECK(cube_buf, NULL, "HDmalloc");
+
+    /* Initialize the cube buffer */
+    cube_ptr = cube_buf;
+    for(s = 0; s < max_cube_size; s++)
+        *cube_ptr++ = (uint16_t)s;
+
+    /* Allocate cube buffer for zeroing values on disk */
+    zero_buf = (uint16_t *)HDcalloc(sizeof(uint16_t), max_cube_size);
+    CHECK(zero_buf, NULL, "HDcalloc");
+
+    for(large_rank = 1; large_rank <= max_rank; large_rank++) {
+        for(small_rank = 1; small_rank < large_rank; small_rank++) {
+            chunk_edge_size = 0;
+            test_select_hyper_checker_board_dr__run_test(test_num, cube_buf,
+                    zero_buf, edge_size, checker_edge_size, chunk_edge_size, small_rank,
+                    large_rank, dset_type, xfer_plist);
+            test_num++;
+
+            test_select_hyper_checker_board_dr__run_test(test_num, cube_buf,
+                    zero_buf,
+                    edge_size + 1, checker_edge_size, chunk_edge_size, small_rank,
+                    large_rank, dset_type, xfer_plist);
+            test_num++;
+
+            chunk_edge_size = 3;
+            test_select_hyper_checker_board_dr__run_test(test_num, cube_buf,
+                    zero_buf,
+                    edge_size, checker_edge_size, chunk_edge_size, small_rank,
+                    large_rank, dset_type, xfer_plist);
+            test_num++;
+
+            test_select_hyper_checker_board_dr__run_test(test_num, cube_buf,
+                    zero_buf,
+                    edge_size + 1, checker_edge_size, chunk_edge_size, small_rank,
+                    large_rank, dset_type, xfer_plist);
+            test_num++;
+        } /* for loop on small rank */
+    } /* for loop on large rank */
+
+    HDfree(cube_buf);
+    HDfree(zero_buf);
+
+}   /* test_select_hyper_checker_board_dr() */
+
+
 /****************************************************************
 **
 **  test_select_hyper_copy(): Test H5S (dataspace) selection code.
@@ -2345,15 +4373,15 @@ test_select_point_offset(void)
     CHECK(ret, FAIL, "H5Sselect_elements");
 
     /* Read selection from disk */
-    ret=H5Dread(dataset,H5T_NATIVE_UCHAR,sid2,sid1,H5P_DEFAULT,rbuf);
+    ret = H5Dread(dataset, H5T_NATIVE_UCHAR, sid2, sid1, H5P_DEFAULT, rbuf);
     CHECK(ret, FAIL, "H5Dread");
 
     /* Compare data read with data written out */
-    for(i=0; i<POINT1_NPOINTS; i++) {
-        tbuf=wbuf+((coord2[i][0]+offset[0])*SPACE2_DIM2)+coord2[i][1]+offset[1];
-        tbuf2=rbuf+(coord3[i][0]*SPACE3_DIM2)+coord3[i][1];
-        if(*tbuf!=*tbuf2)
-            TestErrPrintf("element values don't match!, i=%d\n",i);
+    for(i = 0; i < POINT1_NPOINTS; i++) {
+        tbuf = wbuf + ((coord2[i][0] + (hsize_t)offset[0]) * SPACE2_DIM2) + coord2[i][1] + (hsize_t)offset[1];
+        tbuf2 = rbuf + (coord3[i][0] * SPACE3_DIM2) + coord3[i][1];
+        if(*tbuf != *tbuf2)
+            TestErrPrintf("element values don't match!, i=%d\n", i);
     } /* end for */
 
     /* Close memory dataspace */
@@ -2410,7 +4438,7 @@ test_select_hyper_union(void)
                *tbuf2;      /* temporary buffer pointer */
     int        i,j;        /* Counters */
     herr_t		ret;		/* Generic return value		*/
-    hsize_t	    npoints;	/* Number of elements in selection */
+    hssize_t	    npoints;	/* Number of elements in selection */
 
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Hyperslab Selection Functions with unions of hyperslabs\n"));
@@ -2448,7 +4476,7 @@ test_select_hyper_union(void)
     CHECK(ret, FAIL, "H5Sselect_hyperslab");
 
     npoints = H5Sget_select_npoints(sid1);
-    VERIFY(npoints, 2*15*13, "H5Sget_select_npoints");
+    VERIFY(npoints, 2 * 15 * 13, "H5Sget_select_npoints");
 
     /* Select 8x26 hyperslab for memory dataset */
     start[0]=15; start[1]=0;
@@ -2561,7 +4589,7 @@ test_select_hyper_union(void)
     CHECK(ret, FAIL, "H5Sselect_hyperslab");
 
     npoints = H5Sget_select_npoints(sid2);
-    VERIFY(npoints, 15*26, "H5Sget_select_npoints");
+    VERIFY(npoints, 15 * 26, "H5Sget_select_npoints");
 
     /* Create a dataset */
     dataset = H5Dcreate2(fid1, SPACE2_NAME, H5T_NATIVE_UCHAR, sid1, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
@@ -2647,7 +4675,7 @@ test_select_hyper_union(void)
     CHECK(ret, FAIL, "H5Sselect_hyperslab");
 
     npoints = H5Sget_select_npoints(sid2);
-    VERIFY(npoints, 15*26, "H5Sget_select_npoints");
+    VERIFY(npoints, 15 * 26, "H5Sget_select_npoints");
 
     /* Create a dataset */
     dataset = H5Dcreate2(fid1, SPACE3_NAME, H5T_NATIVE_UCHAR, sid1, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
@@ -2737,7 +4765,7 @@ test_select_hyper_union(void)
     CHECK(ret, FAIL, "H5Sselect_hyperslab");
 
     npoints = H5Sget_select_npoints(sid2);
-    VERIFY(npoints, 15*26, "H5Sget_select_npoints");
+    VERIFY(npoints, 15 * 26, "H5Sget_select_npoints");
 
     /* Create a dataset */
     dataset = H5Dcreate2(fid1, SPACE4_NAME, H5T_NATIVE_UCHAR, sid1, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
@@ -2834,7 +4862,7 @@ test_select_hyper_union(void)
     CHECK(ret, FAIL, "H5Sselect_hyperslab");
 
     npoints = H5Sget_select_npoints(sid2);
-    VERIFY(npoints, 15*26, "H5Sget_select_npoints");
+    VERIFY(npoints, 15 * 26, "H5Sget_select_npoints");
 
     /* Create a dataset */
     dataset = H5Dcreate2(fid1,SPACE5_NAME, H5T_NATIVE_UCHAR, sid1, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
@@ -3277,7 +5305,7 @@ test_select_hyper_and_2d(void)
                *tbuf2;      /* temporary buffer pointer */
     int        i,j;        /* Counters */
     herr_t		ret;    /* Generic return value		*/
-    hsize_t	    npoints;	/* Number of elements in selection */
+    hssize_t	    npoints;	/* Number of elements in selection */
 
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Hyperslab Selection Functions with intersection of 2-D hyperslabs\n"));
@@ -3322,7 +5350,7 @@ test_select_hyper_and_2d(void)
     CHECK(ret, FAIL, "H5Sselect_hyperslab");
 
     npoints = H5Sget_select_npoints(sid1);
-    VERIFY(npoints, 5*5, "H5Sget_select_npoints");
+    VERIFY(npoints, 5 * 5, "H5Sget_select_npoints");
 
     /* Select 25 hyperslab for memory dataset */
     start[0]=0;
@@ -3333,7 +5361,7 @@ test_select_hyper_and_2d(void)
     CHECK(ret, FAIL, "H5Sselect_hyperslab");
 
     npoints = H5Sget_select_npoints(sid2);
-    VERIFY(npoints, 5*5, "H5Sget_select_npoints");
+    VERIFY(npoints, 5 * 5, "H5Sget_select_npoints");
 
     /* Create a dataset */
     dataset = H5Dcreate2(fid1, SPACE2_NAME, H5T_NATIVE_UCHAR, sid1, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
@@ -3406,7 +5434,7 @@ test_select_hyper_xor_2d(void)
                *tbuf2;      /* temporary buffer pointer */
     int        i,j;        /* Counters */
     herr_t		ret;    /* Generic return value		*/
-    hsize_t	    npoints;	/* Number of elements in selection */
+    hssize_t	    npoints;	/* Number of elements in selection */
 
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Hyperslab Selection Functions with XOR of 2-D hyperslabs\n"));
@@ -3537,7 +5565,7 @@ test_select_hyper_notb_2d(void)
                *tbuf2;      /* temporary buffer pointer */
     int        i,j;        /* Counters */
     herr_t		ret;    /* Generic return value		*/
-    hsize_t	    npoints;	/* Number of elements in selection */
+    hssize_t	    npoints;	/* Number of elements in selection */
 
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Hyperslab Selection Functions with NOTB of 2-D hyperslabs\n"));
@@ -3667,7 +5695,7 @@ test_select_hyper_nota_2d(void)
                *tbuf2;      /* temporary buffer pointer */
     int        i,j;        /* Counters */
     herr_t		ret;    /* Generic return value		*/
-    hsize_t	    npoints;	/* Number of elements in selection */
+    hssize_t	    npoints;	/* Number of elements in selection */
 
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Hyperslab Selection Functions with NOTA of 2-D hyperslabs\n"));
@@ -3878,7 +5906,7 @@ test_select_hyper_union_random_5d(hid_t read_plist)
 #else /* QAK */
         seed=987909620;
 #endif /* QAK */
-        HDsrand(seed);
+        HDsrandom(seed);
 
 #ifdef QAK
 printf("test_num=%d, seed=%u\n",test_num,seed);
@@ -3893,26 +5921,26 @@ printf("hyperslab=%d\n",i);
 #endif /* QAK */
             /* Select random hyperslab location & size for selection */
             for(j=0; j<SPACE5_RANK; j++) {
-                start[j]=rand()%dims1[j];
-                count[j]=(rand()%(dims1[j]-start[j]))+1;
+                start[j] = ((hsize_t)HDrandom() % dims1[j]);
+                count[j] = (((hsize_t)HDrandom() % (dims1[j] - start[j])) + 1);
 #ifdef QAK
 printf("start[%d]=%d, count[%d]=%d (end[%d]=%d)\n",j,(int)start[j],j,(int)count[j],j,(int)(start[j]+count[j]-1));
 #endif /* QAK */
             } /* end for */
 
             /* Select hyperslab */
-            ret = H5Sselect_hyperslab(sid1,(i==0 ? H5S_SELECT_SET : H5S_SELECT_OR),start,NULL,count,NULL);
+            ret = H5Sselect_hyperslab(sid1, (i == 0 ? H5S_SELECT_SET : H5S_SELECT_OR), start, NULL, count, NULL);
             CHECK(ret, FAIL, "H5Sselect_hyperslab");
         } /* end for */
 
         /* Get the number of elements selected */
-        npoints=H5Sget_select_npoints(sid1);
+        npoints = H5Sget_select_npoints(sid1);
         CHECK(npoints, 0, "H5Sget_select_npoints");
 
         /* Select linear 1-D hyperslab for memory dataset */
-        start[0]=0;
-        count[0]=npoints;
-        ret = H5Sselect_hyperslab(sid2,H5S_SELECT_SET,start,NULL,count,NULL);
+        start[0] = 0;
+        count[0] = (hsize_t)npoints;
+        ret = H5Sselect_hyperslab(sid2, H5S_SELECT_SET, start, NULL, count, NULL);
         CHECK(ret, FAIL, "H5Sselect_hyperslab");
 
         npoints2 = H5Sget_select_npoints(sid2);
@@ -4973,24 +7001,24 @@ typedef struct {
 static herr_t
 test_select_hyper_iter3(void *_elem, hid_t UNUSED type_id, unsigned ndim, const hsize_t *point, void *_operator_data)
 {
-    unsigned short *tbuf=(unsigned short *)_elem;     /* temporary buffer pointer */
-    fill_iter_info *iter_info=(fill_iter_info *)_operator_data; /* Get the pointer to the iterator information */
+    unsigned *tbuf = (unsigned *)_elem;     /* temporary buffer pointer */
+    fill_iter_info *iter_info = (fill_iter_info *)_operator_data; /* Get the pointer to the iterator information */
     hsize_t *coord_ptr;        /* Pointer to the coordinate information for a point*/
 
     /* Check value in current buffer location */
-    if(*tbuf!=iter_info->fill_value)
+    if(*tbuf != iter_info->fill_value)
         return(-1);
     else {
         /* Check number of dimensions */
-        if(ndim!=SPACE7_RANK)
+        if(ndim != SPACE7_RANK)
             return(-1);
         else {
             /* Check Coordinates */
-            coord_ptr=iter_info->coords+(2*iter_info->curr_coord);
+            coord_ptr = iter_info->coords + (2 * iter_info->curr_coord);
             iter_info->curr_coord++;
-            if(coord_ptr[0]!=point[0])
+            if(coord_ptr[0] != point[0])
                 return(-1);
-            else if(coord_ptr[1]!=point[1])
+            else if(coord_ptr[1] != point[1])
                 return(-1);
             else
                 return(0);
@@ -5009,25 +7037,25 @@ test_select_fill_all(void)
 {
     hid_t	sid1;           /* Dataspace ID */
     hsize_t	dims1[] = {SPACE7_DIM1, SPACE7_DIM2};
-    int         fill_value;     /* Fill value */
+    unsigned    fill_value;     /* Fill value */
     fill_iter_info iter_info;   /* Iterator information structure */
     hsize_t     points[SPACE7_DIM1*SPACE7_DIM2][SPACE7_RANK];   /* Coordinates of selection */
-    unsigned short *wbuf,       /* buffer to write to disk */
+    unsigned   *wbuf,           /* buffer to write to disk */
                *tbuf;           /* temporary buffer pointer */
-    int         i,j;            /* Counters */
+    unsigned    u, v;           /* Counters */
     herr_t	ret;		/* Generic return value	*/
 
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Filling 'all' Selections\n"));
 
     /* Allocate memory buffer */
-    wbuf = (unsigned short *)HDmalloc(sizeof(unsigned short)*SPACE7_DIM1*SPACE7_DIM2);
+    wbuf = (unsigned *)HDmalloc(sizeof(unsigned) * SPACE7_DIM1 * SPACE7_DIM2);
     CHECK(wbuf, NULL, "HDmalloc");
 
     /* Initialize memory buffer */
-    for(i=0, tbuf=wbuf; i<SPACE7_DIM1; i++)
-        for(j=0; j<SPACE7_DIM2; j++)
-            *tbuf++=(unsigned short)(i*SPACE7_DIM2)+j;
+    for(u = 0, tbuf = wbuf; u < SPACE7_DIM1; u++)
+        for(v = 0; v < SPACE7_DIM2; v++)
+            *tbuf++ = (u * SPACE7_DIM2) + v;
 
     /* Create dataspace for dataset on disk */
     sid1 = H5Screate_simple(SPACE7_RANK, dims1, NULL);
@@ -5036,32 +7064,32 @@ test_select_fill_all(void)
     /* Space defaults to "all" selection */
 
     /* Set fill value */
-    fill_value=SPACE7_FILL;
+    fill_value = SPACE7_FILL;
 
     /* Fill selection in memory */
-    ret=H5Dfill(&fill_value,H5T_NATIVE_INT,wbuf,H5T_NATIVE_USHORT,sid1);
+    ret = H5Dfill(&fill_value, H5T_NATIVE_UINT, wbuf, H5T_NATIVE_UINT, sid1);
     CHECK(ret, FAIL, "H5Dfill");
 
     /* Verify memory buffer the hard way... */
-    for(i=0, tbuf=wbuf; i<SPACE7_DIM1; i++)
-        for(j=0; j<SPACE7_DIM2; j++)
-            if(*tbuf!=(unsigned short)fill_value)
-                TestErrPrintf("Error! j=%d, i=%d, *tbuf=%x, fill_value=%x\n",j,i,(unsigned)*tbuf,(unsigned)fill_value);
+    for(u = 0, tbuf = wbuf; u < SPACE7_DIM1; u++)
+        for(v = 0; v < SPACE7_DIM2; v++)
+            if(*tbuf != fill_value)
+                TestErrPrintf("Error! v=%d, u=%u, *tbuf=%u, fill_value=%u\n", v, u, *tbuf, fill_value);
 
     /* Set the coordinates of the selection */
-    for(i=0; i<SPACE7_DIM1; i++)
-        for(j=0; j<SPACE7_DIM2; j++) {
-            points[(i*SPACE7_DIM2)+j][0]=i;
-            points[(i*SPACE7_DIM2)+j][1]=j;
+    for(u = 0; u < SPACE7_DIM1; u++)
+        for(v = 0; v < SPACE7_DIM2; v++) {
+            points[(u * SPACE7_DIM2) + v][0] = u;
+            points[(u * SPACE7_DIM2) + v][1] = v;
         } /* end for */
 
     /* Initialize the iterator structure */
-    iter_info.fill_value=SPACE7_FILL;
-    iter_info.curr_coord=0;
-    iter_info.coords=(hsize_t *)points;
+    iter_info.fill_value = SPACE7_FILL;
+    iter_info.curr_coord = 0;
+    iter_info.coords = (hsize_t *)points;
 
     /* Iterate through selection, verifying correct data */
-    ret = H5Diterate(wbuf,H5T_NATIVE_USHORT,sid1,test_select_hyper_iter3,&iter_info);
+    ret = H5Diterate(wbuf, H5T_NATIVE_UINT, sid1, test_select_hyper_iter3, &iter_info);
     CHECK(ret, FAIL, "H5Diterate");
 
     /* Close dataspace */
@@ -5085,78 +7113,78 @@ test_select_fill_point(hssize_t *offset)
     hsize_t	dims1[] = {SPACE7_DIM1, SPACE7_DIM2};
     hssize_t    real_offset[SPACE7_RANK];       /* Actual offset to use */
     hsize_t     points[5][SPACE7_RANK] = {{2,4}, {3,8}, {8,4}, {7,5}, {7,7}};
-    size_t      num_points=5;   /* Number of points selected */
+    size_t      num_points = 5; /* Number of points selected */
     int         fill_value;     /* Fill value */
     fill_iter_info iter_info;   /* Iterator information structure */
-    unsigned short *wbuf,       /* buffer to write to disk */
+    unsigned   *wbuf,           /* buffer to write to disk */
                *tbuf;           /* temporary buffer pointer */
-    int         i,j,k;          /* Counters */
+    unsigned   u, v, w;        /* Counters */
     herr_t	ret;		/* Generic return value	*/
 
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Filling 'point' Selections\n"));
 
     /* Allocate memory buffer */
-    wbuf = (unsigned short *)HDmalloc(sizeof(unsigned short)*SPACE7_DIM1*SPACE7_DIM2);
+    wbuf = (unsigned *)HDmalloc(sizeof(unsigned) * SPACE7_DIM1 * SPACE7_DIM2);
     CHECK(wbuf, NULL, "HDmalloc");
 
     /* Initialize memory buffer */
-    for(i=0, tbuf=wbuf; i<SPACE7_DIM1; i++)
-        for(j=0; j<SPACE7_DIM2; j++)
-            *tbuf++=(unsigned short)(i*SPACE7_DIM2)+j;
+    for(u = 0, tbuf = wbuf; u < SPACE7_DIM1; u++)
+        for(v = 0; v < SPACE7_DIM2; v++)
+            *tbuf++ = (unsigned short)(u * SPACE7_DIM2) + v;
 
     /* Create dataspace for dataset on disk */
     sid1 = H5Screate_simple(SPACE7_RANK, dims1, NULL);
     CHECK(sid1, FAIL, "H5Screate_simple");
 
     /* Select "point" selection */
-    ret = H5Sselect_elements(sid1, H5S_SELECT_SET,num_points,(const hsize_t *)points);
+    ret = H5Sselect_elements(sid1, H5S_SELECT_SET, num_points, (const hsize_t *)points);
     CHECK(ret, FAIL, "H5Sselect_elements");
 
-    if(offset!=NULL) {
-        HDmemcpy(real_offset,offset,SPACE7_RANK*sizeof(hssize_t));
+    if(offset != NULL) {
+        HDmemcpy(real_offset, offset, SPACE7_RANK * sizeof(hssize_t));
 
         /* Set offset, if provided */
-        ret = H5Soffset_simple(sid1,real_offset);
+        ret = H5Soffset_simple(sid1, real_offset);
         CHECK(ret, FAIL, "H5Soffset_simple");
     } /* end if */
     else
-        HDmemset(real_offset,0,SPACE7_RANK*sizeof(hssize_t));
+        HDmemset(real_offset, 0, SPACE7_RANK * sizeof(hssize_t));
 
     /* Set fill value */
-    fill_value=SPACE7_FILL;
+    fill_value = SPACE7_FILL;
 
     /* Fill selection in memory */
-    ret=H5Dfill(&fill_value,H5T_NATIVE_INT,wbuf,H5T_NATIVE_USHORT,sid1);
+    ret = H5Dfill(&fill_value, H5T_NATIVE_INT, wbuf, H5T_NATIVE_UINT, sid1);
     CHECK(ret, FAIL, "H5Dfill");
 
     /* Verify memory buffer the hard way... */
-    for(i=0, tbuf=wbuf; i<SPACE7_DIM1; i++)
-        for(j=0; j<SPACE7_DIM2; j++, tbuf++) {
-            for(k=0; k<(int)num_points; k++) {
-                if(i==(int)(points[k][0]+real_offset[0]) && j==(int)(points[k][1]+real_offset[1])) {
-                    if(*tbuf!=(unsigned short)fill_value)
-                        TestErrPrintf("Error! j=%d, i=%d, *tbuf=%u, fill_value=%u\n",j,i,(unsigned)*tbuf,(unsigned)fill_value);
+    for(u = 0, tbuf = wbuf; u < SPACE7_DIM1; u++)
+        for(v = 0; v < SPACE7_DIM2; v++, tbuf++) {
+            for(w = 0; w < (unsigned)num_points; w++) {
+                if(u == (unsigned)(points[w][0] + (hsize_t)real_offset[0]) && v == (unsigned)(points[w][1] + (hsize_t)real_offset[1])) {
+                    if(*tbuf != (unsigned)fill_value)
+                        TestErrPrintf("Error! v=%u, u=%u, *tbuf=%u, fill_value=%u\n", v, u, *tbuf, (unsigned)fill_value);
                     break;
                 } /* end if */
             } /* end for */
-            if(k==(int)num_points && *tbuf!=((unsigned short)(i*SPACE7_DIM2)+j))
-                TestErrPrintf("Error! j=%d, i=%d, *tbuf=%u, should be: %u\n",j,i,(unsigned)*tbuf,(unsigned)((i*SPACE7_DIM2)+j));
+            if(w == (unsigned)num_points && *tbuf != ((u * SPACE7_DIM2) + v))
+                TestErrPrintf("Error! v=%d, u=%d, *tbuf=%u, should be: %u\n", v, u, *tbuf, ((u * SPACE7_DIM2) + v));
         } /* end for */
 
     /* Initialize the iterator structure */
-    iter_info.fill_value=SPACE7_FILL;
-    iter_info.curr_coord=0;
-    iter_info.coords=(hsize_t *)points;
+    iter_info.fill_value = SPACE7_FILL;
+    iter_info.curr_coord = 0;
+    iter_info.coords = (hsize_t *)points;
 
     /* Add in the offset */
-    for(i=0; i<(int)num_points; i++) {
-        points[i][0]+=real_offset[0];
-        points[i][1]+=real_offset[1];
+    for(u = 0; u < (unsigned)num_points; u++) {
+        points[u][0] = (hsize_t)(points[u][0] + real_offset[0]);
+        points[u][1] = (hsize_t)(points[u][1] + real_offset[1]);
     } /* end for */
 
     /* Iterate through selection, verifying correct data */
-    ret = H5Diterate(wbuf,H5T_NATIVE_USHORT,sid1,test_select_hyper_iter3,&iter_info);
+    ret = H5Diterate(wbuf, H5T_NATIVE_UINT, sid1, test_select_hyper_iter3, &iter_info);
     CHECK(ret, FAIL, "H5Diterate");
 
     /* Close dataspace */
@@ -5185,78 +7213,78 @@ test_select_fill_hyper_simple(hssize_t *offset)
     hsize_t     points[16][SPACE7_RANK];        /* Coordinates selected */
     int         fill_value;     /* Fill value */
     fill_iter_info iter_info;   /* Iterator information structure */
-    unsigned short *wbuf,       /* buffer to write to disk */
+    unsigned   *wbuf,           /* buffer to write to disk */
                *tbuf;           /* temporary buffer pointer */
-    int         i,j;            /* Counters */
+    unsigned    u, v;           /* Counters */
     herr_t	ret;		/* Generic return value	*/
 
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Filling Simple 'hyperslab' Selections\n"));
 
     /* Allocate memory buffer */
-    wbuf = (unsigned short *)HDmalloc(sizeof(unsigned short)*SPACE7_DIM1*SPACE7_DIM2);
+    wbuf = (unsigned *)HDmalloc(sizeof(unsigned) * SPACE7_DIM1 * SPACE7_DIM2);
     CHECK(wbuf, NULL, "HDmalloc");
 
     /* Initialize memory buffer */
-    for(i=0, tbuf=wbuf; i<SPACE7_DIM1; i++)
-        for(j=0; j<SPACE7_DIM2; j++)
-            *tbuf++=(unsigned short)(i*SPACE7_DIM2)+j;
+    for(u = 0, tbuf = wbuf; u < SPACE7_DIM1; u++)
+        for(v = 0; v < SPACE7_DIM2; v++)
+            *tbuf++ = (unsigned short)(u * SPACE7_DIM2) + v;
 
     /* Create dataspace for dataset on disk */
     sid1 = H5Screate_simple(SPACE7_RANK, dims1, NULL);
     CHECK(sid1, FAIL, "H5Screate_simple");
 
     /* Select "hyperslab" selection */
-    start[0]=3; start[1]=3;
-    count[0]=4; count[1]=4;
-    ret = H5Sselect_hyperslab(sid1, H5S_SELECT_SET,start,NULL,count,NULL);
+    start[0] = 3; start[1] = 3;
+    count[0] = 4; count[1] = 4;
+    ret = H5Sselect_hyperslab(sid1, H5S_SELECT_SET, start, NULL, count, NULL);
     CHECK(ret, FAIL, "H5Sselect_hyperslab");
 
-    if(offset!=NULL) {
-        HDmemcpy(real_offset,offset,SPACE7_RANK*sizeof(hssize_t));
+    if(offset != NULL) {
+        HDmemcpy(real_offset, offset, SPACE7_RANK * sizeof(hssize_t));
 
         /* Set offset, if provided */
-        ret = H5Soffset_simple(sid1,real_offset);
+        ret = H5Soffset_simple(sid1, real_offset);
         CHECK(ret, FAIL, "H5Soffset_simple");
     } /* end if */
     else
-        HDmemset(real_offset,0,SPACE7_RANK*sizeof(hssize_t));
+        HDmemset(real_offset, 0, SPACE7_RANK * sizeof(hssize_t));
 
     /* Set fill value */
-    fill_value=SPACE7_FILL;
+    fill_value = SPACE7_FILL;
 
     /* Fill selection in memory */
-    ret=H5Dfill(&fill_value,H5T_NATIVE_INT,wbuf,H5T_NATIVE_USHORT,sid1);
+    ret = H5Dfill(&fill_value, H5T_NATIVE_INT, wbuf, H5T_NATIVE_UINT, sid1);
     CHECK(ret, FAIL, "H5Dfill");
 
     /* Verify memory buffer the hard way... */
-    for(i=0, tbuf=wbuf; i<SPACE7_DIM1; i++)
-        for(j=0; j<SPACE7_DIM2; j++, tbuf++) {
-            if((i>=(int)(start[0]+real_offset[0]) && i<(int)(start[0]+count[0]+real_offset[0]))
-                && (j>=(int)(start[1]+real_offset[1]) && j<(int)(start[1]+count[1]+real_offset[1]))) {
-                    if(*tbuf!=(unsigned short)fill_value)
-                        TestErrPrintf("Error! j=%d, i=%d, *tbuf=%u, fill_value=%u\n",j,i,(unsigned)*tbuf,(unsigned)fill_value);
+    for(u = 0, tbuf = wbuf; u < SPACE7_DIM1; u++)
+        for(v = 0; v < SPACE7_DIM2; v++, tbuf++) {
+            if((u >= (unsigned)(start[0] + real_offset[0]) && u < (unsigned)(start[0] + count[0] + real_offset[0]))
+                && (v >= (unsigned)(start[1] + real_offset[1]) && v < (unsigned)(start[1] + count[1] + real_offset[1]))) {
+                    if(*tbuf != (unsigned)fill_value)
+                        TestErrPrintf("Error! v=%u, u=%u, *tbuf=%u, fill_value=%u\n", v, u, *tbuf, (unsigned)fill_value);
                 } /* end if */
             else {
-                if(*tbuf!=((unsigned short)(i*SPACE7_DIM2)+j))
-                    TestErrPrintf("Error! j=%d, i=%d, *tbuf=%u, should be: %u\n",j,i,(unsigned)*tbuf,(unsigned)((i*SPACE7_DIM2)+j));
+                if(*tbuf != ((unsigned)(u * SPACE7_DIM2) + v))
+                    TestErrPrintf("Error! v=%u, u=%u, *tbuf=%u, should be: %u\n", v, u, *tbuf, ((u * SPACE7_DIM2) + v));
             } /* end else */
         } /* end for */
 
     /* Initialize the iterator structure */
-    iter_info.fill_value=SPACE7_FILL;
-    iter_info.curr_coord=0;
-    iter_info.coords=(hsize_t *)points;
+    iter_info.fill_value = SPACE7_FILL;
+    iter_info.curr_coord = 0;
+    iter_info.coords = (hsize_t *)points;
 
     /* Set the coordinates of the selection (with the offset) */
-    for(i=0, num_points=0; i<(int)count[0]; i++)
-        for(j=0; j<(int)count[1]; j++, num_points++) {
-            points[num_points][0]=i+start[0]+real_offset[0];
-            points[num_points][1]=j+start[1]+real_offset[1];
+    for(u = 0, num_points = 0; u < (unsigned)count[0]; u++)
+        for(v = 0; v < (unsigned)count[1]; v++, num_points++) {
+            points[num_points][0] = (hsize_t)(u + start[0] + real_offset[0]);
+            points[num_points][1] = (hsize_t)(v + start[1] + real_offset[1]);
         } /* end for */
 
     /* Iterate through selection, verifying correct data */
-    ret = H5Diterate(wbuf,H5T_NATIVE_USHORT,sid1,test_select_hyper_iter3,&iter_info);
+    ret = H5Diterate(wbuf, H5T_NATIVE_UINT, sid1, test_select_hyper_iter3, &iter_info);
     CHECK(ret, FAIL, "H5Diterate");
 
     /* Close dataspace */
@@ -5292,79 +7320,79 @@ test_select_fill_hyper_regular(hssize_t *offset)
     size_t      num_points=16;  /* Number of points selected */
     int         fill_value;     /* Fill value */
     fill_iter_info iter_info;   /* Iterator information structure */
-    unsigned short *wbuf,       /* buffer to write to disk */
+    unsigned   *wbuf,           /* buffer to write to disk */
                *tbuf;           /* temporary buffer pointer */
-    int         i,j,k;          /* Counters */
+    unsigned    u, v, w;        /* Counters */
     herr_t	ret;		/* Generic return value	*/
 
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Filling Regular 'hyperslab' Selections\n"));
 
     /* Allocate memory buffer */
-    wbuf = (unsigned short *)HDmalloc(sizeof(unsigned short)*SPACE7_DIM1*SPACE7_DIM2);
+    wbuf = (unsigned *)HDmalloc(sizeof(unsigned) * SPACE7_DIM1 * SPACE7_DIM2);
     CHECK(wbuf, NULL, "HDmalloc");
 
     /* Initialize memory buffer */
-    for(i=0, tbuf=wbuf; i<SPACE7_DIM1; i++)
-        for(j=0; j<SPACE7_DIM2; j++)
-            *tbuf++=(unsigned short)(i*SPACE7_DIM2)+j;
+    for(u = 0, tbuf = wbuf; u < SPACE7_DIM1; u++)
+        for(v = 0; v < SPACE7_DIM2; v++)
+            *tbuf++ =(u * SPACE7_DIM2) + v;
 
     /* Create dataspace for dataset on disk */
     sid1 = H5Screate_simple(SPACE7_RANK, dims1, NULL);
     CHECK(sid1, FAIL, "H5Screate_simple");
 
     /* Select "hyperslab" selection */
-    start[0]=2; start[1]=2;
-    stride[0]=4; stride[1]=4;
-    count[0]=2; count[1]=2;
-    block[0]=2; block[1]=2;
-    ret = H5Sselect_hyperslab(sid1,H5S_SELECT_SET,start,stride,count,block);
+    start[0] = 2; start[1] = 2;
+    stride[0] = 4; stride[1] = 4;
+    count[0] = 2; count[1] = 2;
+    block[0] = 2; block[1] = 2;
+    ret = H5Sselect_hyperslab(sid1, H5S_SELECT_SET, start, stride, count, block);
     CHECK(ret, FAIL, "H5Sselect_hyperslab");
 
-    if(offset!=NULL) {
-        HDmemcpy(real_offset,offset,SPACE7_RANK*sizeof(hssize_t));
+    if(offset != NULL) {
+        HDmemcpy(real_offset, offset, SPACE7_RANK * sizeof(hssize_t));
 
         /* Set offset, if provided */
-        ret = H5Soffset_simple(sid1,real_offset);
+        ret = H5Soffset_simple(sid1, real_offset);
         CHECK(ret, FAIL, "H5Soffset_simple");
     } /* end if */
     else
-        HDmemset(real_offset,0,SPACE7_RANK*sizeof(hssize_t));
+        HDmemset(real_offset, 0, SPACE7_RANK * sizeof(hssize_t));
 
     /* Set fill value */
-    fill_value=SPACE7_FILL;
+    fill_value = SPACE7_FILL;
 
     /* Fill selection in memory */
-    ret=H5Dfill(&fill_value,H5T_NATIVE_INT,wbuf,H5T_NATIVE_USHORT,sid1);
+    ret = H5Dfill(&fill_value, H5T_NATIVE_INT, wbuf, H5T_NATIVE_UINT, sid1);
     CHECK(ret, FAIL, "H5Dfill");
 
     /* Verify memory buffer the hard way... */
-    for(i=0, tbuf=wbuf; i<SPACE7_DIM1; i++)
-        for(j=0; j<SPACE7_DIM2; j++, tbuf++) {
-            for(k=0; k<(int)num_points; k++) {
-                if(i==(int)(points[k][0]+real_offset[0]) && j==(int)(points[k][1]+real_offset[1])) {
-                    if(*tbuf!=(unsigned short)fill_value)
-                        TestErrPrintf("Error! j=%d, i=%d, *tbuf=%u, fill_value=%u\n",j,i,(unsigned)*tbuf,(unsigned)fill_value);
+    for(u = 0, tbuf = wbuf; u < SPACE7_DIM1; u++)
+        for(v = 0; v < SPACE7_DIM2; v++, tbuf++) {
+            for(w = 0; w < (unsigned)num_points; w++) {
+                if(u == (unsigned)(points[w][0] + real_offset[0]) && v == (unsigned)(points[w][1] + real_offset[1])) {
+                    if(*tbuf != (unsigned)fill_value)
+                        TestErrPrintf("Error! v=%u, u=%u, *tbuf=%u, fill_value=%u\n", v, u, *tbuf, (unsigned)fill_value);
                     break;
                 } /* end if */
             } /* end for */
-            if(k==(int)num_points && *tbuf!=((unsigned short)(i*SPACE7_DIM2)+j))
-                TestErrPrintf("Error! j=%d, i=%d, *tbuf=%u, should be: %u\n",j,i,(unsigned)*tbuf,(unsigned)((i*SPACE7_DIM2)+j));
+            if(w == (unsigned)num_points && *tbuf != ((u * SPACE7_DIM2) + v))
+                TestErrPrintf("Error! v=%d, u=%d, *tbuf=%u, should be: %u\n", v, u, *tbuf, ((u * SPACE7_DIM2) + v));
         } /* end for */
 
     /* Initialize the iterator structure */
-    iter_info.fill_value=SPACE7_FILL;
-    iter_info.curr_coord=0;
-    iter_info.coords=(hsize_t *)points;
+    iter_info.fill_value = SPACE7_FILL;
+    iter_info.curr_coord = 0;
+    iter_info.coords = (hsize_t *)points;
 
     /* Add in the offset */
-    for(i=0; i<(int)num_points; i++) {
-        points[i][0] += real_offset[0];
-        points[i][1] += real_offset[1];
+    for(u = 0; u < (unsigned)num_points; u++) {
+        points[u][0] = (hsize_t)(points[u][0] + real_offset[0]);
+        points[u][1] = (hsize_t)(points[u][1] + real_offset[1]);
     } /* end for */
 
     /* Iterate through selection, verifying correct data */
-    ret = H5Diterate(wbuf,H5T_NATIVE_USHORT,sid1,test_select_hyper_iter3,&iter_info);
+    ret = H5Diterate(wbuf, H5T_NATIVE_UINT, sid1, test_select_hyper_iter3, &iter_info);
     CHECK(ret, FAIL, "H5Diterate");
 
     /* Close dataspace */
@@ -5407,72 +7435,72 @@ test_select_fill_hyper_irregular(hssize_t *offset)
         {6,4}, {6,5}, {6,6}, {6,7},
         {7,4}, {7,5}, {7,6}, {7,7},
         };
-    size_t      num_points=32;  /* Number of points selected */
-    size_t      num_iter_points=28;  /* Number of resulting points */
+    size_t      num_points = 32;  /* Number of points selected */
+    size_t      num_iter_points = 28;  /* Number of resulting points */
     int         fill_value;     /* Fill value */
     fill_iter_info iter_info;   /* Iterator information structure */
-    unsigned short *wbuf,       /* buffer to write to disk */
+    unsigned   *wbuf,           /* buffer to write to disk */
                *tbuf;           /* temporary buffer pointer */
-    int         i,j,k;          /* Counters */
+    unsigned    u, v, w;        /* Counters */
     herr_t	ret;		/* Generic return value	*/
 
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Filling Irregular 'hyperslab' Selections\n"));
 
     /* Allocate memory buffer */
-    wbuf = (unsigned short *)HDmalloc(sizeof(unsigned short)*SPACE7_DIM1*SPACE7_DIM2);
+    wbuf = (unsigned *)HDmalloc(sizeof(unsigned) * SPACE7_DIM1 * SPACE7_DIM2);
     CHECK(wbuf, NULL, "HDmalloc");
 
     /* Initialize memory buffer */
-    for(i=0, tbuf=wbuf; i<SPACE7_DIM1; i++)
-        for(j=0; j<SPACE7_DIM2; j++)
-            *tbuf++=(unsigned short)(i*SPACE7_DIM2)+j;
+    for(u = 0, tbuf = wbuf; u < SPACE7_DIM1; u++)
+        for(v = 0; v < SPACE7_DIM2; v++)
+            *tbuf++ = (u * SPACE7_DIM2) + v;
 
     /* Create dataspace for dataset on disk */
     sid1 = H5Screate_simple(SPACE7_RANK, dims1, NULL);
     CHECK(sid1, FAIL, "H5Screate_simple");
 
     /* Select first "hyperslab" selection */
-    start[0]=2; start[1]=2;
-    count[0]=4; count[1]=4;
-    ret = H5Sselect_hyperslab(sid1,H5S_SELECT_SET,start,NULL,count,NULL);
+    start[0] = 2; start[1] = 2;
+    count[0] = 4; count[1] = 4;
+    ret = H5Sselect_hyperslab(sid1, H5S_SELECT_SET, start, NULL, count, NULL);
     CHECK(ret, FAIL, "H5Sselect_hyperslab");
 
     /* Combine with second "hyperslab" selection */
-    start[0]=4; start[1]=4;
-    count[0]=4; count[1]=4;
-    ret = H5Sselect_hyperslab(sid1,H5S_SELECT_OR,start,NULL,count,NULL);
+    start[0] = 4; start[1] = 4;
+    count[0] = 4; count[1] = 4;
+    ret = H5Sselect_hyperslab(sid1, H5S_SELECT_OR, start, NULL, count, NULL);
     CHECK(ret, FAIL, "H5Sselect_hyperslab");
 
-    if(offset!=NULL) {
-        HDmemcpy(real_offset,offset,SPACE7_RANK*sizeof(hssize_t));
+    if(offset != NULL) {
+        HDmemcpy(real_offset, offset, SPACE7_RANK * sizeof(hssize_t));
 
         /* Set offset, if provided */
-        ret = H5Soffset_simple(sid1,real_offset);
+        ret = H5Soffset_simple(sid1, real_offset);
         CHECK(ret, FAIL, "H5Soffset_simple");
     } /* end if */
     else
-        HDmemset(real_offset,0,SPACE7_RANK*sizeof(hssize_t));
+        HDmemset(real_offset, 0, SPACE7_RANK * sizeof(hssize_t));
 
     /* Set fill value */
-    fill_value=SPACE7_FILL;
+    fill_value = SPACE7_FILL;
 
     /* Fill selection in memory */
-    ret=H5Dfill(&fill_value,H5T_NATIVE_INT,wbuf,H5T_NATIVE_USHORT,sid1);
+    ret = H5Dfill(&fill_value, H5T_NATIVE_INT, wbuf, H5T_NATIVE_UINT, sid1);
     CHECK(ret, FAIL, "H5Dfill");
 
     /* Verify memory buffer the hard way... */
-    for(i=0, tbuf=wbuf; i<SPACE7_DIM1; i++)
-        for(j=0; j<SPACE7_DIM2; j++, tbuf++) {
-            for(k=0; k<(int)num_points; k++) {
-                if(i==(int)(points[k][0]+real_offset[0]) && j==(int)(points[k][1]+real_offset[1])) {
-                    if(*tbuf!=(unsigned short)fill_value)
-                        TestErrPrintf("Error! j=%d, i=%d, *tbuf=%u, fill_value=%u\n",j,i,(unsigned)*tbuf,(unsigned)fill_value);
+    for(u = 0, tbuf = wbuf; u < SPACE7_DIM1; u++)
+        for(v = 0; v < SPACE7_DIM2; v++, tbuf++) {
+            for(w = 0; w < (unsigned)num_points; w++) {
+                if(u == (unsigned)(points[w][0] + real_offset[0]) && v == (unsigned)(points[w][1] + real_offset[1])) {
+                    if(*tbuf != (unsigned)fill_value)
+                        TestErrPrintf("Error! v=%u, u=%u, *tbuf=%u, fill_value=%u\n", v, u, *tbuf, (unsigned)fill_value);
                     break;
                 } /* end if */
             } /* end for */
-            if(k==(int)num_points && *tbuf!=((unsigned short)(i*SPACE7_DIM2)+j))
-                TestErrPrintf("Error! j=%d, i=%d, *tbuf=%u, should be: %u\n",j,i,(unsigned)*tbuf,(unsigned)((i*SPACE7_DIM2)+j));
+            if(w == (unsigned)num_points && *tbuf != ((u * SPACE7_DIM2) + v))
+                TestErrPrintf("Error! v=%u, u=%u, *tbuf=%u, should be: %u\n", v, u, *tbuf, ((u * SPACE7_DIM2) + v));
         } /* end for */
 
     /* Initialize the iterator structure */
@@ -5481,13 +7509,13 @@ test_select_fill_hyper_irregular(hssize_t *offset)
     iter_info.coords = (hsize_t *)iter_points;
 
     /* Add in the offset */
-    for(i=0; i<(int)num_iter_points; i++) {
-        iter_points[i][0] += real_offset[0];
-        iter_points[i][1] += real_offset[1];
+    for(u = 0; u < (unsigned)num_iter_points; u++) {
+        iter_points[u][0] = (hsize_t)(iter_points[u][0] + real_offset[0]);
+        iter_points[u][1] = (hsize_t)(iter_points[u][1] + real_offset[1]);
     } /* end for */
 
     /* Iterate through selection, verifying correct data */
-    ret = H5Diterate(wbuf, H5T_NATIVE_USHORT, sid1, test_select_hyper_iter3, &iter_info);
+    ret = H5Diterate(wbuf, H5T_NATIVE_UINT, sid1, test_select_hyper_iter3, &iter_info);
     CHECK(ret, FAIL, "H5Diterate");
 
     /* Close dataspace */
@@ -7005,6 +9033,2855 @@ test_shape_same(void)
     CHECK(ret, FAIL, "H5Sclose");
 }   /* test_shape_same() */
 
+/****************************************************************
+**
+**  test_shape_same_dr__smoke_check_1(): 
+**
+**	Create a square, 2 D data space (10 X 10), and select 
+**	all of it.
+**
+**      Similarly, create nine, 3 D data spaces (10 X 10 X 10), 
+**	and select (10 X 10 X 1) hyper slabs in each, three with 
+**	the slab parallel to the xy plane, three parallel to the 
+**	xz plane, and three parallel to the yz plane.
+**
+**	Assuming that z is the fastest changing dimension, 
+**	H5S_select_shape_same() should return TRUE when comparing 
+**	the full 2 D space against any hyperslab parallel to the 
+**	yz plane in the 3 D space, and FALSE when comparing the 
+**	full 2 D space against the other two hyper slabs.
+**
+**	Also create two additional 3 D data spaces (10 X 10 X 10), 
+**	and select a (10 X 10 X 2) hyper slab parallel to the yz 
+**	axis in one of them, and two parallel (10 X 10 X 1) hyper 
+**	slabs parallel to the yz axis in the other.  
+**	H5S_select_shape_same() should return FALSE when comparing 
+**	each to the 2 D selection.
+**
+****************************************************************/
+static void
+test_shape_same_dr__smoke_check_1(void)
+{
+    hid_t	small_square_sid;
+    hid_t	small_cube_xy_slice_0_sid;
+    hid_t	small_cube_xy_slice_1_sid;
+    hid_t	small_cube_xy_slice_2_sid;
+    hid_t	small_cube_xz_slice_0_sid;
+    hid_t	small_cube_xz_slice_1_sid;
+    hid_t	small_cube_xz_slice_2_sid;
+    hid_t	small_cube_yz_slice_0_sid;
+    hid_t	small_cube_yz_slice_1_sid;
+    hid_t	small_cube_yz_slice_2_sid;
+    hid_t	small_cube_yz_slice_3_sid;
+    hid_t	small_cube_yz_slice_4_sid;
+    hsize_t	small_cube_dims[] = {10, 10, 10};
+    hsize_t	start[3];
+    hsize_t	stride[3];
+    hsize_t	count[3];
+    hsize_t	block[3];
+    htri_t	check;		/* Shape comparison return value */
+    herr_t	ret;		/* Generic return value	*/
+
+    MESSAGE(7, ("	Smoke check 1: Slices through a cube.\n"));
+
+    /* Create the 10 x 10 dataspace  */
+    small_square_sid = H5Screate_simple(2, small_cube_dims, NULL);
+    CHECK(small_square_sid, FAIL, "H5Screate_simple");
+
+    /* Create the 10 X 10 X 10 dataspaces for the hyperslab parallel to the xy axis */
+    small_cube_xy_slice_0_sid = H5Screate_simple(3, small_cube_dims, NULL);
+    CHECK(small_cube_xy_slice_0_sid, FAIL, "H5Screate_simple");
+
+    small_cube_xy_slice_1_sid = H5Screate_simple(3, small_cube_dims, NULL);
+    CHECK(small_cube_xy_slice_1_sid, FAIL, "H5Screate_simple");
+
+    small_cube_xy_slice_2_sid = H5Screate_simple(3, small_cube_dims, NULL);
+    CHECK(small_cube_xy_slice_2_sid, FAIL, "H5Screate_simple");
+
+    start[0] = 0;	/* x */
+    start[1] = 0;	/* y */
+    start[2] = 0;	/* z */
+
+    /* stride is a bit silly here, since we are only selecting a single  */
+    /* contiguous plane, but include it anyway, with values large enough */
+    /* to ensure that we will only get the single block selected. */
+    stride[0] = 20;	/* x */
+    stride[1] = 20;	/* y */
+    stride[2] = 20;	/* z */
+
+    count[0] = 1;	/* x */
+    count[1] = 1;	/* y */
+    count[2] = 1;	/* z */
+
+    block[0] = 10;	/* x */
+    block[1] = 10;	/* y */
+    block[2] =  1;	/* z */
+    ret = H5Sselect_hyperslab(small_cube_xy_slice_0_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[2] = 5;
+    ret = H5Sselect_hyperslab(small_cube_xy_slice_1_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[2] = 9;
+    ret = H5Sselect_hyperslab(small_cube_xy_slice_2_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+
+    /* Create the 10 X 10 X 10 dataspaces for the hyperslab parallel to the xz axis */
+    small_cube_xz_slice_0_sid = H5Screate_simple(3, small_cube_dims, NULL);
+    CHECK(small_cube_xz_slice_0_sid, FAIL, "H5Screate_simple");
+
+    small_cube_xz_slice_1_sid = H5Screate_simple(3, small_cube_dims, NULL);
+    CHECK(small_cube_xz_slice_1_sid, FAIL, "H5Screate_simple");
+
+    small_cube_xz_slice_2_sid = H5Screate_simple(3, small_cube_dims, NULL);
+    CHECK(small_cube_xz_slice_2_sid, FAIL, "H5Screate_simple");
+
+    start[0] = 0;	/* x */
+    start[1] = 0;	/* y */
+    start[2] = 0;	/* z */
+
+    /* stride is a bit silly here, since we are only selecting a single  */
+    /* contiguous chunk, but include it anyway, with values large enough */
+    /* to ensure that we will only get the single chunk. */
+    stride[0] = 20;	/* x */
+    stride[1] = 20;	/* y */
+    stride[2] = 20;	/* z */
+
+    count[0] = 1;	/* x */
+    count[1] = 1;	/* y */
+    count[2] = 1;	/* z */
+
+    block[0] = 10;	/* x */
+    block[1] =  1;	/* y */
+    block[2] = 10;	/* z */
+    ret = H5Sselect_hyperslab(small_cube_xz_slice_0_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[1] = 4;
+    ret = H5Sselect_hyperslab(small_cube_xz_slice_1_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[1] = 9;
+    ret = H5Sselect_hyperslab(small_cube_xz_slice_2_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+
+    /* Create the 10 X 10 X 10 dataspaces for the hyperslabs parallel to the yz axis */
+    small_cube_yz_slice_0_sid = H5Screate_simple(3, small_cube_dims, NULL);
+    CHECK(small_cube_yz_slice_0_sid, FAIL, "H5Screate_simple");
+
+    small_cube_yz_slice_1_sid = H5Screate_simple(3, small_cube_dims, NULL);
+    CHECK(small_cube_yz_slice_1_sid, FAIL, "H5Screate_simple");
+
+    small_cube_yz_slice_2_sid = H5Screate_simple(3, small_cube_dims, NULL);
+    CHECK(small_cube_yz_slice_2_sid, FAIL, "H5Screate_simple");
+
+    small_cube_yz_slice_3_sid = H5Screate_simple(3, small_cube_dims, NULL);
+    CHECK(small_cube_yz_slice_3_sid, FAIL, "H5Screate_simple");
+
+    small_cube_yz_slice_4_sid = H5Screate_simple(3, small_cube_dims, NULL);
+    CHECK(small_cube_yz_slice_4_sid, FAIL, "H5Screate_simple");
+
+    start[0] = 0;	/* x */
+    start[1] = 0;	/* y */
+    start[2] = 0;	/* z */
+
+    /* stride is a bit silly here, since we are only selecting a single  */
+    /* contiguous chunk, but include it anyway, with values large enough */
+    /* to ensure that we will only get the single chunk. */
+    stride[0] = 20;	/* x */
+    stride[1] = 20;	/* y */
+    stride[2] = 20;	/* z */
+
+    count[0] = 1;	/* x */
+    count[1] = 1;	/* y */
+    count[2] = 1;	/* z */
+
+    block[0] =  1;	/* x */
+    block[1] = 10;	/* y */
+    block[2] = 10;	/* z */
+
+    ret = H5Sselect_hyperslab(small_cube_yz_slice_0_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[0] = 4;
+    ret = H5Sselect_hyperslab(small_cube_yz_slice_1_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[0] = 9;
+    ret = H5Sselect_hyperslab(small_cube_yz_slice_2_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[0] = 4;
+    block[0] = 2;
+    ret = H5Sselect_hyperslab(small_cube_yz_slice_3_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[0] = 3;
+    block[0] = 1;
+    ret = H5Sselect_hyperslab(small_cube_yz_slice_4_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[0] = 6;
+    ret = H5Sselect_hyperslab(small_cube_yz_slice_4_sid, H5S_SELECT_OR,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+
+    /* setup is done -- run the tests: */
+
+    /* Compare against "xy" selection */
+    check = H5S_select_shape_same_test(small_cube_xy_slice_0_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5S_select_shape_same_test");
+
+    check = H5S_select_shape_same_test(small_cube_xy_slice_1_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5S_select_shape_same_test");
+
+    check = H5S_select_shape_same_test(small_cube_xy_slice_2_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5S_select_shape_same_test");
+
+
+    /* Compare against "xz" selection */
+    check = H5S_select_shape_same_test(small_cube_xz_slice_0_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5S_select_shape_same_test");
+
+    check = H5S_select_shape_same_test(small_cube_xz_slice_1_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5S_select_shape_same_test");
+
+    check = H5S_select_shape_same_test(small_cube_xz_slice_2_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5S_select_shape_same_test");
+
+
+    /* Compare against "yz" selection */
+    check = H5S_select_shape_same_test(small_cube_yz_slice_0_sid, small_square_sid);
+    VERIFY(check, TRUE, "H5S_select_shape_same_test");
+
+    check = H5S_select_shape_same_test(small_cube_yz_slice_1_sid, small_square_sid);
+    VERIFY(check, TRUE, "H5S_select_shape_same_test");
+
+    check = H5S_select_shape_same_test(small_cube_yz_slice_2_sid, small_square_sid);
+    VERIFY(check, TRUE, "H5S_select_shape_same_test");
+
+    check = H5S_select_shape_same_test(small_cube_yz_slice_3_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5S_select_shape_same_test");
+
+    check = H5S_select_shape_same_test(small_cube_yz_slice_4_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5S_select_shape_same_test");
+
+
+    /* Close dataspaces */
+    ret = H5Sclose(small_square_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+
+    ret = H5Sclose(small_cube_xy_slice_0_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(small_cube_xy_slice_1_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(small_cube_xy_slice_2_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+
+    ret = H5Sclose(small_cube_xz_slice_0_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(small_cube_xz_slice_1_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(small_cube_xz_slice_2_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+
+    ret = H5Sclose(small_cube_yz_slice_0_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(small_cube_yz_slice_1_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(small_cube_yz_slice_2_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(small_cube_yz_slice_3_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(small_cube_yz_slice_4_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+} /* test_shape_same_dr__smoke_check_1() */
+
+/****************************************************************
+**
+**  test_shape_same_dr__smoke_check_2(): 
+**
+**	Create a square, 2 D data space (10 X 10), and select 
+**	a "checker board" hyper slab as follows:
+**
+**		* * - - * * - - * *
+**              * * - - * * - - * *
+**              - - * * - - * * - -
+**              - - * * - - * * - -
+**		* * - - * * - - * *
+**              * * - - * * - - * *
+**              - - * * - - * * - -
+**              - - * * - - * * - -
+**		* * - - * * - - * *
+**              * * - - * * - - * *
+**
+**	where asterisks indicate selected elements, and dashes 
+**	indicate unselected elements.
+**
+**	Similarly, create nine, 3 D data spaces (10 X 10 X 10), 
+**	and select similar (10 X 10 X 1) checker board hyper 
+**	slabs in each, three with the slab parallel to  the xy 
+**	plane, three parallel to the xz plane, and three parallel 
+**	to the yz plane.
+**
+**	Assuming that z is the fastest changing dimension, 
+**	H5S_select_shape_same() should return TRUE when comparing 
+**	the 2 D space checker board selection against a checker 
+**	board hyperslab parallel to the yz plane in the 3 D 
+**	space, and FALSE when comparing the 2 D checkerboard 
+**	selection against two hyper slabs parallel to the xy 
+**	or xz planes.
+**
+**	Also create an additional 3 D data spaces (10 X 10 X 10), 
+**	and select a checker board parallel with the yz axis, 
+**	save with some squares being on different planes.  
+**	H5S_select_shape_same() should return FALSE when 
+**	comparing this selection to the 2 D selection.
+**
+****************************************************************/
+static void
+test_shape_same_dr__smoke_check_2(void)
+{
+    hid_t	small_square_sid;
+    hid_t	small_cube_xy_slice_0_sid;
+    hid_t	small_cube_xy_slice_1_sid;
+    hid_t	small_cube_xy_slice_2_sid;
+    hid_t	small_cube_xz_slice_0_sid;
+    hid_t	small_cube_xz_slice_1_sid;
+    hid_t	small_cube_xz_slice_2_sid;
+    hid_t	small_cube_yz_slice_0_sid;
+    hid_t	small_cube_yz_slice_1_sid;
+    hid_t	small_cube_yz_slice_2_sid;
+    hid_t	small_cube_yz_slice_3_sid;
+    hsize_t	small_cube_dims[] = {10, 10, 10};
+    hsize_t	start[3];
+    hsize_t	stride[3];
+    hsize_t	count[3];
+    hsize_t	block[3];
+    htri_t	check;		/* Shape comparison return value */
+    herr_t	ret;		/* Generic return value	*/
+
+    MESSAGE(7, ("	Smoke check 2: Checker board slices through a cube.\n"));
+
+    /* Create the 10 x 10 dataspace  */
+    small_square_sid = H5Screate_simple(2, small_cube_dims, NULL);
+    CHECK(small_square_sid, FAIL, "H5Screate_simple");
+
+    start[0] = 0;	/* x */
+    start[1] = 0;	/* y */
+
+    stride[0] = 4;	/* x */
+    stride[1] = 4;	/* y */
+
+    count[0] = 3;	/* x */
+    count[1] = 3;	/* y */
+
+    block[0] = 2;	/* x */
+    block[1] = 2;	/* y */
+    ret = H5Sselect_hyperslab(small_square_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[0] = 2;	/* x */
+    start[1] = 2;	/* y */
+
+    stride[0] = 4;	/* x */
+    stride[1] = 4;	/* y */
+
+    count[0] = 2;	/* x */
+    count[1] = 2;	/* y */
+
+    block[0] = 2;	/* x */
+    block[1] = 2;	/* y */
+    ret = H5Sselect_hyperslab(small_square_sid, H5S_SELECT_OR,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+
+    /* Create the 10 X 10 X 10 dataspaces for the hyperslab parallel to the xy axis */
+    small_cube_xy_slice_0_sid = H5Screate_simple(3, small_cube_dims, NULL);
+    CHECK(small_cube_xy_slice_0_sid, FAIL, "H5Screate_simple");
+
+    small_cube_xy_slice_1_sid = H5Screate_simple(3, small_cube_dims, NULL);
+    CHECK(small_cube_xy_slice_1_sid, FAIL, "H5Screate_simple");
+
+    small_cube_xy_slice_2_sid = H5Screate_simple(3, small_cube_dims, NULL);
+    CHECK(small_cube_xy_slice_2_sid, FAIL, "H5Screate_simple");
+
+
+    start[0] = 0;	/* x */
+    start[1] = 0;	/* y */
+    start[2] = 0;	/* z */
+
+    stride[0] =  4;	/* x */
+    stride[1] =  4;	/* y  */
+    stride[2] =  20;	/* z -- large enough that there will only be one slice */
+
+    count[0] = 3;	/* x */
+    count[1] = 3;	/* y */
+    count[2] = 1;	/* z */
+
+    block[0] = 2;	/* x */
+    block[1] = 2;	/* y */
+    block[2] = 1;	/* z */
+    ret = H5Sselect_hyperslab(small_cube_xy_slice_0_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[2] = 3;
+    ret = H5Sselect_hyperslab(small_cube_xy_slice_1_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[2] = 9;
+    ret = H5Sselect_hyperslab(small_cube_xy_slice_2_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+
+    start[0] = 2;	/* x */
+    start[1] = 2;	/* y */
+    start[2] = 0;	/* z */
+
+    stride[0] =  4;	/* x */
+    stride[1] =  4;	/* y  */
+    stride[2] =  20;	/* z -- large enough that there will only be one slice */
+
+    count[0] = 2;	/* x */
+    count[1] = 2;	/* y */
+    count[2] = 1;	/* z */
+
+    block[0] = 2;	/* x */
+    block[1] = 2;	/* y */
+    block[2] = 1;	/* z */
+    ret = H5Sselect_hyperslab(small_cube_xy_slice_0_sid, H5S_SELECT_OR,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[2] = 3;
+    ret = H5Sselect_hyperslab(small_cube_xy_slice_1_sid, H5S_SELECT_OR,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[2] = 9;
+    ret = H5Sselect_hyperslab(small_cube_xy_slice_2_sid, H5S_SELECT_OR,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+
+    /* Create the 10 X 10 X 10 dataspaces for the hyperslab parallel to the xz axis */
+    small_cube_xz_slice_0_sid = H5Screate_simple(3, small_cube_dims, NULL);
+    CHECK(small_cube_xz_slice_0_sid, FAIL, "H5Screate_simple");
+
+    small_cube_xz_slice_1_sid = H5Screate_simple(3, small_cube_dims, NULL);
+    CHECK(small_cube_xz_slice_1_sid, FAIL, "H5Screate_simple");
+
+    small_cube_xz_slice_2_sid = H5Screate_simple(3, small_cube_dims, NULL);
+    CHECK(small_cube_xz_slice_2_sid, FAIL, "H5Screate_simple");
+
+
+    start[0] = 0;	/* x */
+    start[1] = 0;	/* y */
+    start[2] = 0;	/* z */
+
+    stride[0] =  4;	/* x */
+    stride[1] = 20;	/* y -- large enough that there will only be one slice */
+    stride[2] =  4;	/* z */
+
+    count[0] = 3;	/* x */
+    count[1] = 1;	/* y */
+    count[2] = 3;	/* z */
+
+    block[0] = 2;	/* x */
+    block[1] = 1;	/* y */
+    block[2] = 2;	/* z */
+    ret = H5Sselect_hyperslab(small_cube_xz_slice_0_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[1] = 5;
+    ret = H5Sselect_hyperslab(small_cube_xz_slice_1_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[1] = 9;
+    ret = H5Sselect_hyperslab(small_cube_xz_slice_2_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[0] = 2;	/* x */
+    start[1] = 0;	/* y */
+    start[2] = 2;	/* z */
+
+    stride[0] =  4;	/* x */
+    stride[1] = 20;	/* y -- large enough that there will only be one slice */
+    stride[2] =  4;	/* z */
+
+    count[0] = 2;	/* x */
+    count[1] = 1;	/* y */
+    count[2] = 2;	/* z */
+
+    block[0] = 2;	/* x */
+    block[1] = 1;	/* y */
+    block[2] = 2;	/* z */
+    ret = H5Sselect_hyperslab(small_cube_xz_slice_0_sid, H5S_SELECT_OR,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[1] = 5;
+    ret = H5Sselect_hyperslab(small_cube_xz_slice_1_sid, H5S_SELECT_OR,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[1] = 9;
+    ret = H5Sselect_hyperslab(small_cube_xz_slice_2_sid, H5S_SELECT_OR,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+
+    /* Create the 10 X 10 X 10 dataspaces for the hyperslabs parallel to the yz axis */
+    small_cube_yz_slice_0_sid = H5Screate_simple(3, small_cube_dims, NULL);
+    CHECK(small_cube_yz_slice_0_sid, FAIL, "H5Screate_simple");
+
+    small_cube_yz_slice_1_sid = H5Screate_simple(3, small_cube_dims, NULL);
+    CHECK(small_cube_yz_slice_1_sid, FAIL, "H5Screate_simple");
+
+    small_cube_yz_slice_2_sid = H5Screate_simple(3, small_cube_dims, NULL);
+    CHECK(small_cube_yz_slice_2_sid, FAIL, "H5Screate_simple");
+
+    small_cube_yz_slice_3_sid = H5Screate_simple(3, small_cube_dims, NULL);
+    CHECK(small_cube_yz_slice_3_sid, FAIL, "H5Screate_simple");
+
+    start[0] = 0;	/* x */
+    start[1] = 0;	/* y */
+    start[2] = 0;	/* z */
+
+    stride[0] = 20;	/* x -- large enough that there will only be one slice */
+    stride[1] =  4;	/* y  */
+    stride[2] =  4;	/* z */
+
+    count[0] = 1;	/* x */
+    count[1] = 3;	/* y */
+    count[2] = 3;	/* z */
+
+    block[0] = 1;	/* x */
+    block[1] = 2;	/* y */
+    block[2] = 2;	/* z */
+    ret = H5Sselect_hyperslab(small_cube_yz_slice_0_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[0] = 8;
+    ret = H5Sselect_hyperslab(small_cube_yz_slice_1_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[0] = 9;
+    ret = H5Sselect_hyperslab(small_cube_yz_slice_2_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[0] = 3;
+    ret = H5Sselect_hyperslab(small_cube_yz_slice_3_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+
+    start[0] = 0;	/* x */
+    start[1] = 2;	/* y */
+    start[2] = 2;	/* z */
+
+    stride[0] = 20;	/* x -- large enough that there will only be one slice */
+    stride[1] =  4;	/* y */
+    stride[2] =  4;	/* z */
+
+    count[0] = 1;	/* x */
+    count[1] = 2;	/* y */
+    count[2] = 2;	/* z */
+
+    block[0] = 1;	/* x */
+    block[1] = 2;	/* y */
+    block[2] = 2;	/* z */
+    ret = H5Sselect_hyperslab(small_cube_yz_slice_0_sid, H5S_SELECT_OR,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[0] = 8;
+    ret = H5Sselect_hyperslab(small_cube_yz_slice_1_sid, H5S_SELECT_OR,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[0] = 9;
+    ret = H5Sselect_hyperslab(small_cube_yz_slice_2_sid, H5S_SELECT_OR,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[0] = 4;
+    /* This test gets the right answer, but it fails the shape same
+     * test in an unexpected point.  Bring this up with Quincey, as 
+     * the oddness looks like it is not related to my code.
+     *                                      -- JRM
+     */
+    ret = H5Sselect_hyperslab(small_cube_yz_slice_3_sid, H5S_SELECT_OR,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+
+    /* setup is done -- run the tests: */
+
+    /* Compare against "xy" selection */
+    check = H5S_select_shape_same_test(small_cube_xy_slice_0_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5S_select_shape_same_test");
+
+    check = H5S_select_shape_same_test(small_cube_xy_slice_1_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5S_select_shape_same_test");
+
+    check = H5S_select_shape_same_test(small_cube_xy_slice_2_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5S_select_shape_same_test");
+
+
+    /* Compare against "xz" selection */
+    check = H5S_select_shape_same_test(small_cube_xz_slice_0_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5S_select_shape_same_test");
+
+    check = H5S_select_shape_same_test(small_cube_xz_slice_1_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5S_select_shape_same_test");
+
+    check = H5S_select_shape_same_test(small_cube_xz_slice_2_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5S_select_shape_same_test");
+
+
+    /* Compare against "yz" selection */
+    check = H5S_select_shape_same_test(small_cube_yz_slice_0_sid, small_square_sid);
+    VERIFY(check, TRUE, "H5S_select_shape_same_test");
+
+    check = H5S_select_shape_same_test(small_cube_yz_slice_1_sid, small_square_sid);
+    VERIFY(check, TRUE, "H5S_select_shape_same_test");
+
+    check = H5S_select_shape_same_test(small_cube_yz_slice_2_sid, small_square_sid);
+    VERIFY(check, TRUE, "H5S_select_shape_same_test");
+
+    check = H5S_select_shape_same_test(small_cube_yz_slice_3_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5S_select_shape_same_test");
+
+
+    /* Close dataspaces */
+    ret = H5Sclose(small_square_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+
+    ret = H5Sclose(small_cube_xy_slice_0_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(small_cube_xy_slice_1_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(small_cube_xy_slice_2_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+
+    ret = H5Sclose(small_cube_xz_slice_0_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(small_cube_xz_slice_1_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(small_cube_xz_slice_2_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+
+    ret = H5Sclose(small_cube_yz_slice_0_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(small_cube_yz_slice_1_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(small_cube_yz_slice_2_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(small_cube_yz_slice_3_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+} /* test_shape_same_dr__smoke_check_2() */
+
+
+/****************************************************************
+**
+**  test_shape_same_dr__smoke_check_3(): 
+**
+**	Create a square, 2 D data space (10 X 10), and select an 
+**	irregular hyper slab as follows:
+**
+**		y
+**		9 - - - - - - - - - -
+**		8 - - - - - - - - - -
+**		7 - - - * * * * - - -
+**		6 - - * * * * * - - -
+**		5 - - * * - - - - - -
+**		4 - - * * - * * - - -
+**		3 - - * * - * * - - -
+**		2 - - - - - - - - - -
+**		1 - - - - - - - - - -
+**	 	0 - - - - - - - - - -
+**                0 1 2 3 4 5 6 7 8 9 x
+**
+**	where asterisks indicate selected elements, and dashes 
+**	indicate unselected elements.
+**
+**	Similarly, create nine, 3 D data spaces (10 X 10 X 10), 
+**	and select similar irregular hyper slabs in each, three 
+**	with the slab parallel to the xy plane, three parallel 
+**	to the xz plane, and three parallel to the yz plane.  
+**	Further, translate the irregular slab in 2/3rds of the 
+**	cases.
+**
+**	Assuming that z is the fastest changing dimension, 
+**	H5S_select_shape_same() should return TRUE when 
+**	comparing the 2 D irregular hyperslab selection 
+**	against the irregular hyperslab selections parallel 
+**	to the yz plane in the 3 D space, and FALSE when 
+**	comparing it against the irregular hyper slabs 
+**	selections parallel to the xy or xz planes.
+**
+****************************************************************/
+static void
+test_shape_same_dr__smoke_check_3(void)
+{
+    hid_t	small_square_sid;
+    hid_t	small_cube_xy_slice_0_sid;
+    hid_t	small_cube_xy_slice_1_sid;
+    hid_t	small_cube_xy_slice_2_sid;
+    hid_t	small_cube_xz_slice_0_sid;
+    hid_t	small_cube_xz_slice_1_sid;
+    hid_t	small_cube_xz_slice_2_sid;
+    hid_t	small_cube_yz_slice_0_sid;
+    hid_t	small_cube_yz_slice_1_sid;
+    hid_t	small_cube_yz_slice_2_sid;
+    hsize_t	small_cube_dims[] = {10, 10, 10};
+    hsize_t	start[3];
+    hsize_t	stride[3];
+    hsize_t	count[3];
+    hsize_t	block[3];
+    htri_t	check;		/* Shape comparison return value */
+    herr_t	ret;		/* Generic return value	*/
+
+    MESSAGE(7, ("	Smoke check 3: Offset subsets of slices through a cube.\n"));
+
+    /* Create the 10 x 10 dataspace  */
+    small_square_sid = H5Screate_simple(2, small_cube_dims, NULL);
+    CHECK(small_square_sid, FAIL, "H5Screate_simple");
+
+    start[0] = 2;	/* x */
+    start[1] = 3;	/* y */
+
+    stride[0] = 20;	/* x */
+    stride[1] = 20;	/* y */
+
+    count[0] = 1;	/* x */
+    count[1] = 1;	/* y */
+
+    block[0] = 2;	/* x */
+    block[1] = 4;	/* y */
+    ret = H5Sselect_hyperslab(small_square_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[0] = 3;	/* x */
+    start[1] = 6;	/* y */
+
+    stride[0] = 20;	/* x */
+    stride[1] = 20;	/* y */
+
+    count[0] = 1;	/* x */
+    count[1] = 1;	/* y */
+
+    block[0] = 4;	/* x */
+    block[1] = 2;	/* y */
+    ret = H5Sselect_hyperslab(small_square_sid, H5S_SELECT_OR,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[0] = 5;	/* x */
+    start[1] = 3;	/* y */
+
+    stride[0] = 20;	/* x */
+    stride[1] = 20;	/* y */
+
+    count[0] = 1;	/* x */
+    count[1] = 1;	/* y */
+
+    block[0] = 2;	/* x */
+    block[1] = 2;	/* y */
+    ret = H5Sselect_hyperslab(small_square_sid, H5S_SELECT_OR,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+
+    /* Create the 10 X 10 X 10 dataspaces for the hyperslab parallel to the xy axis */
+    small_cube_xy_slice_0_sid = H5Screate_simple(3, small_cube_dims, NULL);
+    CHECK(small_cube_xy_slice_0_sid, FAIL, "H5Screate_simple");
+
+    small_cube_xy_slice_1_sid = H5Screate_simple(3, small_cube_dims, NULL);
+    CHECK(small_cube_xy_slice_1_sid, FAIL, "H5Screate_simple");
+
+    small_cube_xy_slice_2_sid = H5Screate_simple(3, small_cube_dims, NULL);
+    CHECK(small_cube_xy_slice_2_sid, FAIL, "H5Screate_simple");
+
+
+    start[0] = 2;	/* x */
+    start[1] = 3;	/* y */
+    start[2] = 5;	/* z */
+
+    stride[0] =  20;	/* x */
+    stride[1] =  20;	/* y */
+    stride[2] =  20;	/* z */
+
+    count[0] = 1;	/* x */
+    count[1] = 1;	/* y */
+    count[2] = 1;	/* z */
+
+    block[0] = 2;	/* x */
+    block[1] = 4;	/* y */
+    block[2] = 1;	/* z */
+    ret = H5Sselect_hyperslab(small_cube_xy_slice_0_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    /* move the starting point to the origin */
+    start[0] -= 1;	/* x */
+    start[1] -= 2;	/* y */
+    ret = H5Sselect_hyperslab(small_cube_xy_slice_1_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    /* move the irregular selection to the upper right hand corner */
+    start[0] += 5;	/* x */
+    start[1] += 5;	/* y */
+    ret = H5Sselect_hyperslab(small_cube_xy_slice_2_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[0] = 3;	/* x */
+    start[1] = 6;	/* y */
+    start[2] = 5;	/* z */
+
+    stride[0] =  20;	/* x */
+    stride[1] =  20;	/* y  */
+    stride[2] =  20;	/* z */
+
+    count[0] = 1;	/* x */
+    count[1] = 1;	/* y */
+    count[2] = 1;	/* z */
+
+    block[0] = 4;	/* x */
+    block[1] = 2;	/* y */
+    block[2] = 1;	/* z */
+    ret = H5Sselect_hyperslab(small_cube_xy_slice_0_sid, H5S_SELECT_OR,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    /* move the starting point to the origin */
+    start[0] -= 1;	/* x */
+    start[1] -= 2;	/* y */
+    ret = H5Sselect_hyperslab(small_cube_xy_slice_1_sid, H5S_SELECT_OR,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    /* move the irregular selection to the upper right hand corner */
+    start[0] += 5;	/* x */
+    start[1] += 5;	/* y */
+    ret = H5Sselect_hyperslab(small_cube_xy_slice_2_sid, H5S_SELECT_OR,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[0] = 5;	/* x */
+    start[1] = 3;	/* y */
+    start[2] = 5;	/* z */
+
+    stride[0] =  20;	/* x */
+    stride[1] =  20;	/* y */
+    stride[2] =  20;	/* z */
+
+    count[0] = 1;	/* x */
+    count[1] = 1;	/* y */
+    count[2] = 1;	/* z */
+
+    block[0] = 2;	/* x */
+    block[1] = 2;	/* y */
+    block[2] = 1;	/* z */
+    ret = H5Sselect_hyperslab(small_cube_xy_slice_0_sid, H5S_SELECT_OR,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    /* move the starting point to the origin */
+    start[0] -= 1;	/* x */
+    start[1] -= 2;	/* y */
+    ret = H5Sselect_hyperslab(small_cube_xy_slice_1_sid, H5S_SELECT_OR,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    /* move the irregular selection to the upper right hand corner */
+    start[0] += 5;	/* x */
+    start[1] += 5;	/* y */
+    ret = H5Sselect_hyperslab(small_cube_xy_slice_2_sid, H5S_SELECT_OR,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+
+    /* Create the 10 X 10 X 10 dataspaces for the hyperslab parallel to the xz axis */
+    small_cube_xz_slice_0_sid = H5Screate_simple(3, small_cube_dims, NULL);
+    CHECK(small_cube_xz_slice_0_sid, FAIL, "H5Screate_simple");
+
+    small_cube_xz_slice_1_sid = H5Screate_simple(3, small_cube_dims, NULL);
+    CHECK(small_cube_xz_slice_1_sid, FAIL, "H5Screate_simple");
+
+    small_cube_xz_slice_2_sid = H5Screate_simple(3, small_cube_dims, NULL);
+    CHECK(small_cube_xz_slice_2_sid, FAIL, "H5Screate_simple");
+
+    start[0] = 2;	/* x */
+    start[1] = 5;	/* y */
+    start[2] = 3;	/* z */
+
+    stride[0] = 20;	/* x */
+    stride[1] = 20;	/* y */
+    stride[2] = 20;	/* z */
+
+    count[0] = 1;	/* x */
+    count[1] = 1;	/* y */
+    count[2] = 1;	/* z */
+
+    block[0] = 2;	/* x */
+    block[1] = 1;	/* y */
+    block[2] = 4;	/* z */
+    ret = H5Sselect_hyperslab(small_cube_xz_slice_0_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    /* move the starting point to the origin */
+    start[0] -= 1;	/* x */
+    start[2] -= 2;	/* y */
+    ret = H5Sselect_hyperslab(small_cube_xz_slice_1_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    /* move the irregular selection to the upper right hand corner */
+    start[0] += 5;	/* x */
+    start[2] += 5;	/* y */
+    ret = H5Sselect_hyperslab(small_cube_xz_slice_2_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[0] = 3;	/* x */
+    start[1] = 5;	/* y */
+    start[2] = 6;	/* z */
+
+    stride[0] = 20;	/* x */
+    stride[1] = 20;	/* y */
+    stride[2] = 20;	/* z */
+
+    count[0] = 1;	/* x */
+    count[1] = 1;	/* y */
+    count[2] = 1;	/* z */
+
+    block[0] = 4;	/* x */
+    block[1] = 1;	/* y */
+    block[2] = 2;	/* z */
+    ret = H5Sselect_hyperslab(small_cube_xz_slice_0_sid, H5S_SELECT_OR,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    /* move the starting point to the origin */
+    start[0] -= 1;	/* x */
+    start[2] -= 2;	/* y */
+    ret = H5Sselect_hyperslab(small_cube_xz_slice_1_sid, H5S_SELECT_OR,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    /* move the irregular selection to the upper right hand corner */
+    start[0] += 5;	/* x */
+    start[2] += 5;	/* y */
+    ret = H5Sselect_hyperslab(small_cube_xz_slice_2_sid, H5S_SELECT_OR,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[0] = 5;	/* x */
+    start[1] = 5;	/* y */
+    start[2] = 3;	/* z */
+
+    stride[0] = 20;	/* x */
+    stride[1] = 20;	/* y */
+    stride[2] = 20;	/* z */
+
+    count[0] = 1;	/* x */
+    count[1] = 1;	/* y */
+    count[2] = 1;	/* z */
+
+    block[0] = 2;	/* x */
+    block[1] = 1;	/* y */
+    block[2] = 2;	/* z */
+    ret = H5Sselect_hyperslab(small_cube_xz_slice_0_sid, H5S_SELECT_OR,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    /* move the starting point to the origin */
+    start[0] -= 1;	/* x */
+    start[2] -= 2;	/* y */
+    ret = H5Sselect_hyperslab(small_cube_xz_slice_1_sid, H5S_SELECT_OR,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    /* move the irregular selection to the upper right hand corner */
+    start[0] += 5;	/* x */
+    start[2] += 5;	/* y */
+    ret = H5Sselect_hyperslab(small_cube_xz_slice_2_sid, H5S_SELECT_OR,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+
+/* QAK: Start here.
+ */
+    /* Create the 10 X 10 X 10 dataspaces for the hyperslabs parallel to the yz axis */
+    small_cube_yz_slice_0_sid = H5Screate_simple(3, small_cube_dims, NULL);
+    CHECK(small_cube_yz_slice_0_sid, FAIL, "H5Screate_simple");
+
+    small_cube_yz_slice_1_sid = H5Screate_simple(3, small_cube_dims, NULL);
+    CHECK(small_cube_yz_slice_1_sid, FAIL, "H5Screate_simple");
+
+    small_cube_yz_slice_2_sid = H5Screate_simple(3, small_cube_dims, NULL);
+    CHECK(small_cube_yz_slice_2_sid, FAIL, "H5Screate_simple");
+
+    start[0] = 8;	/* x */
+    start[1] = 2;	/* y */
+    start[2] = 3;	/* z */
+
+    stride[0] = 20;	/* x -- large enough that there will only be one slice */
+    stride[1] = 20;	/* y */
+    stride[2] = 20;	/* z */
+
+    count[0] = 1;	/* x */
+    count[1] = 1;	/* y */
+    count[2] = 1;	/* z */
+
+    block[0] = 1;	/* x */
+    block[1] = 2;	/* y */
+    block[2] = 4;	/* z */
+    ret = H5Sselect_hyperslab(small_cube_yz_slice_0_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    /* move the starting point to the origin */
+    start[1] -= 1;	/* x */
+    start[2] -= 2;	/* y */
+    ret = H5Sselect_hyperslab(small_cube_yz_slice_1_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    /* move the irregular selection to the upper right hand corner */
+    start[0] += 5;	/* x */
+    start[2] += 5;	/* y */
+    ret = H5Sselect_hyperslab(small_cube_yz_slice_2_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[0] = 8;	/* x */
+    start[1] = 3;	/* y */
+    start[2] = 6;	/* z */
+
+    stride[0] = 20;	/* x */
+    stride[1] = 20;	/* y */
+    stride[2] = 20;	/* z */
+
+    count[0] = 1;	/* x */
+    count[1] = 1;	/* y */
+    count[2] = 1;	/* z */
+
+    block[0] = 1;	/* x */
+    block[1] = 4;	/* y */
+    block[2] = 2;	/* z */
+    ret = H5Sselect_hyperslab(small_cube_yz_slice_0_sid, H5S_SELECT_OR,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    /* move the starting point to the origin */
+    start[1] -= 1;	/* x */
+    start[2] -= 2;	/* y */
+    ret = H5Sselect_hyperslab(small_cube_yz_slice_1_sid, H5S_SELECT_OR,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    /* move the irregular selection to the upper right hand corner */
+    start[0] += 5;	/* x */
+    start[2] += 5;	/* y */
+    ret = H5Sselect_hyperslab(small_cube_yz_slice_2_sid, H5S_SELECT_OR,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    start[0] = 8;	/* x */
+    start[1] = 5;	/* y */
+    start[2] = 3;	/* z */
+
+    stride[0] = 20;	/* x */
+    stride[1] = 20;	/* y */
+    stride[2] = 20;	/* z */
+
+    count[0] = 1;	/* x */
+    count[1] = 1;	/* y */
+    count[2] = 1;	/* z */
+
+    block[0] = 1;	/* x */
+    block[1] = 2;	/* y */
+    block[2] = 2;	/* z */
+    ret = H5Sselect_hyperslab(small_cube_yz_slice_0_sid, H5S_SELECT_OR,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    /* move the starting point to the origin */
+    start[1] -= 1;	/* x */
+    start[2] -= 2;	/* y */
+    ret = H5Sselect_hyperslab(small_cube_yz_slice_1_sid, H5S_SELECT_OR,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    /* move the irregular selection to the upper right hand corner */
+    start[0] += 5;	/* x */
+    start[2] += 5;	/* y */
+    ret = H5Sselect_hyperslab(small_cube_yz_slice_2_sid, H5S_SELECT_OR,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+
+    /* setup is done -- run the tests: */
+
+    /* Compare against "xy" selection */
+    check = H5S_select_shape_same_test(small_cube_xy_slice_0_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5S_select_shape_same_test");
+
+    check = H5S_select_shape_same_test(small_cube_xy_slice_1_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5S_select_shape_same_test");
+
+    check = H5S_select_shape_same_test(small_cube_xy_slice_2_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5S_select_shape_same_test");
+
+
+    /* Compare against "xz" selection */
+    check = H5S_select_shape_same_test(small_cube_xz_slice_0_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5S_select_shape_same_test");
+
+    check = H5S_select_shape_same_test(small_cube_xz_slice_1_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5S_select_shape_same_test");
+
+    check = H5S_select_shape_same_test(small_cube_xz_slice_2_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5S_select_shape_same_test");
+
+
+    /* Compare against "yz" selection */
+    check = H5S_select_shape_same_test(small_cube_yz_slice_0_sid, small_square_sid);
+    VERIFY(check, TRUE, "H5S_select_shape_same_test");
+
+    check = H5S_select_shape_same_test(small_cube_yz_slice_1_sid, small_square_sid);
+    VERIFY(check, TRUE, "H5S_select_shape_same_test");
+
+    check = H5S_select_shape_same_test(small_cube_yz_slice_2_sid, small_square_sid);
+    VERIFY(check, TRUE, "H5S_select_shape_same_test");
+
+
+    /* Close dataspaces */
+    ret = H5Sclose(small_square_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+
+    ret = H5Sclose(small_cube_xy_slice_0_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(small_cube_xy_slice_1_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(small_cube_xy_slice_2_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+
+    ret = H5Sclose(small_cube_xz_slice_0_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(small_cube_xz_slice_1_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(small_cube_xz_slice_2_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+
+    ret = H5Sclose(small_cube_yz_slice_0_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(small_cube_yz_slice_1_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(small_cube_yz_slice_2_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+} /* test_shape_same_dr__smoke_check_3() */
+
+
+/****************************************************************
+**
+**  test_shape_same_dr__smoke_check_4(): 
+**
+**	Create a square, 2 D data space (10 X 10), and select 
+**	the entire space.
+**
+**	Similarly, create 3 D and 4 D data spaces:
+**
+**		(1 X 10 X 10)
+**		(10 X 1 X 10)
+**		(10 X 10 X 1)
+**		(10 X 10 X 10)
+**
+**		(1 X 1 X 10 X 10)
+**		(1 X 10 X 1 X 10)
+**		(1 X 10 X 10 X 1)
+**		(10 X 1 X 1 X 10)
+**		(10 X 1 X 10 X 1)
+**		(10 X 10 X 1 X 1)
+**		(10 X 1 X 10 X 10)
+**
+**	And select these entire spaces as well.
+**
+**	Compare the 2 D space against all the other spaces
+**	with H5S_select_shape_same().  The (1 X 10 X 10) & 
+**	(1 X 1 X 10 X 10) should return TRUE.  All others
+**	should return FALSE.
+**
+****************************************************************/
+static void
+test_shape_same_dr__smoke_check_4(void)
+{
+    hid_t	square_sid;
+    hid_t	three_d_space_0_sid;
+    hid_t	three_d_space_1_sid;
+    hid_t	three_d_space_2_sid;
+    hid_t	three_d_space_3_sid;
+    hid_t	four_d_space_0_sid;
+    hid_t	four_d_space_1_sid;
+    hid_t	four_d_space_2_sid;
+    hid_t	four_d_space_3_sid;
+    hid_t	four_d_space_4_sid;
+    hid_t	four_d_space_5_sid;
+    hid_t	four_d_space_6_sid;
+    hsize_t	dims[] = {10, 10, 10, 10};
+    htri_t	check;		/* Shape comparison return value */
+    herr_t	ret;		/* Generic return value	*/
+
+    MESSAGE(7, ("	Smoke check 4: Spaces of different dimension but same size.\n"));
+
+    /* Create the 10 x 10 dataspace  */
+    square_sid = H5Screate_simple(2, dims, NULL);
+    CHECK(square_sid, FAIL, "H5Screate_simple");
+
+    /* create (1 X 10 X 10) data space */
+    dims[0] = 1;
+    dims[1] = 10;
+    dims[2] = 10;
+    three_d_space_0_sid = H5Screate_simple(3, dims, NULL);
+    CHECK(three_d_space_0_sid, FAIL, "H5Screate_simple");
+
+    /* create (10 X 1 X 10) data space */
+    dims[0] = 10;
+    dims[1] =  1;
+    dims[2] = 10;
+    three_d_space_1_sid = H5Screate_simple(3, dims, NULL);
+    CHECK(three_d_space_1_sid, FAIL, "H5Screate_simple");
+
+    /* create (10 X 10 X 1) data space */
+    dims[0] = 10;
+    dims[1] = 10;
+    dims[2] =  1;
+    three_d_space_2_sid = H5Screate_simple(3, dims, NULL);
+    CHECK(three_d_space_2_sid, FAIL, "H5Screate_simple");
+
+    /* create (10 X 10 X 10) data space */
+    dims[0] = 10;
+    dims[1] = 10;
+    dims[2] = 10;
+    three_d_space_3_sid = H5Screate_simple(3, dims, NULL);
+    CHECK(three_d_space_3_sid, FAIL, "H5Screate_simple");
+
+
+    /* create (1 X 1 X 10 X 10) data space */
+    dims[0] =  1;
+    dims[1] =  1;
+    dims[2] = 10;
+    dims[3] = 10;
+    four_d_space_0_sid = H5Screate_simple(4, dims, NULL);
+    CHECK(four_d_space_0_sid, FAIL, "H5Screate_simple");
+
+    /* create (1 X 10 X 1 X 10) data space */
+    dims[0] =  1;
+    dims[1] = 10;
+    dims[2] =  1;
+    dims[3] = 10;
+    four_d_space_1_sid = H5Screate_simple(4, dims, NULL);
+    CHECK(four_d_space_1_sid, FAIL, "H5Screate_simple");
+
+    /* create (1 X 10 X 10 X 1) data space */
+    dims[0] =  1;
+    dims[1] = 10;
+    dims[2] = 10;
+    dims[3] =  1;
+    four_d_space_2_sid = H5Screate_simple(4, dims, NULL);
+    CHECK(four_d_space_2_sid, FAIL, "H5Screate_simple");
+
+    /* create (10 X 1 X 1 X 10) data space */
+    dims[0] = 10;
+    dims[1] =  1;
+    dims[2] =  1;
+    dims[3] = 10;
+    four_d_space_3_sid = H5Screate_simple(4, dims, NULL);
+    CHECK(four_d_space_3_sid, FAIL, "H5Screate_simple");
+
+    /* create (10 X 1 X 10 X 1) data space */
+    dims[0] = 10;
+    dims[1] =  1;
+    dims[2] = 10;
+    dims[3] =  1;
+    four_d_space_4_sid = H5Screate_simple(4, dims, NULL);
+    CHECK(four_d_space_4_sid, FAIL, "H5Screate_simple");
+
+    /* create (10 X 10 X 1 X 1) data space */
+    dims[0] = 10;
+    dims[1] = 10;
+    dims[2] =  1;
+    dims[3] =  1;
+    four_d_space_5_sid = H5Screate_simple(4, dims, NULL);
+    CHECK(four_d_space_5_sid, FAIL, "H5Screate_simple");
+
+    /* create (10 X 1 X 10 X 10) data space */
+    dims[0] = 10;
+    dims[1] =  1;
+    dims[2] = 10;
+    dims[3] = 10;
+    four_d_space_6_sid = H5Screate_simple(4, dims, NULL);
+    CHECK(four_d_space_6_sid, FAIL, "H5Screate_simple");
+
+
+    /* setup is done -- run the tests: */
+
+    check = H5S_select_shape_same_test(three_d_space_0_sid, square_sid);
+    VERIFY(check, TRUE, "H5S_select_shape_same_test");
+
+    check = H5S_select_shape_same_test(three_d_space_1_sid, square_sid);
+    VERIFY(check, FALSE, "H5S_select_shape_same_test");
+
+    check = H5S_select_shape_same_test(three_d_space_2_sid, square_sid);
+    VERIFY(check, FALSE, "H5S_select_shape_same_test");
+
+    check = H5S_select_shape_same_test(three_d_space_3_sid, square_sid);
+    VERIFY(check, FALSE, "H5S_select_shape_same_test");
+
+
+    check = H5S_select_shape_same_test(four_d_space_0_sid, square_sid);
+    VERIFY(check, TRUE, "H5S_select_shape_same_test");
+
+    check = H5S_select_shape_same_test(four_d_space_1_sid, square_sid);
+    VERIFY(check, FALSE, "H5S_select_shape_same_test");
+
+    check = H5S_select_shape_same_test(four_d_space_2_sid, square_sid);
+    VERIFY(check, FALSE, "H5S_select_shape_same_test");
+
+    check = H5S_select_shape_same_test(four_d_space_3_sid, square_sid);
+    VERIFY(check, FALSE, "H5S_select_shape_same_test");
+
+    check = H5S_select_shape_same_test(four_d_space_4_sid, square_sid);
+    VERIFY(check, FALSE, "H5S_select_shape_same_test");
+
+    check = H5S_select_shape_same_test(four_d_space_5_sid, square_sid);
+    VERIFY(check, FALSE, "H5S_select_shape_same_test");
+
+    check = H5S_select_shape_same_test(four_d_space_6_sid, square_sid);
+    VERIFY(check, FALSE, "H5S_select_shape_same_test");
+
+
+    /* Close dataspaces */
+    ret = H5Sclose(square_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+
+    ret = H5Sclose(three_d_space_0_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(three_d_space_1_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(three_d_space_2_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(three_d_space_3_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+
+    ret = H5Sclose(four_d_space_0_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(four_d_space_1_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(four_d_space_2_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(four_d_space_3_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(four_d_space_4_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(four_d_space_5_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(four_d_space_6_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+} /* test_shape_same_dr__smoke_check_4() */
+
+/****************************************************************
+**
+**  test_shape_same_dr__full_space_vs_slice(): Tests selection
+**	of a full n-cube data space vs an n-dimensional slice of 
+**	of an m-cube (m > n) in a call to H5S_select_shape_same().  
+**	Note that this test does not require the n-cube and the 
+**	n-dimensional slice to have the same rank (although
+**	H5S_select_shape_same() should always return FALSE if 
+**	they don't). 
+**
+**	Per Quincey's suggestion, only test up to 5 dimensional
+**	spaces.
+**
+****************************************************************/
+static void
+test_shape_same_dr__full_space_vs_slice(int test_num,
+                                        int small_rank,
+                                        int large_rank,
+                                        int offset,
+                                        hsize_t edge_size,
+                                        hbool_t dim_selected[],
+                                        hbool_t expected_result)
+{
+    char	test_desc_0[128];
+    char	test_desc_1[128];
+    int         i;
+    hid_t	n_cube_0_sid;  /* the fully selected hyper cube */
+    hid_t	n_cube_1_sid;  /* the hyper cube in which a slice is selected */
+    hsize_t	dims[SS_DR_MAX_RANK];
+    hsize_t	start[SS_DR_MAX_RANK];
+    hsize_t *	start_ptr;
+    hsize_t	stride[SS_DR_MAX_RANK];
+    hsize_t *	stride_ptr;
+    hsize_t	count[SS_DR_MAX_RANK];
+    hsize_t *	count_ptr;
+    hsize_t	block[SS_DR_MAX_RANK];
+    hsize_t *	block_ptr;
+    htri_t	check;		/* Shape comparison return value */
+    herr_t	ret;		/* Generic return value	*/
+
+    HDassert( 0 < small_rank );
+    HDassert( small_rank <= large_rank );
+    HDassert( large_rank <= SS_DR_MAX_RANK );
+    HDassert( 0 <= offset );
+    HDassert( offset < large_rank );
+    HDassert( edge_size > 0 ); 
+    HDassert( edge_size <= 1000 ); 
+
+    sprintf(test_desc_0, 
+              "\tn-cube slice through m-cube (n <= m) test %d.\n", 
+              test_num);
+    MESSAGE(7, (test_desc_0));
+
+    /* This statement must be updated if SS_DR_MAX_RANK is changed */
+    sprintf(test_desc_1, 
+              "\t\tranks: %d/%d offset: %d dim_selected: %d/%d/%d/%d/%d.\n",
+              small_rank, large_rank, offset,
+              (int)dim_selected[0],
+              (int)dim_selected[1],
+              (int)dim_selected[2],
+              (int)dim_selected[3],
+              (int)dim_selected[4]);
+    MESSAGE(7, (test_desc_1));
+
+    /* copy the edge size into the dims array */
+    for(i = 0; i < SS_DR_MAX_RANK; i++)
+        dims[i] = edge_size;
+
+    /* Create the small n-cube */
+    n_cube_0_sid = H5Screate_simple(small_rank, dims, NULL);
+    CHECK(n_cube_0_sid, FAIL, "H5Screate_simple");
+
+
+    /* Create the large n-cube */
+    n_cube_1_sid = H5Screate_simple(large_rank, dims, NULL);
+    CHECK(n_cube_1_sid, FAIL, "H5Screate_simple");
+
+    /* set up start, stride, count, and block for the hyperslab selection */
+    for(i = 0; i < SS_DR_MAX_RANK; i++) {
+        stride[i] = 2 * edge_size; /* a bit silly in this case */
+        count[i] = 1;
+        if(dim_selected[i]) {
+            start[i] = 0;
+            block[i] = edge_size;
+        } /* end if */
+        else {
+            start[i] = (hsize_t)offset;
+            block[i] = 1;
+        } /* end else */
+    } /* end for */
+
+    /* since large rank may be less than SS_DR_MAX_RANK, we may not
+     * use the entire start, stride, count, and block arrays.  This
+     * is a problem, since it is inconvenient to set up the dim_selected
+     * array to reflect the large rank, and thus if large_rank <
+     * SS_DR_MAX_RANK, we need to hide the lower index entries
+     * from H5Sselect_hyperslab().
+     *
+     * Do this by setting up pointers to the first valid entry in start,
+     * stride, count, and block below, and pass these pointers in
+     * to H5Sselect_hyperslab() instead of the array base addresses.
+     */
+
+    i = SS_DR_MAX_RANK - large_rank;
+    HDassert(i >= 0);
+
+    start_ptr  = &(start[i]);
+    stride_ptr = &(stride[i]);
+    count_ptr  = &(count[i]);
+    block_ptr  = &(block[i]);
+
+
+    /* select the hyper slab */
+    ret = H5Sselect_hyperslab(n_cube_1_sid, H5S_SELECT_SET,
+                              start_ptr, stride_ptr, count_ptr, block_ptr);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+
+    /* setup is done -- run the test: */
+    check = H5S_select_shape_same_test(n_cube_0_sid, n_cube_1_sid);
+    VERIFY(check, expected_result, "test_shape_same_dr__full_space_vs_slice");
+
+
+    /* Close dataspaces */
+    ret = H5Sclose(n_cube_0_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(n_cube_1_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+}   /* test_shape_same_dr__full_space_vs_slice() */
+
+
+/****************************************************************
+**
+**  test_shape_same_dr__run_full_space_vs_slice_tests(): 
+**
+**	Run the est_shape_same_dr__full_space_vs_slice() test
+**	over a variety of ranks and offsets.
+**
+**	At present, we test H5S_select_shape_same() with 
+**	fully selected 1, 2, 3, and 4 cubes as one parameter, and
+**	1, 2, 3, and 4 dimensional slices through a n-cube of rank
+**	no more than 5 (and at least the rank of the slice).  
+**	 We stop at rank 5, as Quincey suggested that it would be 
+**	sufficient.
+**
+**	All the n-cubes will have lengths of the same size, so 
+**	H5S_select_shape_same() should return true iff:
+**
+**	1) the rank for the fully selected n cube equals the 
+**         number of dimensions selected in the slice through the
+**         m-cube (m >= n).
+**
+**	2) The dimensions selected in the slice through the m-cube
+**	   are the dimesnions with the most quickly changing 
+**	   indices.
+**
+****************************************************************/
+static void
+test_shape_same_dr__run_full_space_vs_slice_tests(void)
+{
+    hbool_t dim_selected[5];
+    hbool_t expected_result;
+    int i, j;
+    int v, w, x, y, z;
+    int test_num = 0;
+    int small_rank;
+    int large_rank;
+    hsize_t edge_size = 10;
+
+    for(large_rank = 1; large_rank <= 5; large_rank++) {
+        for(small_rank = 1; small_rank <= large_rank; small_rank++) {
+            v = 0;
+            do {
+                if(v == 0)
+                    dim_selected[0] = FALSE;
+                else
+                    dim_selected[0] = TRUE;
+
+                w = 0;
+                do {
+                    if(w == 0)
+                        dim_selected[1] = FALSE;
+                    else
+                        dim_selected[1] = TRUE;
+
+                    x = 0;
+                    do {
+                        if(x == 0)
+                            dim_selected[2] = FALSE;
+                        else
+                            dim_selected[2] = TRUE;
+
+                        y = 0;
+                        do {
+                            if(y == 0)
+                                dim_selected[3] = FALSE;
+                            else
+                                dim_selected[3] = TRUE;
+
+                            z = 0;
+                            do {
+                                if(z == 0)
+                                    dim_selected[4] = FALSE;
+                                else
+                                    dim_selected[4] = TRUE;
+
+                                /* compute the expected result: */
+                                i = 0;
+                                j = 4;
+                                expected_result = TRUE;
+                                while((i < small_rank) && expected_result) {
+                                    if(!dim_selected[j])
+                                        expected_result = FALSE;
+                                    i++;
+                                    j--;
+                                } /* end while */
+
+                                while((i < large_rank) && expected_result) {
+                                    if(dim_selected[j])
+                                        expected_result = FALSE;
+                                    i++;
+                                    j--;
+                                } /* end while */
+
+
+                                /* everything is set up -- run the tests */
+
+                                test_shape_same_dr__full_space_vs_slice
+                                (
+                                    test_num++,
+                                    small_rank,
+                                    large_rank,
+                                    0,
+                                    edge_size,
+                                    dim_selected,
+                                    expected_result
+                                );
+
+                                test_shape_same_dr__full_space_vs_slice
+                                (
+                                    test_num++,
+                                    small_rank,
+                                    large_rank,
+                                    large_rank / 2,
+                                    edge_size,
+                                    dim_selected,
+                                    expected_result
+                                );
+
+                                test_shape_same_dr__full_space_vs_slice
+                                (
+                                    test_num++,
+                                    small_rank,
+                                    large_rank,
+                                    large_rank - 1,
+                                    edge_size,
+                                    dim_selected,
+                                    expected_result
+                                );
+                                    
+                                z++;
+                            } while((z < 2) && (large_rank >= 1));
+
+                            y++;
+                        } while((y < 2) && (large_rank >= 2));
+
+                        x++;
+                    } while((x < 2) && (large_rank >= 3));
+
+                    w++;
+                } while((w < 2) && (large_rank >= 4));
+
+                v++;
+            } while((v < 2) && (large_rank >= 5));
+        } /* end for */
+    } /* end for */
+
+} /* test_shape_same_dr__run_full_space_vs_slice_tests() */
+
+
+/****************************************************************
+**
+**  test_shape_same_dr__checkerboard(): Tests selection of a 
+**	"checker board" subset of a full n-cube data space vs 
+** 	a "checker board" n-dimensional slice of an m-cube (m > n).
+**	in a call to H5S_select_shape_same().  
+**
+**	Note that this test does not require the n-cube and the 
+**	n-dimensional slice to have the same rank (although
+**	H5S_select_shape_same() should always return FALSE if 
+**	they don't). 
+**
+**	Per Quincey's suggestion, only test up to 5 dimensional
+**	spaces.
+**
+****************************************************************/
+static void
+test_shape_same_dr__checkerboard(int test_num,
+                                 int small_rank,
+                                 int large_rank,
+                                 int offset,
+                                 hsize_t edge_size,
+                                 hsize_t checker_size,
+                                 hbool_t dim_selected[],
+                                 hbool_t expected_result)
+{
+    char	test_desc_0[128];
+    char	test_desc_1[128];
+    int         i;
+    int		dims_selected = 0;
+    hid_t	n_cube_0_sid;  /* the checker board selected 
+                                * hyper cube 
+                                */
+    hid_t	n_cube_1_sid;  /* the hyper cube in which a 
+                                * checkerboard slice is selected 
+                                */
+    hsize_t	dims[SS_DR_MAX_RANK];
+    hsize_t	base_start[2];
+    hsize_t	start[SS_DR_MAX_RANK];
+    hsize_t *	start_ptr;
+    hsize_t	base_stride[2];
+    hsize_t	stride[SS_DR_MAX_RANK];
+    hsize_t *	stride_ptr;
+    hsize_t	base_count[2];
+    hsize_t	count[SS_DR_MAX_RANK];
+    hsize_t *	count_ptr;
+    hsize_t	base_block[2];
+    hsize_t	block[SS_DR_MAX_RANK];
+    hsize_t *	block_ptr;
+    htri_t	check;		/* Shape comparison return value */
+    herr_t	ret;		/* Generic return value	*/
+
+    HDassert( 0 < small_rank );
+    HDassert( small_rank <= large_rank );
+    HDassert( large_rank <= SS_DR_MAX_RANK );
+    HDassert( 0 < checker_size );
+    HDassert( checker_size <= edge_size ); 
+    HDassert( edge_size <= 1000 ); 
+    HDassert( 0 <= offset );
+    HDassert( offset < (int)edge_size );
+
+    for(i = SS_DR_MAX_RANK - large_rank; i < SS_DR_MAX_RANK; i++)
+        if(dim_selected[i] == TRUE)
+            dims_selected++;
+
+    HDassert( dims_selected >= 0 );
+    HDassert( dims_selected <= large_rank );
+
+    sprintf(test_desc_0, 
+              "\tcheckerboard n-cube slice through m-cube (n <= m) test %d.\n", 
+              test_num);
+    MESSAGE(7, (test_desc_0));
+
+    /* This statement must be updated if SS_DR_MAX_RANK is changed */
+    sprintf(test_desc_1, 
+              "\tranks: %d/%d edge/chkr size: %d/%d offset: %d dim_selected: %d/%d/%d/%d/%d:%d.\n",
+              small_rank, large_rank,
+              (int)edge_size, (int)checker_size,
+              offset,
+              (int)dim_selected[0],
+              (int)dim_selected[1],
+              (int)dim_selected[2],
+              (int)dim_selected[3],
+              (int)dim_selected[4],
+              dims_selected);
+    MESSAGE(7, (test_desc_1));
+
+    /* copy the edge size into the dims array */
+    for(i = 0; i < SS_DR_MAX_RANK; i++)
+        dims[i] = edge_size;
+
+    /* Create the small n-cube */
+    n_cube_0_sid = H5Screate_simple(small_rank, dims, NULL);
+    CHECK(n_cube_0_sid, FAIL, "H5Screate_simple");
+
+    /* Select a "checkerboard" pattern in the small n-cube.
+     *
+     * In the 1-D case, the "checkerboard" would look like this:
+     *
+     *		* * - - * * - - * *
+     *
+     * and in the 2-D case, it would look like this:
+     *
+     *		* * - - * * - - * *
+     *          * * - - * * - - * *
+     *          - - * * - - * * - -
+     *          - - * * - - * * - -
+     *		* * - - * * - - * *
+     *          * * - - * * - - * *
+     *          - - * * - - * * - -
+     *          - - * * - - * * - -
+     *		* * - - * * - - * *
+     *          * * - - * * - - * *
+     *
+     * In both cases, asterisks indicate selected elements, 
+     * and dashes indicate unselected elements.
+     *
+     * 3-D and 4-D ascii art is somewhat painful, so I'll
+     * leave those selections to your imagination. :-)
+     *
+     * Note, that since the edge_size and checker_size are
+     * parameters that are passed in, the selection need 
+     * not look exactly like the selection shown above.
+     * At present, the function allows checker sizes that 
+     * are not even divisors of the edge size -- thus 
+     * something like the following is also possible:
+     *
+     *		* * * - - - * * * -
+     *		* * * - - - * * * -
+     *		* * * - - - * * * -
+     *          - - - * * * - - - *
+     *          - - - * * * - - - *
+     *          - - - * * * - - - *
+     *		* * * - - - * * * -
+     *		* * * - - - * * * -
+     *		* * * - - - * * * -
+     *          - - - * * * - - - *
+     *
+     * As the above pattern can't be selected in one 
+     * call to H5Sselect_hyperslab(), and since the
+     * values in the start, stride, count, and block
+     * arrays will be repeated over all entries in 
+     * the selected space case, and over all selected
+     * dimensions in the selected hyperslab case, we
+     * compute these values first and store them in 
+     * in the base_start, base_stride, base_count, 
+     * and base_block arrays.
+     */
+
+    base_start[0] = 0;
+    base_start[1] = checker_size;
+
+    base_stride[0] = 2 * checker_size;
+    base_stride[1] = 2 * checker_size;
+
+    /* Note that the following computation depends on the C99 
+     * requirement that integer division discard any fraction 
+     * (truncation towards zero) to function correctly. As we 
+     * now require C99, this shouldn't be a problem, but noting
+     * it may save us some pain if we are ever obliged to support
+     * pre-C99 compilers again.
+     */
+
+    base_count[0] = edge_size / (checker_size * 2);
+    if((edge_size % (checker_size * 2)) > 0)
+	base_count[0]++;
+
+    base_count[1] = (edge_size - checker_size) / (checker_size * 2);
+    if(((edge_size - checker_size) % (checker_size * 2)) > 0)
+        base_count[1]++;
+
+    base_block[0] = checker_size;
+    base_block[1] = checker_size;
+
+    /* now setup start, stride, count, and block arrays for 
+     * the first call to H5Sselect_hyperslab().
+     */
+    for(i = 0; i < SS_DR_MAX_RANK; i++) {
+        start[i]  = base_start[0];
+        stride[i] = base_stride[0];
+        count[i]  = base_count[0];
+        block[i]  = base_block[0];
+    } /* end for */
+
+    ret = H5Sselect_hyperslab(n_cube_0_sid, H5S_SELECT_SET,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    /* if small_rank == 1, or if edge_size == checker_size, we 
+     * are done, as either there is no added dimension in which
+     * to place offset selected "checkers".
+     * 
+     * Otherwise, set up start, stride, count and block, and
+     * make the additional selection.
+     */
+
+    if((small_rank > 1) && (checker_size < edge_size)) {
+        for(i = 0; i < SS_DR_MAX_RANK; i++) {
+            start[i]  = base_start[1];
+            stride[i] = base_stride[1];
+            count[i]  = base_count[1];
+            block[i]  = base_block[1];
+        } /* end for */
+
+        ret = H5Sselect_hyperslab(n_cube_0_sid, H5S_SELECT_OR,
+                                  start, stride, count, block);
+        CHECK(ret, FAIL, "H5Sselect_hyperslab");
+    } /* end if */
+
+    /* Wierdness alert:
+     *
+     * Some how, it seems that selections can extend beyond the 
+     * boundaries of the target data space -- hence the following
+     * code to manually clip the selection back to the data space
+     * proper.
+     */
+    for(i = 0; i < SS_DR_MAX_RANK; i++) {
+        start[i]  = 0;
+        stride[i] = edge_size;
+        count[i]  = 1;
+        block[i]  = edge_size;
+    } /* end for */
+
+    ret = H5Sselect_hyperslab(n_cube_0_sid, H5S_SELECT_AND,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+
+    /* Create the large n-cube */
+    n_cube_1_sid = H5Screate_simple(large_rank, dims, NULL);
+    CHECK(n_cube_1_sid, FAIL, "H5Screate_simple");
+
+
+    /* Now select the checkerboard selection in the (possibly larger) n-cube.
+     * 
+     * Since we have already calculated the base start, stride, count, 
+     * and block, re-use the values in setting up start, stride, count,
+     * and block.
+     */
+    for(i = 0; i < SS_DR_MAX_RANK; i++) {
+        if(dim_selected[i]) {
+            start[i]  = base_start[0];
+            stride[i] = base_stride[0];
+            count[i]  = base_count[0];
+            block[i]  = base_block[0];
+        } /* end if */
+        else {
+            start[i]  = (hsize_t)offset;
+            stride[i] = (hsize_t)(2 * edge_size);
+            count[i]  = 1;
+            block[i]  = 1;
+        } /* end else */
+    } /* end for */
+
+    /* Since large rank may be less than SS_DR_MAX_RANK, we may not
+     * use the entire start, stride, count, and block arrays.  This
+     * is a problem, since it is inconvenient to set up the dim_selected
+     * array to reflect the large rank, and thus if large_rank <
+     * SS_DR_MAX_RANK, we need to hide the lower index entries
+     * from H5Sselect_hyperslab().
+     *
+     * Do this by setting up pointers to the first valid entry in start,
+     * stride, count, and block below, and pass these pointers in
+     * to H5Sselect_hyperslab() instead of the array base addresses.
+     */
+
+    i = SS_DR_MAX_RANK - large_rank;
+    HDassert( i >= 0 );
+
+    start_ptr  = &(start[i]);
+    stride_ptr = &(stride[i]);
+    count_ptr  = &(count[i]);
+    block_ptr  = &(block[i]);
+
+    /* select the hyper slab */
+    ret = H5Sselect_hyperslab(n_cube_1_sid, H5S_SELECT_SET,
+                              start_ptr, stride_ptr, count_ptr, block_ptr);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    /* As before, if the number of dimensions selected is less than or 
+     * equal to 1, or if edge_size == checker_size, we are done, as 
+     * either there is no added dimension in which to place offset selected 
+     * "checkers", or the hyperslab is completely occupied by one 
+     * "checker".
+     *
+     * Otherwise, set up start, stride, count and block, and
+     * make the additional selection.
+     */
+    if((dims_selected > 1) && (checker_size < edge_size)) {
+        for(i = 0; i < SS_DR_MAX_RANK; i++) {
+            if(dim_selected[i]) {
+                start[i]  = base_start[1];
+                stride[i] = base_stride[1];
+                count[i]  = base_count[1];
+                block[i]  = base_block[1];
+            } /* end if */
+            else {
+                start[i]  = (hsize_t)offset;
+                stride[i] = (hsize_t)(2 * edge_size);
+                count[i]  = 1;
+                block[i]  = 1;
+            } /* end else */
+        } /* end for */
+
+        ret = H5Sselect_hyperslab(n_cube_1_sid, H5S_SELECT_OR,
+                                  start_ptr, stride_ptr, count_ptr, block_ptr);
+        CHECK(ret, FAIL, "H5Sselect_hyperslab");
+    } /* end if */
+
+
+    /* Wierdness alert:
+     *
+     * Again, it seems that selections can extend beyond the 
+     * boundaries of the target data space -- hence the following
+     * code to manually clip the selection back to the data space
+     * proper.
+     */
+    for(i = 0; i < SS_DR_MAX_RANK; i++) {
+        start[i]  = 0;
+        stride[i] = edge_size;
+        count[i]  = 1;
+        block[i]  = edge_size;
+    } /* end for */
+
+    ret = H5Sselect_hyperslab(n_cube_1_sid, H5S_SELECT_AND,
+                              start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    /* setup is done -- run the test: */
+    check = H5S_select_shape_same_test(n_cube_0_sid, n_cube_1_sid);
+    VERIFY(check, expected_result, "test_shape_same_dr__checkerboard");
+
+
+    /* Close dataspaces */
+    ret = H5Sclose(n_cube_0_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(n_cube_1_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+}   /* test_shape_same_dr__checkerboard() */
+
+
+/****************************************************************
+**
+**  test_shape_same_dr__run_checkerboard_tests(): 
+**
+**	In this set of tests, we test H5S_select_shape_same() 
+**      with a "checkerboard" selection of 1, 2, 3, and 4 cubes as 
+**      one parameter, and 1, 2, 3, and 4 dimensional checkerboard 
+**      slices through a n-cube of rank no more than 5 (and at 
+**      least the rank of the slice).  
+**
+**      All the n-cubes will have lengths of the same size, so 
+**      H5S_select_shape_same() should return true iff:
+**
+**      1) the rank of the n cube equals the number of dimensions 
+**         selected in the checker board slice through the m-cube 
+**         (m >= n).
+**
+**      2) The dimensions selected in the checkerboard slice 
+**         through the m-cube are the dimensions with the most 
+**         quickly changing indices.
+**
+****************************************************************/
+static void
+test_shape_same_dr__run_checkerboard_tests(void)
+{
+    hbool_t dim_selected[5];
+    hbool_t expected_result;
+    int i, j;
+    int v, w, x, y, z;
+    int test_num = 0;
+    int small_rank;
+    int large_rank;
+
+    for(large_rank = 1; large_rank <= 5; large_rank++) {
+        for(small_rank = 1; small_rank <= large_rank; small_rank++) {
+            v = 0;
+            do {
+                if(v == 0)
+                    dim_selected[0] = FALSE;
+                else
+                    dim_selected[0] = TRUE;
+
+                w = 0;
+                do {
+                    if(w == 0)
+                        dim_selected[1] = FALSE;
+                    else
+                        dim_selected[1] = TRUE;
+
+                    x = 0;
+                    do {
+                        if(x == 0)
+                            dim_selected[2] = FALSE;
+                        else
+                            dim_selected[2] = TRUE;
+
+                        y = 0;
+                        do {
+                            if(y == 0)
+                                dim_selected[3] = FALSE;
+                            else
+                                dim_selected[3] = TRUE;
+
+                            z = 0;
+                            do {
+                                if(z == 0)
+                                    dim_selected[4] = FALSE;
+                                else
+                                    dim_selected[4] = TRUE;
+                                
+
+                                /* compute the expected result: */
+                                i = 0;
+                                j = 4;
+                                expected_result = TRUE;
+                                while((i < small_rank) && expected_result) {
+                                    if(!dim_selected[j])
+                                        expected_result = FALSE;
+                                    i++;
+                                    j--;
+                                } /* end while */
+
+                                while((i < large_rank) && expected_result) {
+                                    if(dim_selected[j])
+                                        expected_result = FALSE;
+                                    i++;
+                                    j--;
+                                } /* end while */
+
+
+                                /* everything is set up -- run the tests */
+
+                                /* run test with edge size 16, checker
+                                 * size 1, and a variety of offsets
+                                 */
+                                test_shape_same_dr__checkerboard
+                                (
+                                    test_num++,
+                                    small_rank,
+                                    large_rank,
+                                    /* offset */       0,
+                                    /* edge_size */    16,
+                                    /* checker_size */ 1,
+                                    dim_selected,
+                                    expected_result
+                                );
+
+                                test_shape_same_dr__checkerboard
+                                (
+                                    test_num++,
+                                    small_rank,
+                                    large_rank,
+                                    /* offset */       5,
+                                    /* edge_size */    16,
+                                    /* checker_size */ 1,
+                                    dim_selected,
+                                    expected_result
+                                );
+
+                                test_shape_same_dr__checkerboard
+                                (
+                                    test_num++,
+                                    small_rank,
+                                    large_rank,
+                                    /* offset */       15,
+                                    /* edge_size */    16,
+                                    /* checker_size */ 1,
+                                    dim_selected,
+                                    expected_result
+                                );
+
+
+                                /* run test with edge size 10, checker
+                                 * size 2, and a variety of offsets
+                                 */
+                                test_shape_same_dr__checkerboard
+                                (
+                                    test_num++,
+                                    small_rank,
+                                    large_rank,
+                                    /* offset */       0,
+                                    /* edge_size */    10,
+                                    /* checker_size */ 2,
+                                    dim_selected,
+                                    expected_result
+                                );
+
+                                test_shape_same_dr__checkerboard
+                                (
+                                    test_num++,
+                                    small_rank,
+                                    large_rank,
+                                    /* offset */       5,
+                                    /* edge_size */    10,
+                                    /* checker_size */ 2,
+                                    dim_selected,
+                                    expected_result
+                                );
+
+                                test_shape_same_dr__checkerboard
+                                (
+                                    test_num++,
+                                    small_rank,
+                                    large_rank,
+                                    /* offset */       9,
+                                    /* edge_size */    10,
+                                    /* checker_size */ 2,
+                                    dim_selected,
+                                    expected_result
+                                );
+
+
+                                /* run test with edge size 10, checker
+                                 * size 3, and a variety of offsets
+                                 */
+                                test_shape_same_dr__checkerboard
+                                (
+                                    test_num++,
+                                    small_rank,
+                                    large_rank,
+                                    /* offset */       0,
+                                    /* edge_size */    10,
+                                    /* checker_size */ 3,
+                                    dim_selected,
+                                    expected_result
+                                );
+
+                                test_shape_same_dr__checkerboard
+                                (
+                                    test_num++,
+                                    small_rank,
+                                    large_rank,
+                                    /* offset */       5,
+                                    /* edge_size */    10,
+                                    /* checker_size */ 3,
+                                    dim_selected,
+                                    expected_result
+                                );
+
+                                test_shape_same_dr__checkerboard
+                                (
+                                    test_num++,
+                                    small_rank,
+                                    large_rank,
+                                    /* offset */       9,
+                                    /* edge_size */    10,
+                                    /* checker_size */ 3,
+                                    dim_selected,
+                                    expected_result
+                                );
+
+
+                                /* run test with edge size 8, checker
+                                 * size 8, and a variety of offsets
+                                 */
+                                test_shape_same_dr__checkerboard
+                                (
+                                    test_num++,
+                                    small_rank,
+                                    large_rank,
+                                    /* offset */       0,
+                                    /* edge_size */    8,
+                                    /* checker_size */ 8,
+                                    dim_selected,
+                                    expected_result
+                                );
+
+                                test_shape_same_dr__checkerboard
+                                (
+                                    test_num++,
+                                    small_rank,
+                                    large_rank,
+                                    /* offset */       4,
+                                    /* edge_size */    8,
+                                    /* checker_size */ 8,
+                                    dim_selected,
+                                    expected_result
+                                );
+
+                                test_shape_same_dr__checkerboard
+                                (
+                                    test_num++,
+                                    small_rank,
+                                    large_rank,
+                                    /* offset */       7,
+                                    /* edge_size */    8,
+                                    /* checker_size */ 8,
+                                    dim_selected,
+                                    expected_result
+                                );
+
+                                z++;
+                            } while((z < 2) && (large_rank >= 1));
+
+                            y++;
+                        } while((y < 2) && (large_rank >= 2));
+
+                        x++;
+                    } while((x < 2) && (large_rank >= 3));
+
+                    w++;
+                } while((w < 2) && (large_rank >= 4));
+
+                v++;
+            } while((v < 2) && (large_rank >= 5));
+        } /* end for */
+    } /* end for */
+
+} /* test_shape_same_dr__run_checkerboard_tests() */
+
+
+/****************************************************************
+**
+**  test_shape_same_dr__irregular(): 
+**
+**	Tests selection of an "irregular" subset of a full 
+**      n-cube data space vs an identical "irregular" subset
+**	of an n-dimensional slice of an m-cube (m > n).
+**	in a call to H5S_select_shape_same().  
+**
+**	Note that this test does not require the n-cube and the 
+**	n-dimensional slice to have the same rank (although
+**	H5S_select_shape_same() should always return FALSE if 
+**	they don't). 
+**
+****************************************************************/
+static void
+test_shape_same_dr__irregular(int test_num,
+                              int small_rank,
+                              int large_rank,
+                              int pattern_offset,
+                              int slice_offset,
+                              hbool_t dim_selected[],
+                              hbool_t expected_result)
+{
+    char	test_desc_0[128];
+    char	test_desc_1[128];
+    int		edge_size = 10;
+    int         i;
+    int         j;
+    int         k;
+    int		dims_selected = 0;
+    hid_t	n_cube_0_sid;  /* the hyper cube containing
+                                * an irregular selection
+                                */
+    hid_t	n_cube_1_sid;  /* the hyper cube in which a 
+                                * slice contains an irregular
+                                * selection.
+                                */
+    hsize_t	dims[SS_DR_MAX_RANK];
+    hsize_t	start_0[SS_DR_MAX_RANK]  = { 2,  2,  2,  2,  5};
+    hsize_t	stride_0[SS_DR_MAX_RANK] = {10, 10, 10, 10, 10};
+    hsize_t	count_0[SS_DR_MAX_RANK]  = { 1,  1,  1,  1,  1};
+    hsize_t     block_0[SS_DR_MAX_RANK]  = { 2,  2,  2,  2,  3};
+
+    hsize_t	start_1[SS_DR_MAX_RANK]  = { 2,  2,  2,  5,  2};
+    hsize_t	stride_1[SS_DR_MAX_RANK] = {10, 10, 10, 10, 10};
+    hsize_t	count_1[SS_DR_MAX_RANK]  = { 1,  1,  1,  1,  1};
+    hsize_t     block_1[SS_DR_MAX_RANK]  = { 2,  2,  2,  3,  2};
+
+    hsize_t	start_2[SS_DR_MAX_RANK]  = { 2,  2,  5,  2,  2};
+    hsize_t	stride_2[SS_DR_MAX_RANK] = {10, 10, 10, 10, 10};
+    hsize_t	count_2[SS_DR_MAX_RANK]  = { 1,  1,  1,  1,  1};
+    hsize_t     block_2[SS_DR_MAX_RANK]  = { 2,  2,  3,  2,  2};
+
+    hsize_t	start_3[SS_DR_MAX_RANK]  = { 2,  5,  2,  2,  2};
+    hsize_t	stride_3[SS_DR_MAX_RANK] = {10, 10, 10, 10, 10};
+    hsize_t	count_3[SS_DR_MAX_RANK]  = { 1,  1,  1,  1,  1};
+    hsize_t     block_3[SS_DR_MAX_RANK]  = { 2,  3,  2,  2,  2};
+
+    hsize_t	start_4[SS_DR_MAX_RANK]  = { 5,  2,  2,  2,  2};
+    hsize_t	stride_4[SS_DR_MAX_RANK] = {10, 10, 10, 10, 10};
+    hsize_t	count_4[SS_DR_MAX_RANK]  = { 1,  1,  1,  1,  1};
+    hsize_t     block_4[SS_DR_MAX_RANK]  = { 3,  2,  2,  2,  2};
+
+    hsize_t	clip_start[SS_DR_MAX_RANK]  = { 0,  0,  0,  0,  0};
+    hsize_t	clip_stride[SS_DR_MAX_RANK] = {10, 10, 10, 10, 10};
+    hsize_t	clip_count[SS_DR_MAX_RANK]  = { 1,  1,  1,  1,  1};
+    hsize_t     clip_block[SS_DR_MAX_RANK]  = {10, 10, 10, 10, 10};
+
+
+    hsize_t	*(starts[SS_DR_MAX_RANK]) = 
+                	{start_0, start_1, start_2, start_3, start_4};
+    hsize_t     *(strides[SS_DR_MAX_RANK]) =
+                	{stride_0, stride_1, stride_2, stride_3, stride_4};
+    hsize_t     *(counts[SS_DR_MAX_RANK]) =
+                	{count_0, count_1, count_2, count_3, count_4};
+    hsize_t     *(blocks[SS_DR_MAX_RANK]) =
+                	{block_0, block_1, block_2, block_3, block_4};
+
+    hsize_t	start[SS_DR_MAX_RANK];
+    hsize_t *	start_ptr;
+    hsize_t	stride[SS_DR_MAX_RANK];
+    hsize_t *	stride_ptr;
+    hsize_t	count[SS_DR_MAX_RANK];
+    hsize_t *	count_ptr;
+    hsize_t	block[SS_DR_MAX_RANK];
+    hsize_t *	block_ptr;
+    htri_t	check;		/* Shape comparison return value */
+    herr_t	ret;		/* Generic return value	*/
+
+    HDassert( 0 < small_rank );
+    HDassert( small_rank <= large_rank );
+    HDassert( large_rank <= SS_DR_MAX_RANK );
+    HDassert( 9 <= edge_size ); 
+    HDassert( edge_size <= 1000 ); 
+    HDassert( 0 <= slice_offset );
+    HDassert( slice_offset < edge_size );
+    HDassert( -2 <= pattern_offset );
+    HDassert( pattern_offset <= 2 );
+
+    for(i = SS_DR_MAX_RANK - large_rank; i < SS_DR_MAX_RANK; i++)
+        if(dim_selected[i] == TRUE)
+            dims_selected++;
+
+    HDassert( dims_selected >= 0 );
+    HDassert( dims_selected <= large_rank );
+
+    sprintf(test_desc_0, 
+              "\tirregular sub set of n-cube slice through m-cube (n <= m) test %d.\n", 
+              test_num);
+    MESSAGE(7, (test_desc_0));
+
+    /* This statement must be updated if SS_DR_MAX_RANK is changed */
+    sprintf(test_desc_1, 
+              "\tranks: %d/%d edge: %d s/p offset: %d/%d dim_selected: %d/%d/%d/%d/%d:%d.\n",
+              small_rank, large_rank,
+              edge_size, 
+              slice_offset, pattern_offset,
+              (int)dim_selected[0],
+              (int)dim_selected[1],
+              (int)dim_selected[2],
+              (int)dim_selected[3],
+              (int)dim_selected[4],
+              dims_selected);
+    MESSAGE(7, (test_desc_1));
+
+    /* copy the edge size into the dims array */
+    for(i = 0; i < SS_DR_MAX_RANK; i++)
+        dims[i] = (hsize_t)edge_size;
+
+    /* Create the small n-cube */
+    n_cube_0_sid = H5Screate_simple(small_rank, dims, NULL);
+    CHECK(n_cube_0_sid, FAIL, "H5Screate_simple");
+
+    /* Select an "irregular" pattern in the small n-cube.  This
+     * pattern can be though of a set of four 3 x 2 x 2 X 2 
+     * four dimensional prisims, each parallel to one of the 
+     * axies and none of them intersecting with the other. 
+     *
+     * In the lesser dimensional cases, this 4D pattern is 
+     * projected onto the lower dimensional space.
+     *
+     * In the 1-D case, the projection of the pattern looks
+     * like this:
+     *
+     *		  - - * * - * * * - -
+     *            0 1 2 3 4 5 6 7 8 9 x
+     *
+     * and in the 2-D case, it would look like this:
+     *
+     *
+     *		y
+     *		9 - - - - - - - - - -
+     *		8 - - - - - - - - - -
+     *		7 - - * * - - - - - -
+     *		6 - - * * - - - - - -
+     *		5 - - * * - - - - - -
+     *		4 - - - - - - - - - -
+     *		3 - - * * - * * * - -
+     *		2 - - * * - * * * - -
+     *		1 - - - - - - - - - -
+     *	 	0 - - - - - - - - - -
+     *            0 1 2 3 4 5 6 7 8 9 x
+     *
+     * In both cases, asterisks indicate selected elements, 
+     * and dashes indicate unselected elements.
+     *
+     * Note that is this case, since the edge size is fixed,
+     * the pattern does not change.  However, we do use the 
+     * displacement parameter to allow it to be moved around 
+     * within the n-cube or hyper slab.
+     */
+
+    /* first, ensure that the small n-cube has no selection */
+    ret = H5Sselect_none(n_cube_0_sid);
+    CHECK(ret, FAIL, "H5Sselect_none");
+
+    /* now, select the irregular pattern */
+    for(i = 0; i < SS_DR_MAX_RANK; i++) {
+        ret = H5Sselect_hyperslab(n_cube_0_sid, H5S_SELECT_OR,
+                                  starts[i], strides[i], counts[i], blocks[i]);
+        CHECK(ret, FAIL, "H5Sselect_hyperslab");
+    } /* end for */
+
+    /* finally, clip the selection to ensure that it lies fully 
+     * within the n-cube.
+     */
+    ret = H5Sselect_hyperslab(n_cube_0_sid, H5S_SELECT_AND,
+                              clip_start, clip_stride, clip_count, clip_block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+
+    /* Create the large n-cube */
+    n_cube_1_sid = H5Screate_simple(large_rank, dims, NULL);
+    CHECK(n_cube_1_sid, FAIL, "H5Screate_simple");
+
+    /* Ensure that the large n-cube has no selection */
+    H5Sselect_none(n_cube_1_sid);
+    CHECK(ret, FAIL, "H5Sselect_none");
+
+
+    /* Since large rank may be less than SS_DR_MAX_RANK, we may not
+     * use the entire start, stride, count, and block arrays.  This
+     * is a problem, since it is inconvenient to set up the dim_selected
+     * array to reflect the large rank, and thus if large_rank <
+     * SS_DR_MAX_RANK, we need to hide the lower index entries
+     * from H5Sselect_hyperslab().
+     *
+     * Do this by setting up pointers to the first valid entry in start,
+     * stride, count, and block below, and pass these pointers in
+     * to H5Sselect_hyperslab() instead of the array base addresses.
+     */
+
+    i = SS_DR_MAX_RANK - large_rank;
+    HDassert( i >= 0 );
+
+    start_ptr  = &(start[i]);
+    stride_ptr = &(stride[i]);
+    count_ptr  = &(count[i]);
+    block_ptr  = &(block[i]);
+
+
+    /* Now select the irregular selection in the (possibly larger) n-cube.
+     * 
+     * Basic idea is to project the pattern used in the smaller n-cube 
+     * onto the dimensions selected in the larger n-cube, with the displacement
+     * specified.
+     */
+    for(i = 0; i < SS_DR_MAX_RANK; i++) {
+        j = 0;
+        for(k = 0; k < SS_DR_MAX_RANK; k++) {
+            if(dim_selected[k]) {
+                start[k]  = (starts[i])[j] + (hsize_t)pattern_offset;
+                stride[k] = (strides[i])[j];
+                count[k]  = (counts[i])[j];
+                block[k]  = (blocks[i])[j];
+                j++;
+            } /* end if */
+            else {
+                start[k]  = (hsize_t)slice_offset;
+                stride[k] = (hsize_t)(2 * edge_size);
+                count[k]  = 1;
+                block[k]  = 1;
+            } /* end else */
+        } /* end for */
+
+        /* select the hyper slab */
+        ret = H5Sselect_hyperslab(n_cube_1_sid, H5S_SELECT_OR,
+                              start_ptr, stride_ptr, count_ptr, block_ptr);
+        CHECK(ret, FAIL, "H5Sselect_hyperslab");
+    } /* end for */
+
+    /* it is possible that the selection extends beyond the data space.
+     * clip the selection to ensure that it doesn't.
+     */
+    ret = H5Sselect_hyperslab(n_cube_1_sid, H5S_SELECT_AND,
+                              clip_start, clip_stride, clip_count, clip_block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+
+    /* setup is done -- run the test: */
+    check = H5S_select_shape_same_test(n_cube_0_sid, n_cube_1_sid);
+    VERIFY(check, expected_result, "test_shape_same_dr__checkerboard");
+
+
+    /* Close dataspaces */
+    ret = H5Sclose(n_cube_0_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    ret = H5Sclose(n_cube_1_sid);
+    CHECK(ret, FAIL, "H5Sclose");
+
+}   /* test_shape_same_dr__irregular() */
+
+
+/****************************************************************
+**
+**  test_shape_same_dr__run_irregular_tests(): 
+**
+**	In this set of tests, we test H5S_select_shape_same() 
+**      with an "irregular" subselection of 1, 2, 3, and 4 cubes as 
+**      one parameter, and irregular subselections of 1, 2, 3, 
+**      and 4 dimensional slices through a n-cube of rank no more 
+**      than 5 (and at least the rank of the slice) as the other.  
+**      Note that the "irregular" selection may be offset between 
+**	the n-cube and the slice.
+**
+**      All the irregular selections will be identical (modulo rank)
+**      so H5S_select_shape_same() should return true iff:
+**
+**      1) the rank of the n cube equals the number of dimensions 
+**         selected in the irregular slice through the m-cube 
+**         (m >= n).
+**
+**      2) The dimensions selected in the irregular slice 
+**         through the m-cube are the dimensions with the most 
+**         quickly changing indices.
+**
+****************************************************************/
+static void
+test_shape_same_dr__run_irregular_tests(void)
+{
+    hbool_t dim_selected[5];
+    hbool_t expected_result;
+    int i, j;
+    int v, w, x, y, z;
+    int test_num = 0;
+    int small_rank;
+    int large_rank;
+
+    for(large_rank = 1; large_rank <= 5; large_rank++) {
+        for(small_rank = 1; small_rank <= large_rank; small_rank++) {
+            v = 0;
+            do {
+                if(v == 0)
+                    dim_selected[0] = FALSE;
+                else
+                    dim_selected[0] = TRUE;
+
+                w = 0;
+                do {
+                    if(w == 0)
+                        dim_selected[1] = FALSE;
+                    else
+                        dim_selected[1] = TRUE;
+
+                    x = 0;
+                    do {
+                        if(x == 0)
+                            dim_selected[2] = FALSE;
+                        else
+                            dim_selected[2] = TRUE;
+
+                        y = 0;
+                        do {
+                            if(y == 0)
+                                dim_selected[3] = FALSE;
+                            else
+                                dim_selected[3] = TRUE;
+
+                            z = 0;
+                            do {
+                                if(z == 0)
+                                    dim_selected[4] = FALSE;
+                                else
+                                    dim_selected[4] = TRUE;
+                                
+
+                                /* compute the expected result: */
+                                i = 0;
+                                j = 4;
+                                expected_result = TRUE;
+                                while((i < small_rank) && expected_result) {
+                                    if(!dim_selected[j])
+                                        expected_result = FALSE;
+                                    i++;
+                                    j--;
+                                } /* end while */
+
+                                while((i < large_rank) && expected_result) {
+                                    if(dim_selected[j])
+                                        expected_result = FALSE;
+                                    i++;
+                                    j--;
+                                } /* end while */
+
+
+                                /* everything is set up -- run the tests */
+
+                                test_shape_same_dr__irregular
+                                (
+                                    test_num++,
+                                    small_rank,
+                                    large_rank,
+                                    /* pattern_offset */ -2,
+                                    /* slice_offset */ 0,
+                                    dim_selected,
+                                    expected_result
+                                );
+
+                                test_shape_same_dr__irregular
+                                (
+                                    test_num++,
+                                    small_rank,
+                                    large_rank,
+                                    /* pattern_offset */ -2,
+                                    /* slice_offset */ 4,
+                                    dim_selected,
+                                    expected_result
+                                );
+
+                                test_shape_same_dr__irregular
+                                (
+                                    test_num++,
+                                    small_rank,
+                                    large_rank,
+                                    /* pattern_offset */ -2,
+                                    /* slice_offset */ 9,
+                                    dim_selected,
+                                    expected_result
+                                );
+
+
+                                test_shape_same_dr__irregular
+                                (
+                                    test_num++,
+                                    small_rank,
+                                    large_rank,
+                                    /* pattern_offset */ 0,
+                                    /* slice_offset */ 0,
+                                    dim_selected,
+                                    expected_result
+                                );
+
+                                test_shape_same_dr__irregular
+                                (
+                                    test_num++,
+                                    small_rank,
+                                    large_rank,
+                                    /* pattern_offset */ 0,
+                                    /* slice_offset */ 6,
+                                    dim_selected,
+                                    expected_result
+                                );
+
+                                test_shape_same_dr__irregular
+                                (
+                                    test_num++,
+                                    small_rank,
+                                    large_rank,
+                                    /* pattern_offset */ 0,
+                                    /* slice_offset */ 9,
+                                    dim_selected,
+                                    expected_result
+                                );
+
+
+                                test_shape_same_dr__irregular
+                                (
+                                    test_num++,
+                                    small_rank,
+                                    large_rank,
+                                    /* pattern_offset */ 2,
+                                    /* slice_offset */ 0,
+                                    dim_selected,
+                                    expected_result
+                                );
+
+                                test_shape_same_dr__irregular
+                                (
+                                    test_num++,
+                                    small_rank,
+                                    large_rank,
+                                    /* pattern_offset */ 2,
+                                    /* slice_offset */ 5,
+                                    dim_selected,
+                                    expected_result
+                                );
+
+                                test_shape_same_dr__irregular
+                                (
+                                    test_num++,
+                                    small_rank,
+                                    large_rank,
+                                    /* pattern_offset */ 2,
+                                    /* slice_offset */ 9,
+                                    dim_selected,
+                                    expected_result
+                                );
+
+                                z++;
+                            } while((z < 2) && (large_rank >= 1));
+
+                            y++;
+                        } while((y < 2) && (large_rank >= 2));
+
+                        x++;
+                    } while((x < 2) && (large_rank >= 3));
+
+                    w++;
+                } while((w < 2) && (large_rank >= 4));
+
+                v++;
+            } while((v < 2 ) && (large_rank >= 5));
+        } /* end for */
+    } /* end for */
+
+} /* test_shape_same_dr__run_irregular_tests() */
+
+
+/****************************************************************
+**
+**  test_shape_same_dr(): Tests selections on dataspace with 
+**      different ranks, to verify that "shape same" routine 
+**	is now handling this case correctly.
+**
+****************************************************************/
+static void
+test_shape_same_dr(void)
+{
+    /* Output message about test being performed */
+    MESSAGE(6, ("Testing Same Shape/Different Rank Comparisons\n"));
+
+
+    /* first run some smoke checks */
+    test_shape_same_dr__smoke_check_1();
+    test_shape_same_dr__smoke_check_2();
+    test_shape_same_dr__smoke_check_3();
+    test_shape_same_dr__smoke_check_4();
+
+
+    /* now run more intensive tests. */
+    test_shape_same_dr__run_full_space_vs_slice_tests();
+    test_shape_same_dr__run_checkerboard_tests();
+    test_shape_same_dr__run_irregular_tests();
+
+}   /* test_shape_same_dr() */
+
 
 /****************************************************************
 **
@@ -8241,6 +13118,14 @@ test_select(void)
     test_select_hyper_contig3(H5T_STD_U16LE,plist_id); /* Test yet more contiguous hyperslab selection cases */
     test_select_hyper_contig3(H5T_STD_U16BE,H5P_DEFAULT); /* Test yet more contiguous hyperslab selection cases */
     test_select_hyper_contig3(H5T_STD_U16BE,plist_id); /* Test yet more contiguous hyperslab selection cases */
+    test_select_hyper_contig_dr(H5T_STD_U16LE, H5P_DEFAULT);
+    test_select_hyper_contig_dr(H5T_STD_U16LE, plist_id);
+    test_select_hyper_contig_dr(H5T_STD_U16BE, H5P_DEFAULT);
+    test_select_hyper_contig_dr(H5T_STD_U16BE, plist_id);
+    test_select_hyper_checker_board_dr(H5T_STD_U16LE, H5P_DEFAULT);
+    test_select_hyper_checker_board_dr(H5T_STD_U16LE, plist_id);
+    test_select_hyper_checker_board_dr(H5T_STD_U16BE, H5P_DEFAULT);
+    test_select_hyper_checker_board_dr(H5T_STD_U16BE, plist_id);
     test_select_hyper_copy();   /* Test hyperslab selection copying code */
     test_select_point_copy();   /* Test point selection copying code */
     test_select_hyper_offset(); /* Test selection offset code with hyperslabs */
@@ -8320,6 +13205,9 @@ test_select(void)
     /* Test "same shape" routine */
     test_shape_same();
 
+    /* Test "same shape" routine for selections of different rank */
+    test_shape_same_dr();
+
     /* Test "re-build" routine */
     test_space_rebuild();