Merging in latest from upstream (HDFFV/hdf5:refs/heads/develop)

* commit '5fe1216a4e6af8feef0551f7bece8a0e193310a9':
  Fix return type for H5Sselect_intersect_block().
  Updated H5TRACE macro.
  Add H5Sselect_shape_same and H5Sselect_intersect_block API routines, along with tests and minor cleanups and refactorings.

18 files changed, 1239 insertions, 1033 deletions

diff --git a/src/H5Dchunk.c b/src/H5Dchunk.c
index 7a07225..ec8ea4d 100644
--- a/src/H5Dchunk.c
+++ b/src/H5Dchunk.c
@@ -1245,7 +1245,7 @@ H5D__chunk_io_init(const H5D_io_info_t *io_info, const H5D_type_info_t *type_inf
         } /* end else */
 
         /* Build the memory selection for each chunk */
-        if(sel_hyper_flag && H5S_select_shape_same(file_space, mem_space) == TRUE) {
+        if(sel_hyper_flag && H5S_SELECT_SHAPE_SAME(file_space, mem_space) == TRUE) {
             /* Reset chunk template information */
             fm->mchunk_tmpl = NULL;
 
@@ -1811,7 +1811,7 @@ H5D__create_chunk_file_map_hyper(H5D_chunk_map_t *fm, const H5D_io_info_t
     while(sel_points) {
         /* Check for intersection of current chunk and file selection */
         /* (Casting away const OK - QAK) */
-        if(TRUE == H5S_hyper_intersect_block((H5S_t *)fm->file_space, coords, end)) {
+        if(TRUE == H5S_SELECT_INTERSECT_BLOCK(fm->file_space, coords, end)) {
             H5D_chunk_info_t *new_chunk_info;   /* chunk information to insert into skip list */
             hssize_t    schunk_points;          /* Number of elements in chunk selection */
 
@@ -2030,12 +2030,8 @@ H5D__create_chunk_mem_map_hyper(const H5D_chunk_map_t *fm)
                 /* Sanity check */
                 HDassert(H5S_SEL_HYPERSLABS == chunk_sel_type);
 
-                /* Release the current selection */
-                if(H5S_SELECT_RELEASE(chunk_info->mspace) < 0)
-                    HGOTO_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release selection")
-
                 /* Copy the file chunk's selection */
-                if(H5S_select_copy(chunk_info->mspace, chunk_info->fspace, FALSE) < 0)
+                if(H5S_SELECT_COPY(chunk_info->mspace, chunk_info->fspace, FALSE) < 0)
                     HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, FAIL, "unable to copy selection")
 
                 /* Compute the adjustment for this chunk */
diff --git a/src/H5Dio.c b/src/H5Dio.c
index 9343b80..cdb73e3 100644
--- a/src/H5Dio.c
+++ b/src/H5Dio.c
@@ -490,7 +490,7 @@ H5D__read(H5D_t *dataset, hid_t mem_type_id, const H5S_t *mem_space,
      * Note that in general, this requires us to touch up the memory buffer as 
      * well.
      */
-    if(TRUE == H5S_select_shape_same(mem_space, file_space) &&
+    if(TRUE == H5S_SELECT_SHAPE_SAME(mem_space, file_space) &&
             H5S_GET_EXTENT_NDIMS(mem_space) != H5S_GET_EXTENT_NDIMS(file_space)) {
         void *adj_buf = NULL;   /* Pointer to the location in buf corresponding  */
                                 /* to the beginning of the projected mem space.  */
@@ -725,7 +725,7 @@ H5D__write(H5D_t *dataset, hid_t mem_type_id, const H5S_t *mem_space,
      * Note that in general, this requires us to touch up the memory buffer 
      * as well.
      */
-    if(TRUE == H5S_select_shape_same(mem_space, file_space) &&
+    if(TRUE == H5S_SELECT_SHAPE_SAME(mem_space, file_space) &&
             H5S_GET_EXTENT_NDIMS(mem_space) != H5S_GET_EXTENT_NDIMS(file_space)) {
         void *adj_buf = NULL;   /* Pointer to the location in buf corresponding  */
                                 /* to the beginning of the projected mem space.  */
diff --git a/src/H5Fint.c b/src/H5Fint.c
index 758900b..7ed3ca8 100644
--- a/src/H5Fint.c
+++ b/src/H5Fint.c
@@ -868,7 +868,7 @@ H5F__is_hdf5(const char *name, hid_t fapl_id)
 
     /* The file is an hdf5 file if the hdf5 file signature can be found */
     if(H5FD_locate_signature(file, &sig_addr) < 0)
-        HGOTO_ERROR(H5E_FILE, H5E_NOTHDF5, FAIL, "unable to locate file signature")
+        HGOTO_ERROR(H5E_FILE, H5E_NOTHDF5, FAIL, "error while trying to locate file signature")
     ret_value = (HADDR_UNDEF != sig_addr);
 
 done:
diff --git a/src/H5Pdcpl.c b/src/H5Pdcpl.c
index 6b9edf1..721ba89 100644
--- a/src/H5Pdcpl.c
+++ b/src/H5Pdcpl.c
@@ -827,7 +827,7 @@ H5P__dcrt_layout_cmp(const void *_layout1, const void *_layout2,
                     if((equal = H5S_extent_equal(layout1->storage.u.virt.list[u].source_dset.virtual_select, layout2->storage.u.virt.list[u].source_dset.virtual_select)) < 0) HGOTO_DONE(-1)
                     if(!equal)
                         HGOTO_DONE(1)
-                    if((equal = H5S_select_shape_same(layout1->storage.u.virt.list[u].source_dset.virtual_select, layout2->storage.u.virt.list[u].source_dset.virtual_select)) < 0) HGOTO_DONE(-1)
+                    if((equal = H5S_SELECT_SHAPE_SAME(layout1->storage.u.virt.list[u].source_dset.virtual_select, layout2->storage.u.virt.list[u].source_dset.virtual_select)) < 0) HGOTO_DONE(-1)
                     if(!equal)
                         HGOTO_DONE(1)
 
@@ -847,7 +847,7 @@ H5P__dcrt_layout_cmp(const void *_layout1, const void *_layout2,
                     if((equal = H5S_extent_equal(layout1->storage.u.virt.list[u].source_select, layout2->storage.u.virt.list[u].source_select)) < 0) HGOTO_DONE(-1)
                     if(!equal)
                         HGOTO_DONE(1)
-                    if((equal = H5S_select_shape_same(layout1->storage.u.virt.list[u].source_select, layout2->storage.u.virt.list[u].source_select)) < 0) HGOTO_DONE(-1)
+                    if((equal = H5S_SELECT_SHAPE_SAME(layout1->storage.u.virt.list[u].source_select, layout2->storage.u.virt.list[u].source_select)) < 0) HGOTO_DONE(-1)
                     if(!equal)
                         HGOTO_DONE(1)
                 } /* end for */
diff --git a/src/H5Sall.c b/src/H5Sall.c
index fbe7041..9d0a65a 100644
--- a/src/H5Sall.c
+++ b/src/H5Sall.c
@@ -28,11 +28,11 @@
 /***********/
 /* Headers */
 /***********/
-#include "H5private.h"		/* Generic Functions			*/
-#include "H5Eprivate.h"		/* Error handling		        */
-#include "H5Iprivate.h"		/* ID Functions		                */
-#include "H5Spkg.h"		/* Dataspace functions			*/
-#include "H5VMprivate.h"        /* Vector functions                     */
+#include "H5private.h"          /* Generic Functions                        */
+#include "H5Eprivate.h"		/* Error handling			    */
+#include "H5Iprivate.h"         /* ID Functions                             */
+#include "H5Spkg.h"             /* Dataspace functions                      */
+#include "H5VMprivate.h"        /* Vector functions                         */
 
 
 /****************/
@@ -63,6 +63,8 @@ static htri_t H5S__all_is_contiguous(const H5S_t *space);
 static htri_t H5S__all_is_single(const H5S_t *space);
 static htri_t H5S__all_is_regular(const H5S_t *space);
 static htri_t H5S__all_shape_same(const H5S_t *space1, const H5S_t *space2);
+static htri_t H5S__all_intersect_block(const H5S_t *space, const hsize_t *start,
+    const hsize_t *end);
 static herr_t H5S__all_adjust_u(H5S_t *space, const hsize_t *offset);
 static herr_t H5S__all_project_scalar(const H5S_t *space, hsize_t *offset);
 static herr_t H5S__all_project_simple(const H5S_t *space, H5S_t *new_space, hsize_t *offset);
@@ -108,6 +110,7 @@ const H5S_select_class_t H5S_sel_all[1] = {{
     H5S__all_is_single,
     H5S__all_is_regular,
     H5S__all_shape_same,
+    H5S__all_intersect_block,
     H5S__all_adjust_u,
     H5S__all_project_scalar,
     H5S__all_project_simple,
@@ -976,6 +979,41 @@ done:
 
 /*--------------------------------------------------------------------------
  NAME
+    H5S__all_intersect_block
+ PURPOSE
+    Detect intersections of selection with block
+ USAGE
+    htri_t H5S__all_intersect_block(space, start, end)
+        const H5S_t *space;     IN: Dataspace with selection to use
+        const hsize_t *start;   IN: Starting coordinate for block
+        const hsize_t *end;     IN: Ending coordinate for block
+ RETURNS
+    Non-negative TRUE / FALSE on success, negative on failure
+ DESCRIPTION
+    Quickly detect intersections with a block
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+htri_t
+H5S__all_intersect_block(const H5S_t H5_ATTR_UNUSED *space,
+    const hsize_t H5_ATTR_UNUSED *start, const hsize_t H5_ATTR_UNUSED *end)
+{
+    FUNC_ENTER_STATIC_NOERR
+
+    /* Sanity check */
+    HDassert(space);
+    HDassert(H5S_SEL_ALL == H5S_GET_SELECT_TYPE(space));
+    HDassert(start);
+    HDassert(end);
+
+    FUNC_LEAVE_NOAPI(TRUE)
+} /* end H5S__all_intersect_block() */
+
+
+/*--------------------------------------------------------------------------
+ NAME
     H5S__all_adjust_u
  PURPOSE
     Adjust an "all" selection by subtracting an offset
diff --git a/src/H5Shyper.c b/src/H5Shyper.c
index 2acc135..492cd9e 100644
--- a/src/H5Shyper.c
+++ b/src/H5Shyper.c
@@ -28,30 +28,20 @@
 /***********/
 /* Headers */
 /***********/
-#include "H5private.h"      /* Generic Functions        */
-#include "H5CXprivate.h"    /* API Contexts             */
-#include "H5Eprivate.h"		/* Error handling			*/
-#include "H5FLprivate.h"	/* Free Lists				*/
-#include "H5Iprivate.h"		/* ID Functions				*/
-#include "H5MMprivate.h"    /* Memory management        */
-#include "H5Spkg.h"         /* Dataspace functions      */
-#include "H5VMprivate.h"    /* Vector functions         */
+#include "H5private.h"          /* Generic Functions                        */
+#include "H5CXprivate.h"        /* API Contexts                             */
+#include "H5Eprivate.h"		/* Error handling			    */
+#include "H5FLprivate.h"	/* Free Lists				    */
+#include "H5Iprivate.h"         /* ID Functions                             */
+#include "H5MMprivate.h"        /* Memory management                        */
+#include "H5Spkg.h"             /* Dataspace functions                      */
+#include "H5VMprivate.h"        /* Vector functions                         */
 
 
 /****************/
 /* Local Macros */
 /****************/
 
-/* Macro for checking if two ranges overlap one another */
-/*
- * Check for the inverse of whether the ranges are disjoint.  If they are
- * disjoint, then the low bound of one of the ranges must be greater than the
- * high bound of the other.
- */
-/* (Assumes that low & high bounds are _inclusive_) */
-#define H5S_RANGE_OVERLAP(L1, H1, L2, H2)             \
-    (!((L1) > (H2) || (L2) > (H1)))
-
 /* Flags for which hyperslab fragments to compute */
 #define H5S_HYPER_COMPUTE_B_NOT_A 0x01
 #define H5S_HYPER_COMPUTE_A_AND_B 0x02
@@ -197,6 +187,8 @@ static htri_t H5S__hyper_is_contiguous(const H5S_t *space);
 static htri_t H5S__hyper_is_single(const H5S_t *space);
 static htri_t H5S__hyper_is_regular(const H5S_t *space);
 static htri_t H5S__hyper_shape_same(const H5S_t *space1, const H5S_t *space2);
+static htri_t H5S__hyper_intersect_block(const H5S_t *space, const hsize_t *start,
+    const hsize_t *end);
 static herr_t H5S__hyper_adjust_u(H5S_t *space, const hsize_t *offset);
 static herr_t H5S__hyper_project_scalar(const H5S_t *space, hsize_t *offset);
 static herr_t H5S__hyper_project_simple(const H5S_t *space, H5S_t *new_space, hsize_t *offset);
@@ -242,6 +234,7 @@ const H5S_select_class_t H5S_sel_hyper[1] = {{
     H5S__hyper_is_single,
     H5S__hyper_is_regular,
     H5S__hyper_shape_same,
+    H5S__hyper_intersect_block,
     H5S__hyper_adjust_u,
     H5S__hyper_project_scalar,
     H5S__hyper_project_simple,
@@ -4829,7 +4822,6 @@ static herr_t
 H5S__hyper_bounds(const H5S_t *space, hsize_t *start, hsize_t *end)
 {
     const hsize_t *low_bounds, *high_bounds;    /* Pointers to the correct pair of low & high bounds */
-    unsigned u;                 /* Local index variable */
     herr_t ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
@@ -4849,22 +4841,32 @@ H5S__hyper_bounds(const H5S_t *space, hsize_t *start, hsize_t *end)
         high_bounds = space->select.sel_info.hslab->span_lst->high_bounds;
     } /* end else */
 
-    /* Loop over dimensions */
-    for(u = 0; u < space->extent.rank; u++) {
-        /* Sanity check */
-        HDassert(low_bounds[u] <= high_bounds[u]);
+    /* Check for offset set */
+    if(space->select.offset_changed) {
+        unsigned u;                 /* Local index variable */
 
-        /* Check for offset moving selection negative */
-        if(((hssize_t)low_bounds[u] + space->select.offset[u]) < 0)
-            HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "offset moves selection out of bounds")
+        /* Loop over dimensions */
+        for(u = 0; u < space->extent.rank; u++) {
+            /* Sanity check */
+            HDassert(low_bounds[u] <= high_bounds[u]);
 
-        /* Set the low & high bounds in this dimension */
-        start[u] = (hsize_t)((hssize_t)low_bounds[u] + space->select.offset[u]);
-        if((int)u == space->select.sel_info.hslab->unlim_dim)
-            end[u] = H5S_UNLIMITED;
-        else
-            end[u] = (hsize_t)((hssize_t)high_bounds[u] + space->select.offset[u]);
-    } /* end for */
+            /* Check for offset moving selection negative */
+            if(((hssize_t)low_bounds[u] + space->select.offset[u]) < 0)
+                HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "offset moves selection out of bounds")
+
+            /* Set the low & high bounds in this dimension */
+            start[u] = (hsize_t)((hssize_t)low_bounds[u] + space->select.offset[u]);
+            if((int)u == space->select.sel_info.hslab->unlim_dim)
+                end[u] = H5S_UNLIMITED;
+            else
+                end[u] = (hsize_t)((hssize_t)high_bounds[u] + space->select.offset[u]);
+        } /* end for */
+    } /* end if */
+    else {
+        /* Offset vector is still zeros, just copy low & high bounds */
+        H5MM_memcpy(start, low_bounds, sizeof(hsize_t) * space->extent.rank);
+        H5MM_memcpy(end, high_bounds, sizeof(hsize_t) * space->extent.rank);
+    } /* end else */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -6240,32 +6242,31 @@ done:
 
 /*--------------------------------------------------------------------------
  NAME
-    H5S_hyper_intersect_block
+    H5S__hyper_intersect_block
  PURPOSE
-    Detect intersections in span trees
+    Detect intersections of selection with block
  USAGE
-    htri_t H5S_hyper_intersect_block(space, start, end)
-        H5S_t *space;       IN: First dataspace to operate on span tree
-        hssize_t *start;    IN: Starting coordinate for block
-        hssize_t *end;      IN: Ending coordinate for block
+    htri_t H5S__hyper_intersect_block(space, start, end)
+        const H5S_t *space;     IN: Dataspace with selection to use
+        const hsize_t *start;   IN: Starting coordinate for block
+        const hsize_t *end;     IN: Ending coordinate for block
  RETURNS
-    Non-negative on success, negative on failure
+    Non-negative TRUE / FALSE on success, negative on failure
  DESCRIPTION
-    Quickly detect intersections between span tree and block
+    Quickly detect intersections between both regular hyperslabs and span trees
+    with a block
  GLOBAL VARIABLES
  COMMENTS, BUGS, ASSUMPTIONS
     Does not use selection offset.
  EXAMPLES
  REVISION LOG
 --------------------------------------------------------------------------*/
-htri_t
-H5S_hyper_intersect_block(H5S_t *space, const hsize_t *start, const hsize_t *end)
+static htri_t
+H5S__hyper_intersect_block(const H5S_t *space, const hsize_t *start, const hsize_t *end)
 {
-    const hsize_t *low_bounds, *high_bounds;    /* Pointers to the correct pair of low & high bounds */
-    unsigned u;                 /* Local index variable */
     htri_t ret_value = FAIL;    /* Return value */
 
-    FUNC_ENTER_NOAPI(FAIL)
+    FUNC_ENTER_STATIC
 
     /* Sanity check */
     HDassert(space);
@@ -6277,27 +6278,12 @@ H5S_hyper_intersect_block(H5S_t *space, const hsize_t *start, const hsize_t *end
      * to be impossible.
      */
     if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_NO)
-        H5S__hyper_rebuild(space);
-
-    /* Check which set of low & high bounds we should be using */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
-        low_bounds = space->select.sel_info.hslab->diminfo.low_bounds;
-        high_bounds = space->select.sel_info.hslab->diminfo.high_bounds;
-    } /* end if */
-    else {
-        low_bounds = space->select.sel_info.hslab->span_lst->low_bounds;
-        high_bounds = space->select.sel_info.hslab->span_lst->high_bounds;
-    } /* end else */
-
-    /* Loop over selection bounds and block, checking for overlap */
-    for(u = 0; u < space->extent.rank; u++)
-        /* If selection bounds & block don't overlap, can leave now */
-        if(!H5S_RANGE_OVERLAP(low_bounds[u], high_bounds[u], start[u], end[u]))
-            HGOTO_DONE(FALSE)
+        H5S__hyper_rebuild((H5S_t *)space);     /* Casting away const OK -QAK */
 
     /* Check for regular hyperslab intersection */
     if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
         hbool_t single_block;   /* Whether the regular selection is a single block */
+        unsigned u;             /* Local index variable */
 
         /* Check for a single block */
         /* For a regular hyperslab to be single, it must have only one block
@@ -6381,7 +6367,7 @@ H5S_hyper_intersect_block(H5S_t *space, const hsize_t *start, const hsize_t *end
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_intersect_block() */
+} /* end H5S__hyper_intersect_block() */
 
 
 /*--------------------------------------------------------------------------
diff --git a/src/H5Snone.c b/src/H5Snone.c
index 9d64e9d..c262d18 100644
--- a/src/H5Snone.c
+++ b/src/H5Snone.c
@@ -28,11 +28,11 @@
 /***********/
 /* Headers */
 /***********/
-#include "H5private.h"		/* Generic Functions			*/
-#include "H5Eprivate.h"		/* Error handling		        */
-#include "H5Iprivate.h"		/* ID Functions		                */
-#include "H5Spkg.h"		/* Dataspace functions			*/
-#include "H5VMprivate.h"        /* Vector functions                     */
+#include "H5private.h"          /* Generic Functions                        */
+#include "H5Eprivate.h"		/* Error handling			    */
+#include "H5Iprivate.h"         /* ID Functions                             */
+#include "H5Spkg.h"             /* Dataspace functions                      */
+#include "H5VMprivate.h"        /* Vector functions                         */
 
 
 /****************/
@@ -63,9 +63,12 @@ static htri_t H5S__none_is_contiguous(const H5S_t *space);
 static htri_t H5S__none_is_single(const H5S_t *space);
 static htri_t H5S__none_is_regular(const H5S_t *space);
 static htri_t H5S__none_shape_same(const H5S_t *space1, const H5S_t *space2);
+static htri_t H5S__none_intersect_block(const H5S_t *space, const hsize_t *start,
+    const hsize_t *end);
 static herr_t H5S__none_adjust_u(H5S_t *space, const hsize_t *offset);
 static herr_t H5S__none_project_scalar(const H5S_t *space, hsize_t *offset);
-static herr_t H5S__none_project_simple(const H5S_t *space, H5S_t *new_space, hsize_t *offset);
+static herr_t H5S__none_project_simple(const H5S_t *space, H5S_t *new_space,
+    hsize_t *offset);
 static herr_t H5S__none_iter_init(const H5S_t *space, H5S_sel_iter_t *iter);
 
 /* Selection iteration callbacks */
@@ -108,6 +111,7 @@ const H5S_select_class_t H5S_sel_none[1] = {{
     H5S__none_is_single,
     H5S__none_is_regular,
     H5S__none_shape_same,
+    H5S__none_intersect_block,
     H5S__none_adjust_u,
     H5S__none_project_scalar,
     H5S__none_project_simple,
@@ -886,6 +890,41 @@ H5S__none_shape_same(const H5S_t H5_ATTR_UNUSED *space1,
 
 /*--------------------------------------------------------------------------
  NAME
+    H5S__none_intersect_block
+ PURPOSE
+    Detect intersections of selection with block
+ USAGE
+    htri_t H5S__none_intersect_block(space, start, end)
+        const H5S_t *space;     IN: Dataspace with selection to use
+        const hsize_t *start;   IN: Starting coordinate for block
+        const hsize_t *end;     IN: Ending coordinate for block
+ RETURNS
+    Non-negative TRUE / FALSE on success, negative on failure
+ DESCRIPTION
+    Quickly detect intersections with a block
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+htri_t
+H5S__none_intersect_block(const H5S_t H5_ATTR_UNUSED *space,
+    const hsize_t H5_ATTR_UNUSED *start, const hsize_t H5_ATTR_UNUSED *end)
+{
+    FUNC_ENTER_STATIC_NOERR
+
+    /* Sanity check */
+    HDassert(space);
+    HDassert(H5S_SEL_NONE == H5S_GET_SELECT_TYPE(space));
+    HDassert(start);
+    HDassert(end);
+
+    FUNC_LEAVE_NOAPI(FALSE)
+} /* end H5S__none_intersect_block() */
+
+
+/*--------------------------------------------------------------------------
+ NAME
     H5S__none_adjust_u
  PURPOSE
     Adjust an "none" selection by subtracting an offset
diff --git a/src/H5Spkg.h b/src/H5Spkg.h
index 4752c59..278f08d 100644
--- a/src/H5Spkg.h
+++ b/src/H5Spkg.h
@@ -91,6 +91,15 @@
  * H5S_UNLIMITED) */
 #define H5S_MAX_SIZE            ((hsize_t)(hssize_t)(-2))
 
+/* Macro for checking if two ranges overlap one another */
+/*
+ * Check for the inverse of whether the ranges are disjoint.  If they are
+ * disjoint, then the low bound of one of the ranges must be greater than the
+ * high bound of the other.
+ */
+/* (Assumes that low & high bounds are _inclusive_) */
+#define H5S_RANGE_OVERLAP(L1, H1, L2, H2)       (!((L1) > (H2) || (L2) > (H1)))
+
 
 /*
  * Dataspace extent information
@@ -240,6 +249,8 @@ typedef htri_t (*H5S_sel_is_single_func_t)(const H5S_t *space);
 typedef htri_t (*H5S_sel_is_regular_func_t)(const H5S_t *space);
 /* Method to determine if two dataspaces' selections are the same shape */
 typedef htri_t (*H5S_sel_shape_same_func_t)(const H5S_t *space1, const H5S_t *space2);
+/* Method to determine if selection intersects a block */
+typedef htri_t (*H5S_sel_intersect_block_func_t)(const H5S_t *space, const hsize_t *start, const hsize_t *end);
 /* Method to adjust a selection by an offset */
 typedef herr_t (*H5S_sel_adjust_u_func_t)(H5S_t *space, const hsize_t *offset);
 /* Method to construct single element projection onto scalar dataspace */
@@ -268,6 +279,7 @@ typedef struct {
     H5S_sel_is_single_func_t is_single;         /* Method to determine if current selection is a single block */
     H5S_sel_is_regular_func_t is_regular;       /* Method to determine if current selection is "regular" */
     H5S_sel_shape_same_func_t shape_same;       /* Method to determine if two dataspaces' selections are the same shape */
+    H5S_sel_intersect_block_func_t intersect_block; /* Method to determine if a dataspaces' selection intersects a block */
     H5S_sel_adjust_u_func_t adjust_u;           /* Method to adjust a selection by an offset */
     H5S_sel_project_scalar project_scalar;      /* Method to construct scalar dataspace projection */
     H5S_sel_project_simple project_simple;      /* Method to construct simple dataspace projection */
@@ -369,7 +381,6 @@ H5_DLL herr_t H5S__hyper_project_intersection(const H5S_t *src_space,
 
 /* Testing functions */
 #ifdef H5S_TESTING
-H5_DLL htri_t H5S__select_shape_same_test(hid_t sid1, hid_t sid2);
 H5_DLL herr_t H5S__get_rebuild_status_test(hid_t space_id,
     H5S_diminfo_valid_t *status1, H5S_diminfo_valid_t *status2);
 H5_DLL herr_t H5S__get_diminfo_status_test(hid_t space_id,
diff --git a/src/H5Spoint.c b/src/H5Spoint.c
index 875c018..8e1175a 100644
--- a/src/H5Spoint.c
+++ b/src/H5Spoint.c
@@ -28,14 +28,14 @@
 /***********/
 /* Headers */
 /***********/
-#include "H5private.h"      /* Generic Functions        */
-#include "H5CXprivate.h"    /* API Contexts             */
-#include "H5Eprivate.h"		/* Error handling			*/
-#include "H5FLprivate.h"	/* Free Lists				*/
-#include "H5Iprivate.h"     /* ID Functions             */
-#include "H5MMprivate.h"    /* Memory management        */
-#include "H5Spkg.h"         /* Dataspace functions      */
-#include "H5VMprivate.h"        /* Vector functions     */
+#include "H5private.h"          /* Generic Functions                        */
+#include "H5CXprivate.h"        /* API Contexts                             */
+#include "H5Eprivate.h"		/* Error handling			    */
+#include "H5FLprivate.h"	/* Free Lists				    */
+#include "H5Iprivate.h"         /* ID Functions                             */
+#include "H5MMprivate.h"        /* Memory management                        */
+#include "H5Spkg.h"             /* Dataspace functions                      */
+#include "H5VMprivate.h"        /* Vector functions                         */
 
 
 /****************/
@@ -75,6 +75,8 @@ static htri_t H5S__point_is_contiguous(const H5S_t *space);
 static htri_t H5S__point_is_single(const H5S_t *space);
 static htri_t H5S__point_is_regular(const H5S_t *space);
 static htri_t H5S__point_shape_same(const H5S_t *space1, const H5S_t *space2);
+static htri_t H5S__point_intersect_block(const H5S_t *space, const hsize_t *start,
+    const hsize_t *end);
 static herr_t H5S__point_adjust_u(H5S_t *space, const hsize_t *offset);
 static herr_t H5S__point_project_scalar(const H5S_t *space, hsize_t *offset);
 static herr_t H5S__point_project_simple(const H5S_t *space, H5S_t *new_space,
@@ -124,6 +126,7 @@ const H5S_select_class_t H5S_sel_point[1] = {{
     H5S__point_is_single,
     H5S__point_is_regular,
     H5S__point_shape_same,
+    H5S__point_intersect_block,
     H5S__point_adjust_u,
     H5S__point_project_scalar,
     H5S__point_project_simple,
@@ -1998,6 +2001,63 @@ done:
 
 /*--------------------------------------------------------------------------
  NAME
+    H5S__point_intersect_block
+ PURPOSE
+    Detect intersections of selection with block
+ USAGE
+    htri_t H5S__point_intersect_block(space, start, end)
+        const H5S_t *space;     IN: Dataspace with selection to use
+        const hsize_t *start;   IN: Starting coordinate for block
+        const hsize_t *end;     IN: Ending coordinate for block
+ RETURNS
+    Non-negative TRUE / FALSE on success, negative on failure
+ DESCRIPTION
+    Quickly detect intersections with a block
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+htri_t
+H5S__point_intersect_block(const H5S_t *space, const hsize_t *start,
+    const hsize_t *end)
+{
+    H5S_pnt_node_t *pnt;        /* Point information node */
+    htri_t ret_value = FALSE;   /* Return value */
+
+    FUNC_ENTER_STATIC_NOERR
+
+    /* Sanity check */
+    HDassert(space);
+    HDassert(H5S_SEL_POINTS == H5S_GET_SELECT_TYPE(space));
+    HDassert(start);
+    HDassert(end);
+
+    /* Loop over points */
+    pnt = space->select.sel_info.pnt_lst->head;
+    while(pnt) {
+        unsigned u;                 /* Local index variable */
+
+        /* Verify that the point is within the block */
+        for(u = 0; u < space->extent.rank; u++)
+            if(pnt->pnt[u] < start[u] || pnt->pnt[u] > end[u])
+                break;
+
+        /* Check if point was within block for all dimensions */
+        if(u == space->extent.rank)
+            HGOTO_DONE(TRUE)
+
+        /* Advance to next point */
+        pnt = pnt->next;
+    } /* end while */
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5S__point_intersect_block() */
+
+
+/*--------------------------------------------------------------------------
+ NAME
     H5S__point_adjust_u
  PURPOSE
     Adjust a "point" selection by subtracting an offset
diff --git a/src/H5Sprivate.h b/src/H5Sprivate.h
index 6646f84..0a9d2e7 100644
--- a/src/H5Sprivate.h
+++ b/src/H5Sprivate.h
@@ -30,15 +30,6 @@
 #include "H5Pprivate.h"		/* Property lists			*/
 #include "H5Tprivate.h"		/* Datatypes				*/
 
-/* Flags for H5S_find */
-#define H5S_CONV_PAR_IO_POSSIBLE        0x0001
-/* The storage options are mutually exclusive */
-/* (2-bits reserved for storage type currently) */
-#define H5S_CONV_STORAGE_COMPACT        0x0000  /* i.e. '0' */
-#define H5S_CONV_STORAGE_CONTIGUOUS     0x0002  /* i.e. '1' */
-#define H5S_CONV_STORAGE_CHUNKED        0x0004  /* i.e. '2' */
-#define H5S_CONV_STORAGE_MASK           0x0006
-
 /* Forward references of package typedefs */
 typedef struct H5S_extent_t H5S_extent_t;
 typedef struct H5S_pnt_node_t H5S_pnt_node_t;
@@ -192,6 +183,8 @@ typedef struct H5S_sel_iter_op_t {
 #endif /* H5S_MODULE */
 /* Handle these callbacks in a special way, since they have prologs that need to be executed */
 #define H5S_SELECT_COPY(DST,SRC,SHARE)  (H5S_select_copy(DST,SRC,SHARE))
+#define H5S_SELECT_SHAPE_SAME(S1,S2)    (H5S_select_shape_same(S1,S2))
+#define H5S_SELECT_INTERSECT_BLOCK(S,START,END) (H5S_select_intersect_block(S,START,END))
 #define H5S_SELECT_RELEASE(S)           (H5S_select_release(S))
 #define H5S_SELECT_DESERIALIZE(S,BUF)   (H5S_select_deserialize(S,BUF))
 
@@ -252,6 +245,8 @@ H5_DLL herr_t H5S_get_select_num_elem_non_unlim(const H5S_t *space,
 H5_DLL herr_t H5S_select_offset(H5S_t *space, const hssize_t *offset);
 H5_DLL herr_t H5S_select_copy(H5S_t *dst, const H5S_t *src, hbool_t share_selection);
 H5_DLL htri_t H5S_select_shape_same(const H5S_t *space1, const H5S_t *space2);
+H5_DLL htri_t H5S_select_intersect_block(const H5S_t *space, const hsize_t *start,
+    const hsize_t *end);
 H5_DLL herr_t H5S_select_construct_projection(const H5S_t *base_space,
     H5S_t **new_space_ptr, unsigned new_space_rank, const void *buf,
     void const **adj_buf_ptr, hsize_t element_size);
@@ -287,7 +282,6 @@ H5_DLL herr_t H5S_combine_hyperslab(H5S_t *old_space, H5S_seloper_t op,
     const hsize_t *block, H5S_t **new_space);
 H5_DLL herr_t H5S_hyper_add_span_element(H5S_t *space, unsigned rank,
     const hsize_t *coords);
-H5_DLL htri_t H5S_hyper_intersect_block(H5S_t *space, const hsize_t *start, const hsize_t *end);
 H5_DLL herr_t H5S_hyper_adjust_s(H5S_t *space, const hssize_t *offset);
 H5_DLL htri_t H5S_hyper_normalize_offset(H5S_t *space, hssize_t *old_offset);
 H5_DLL herr_t H5S_hyper_denormalize_offset(H5S_t *space, const hssize_t *old_offset);
diff --git a/src/H5Spublic.h b/src/H5Spublic.h
index 23e6846..9e76b4b 100644
--- a/src/H5Spublic.h
+++ b/src/H5Spublic.h
@@ -145,6 +145,9 @@ H5_DLL herr_t H5Sselect_copy(hid_t dst_id, hid_t src_id);
 H5_DLL htri_t H5Sselect_valid(hid_t spaceid);
 H5_DLL herr_t H5Sget_select_bounds(hid_t spaceid, hsize_t start[],
     hsize_t end[]);
+H5_DLL htri_t H5Sselect_shape_same(hid_t space1_id, hid_t space2_id);
+H5_DLL htri_t H5Sselect_intersect_block(hid_t space_id, const hsize_t *start,
+    const hsize_t *end);
 H5_DLL herr_t H5Soffset_simple(hid_t space_id, const hssize_t *offset);
 H5_DLL herr_t H5Sselect_all(hid_t spaceid);
 H5_DLL herr_t H5Sselect_none(hid_t spaceid);
diff --git a/src/H5Sselect.c b/src/H5Sselect.c
index c383fed..e632b11 100644
--- a/src/H5Sselect.c
+++ b/src/H5Sselect.c
@@ -250,11 +250,15 @@ H5S_select_copy(H5S_t *dst, const H5S_t *src, hbool_t share_selection)
     HDassert(dst);
     HDassert(src);
 
+    /* Release the current selection */
+    if(H5S_SELECT_RELEASE(dst) < 0)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release selection")
+
     /* Copy regular fields */
     dst->select = src->select;
 
     /* Perform correct type of copy based on the type of selection */
-    if((ret_value = (*src->select.type->copy)(dst,src,share_selection)) < 0)
+    if((ret_value = (*src->select.type->copy)(dst, src, share_selection)) < 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, FAIL, "can't copy selection specific information")
 
 done:
@@ -281,7 +285,7 @@ done:
 herr_t
 H5S_select_release(H5S_t *ds)
 {
-    herr_t ret_value = FAIL;    /* Return value */
+    herr_t ret_value = SUCCEED;         /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT
 
@@ -1689,9 +1693,12 @@ H5S_get_select_type(const H5S_t *space)
  DESCRIPTION
     Checks to see if the current selection in the dataspaces are the same
     dimensionality and shape.
+
     This is primarily used for reading the entire selection in one swoop.
  GLOBAL VARIABLES
  COMMENTS, BUGS, ASSUMPTIONS
+    This routine participates in the "Inlining C function pointers" pattern,
+    don't call it directly, use the appropriate macro defined in H5Sprivate.h.
  EXAMPLES
  REVISION LOG
 --------------------------------------------------------------------------*/
@@ -1945,6 +1952,164 @@ done:
 
 /*--------------------------------------------------------------------------
  NAME
+    H5Sselect_shape_same
+ PURPOSE
+    Check if two selections are the same shape
+ USAGE
+    htri_t H5Sselect_shape_same(space1_id, space2_id)
+        hid_t space1_id;         IN: ID of 1st Dataspace pointer to compare
+        hid_t space2_id;         IN: ID of 2nd Dataspace pointer to compare
+ RETURNS
+    TRUE/FALSE/FAIL
+ DESCRIPTION
+    Checks to see if the current selection in the dataspaces are the same
+    dimensionality and shape.
+    This is primarily used for reading the entire selection in one swoop.
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+htri_t
+H5Sselect_shape_same(hid_t space1_id, hid_t space2_id)
+{
+    H5S_t *space1, *space2;     /* Dataspaces to compare */
+    htri_t ret_value;           /* Return value */
+
+    FUNC_ENTER_API(FAIL)
+    H5TRACE2("t", "ii", space1_id, space2_id);
+
+    if(NULL == (space1 = (H5S_t *)H5I_object_verify(space1_id, H5I_DATASPACE)))
+        HGOTO_ERROR(H5E_DATASPACE, H5E_BADTYPE, FAIL, "not a dataspace")
+    if(NULL == (space2 = (H5S_t *)H5I_object_verify(space2_id, H5I_DATASPACE)))
+        HGOTO_ERROR(H5E_DATASPACE, H5E_BADTYPE, FAIL, "not a dataspace")
+
+    if((ret_value = H5S_select_shape_same(space1, space2)) < 0)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOMPARE, FAIL, "can't compare selections")
+
+done:
+    FUNC_LEAVE_API(ret_value)
+} /* end H5Sselect_shape_same() */
+
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5S_select_intersect_block
+ PURPOSE
+    Check if current selection intersects with a block
+ USAGE
+    htri_t H5S_select_intersect_block(space, start, end)
+        const H5S_t *space;      IN: Dataspace to compare
+        const hsize_t *start;    IN: Starting coordinate of block
+        const hsize_t *end;      IN: Opposite ("ending") coordinate of block
+ RETURNS
+    TRUE / FALSE / FAIL
+ DESCRIPTION
+    Checks to see if the current selection in the dataspace intersects with
+    the block given.
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+    Assumes that start & end block bounds are _inclusive_, so start == end
+    value OK.
+
+    This routine participates in the "Inlining C function pointers" pattern,
+    don't call it directly, use the appropriate macro defined in H5Sprivate.h.
+--------------------------------------------------------------------------*/
+htri_t
+H5S_select_intersect_block(const H5S_t *space, const hsize_t *start,
+    const hsize_t *end)
+{
+    htri_t ret_value = TRUE;        /* Return value */
+
+    FUNC_ENTER_NOAPI(FAIL)
+
+    /* Check args */
+    HDassert(space);
+    HDassert(start);
+    HDassert(end);
+
+    /* If selections aren't "none", compare their bounds */
+    if(H5S_SEL_NONE != H5S_GET_SELECT_TYPE(space)) {
+        hsize_t low[H5S_MAX_RANK];      /* Low bound of selection in dataspace */
+        hsize_t high[H5S_MAX_RANK];     /* High bound of selection in dataspace */
+        unsigned u;                     /* Local index variable */
+
+        /* Get low & high bounds for dataspace selection */
+        if(H5S_SELECT_BOUNDS(space, low, high) < 0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "can't get selection bounds for dataspace")
+
+        /* Loop over selection bounds and block, checking for overlap */
+        for(u = 0; u < space->extent.rank; u++)
+            /* If selection bounds & block don't overlap, can leave now */
+            if(!H5S_RANGE_OVERLAP(low[u], high[u], start[u], end[u]))
+                HGOTO_DONE(FALSE)
+    } /* end if */
+
+    /* Call selection type's intersect routine */
+    if((ret_value = (*space->select.type->intersect_block)(space, start, end)) < 0)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOMPARE, FAIL, "can't intersect block with selection")
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5S_select_intersect_block() */
+
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5Sselect_intersect_block
+ PURPOSE
+    Check if current selection intersects with a block
+ USAGE
+    htri_t H5Sselect_intersect_block(space_id, start, end)
+        hid_t space1_id;         IN: ID of dataspace pointer to compare
+        const hsize_t *start;    IN: Starting coordinate of block
+        const hsize_t *end;      IN: Opposite ("ending") coordinate of block
+ RETURNS
+    TRUE / FALSE / FAIL
+ DESCRIPTION
+    Checks to see if the current selection in the dataspace intersects with
+    the block given.
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+    Assumes that start & end block bounds are _inclusive_, so start == end
+    value OK.
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+htri_t
+H5Sselect_intersect_block(hid_t space_id, const hsize_t *start, const hsize_t *end)
+{
+    H5S_t *space;                       /* Dataspace to query */
+    unsigned u;                         /* Local index value */
+    htri_t ret_value = FAIL;            /* Return value */
+
+    FUNC_ENTER_API(FAIL)
+    H5TRACE3("t", "i*h*h", space_id, start, end);
+
+    /* Check arguments */
+    if(NULL == (space = (H5S_t *)H5I_object_verify(space_id, H5I_DATASPACE)))
+        HGOTO_ERROR(H5E_DATASPACE, H5E_BADTYPE, FAIL, "not a dataspace")
+    if(NULL == start)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL, "block start array pointer is NULL")
+    if(NULL == end)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL, "block end array pointer is NULL")
+
+    /* Range check start & end values */
+    for(u = 0; u < space->extent.rank; u++)
+        if(start[u] > end[u])
+            HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "block start[%u] (%llu) > end[%u] (%llu)", u, (unsigned long long)start[u], u, (unsigned long long)end[u])
+
+    /* Call internal routine to do comparison */
+    if((ret_value = H5S_select_intersect_block(space, start, end)) < 0)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOMPARE, FAIL, "can't compare selection and block")
+
+done:
+    FUNC_LEAVE_API(ret_value)
+} /* end H5Sselect_intersect_block() */
+
+
+/*--------------------------------------------------------------------------
+ NAME
     H5S_select_construct_projection
 
  PURPOSE
diff --git a/src/H5Stest.c b/src/H5Stest.c
index 2c42713..b61b6bf 100644
--- a/src/H5Stest.c
+++ b/src/H5Stest.c
@@ -66,50 +66,6 @@
 
 /*--------------------------------------------------------------------------
  NAME
-    H5S__select_shape_same_test
- PURPOSE
-    Determine if two dataspace selections are the same shape
- USAGE
-    htri_t H5S__select_shape_same_test(sid1, sid2)
-        hid_t sid1;          IN: 1st dataspace to compare
-        hid_t sid2;          IN: 2nd dataspace to compare
- RETURNS
-    Non-negative TRUE/FALSE on success, negative on failure
- DESCRIPTION
-    Checks to see if the current selection in the dataspaces are the same
-    dimensionality and shape.
- GLOBAL VARIABLES
- COMMENTS, BUGS, ASSUMPTIONS
-    DO NOT USE THIS FUNCTION FOR ANYTHING EXCEPT TESTING
- EXAMPLES
- REVISION LOG
---------------------------------------------------------------------------*/
-htri_t
-H5S__select_shape_same_test(hid_t sid1, hid_t sid2)
-{
-    H5S_t	*space1;                /* Pointer to 1st dataspace */
-    H5S_t	*space2;                /* Pointer to 2nd dataspace */
-    htri_t      ret_value = FAIL;       /* Return value */
-
-    FUNC_ENTER_PACKAGE
-
-    /* Get dataspace structures */
-    if(NULL == (space1 = (H5S_t *)H5I_object_verify(sid1, H5I_DATASPACE)))
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace")
-    if(NULL == (space2 = (H5S_t *)H5I_object_verify(sid2, H5I_DATASPACE)))
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace")
-
-    /* Check if the dataspace selections are the same shape */
-    if((ret_value = H5S_select_shape_same(space1, space2)) < 0)
-        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOMPARE, FAIL, "unable to compare dataspace selections")
-
-done:
-    FUNC_LEAVE_NOAPI(ret_value)
-} /* H5S__select_shape_same_test() */
-
-
-/*--------------------------------------------------------------------------
- NAME
     H5S__get_rebuild_status_test
  PURPOSE
     Determine the status of the diminfo_valid field (whether we know the
diff --git a/test/objcopy.c b/test/objcopy.c
index 1f89e16..94a2b36 100644
--- a/test/objcopy.c
+++ b/test/objcopy.c
@@ -284,8 +284,6 @@ addr_reset(void)
  * Programmer:  Peter Cao
  *              Friday, August 4, 2006
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static herr_t
@@ -345,8 +343,6 @@ error:
  * Programmer:  Peter Cao
  *              Monday, March 5, 2006
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static herr_t
@@ -422,8 +418,6 @@ error:
  * Programmer:  Peter Cao
  *              Friday, August 4, 2006
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static herr_t
@@ -517,8 +511,6 @@ error:
  * Programmer:  Peter Cao
  *              Saturday, December 17, 2005
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static int
@@ -579,8 +571,6 @@ done:
  * Programmer:  Peter Cao
  *              Friday, September 30, 2005
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static int
@@ -856,10 +846,6 @@ error:
  * Note:    This isn't very general, the attributes are assumed to be
  *              those written in test_copy_attach_attributes().
  *
- * Modifier:    Peter Cao
- *              Wednesday, March 21, 2007
- *              Change to compare any attributes of two objects
- *
  *-------------------------------------------------------------------------
  */
 static int
@@ -1167,7 +1153,7 @@ compare_data(hid_t parent1, hid_t parent2, hid_t pid, hid_t tid, size_t nelmts,
                 if((obj2_sid = H5Rget_region(parent2, H5R_DATASET_REGION, ref_buf2)) < 0) TEST_ERROR
 
                 /* Check if dataspaces are the same shape */
-                if(H5S__select_shape_same_test(obj1_sid, obj2_sid) < 0) TEST_ERROR
+                if(H5Sselect_shape_same(obj1_sid, obj2_sid) < 0) TEST_ERROR
 
                 /* Close dataspaces */
                 if(H5Sclose(obj1_sid) < 0) TEST_ERROR
@@ -1213,8 +1199,8 @@ compare_datasets(hid_t did, hid_t did2, hid_t pid, const void *wbuf)
     hssize_t nelmts;                            /* # of elements in dataspace */
     void *rbuf = NULL;                          /* Buffer for reading raw data */
     void *rbuf2 = NULL;                         /* Buffer for reading raw data */
-    H5D_space_status_t space_status;            /* Dataset's raw data space status */
-    H5D_space_status_t space_status2;           /* Dataset's raw data space status */
+    H5D_space_status_t space_status;            /* Dataset's raw dataspace status */
+    H5D_space_status_t space_status2;           /* Dataset's raw dataspace status */
 
     /* Check the datatypes are equal */
 
@@ -1569,8 +1555,6 @@ error:
  * Programmer:  Peter Cao
  *              Friday, September 30, 2005
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static int
@@ -1858,8 +1842,6 @@ error:
  * Programmer:  Neil
  *              Friday, March 11, 2011
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static int
@@ -1999,8 +1981,6 @@ error:
  * Programmer:  Peter Cao
  *              Friday, September 30, 2005
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static int
@@ -2294,8 +2274,6 @@ error:
  * Programmer:  Neil Fortner
  *              Thursday, January 15, 2009
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static int
@@ -2519,8 +2497,6 @@ error:
  * Programmer:  Peter Cao
  *              Friday, September 30, 2005
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static int
@@ -2651,8 +2627,6 @@ error:
  * Programmer:  Peter Cao
  *              Friday, September 30, 2005
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static int
@@ -4396,8 +4370,6 @@ error:
  * Programmer:  Peter Cao
  *              Friday, September 30, 2005
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static int
@@ -6281,8 +6253,6 @@ error:
  * Programmer:  Peter Cao
  *              Friday, September 30, 2005
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static int
@@ -6376,8 +6346,6 @@ error:
  * Programmer:  Peter Cao
  *              August 8, 2006
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static int
@@ -6509,8 +6477,6 @@ error:
  * Programmer:  Peter Cao
  *              Friday, September 30, 2005
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static int
@@ -7024,12 +6990,6 @@ error:
  * Programmer:  Peter Cao
  *              Friday, September 30, 2005
  *
- * Modifications:
- *              Neil Fortner
- *              Tuesday, February 16, 2010
- *              Modified test to test flags for expanding soft and external
- *              links.
- *
  *-------------------------------------------------------------------------
  */
 static int
@@ -8017,7 +7977,7 @@ test_copy_dataset_compact_named_vl(hid_t fcpl_src, hid_t fcpl_dst, hid_t src_fap
     /* make a copy of the datatype for later use */
     if((tid_copy = H5Tcopy(tid)) < 0)TEST_ERROR
 
-    /* named data type */
+    /* named datatype */
     if((H5Tcommit2(fid_src, NAME_DATATYPE_VL, tid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
 
     /* create and set compact plist */
@@ -8171,7 +8131,7 @@ test_copy_dataset_contig_named_vl(hid_t fcpl_src, hid_t fcpl_dst, hid_t src_fapl
     /* make a copy of the datatype for later use */
     if((tid_copy = H5Tcopy(tid)) < 0)TEST_ERROR
 
-    /* named data type */
+    /* named datatype */
     if((H5Tcommit2(fid_src, NAME_DATATYPE_VL, tid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
 
     /* create dataset at SRC file */
@@ -8326,7 +8286,7 @@ test_copy_dataset_chunked_named_vl(hid_t fcpl_src, hid_t fcpl_dst, hid_t src_fap
     /* make a copy of the datatype for later use */
     if((tid_copy = H5Tcopy(tid)) < 0)TEST_ERROR
 
-    /* named data type */
+    /* named datatype */
     if((H5Tcommit2(fid_src, NAME_DATATYPE_VL, tid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
 
      /* create and set chunk plist */
@@ -8487,7 +8447,7 @@ test_copy_dataset_compressed_named_vl(hid_t fcpl_src, hid_t fcpl_dst, hid_t src_
     /* make a copy of the datatype for later use */
     if((tid_copy = H5Tcopy(tid)) < 0)TEST_ERROR
 
-    /* named data type */
+    /* named datatype */
     if((H5Tcommit2(fid_src, NAME_DATATYPE_VL, tid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
 
      /* create and set chunk plist */
@@ -10289,7 +10249,7 @@ test_copy_committed_datatype_merge(hid_t fcpl_src, hid_t fcpl_dst, hid_t src_fap
     /* create datatype */
     if((tid = H5Tcopy(H5T_NATIVE_INT)) < 0)TEST_ERROR
 
-    /* committed data type */
+    /* committed datatype */
     if((H5Tcommit2(fid_src1, NAME_DATATYPE_SIMPLE, tid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
 
     /* create dataset at SRC file */
@@ -10313,7 +10273,7 @@ test_copy_committed_datatype_merge(hid_t fcpl_src, hid_t fcpl_dst, hid_t src_fap
     /* create datatype */
     if((tid = H5Tcopy(H5T_NATIVE_INT)) < 0)TEST_ERROR
 
-    /* committed data type */
+    /* committed datatype */
     if((H5Tcommit2(fid_src2, NAME_DATATYPE_SIMPLE, tid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
 
     /* create dataset at SRC file */
@@ -10524,7 +10484,7 @@ test_copy_committed_datatype_merge_same_file(hid_t fcpl, hid_t fapl, hbool_t reo
     /* create datatype */
     if((tid = H5Tcopy(H5T_NATIVE_INT)) < 0)TEST_ERROR
 
-    /* committed data type */
+    /* committed datatype */
     if((H5Tcommit2(fid, NAME_GROUP_TOP "/" NAME_DATATYPE_SIMPLE, tid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
 
     /* create dataset */
@@ -10551,7 +10511,7 @@ test_copy_committed_datatype_merge_same_file(hid_t fcpl, hid_t fapl, hbool_t reo
     /* create datatype */
     if((tid = H5Tcopy(H5T_NATIVE_INT)) < 0)TEST_ERROR
 
-    /* committed data type */
+    /* committed datatype */
     if((H5Tcommit2(fid, NAME_GROUP_TOP2 "/" NAME_DATATYPE_SIMPLE, tid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
 
     /* create dataset */
@@ -10796,7 +10756,7 @@ test_copy_committed_dt_merge_sugg(hid_t fcpl_src, hid_t fcpl_dst, hid_t src_fapl
     /* create datatype */
     if((tid = H5Tcopy(H5T_NATIVE_INT)) < 0)TEST_ERROR
 
-    /* committed data type */
+    /* committed datatype */
     if((H5Tcommit2(fid_src, NAME_DATATYPE_SIMPLE, tid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
 
     /* create dataset at SRC file */
@@ -10823,7 +10783,7 @@ test_copy_committed_dt_merge_sugg(hid_t fcpl_src, hid_t fcpl_dst, hid_t src_fapl
     /* create datatype */
     if((tid = H5Tcopy(H5T_NATIVE_INT)) < 0)TEST_ERROR
 
-    /* committed data type "a" */
+    /* committed datatype "a" */
     if((H5Tcommit2(fid_dst, "/a", tid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
 
     /* close the datatype */
@@ -10832,7 +10792,7 @@ test_copy_committed_dt_merge_sugg(hid_t fcpl_src, hid_t fcpl_dst, hid_t src_fapl
     /* create datatype */
     if((tid = H5Tcopy(H5T_NATIVE_INT)) < 0)TEST_ERROR
 
-    /* committed data type "b" */
+    /* committed datatype "b" */
     if((H5Tcommit2(fid_dst, "/b", tid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
 
     /* close the datatype */
@@ -11027,7 +10987,7 @@ test_copy_committed_dt_merge_attr(hid_t fcpl_src, hid_t fcpl_dst, hid_t src_fapl
     /* create datatype */
     if((tid = H5Tcopy(H5T_NATIVE_INT)) < 0)TEST_ERROR
 
-    /* committed data type */
+    /* committed datatype */
     if((H5Tcommit2(fid_src, NAME_DATATYPE_SIMPLE, tid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
 
     /* create dataset at SRC file */
@@ -11057,7 +11017,7 @@ test_copy_committed_dt_merge_attr(hid_t fcpl_src, hid_t fcpl_dst, hid_t src_fapl
     /* create datatype */
     if((tid = H5Tcopy(H5T_NATIVE_INT)) < 0)TEST_ERROR
 
-    /* create anonymous committed data type */
+    /* create anonymous committed datatype */
     if((H5Tcommit_anon(fid_dst, tid, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
 
     /* create attribute at SRC file */
@@ -12817,7 +12777,7 @@ test_copy_set_mcdt_search_cb(hid_t fcpl_src, hid_t fcpl_dst, hid_t src_fapl,
     /* create datatype */
     if((tid = H5Tcopy(H5T_NATIVE_INT)) < 0)TEST_ERROR
 
-    /* named data type */
+    /* named datatype */
     if((H5Tcommit2(fid_src, NAME_DATATYPE_SIMPLE, tid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
 
     /* create dataset at SRC file */
@@ -12847,7 +12807,7 @@ test_copy_set_mcdt_search_cb(hid_t fcpl_src, hid_t fcpl_dst, hid_t src_fapl,
     /* create datatype */
     if((tid = H5Tcopy(H5T_NATIVE_INT)) < 0)TEST_ERROR
 
-    /* committed data type "a" */
+    /* committed datatype "a" */
     if((H5Tcommit2(fid_dst, "/a", tid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
 
     /* close the datatype */
@@ -12856,7 +12816,7 @@ test_copy_set_mcdt_search_cb(hid_t fcpl_src, hid_t fcpl_dst, hid_t src_fapl,
     /* create datatype */
     if((tid = H5Tcopy(H5T_NATIVE_INT)) < 0)TEST_ERROR
 
-    /* committed data type "b" */
+    /* committed datatype "b" */
     if((H5Tcommit2(fid_dst, "/b", tid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
 
     /* close the datatype */
@@ -13176,7 +13136,7 @@ test_copy_set_get_mcdt_search_cb(hid_t fcpl_src, hid_t fcpl_dst, hid_t src_fapl,
     /* create datatype */
     if((tid = H5Tcopy(H5T_NATIVE_INT)) < 0)TEST_ERROR
 
-    /* committed data type */
+    /* committed datatype */
     if((H5Tcommit2(fid_src, NAME_DATATYPE_SIMPLE, tid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
 
     /* create dataset at SRC file */
@@ -13206,7 +13166,7 @@ test_copy_set_get_mcdt_search_cb(hid_t fcpl_src, hid_t fcpl_dst, hid_t src_fapl,
     /* create datatype */
     if((tid = H5Tcopy(H5T_NATIVE_INT)) < 0)TEST_ERROR
 
-    /* committed data type "a" */
+    /* committed datatype "a" */
     if((H5Tcommit2(fid_dst, "/a", tid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
 
     /* close the datatype */
@@ -13215,7 +13175,7 @@ test_copy_set_get_mcdt_search_cb(hid_t fcpl_src, hid_t fcpl_dst, hid_t src_fapl,
     /* create datatype */
     if((tid = H5Tcopy(H5T_NATIVE_INT)) < 0)TEST_ERROR
 
-    /* committed data type "b" */
+    /* committed datatype "b" */
     if((H5Tcommit2(fid_dst, "/b", tid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
 
     /* close the datatype */
@@ -13499,8 +13459,6 @@ error:
  * Programmer:  Peter Cao
  *               March 11, 2006
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static int
@@ -13817,8 +13775,6 @@ error:
  * Programmer:  Vailin Choi
  *              Feb 7, 2012
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static int
@@ -14138,8 +14094,6 @@ error:
  * Programmer:  Peter Cao
  *              Friday, September 30, 2005
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 int
diff --git a/test/th5s.c b/test/th5s.c
index a48979b..f0365de 100644
--- a/test/th5s.c
+++ b/test/th5s.c
@@ -187,7 +187,7 @@ test_h5s_basic(void)
     CHECK(ret, FAIL, "H5Sclose");
 
     /*
-     * Check to be sure we can't create a simple data space that has too many
+     * Check to be sure we can't create a simple dataspace that has too many
      * dimensions.
      */
     H5E_BEGIN_TRY {
@@ -318,7 +318,7 @@ test_h5s_basic(void)
 
 /****************************************************************
 **
-**  test_h5s_null(): Test NULL data space
+**  test_h5s_null(): Test NULL dataspace
 **
 ****************************************************************/
 static void
@@ -460,7 +460,7 @@ test_h5s_null(void)
     CHECK(ret, FAIL, "H5Fclose");
 
     /*============================================
-     *  Reopen the file to check the data space
+     *  Reopen the file to check the dataspace
      *============================================
      */
     fid = H5Fopen(NULLFILE, H5F_ACC_RDONLY, H5P_DEFAULT);
@@ -1078,7 +1078,7 @@ test_h5s_zero_dim(void)
         CHECK(ret, FAIL, "H5Fclose");
 
         /*============================================
-         *  Reopen the file to check the data space
+         *  Reopen the file to check the dataspace
          *============================================
          */
         fid1 = H5Fopen(ZEROFILE, H5F_ACC_RDONLY, H5P_DEFAULT);
@@ -1227,7 +1227,7 @@ test_h5s_encode(H5F_libver_t low, H5F_libver_t high)
     ret = H5Sselect_hyperslab(sid1, H5S_SELECT_SET, start, stride, count, block);
     CHECK(ret, FAIL, "H5Sselect_hyperslab");
 
-    /* Encode simple data space in a buffer with the fapl setting */
+    /* Encode simple dataspace in a buffer with the fapl setting */
     ret = H5Sencode2(sid1, NULL, &sbuf_size, fapl);
     CHECK(ret, FAIL, "H5Sencode2");
 
@@ -1242,7 +1242,7 @@ test_h5s_encode(H5F_libver_t low, H5F_libver_t high)
     } H5E_END_TRY;
     VERIFY(ret_id, FAIL, "H5Sdecode");
 
-    /* Encode the simple data space in a buffer with the fapl setting */
+    /* Encode the simple dataspace in a buffer with the fapl setting */
     ret = H5Sencode2(sid1, sbuf, &sbuf_size, fapl);
     CHECK(ret, FAIL, "H5Sencode");
 
@@ -1289,7 +1289,7 @@ test_h5s_encode(H5F_libver_t low, H5F_libver_t high)
     sid2 = H5Screate(H5S_NULL);
     CHECK(sid2, FAIL, "H5Screate");
 
-    /* Encode null data space in a buffer */
+    /* Encode null dataspace in a buffer */
     ret = H5Sencode2(sid2, NULL, &null_size, fapl);
     CHECK(ret, FAIL, "H5Sencode");
 
@@ -1298,7 +1298,7 @@ test_h5s_encode(H5F_libver_t low, H5F_libver_t high)
         CHECK(null_sbuf, NULL, "HDcalloc");
     }
 
-    /* Encode the null data space in the buffer */
+    /* Encode the null dataspace in the buffer */
     ret = H5Sencode2(sid2, null_sbuf, &null_size, fapl);
     CHECK(ret, FAIL, "H5Sencode2");
 
@@ -1325,7 +1325,7 @@ test_h5s_encode(H5F_libver_t low, H5F_libver_t high)
     sid3 = H5Screate(H5S_SCALAR);
     CHECK(sid3, FAIL, "H5Screate_simple");
 
-    /* Encode scalar data space in a buffer */
+    /* Encode scalar dataspace in a buffer */
     ret = H5Sencode2(sid3, NULL, &scalar_size, fapl);
     CHECK(ret, FAIL, "H5Sencode");
 
@@ -1334,7 +1334,7 @@ test_h5s_encode(H5F_libver_t low, H5F_libver_t high)
         CHECK(scalar_buf, NULL, "HDcalloc");
     }
 
-    /* Encode the scalar data space in the buffer */
+    /* Encode the scalar dataspace in the buffer */
     ret = H5Sencode2(sid3, scalar_buf, &scalar_size, fapl);
     CHECK(ret, FAIL, "H5Sencode2");
 
@@ -1419,7 +1419,7 @@ test_h5s_encode1(void)
     ret = H5Sselect_hyperslab(sid1, H5S_SELECT_SET, start, stride, count, block);
     CHECK(ret, FAIL, "H5Sselect_hyperslab");
 
-    /* Encode simple data space in a buffer with the fapl setting */
+    /* Encode simple dataspace in a buffer with the fapl setting */
     ret = H5Sencode1(sid1, NULL, &sbuf_size);
     CHECK(ret, FAIL, "H5Sencode2");
 
@@ -1434,7 +1434,7 @@ test_h5s_encode1(void)
     } H5E_END_TRY;
     VERIFY(ret_id, FAIL, "H5Sdecode");
 
-    /* Encode the simple data space in a buffer */
+    /* Encode the simple dataspace in a buffer */
     ret = H5Sencode1(sid1, sbuf, &sbuf_size);
     CHECK(ret, FAIL, "H5Sencode");
 
@@ -1481,7 +1481,7 @@ test_h5s_encode1(void)
     sid2 = H5Screate(H5S_NULL);
     CHECK(sid2, FAIL, "H5Screate");
 
-    /* Encode null data space in a buffer */
+    /* Encode null dataspace in a buffer */
     ret = H5Sencode1(sid2, NULL, &null_size);
     CHECK(ret, FAIL, "H5Sencode");
 
@@ -1490,7 +1490,7 @@ test_h5s_encode1(void)
         CHECK(null_sbuf, NULL, "HDcalloc");
     }
 
-    /* Encode the null data space in the buffer */
+    /* Encode the null dataspace in the buffer */
     ret = H5Sencode1(sid2, null_sbuf, &null_size);
     CHECK(ret, FAIL, "H5Sencode2");
 
@@ -1515,9 +1515,9 @@ test_h5s_encode1(void)
      */
     /* Create scalar dataspace */
     sid3 = H5Screate(H5S_SCALAR);
-    CHECK(sid3, FAIL, "H5Screate_simple");
+    CHECK(sid3, FAIL, "H5Screate");
 
-    /* Encode scalar data space in a buffer */
+    /* Encode scalar dataspace in a buffer */
     ret = H5Sencode1(sid3, NULL, &scalar_size);
     CHECK(ret, FAIL, "H5Sencode");
 
@@ -1526,7 +1526,7 @@ test_h5s_encode1(void)
         CHECK(scalar_buf, NULL, "HDcalloc");
     }
 
-    /* Encode the scalar data space in the buffer */
+    /* Encode the scalar dataspace in the buffer */
     ret = H5Sencode1(sid3, scalar_buf, &scalar_size);
     CHECK(ret, FAIL, "H5Sencode2");
 
@@ -1622,8 +1622,8 @@ test_h5s_check_encoding(hid_t in_fapl, hid_t in_sid,
         VERIFY(H5Sget_select_npoints(in_sid), H5Sget_select_npoints(d_sid), "Compare npoints");
 
         /* Verify if the two dataspace selections (in_sid, d_sid) are the same shape */
-        check = H5S__select_shape_same_test(in_sid, d_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(in_sid, d_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         /* Compare the starting/ending coordinates of the bounding box for in_sid and d_sid */
         ret = H5Sget_select_bounds(in_sid, in_low_bounds, in_high_bounds);
@@ -2127,7 +2127,7 @@ test_h5s_encode_length(void)
     ret = H5Sselect_hyperslab(sid, H5S_SELECT_SET, &start, &stride, &count, &block);
     CHECK(ret, FAIL, "H5Sselect_hyperslab");
 
-    /* Encode simple data space in a buffer */
+    /* Encode simple dataspace in a buffer */
     ret = H5Sencode2(sid, NULL, &sbuf_size, H5P_DEFAULT);
     CHECK(ret, FAIL, "H5Sencode");
 
@@ -2493,7 +2493,7 @@ test_h5s_chunk(void)
     status = H5Pset_chunk(plist_id, 2, csize);
     CHECK(status, FAIL, "H5Pset_chunk");
 
-    /* Create the data space */
+    /* Create the dataspace */
     dims[0] = 50000;
     dims[1] = 3;
     space_id = H5Screate_simple(2, dims, NULL);
diff --git a/test/tselect.c b/test/tselect.c
index bbab868..4a47929 100644
--- a/test/tselect.c
+++ b/test/tselect.c
@@ -869,7 +869,7 @@ test_select_all_hyper(hid_t xfer_plist)
 
     /* Select no extent for disk dataset */
     ret = H5Sselect_none(sid1);
-    CHECK(ret, FAIL, "H5Sselect_all");
+    CHECK(ret, FAIL, "H5Sselect_none");
 
     /* Read selection from disk (should fail with no selection defined) */
     ret=H5Dread(dataset,H5T_NATIVE_UCHAR,sid2,sid1,xfer_plist,rbuf);
@@ -890,7 +890,7 @@ test_select_all_hyper(hid_t xfer_plist)
 
     /* A quick check to make certain that iterating through a "none" selection works */
     ret = H5Sselect_none(sid2);
-    CHECK(ret, FAIL, "H5Sselect_all");
+    CHECK(ret, FAIL, "H5Sselect_none");
     ret = H5Diterate(rbuf,H5T_NATIVE_UCHAR,sid2,test_select_none_iter1,&tbuf);
     CHECK(ret, FAIL, "H5Diterate");
 
@@ -1662,7 +1662,7 @@ verify_select_hyper_contig_dr__run_test(const uint16_t *cube_buf,
 **  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
+**	tested H5Sselect_shape_same in isolation, so now we try to do
 **	I/O.
 **
 ****************************************************************/
@@ -1846,11 +1846,11 @@ test_select_hyper_contig_dr__run_test(int test_num, const uint16_t *cube_buf,
 
 
     /* first, verify that we can read from disk correctly using selections
-     * of different rank that H5S_select_shape_same() views as being of the
+     * of different rank that H5Sselect_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()
+     * verifying that the data read is correct.  Verify that H5Sselect_shape_same()
      * returns true on the memory and file selections.
      */
 
@@ -1894,12 +1894,11 @@ test_select_hyper_contig_dr__run_test(int test_num, const uint16_t *cube_buf,
                                               block_ptr);
                     CHECK(ret, FAIL, "H5Sselect_hyperslab");
 
-                    /* verify that H5S_select_shape_same() reports the two
+                    /* verify that H5Sselect_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");
+                    check = H5Sselect_shape_same(small_cube_sid, file_large_cube_sid);
+                    VERIFY(check, TRUE, "H5Sselect_shape_same");
 
                     /* Read selection from disk */
                     ret = H5Dread(large_cube_dataset,
@@ -1971,12 +1970,11 @@ test_select_hyper_contig_dr__run_test(int test_num, const uint16_t *cube_buf,
                     CHECK(ret, FAIL, "H5Sselect_hyperslab");
 
 
-                    /* verify that H5S_select_shape_same() reports the two
+                    /* verify that H5Sselect_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");
+                    check = H5Sselect_shape_same(small_cube_sid, mem_large_cube_sid);
+                    VERIFY(check, TRUE, "H5Sselect_shape_same");
 
 
                     /* Read selection from disk */
@@ -2038,12 +2036,12 @@ test_select_hyper_contig_dr__run_test(int test_num, const uint16_t *cube_buf,
 
     /* now we go in the opposite direction, verifying that we can write
      * from memory to file using selections of different rank that
-     * H5S_select_shape_same() views as being of the same shape.
+     * H5Sselect_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
+     * data. Verify that H5Sselect_shape_same() returns true on the
      * memory and file selections.
      */
 
@@ -2087,13 +2085,12 @@ test_select_hyper_contig_dr__run_test(int test_num, const uint16_t *cube_buf,
                     CHECK(ret, FAIL, "H5Sselect_hyperslab");
 
 
-                    /* verify that H5S_select_shape_same() reports the in
+                    /* verify that H5Sselect_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");
+                    check = H5Sselect_shape_same(small_cube_sid, mem_large_cube_sid);
+                    VERIFY(check, TRUE, "H5Sselect_shape_same");
 
 
 	            /* write the slice from the in memory large cube to the on disk small cube */
@@ -2145,7 +2142,7 @@ test_select_hyper_contig_dr__run_test(int test_num, const uint16_t *cube_buf,
     /* 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
+     * data.  Verify that H5Sselect_shape_same() returns true on
      * the memory and file selections.
      */
 
@@ -2197,14 +2194,13 @@ test_select_hyper_contig_dr__run_test(int test_num, const uint16_t *cube_buf,
                     CHECK(ret, FAIL, "H5Sselect_hyperslab");
 
 
-                    /* verify that H5S_select_shape_same() reports the in
+                    /* verify that H5Sselect_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");
+                    check = H5Sselect_shape_same(small_cube_sid, file_large_cube_sid);
+                    VERIFY(check, TRUE, "H5Sselect_shape_same");
 
 
 	            /* write the cube from memory to the target slice of the disk cube */
@@ -2309,7 +2305,7 @@ test_select_hyper_contig_dr__run_test(int test_num, const uint16_t *cube_buf,
 **  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
+**	tested H5Sselect_shape_same in isolation, so now we try to do
 **	I/O.
 **
 ****************************************************************/
@@ -2375,7 +2371,7 @@ test_select_hyper_contig_dr(hid_t dset_type, hid_t xfer_plist)
 /****************************************************************
 **
 **  test_select_hyper_checker_board_dr__select_checker_board():
-**	Given an n-cube data space with each edge of length
+**	Given an n-cube dataspace 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
@@ -2567,8 +2563,8 @@ test_select_hyper_checker_board_dr__select_checker_board(hid_t tgt_n_cube_sid,
     /* 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
+     * boundaries of the target dataspace -- hence the following
+     * code to manually clip the selection back to the dataspace
      * proper.
      */
     for(u = 0; u < SS_DR_MAX_RANK; u++) {
@@ -2732,7 +2728,7 @@ test_select_hyper_checker_board_dr__verify_data(uint16_t * buf_ptr,
 **  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
+**	shape.  We have already tested H5Sselect_shape_same in
 **	isolation, so now we try to do I/O.
 **
 ****************************************************************/
@@ -2938,11 +2934,11 @@ test_select_hyper_checker_board_dr__run_test(int test_num, const uint16_t *cube_
 
 
     /* first, verify that we can read from disk correctly using selections
-     * of different rank that H5S_select_shape_same() views as being of the
+     * of different rank that H5Sselect_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()
+     * verifying that the data read is correct.  Verify that H5Sselect_shape_same()
      * returns true on the memory and file selections.
      *
      * The first step is to set up the needed checker board selection in the
@@ -3004,12 +3000,11 @@ test_select_hyper_checker_board_dr__run_test(int test_num, const uint16_t *cube_
                       sel_start
                     );
 
-                    /* verify that H5S_select_shape_same() reports the two
+                    /* verify that H5Sselect_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");
+                    check = H5Sselect_shape_same(mem_small_cube_sid, file_large_cube_sid);
+                    VERIFY(check, TRUE, "H5Sselect_shape_same");
 
                     /* zero the buffer that we will be using for reading */
                     HDmemset(small_cube_buf_1, 0, sizeof(*small_cube_buf_1) * small_cube_size);
@@ -3111,12 +3106,11 @@ test_select_hyper_checker_board_dr__run_test(int test_num, const uint16_t *cube_
                       sel_start
                     );
 
-                    /* verify that H5S_select_shape_same() reports the two
+                    /* verify that H5Sselect_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");
+                    check = H5Sselect_shape_same(file_small_cube_sid, mem_large_cube_sid);
+                    VERIFY(check, TRUE, "H5Sselect_shape_same");
 
 
                     /* zero out the in memory large cube */
@@ -3195,12 +3189,12 @@ test_select_hyper_checker_board_dr__run_test(int test_num, const uint16_t *cube_
 
     /* 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.
+     * H5Sselect_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
+     * data. Verify that H5Sselect_shape_same() returns true on the
      * memory and file selections.
      */
 
@@ -3264,12 +3258,11 @@ test_select_hyper_checker_board_dr__run_test(int test_num, const uint16_t *cube_
                       sel_start
                     );
 
-                    /* verify that H5S_select_shape_same() reports the two
+                    /* verify that H5Sselect_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");
+                    check = H5Sselect_shape_same(file_small_cube_sid, mem_large_cube_sid);
+                    VERIFY(check, TRUE, "H5Sselect_shape_same");
 
 
 	            /* write the slice from the in memory large cube to the
@@ -3332,7 +3325,7 @@ test_select_hyper_checker_board_dr__run_test(int test_num, const uint16_t *cube_
      * 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
+     * H5Sselect_shape_same() returns true on the memory and file
      * selections.
      */
 
@@ -3396,12 +3389,11 @@ test_select_hyper_checker_board_dr__run_test(int test_num, const uint16_t *cube_
                       sel_start
                     );
 
-                    /* verify that H5S_select_shape_same() reports the two
+                    /* verify that H5Sselect_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");
+                    check = H5Sselect_shape_same(file_large_cube_sid, mem_small_cube_sid);
+                    VERIFY(check, TRUE, "H5Sselect_shape_same");
 
 
 	            /* write the checker board selection of the in memory
@@ -3537,7 +3529,7 @@ test_select_hyper_checker_board_dr__run_test(int test_num, const uint16_t *cube_
 **  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
+**	tested H5Sselect_shape_same in isolation, so now we try to do
 **	I/O.
 **
 **	This is just an initial smoke check, so we will work
@@ -6133,7 +6125,7 @@ test_select_hyper_chunk(hid_t fapl_plist, hid_t xfer_plist)
     CHECK(file, FAIL, "H5Fcreate");
 
     /*
-     * Describe the size of the array and create the data space for fixed
+     * Describe the size of the array and create the dataspace for fixed
      * size dataset.
      */
     dimsf[0] = X;
@@ -7874,7 +7866,7 @@ test_scalar_select2(void)
 
     /* Select all elements in memory & file with "all" selection */
     ret = H5Sselect_all(sid);
-    CHECK(ret, FAIL, "H5Sselect_none");
+    CHECK(ret, FAIL, "H5Sselect_all");
 
     /* Close disk dataspace */
     ret = H5Sclose(sid);
@@ -8202,294 +8194,294 @@ test_shape_same(void)
 
     /* Compare "all" selection to all the selections created */
         /* Compare against itself */
-        check = H5S__select_shape_same_test(all_sid,all_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(all_sid ,all_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         /* Compare against copy of itself */
-        tmp_sid=H5Scopy(all_sid);
+        tmp_sid = H5Scopy(all_sid);
         CHECK(tmp_sid, FAIL, "H5Scopy");
 
-        check = H5S__select_shape_same_test(all_sid,tmp_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(all_sid, tmp_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         ret = H5Sclose(tmp_sid);
         CHECK(ret, FAIL, "H5Sclose");
 
         /* Compare against "none" selection */
-        check = H5S__select_shape_same_test(all_sid,none_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(all_sid, none_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against single point selection */
-        check = H5S__select_shape_same_test(all_sid,single_pt_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(all_sid, single_pt_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against multiple point selection */
-        check = H5S__select_shape_same_test(all_sid,mult_pt_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(all_sid, mult_pt_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "plain" single hyperslab selection */
-        check = H5S__select_shape_same_test(all_sid,single_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(all_sid, single_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "all" single hyperslab selection */
-        check = H5S__select_shape_same_test(all_sid,single_hyper_all_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(all_sid, single_hyper_all_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         /* Compare against "single point" single hyperslab selection */
-        check = H5S__select_shape_same_test(all_sid,single_hyper_pt_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(all_sid, single_hyper_pt_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against regular, strided hyperslab selection */
-        check = H5S__select_shape_same_test(all_sid,regular_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(all_sid, regular_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against irregular hyperslab selection */
-        check = H5S__select_shape_same_test(all_sid,irreg_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(all_sid, irreg_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "no" hyperslab selection */
-        check = H5S__select_shape_same_test(all_sid,none_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(all_sid, none_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against scalar "all" hyperslab selection */
-        check = H5S__select_shape_same_test(all_sid, scalar_all_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(all_sid, scalar_all_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against scalar "none" hyperslab selection */
-        check = H5S__select_shape_same_test(all_sid, scalar_none_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(all_sid, scalar_none_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
     /* Compare "none" selection to all the selections created */
         /* Compare against itself */
-        check = H5S__select_shape_same_test(none_sid,none_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(none_sid, none_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         /* Compare against copy of itself */
-        tmp_sid=H5Scopy(none_sid);
+        tmp_sid = H5Scopy(none_sid);
         CHECK(tmp_sid, FAIL, "H5Scopy");
 
-        check = H5S__select_shape_same_test(none_sid,tmp_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(none_sid, tmp_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         ret = H5Sclose(tmp_sid);
         CHECK(ret, FAIL, "H5Sclose");
 
         /* Compare against "all" selection */
-        check = H5S__select_shape_same_test(none_sid,all_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(none_sid, all_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against single point selection */
-        check = H5S__select_shape_same_test(none_sid,single_pt_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(none_sid, single_pt_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against multiple point selection */
-        check = H5S__select_shape_same_test(none_sid,mult_pt_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(none_sid, mult_pt_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "plain" single hyperslab selection */
-        check = H5S__select_shape_same_test(none_sid,single_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(none_sid, single_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "all" single hyperslab selection */
-        check = H5S__select_shape_same_test(none_sid,single_hyper_all_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(none_sid, single_hyper_all_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "single point" single hyperslab selection */
-        check = H5S__select_shape_same_test(none_sid,single_hyper_pt_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(none_sid, single_hyper_pt_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against regular, strided hyperslab selection */
-        check = H5S__select_shape_same_test(none_sid,regular_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(none_sid, regular_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against irregular hyperslab selection */
-        check = H5S__select_shape_same_test(none_sid,irreg_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(none_sid, irreg_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "no" hyperslab selection */
-        check = H5S__select_shape_same_test(none_sid,none_hyper_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(none_sid, none_hyper_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         /* Compare against scalar "all" hyperslab selection */
-        check = H5S__select_shape_same_test(none_sid, scalar_all_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(none_sid, scalar_all_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against scalar "none" hyperslab selection */
-        check = H5S__select_shape_same_test(none_sid, scalar_none_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(none_sid, scalar_none_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
     /* Compare single point selection to all the selections created */
         /* Compare against itself */
-        check = H5S__select_shape_same_test(single_pt_sid,single_pt_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_pt_sid, single_pt_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         /* Compare against copy of itself */
-        tmp_sid=H5Scopy(single_pt_sid);
+        tmp_sid = H5Scopy(single_pt_sid);
         CHECK(tmp_sid, FAIL, "H5Scopy");
 
-        check = H5S__select_shape_same_test(single_pt_sid,tmp_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_pt_sid, tmp_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         ret = H5Sclose(tmp_sid);
         CHECK(ret, FAIL, "H5Sclose");
 
         /* Compare against "all" selection */
-        check = H5S__select_shape_same_test(single_pt_sid,all_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_pt_sid, all_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "none" selection */
-        check = H5S__select_shape_same_test(single_pt_sid,none_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_pt_sid, none_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against multiple point selection */
-        check = H5S__select_shape_same_test(single_pt_sid,mult_pt_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_pt_sid, mult_pt_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "plain" single hyperslab selection */
-        check = H5S__select_shape_same_test(single_pt_sid,single_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_pt_sid, single_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "all" single hyperslab selection */
-        check = H5S__select_shape_same_test(single_pt_sid,single_hyper_all_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_pt_sid, single_hyper_all_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "single point" single hyperslab selection */
-        check = H5S__select_shape_same_test(single_pt_sid,single_hyper_pt_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_pt_sid, single_hyper_pt_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         /* Compare against regular, strided hyperslab selection */
-        check = H5S__select_shape_same_test(single_pt_sid,regular_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_pt_sid, regular_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against irregular hyperslab selection */
-        check = H5S__select_shape_same_test(single_pt_sid,irreg_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_pt_sid, irreg_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "no" hyperslab selection */
-        check = H5S__select_shape_same_test(single_pt_sid,none_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_pt_sid, none_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against scalar "all" hyperslab selection */
-        check = H5S__select_shape_same_test(single_pt_sid, scalar_all_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_pt_sid, scalar_all_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         /* Compare against scalar "none" hyperslab selection */
-        check = H5S__select_shape_same_test(single_pt_sid, scalar_none_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_pt_sid, scalar_none_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
     /* Compare multiple point selection to all the selections created */
         /* Compare against itself */
-        check = H5S__select_shape_same_test(mult_pt_sid,mult_pt_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(mult_pt_sid, mult_pt_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         /* Compare against copy of itself */
-        tmp_sid=H5Scopy(mult_pt_sid);
+        tmp_sid = H5Scopy(mult_pt_sid);
         CHECK(tmp_sid, FAIL, "H5Scopy");
 
-        check = H5S__select_shape_same_test(mult_pt_sid,tmp_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(mult_pt_sid, tmp_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         ret = H5Sclose(tmp_sid);
         CHECK(ret, FAIL, "H5Sclose");
 
         /* Compare against "all" selection */
-        check = H5S__select_shape_same_test(mult_pt_sid,all_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(mult_pt_sid, all_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "none" selection */
-        check = H5S__select_shape_same_test(mult_pt_sid,none_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(mult_pt_sid, none_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against single point selection */
-        check = H5S__select_shape_same_test(mult_pt_sid,single_pt_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(mult_pt_sid, single_pt_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "plain" single hyperslab selection */
-        check = H5S__select_shape_same_test(mult_pt_sid,single_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(mult_pt_sid, single_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "all" single hyperslab selection */
-        check = H5S__select_shape_same_test(mult_pt_sid,single_hyper_all_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(mult_pt_sid, single_hyper_all_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "single point" single hyperslab selection */
-        check = H5S__select_shape_same_test(mult_pt_sid,single_hyper_pt_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(mult_pt_sid, single_hyper_pt_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against regular, strided hyperslab selection */
-        check = H5S__select_shape_same_test(mult_pt_sid,regular_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(mult_pt_sid, regular_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against irregular hyperslab selection */
-        check = H5S__select_shape_same_test(mult_pt_sid,irreg_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(mult_pt_sid, irreg_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "no" hyperslab selection */
-        check = H5S__select_shape_same_test(mult_pt_sid,none_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(mult_pt_sid, none_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against scalar "all" hyperslab selection */
-        check = H5S__select_shape_same_test(mult_pt_sid, scalar_all_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(mult_pt_sid, scalar_all_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against scalar "none" hyperslab selection */
-        check = H5S__select_shape_same_test(mult_pt_sid, scalar_none_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(mult_pt_sid, scalar_none_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
     /* Compare single "normal" hyperslab selection to all the selections created */
         /* Compare against itself */
-        check = H5S__select_shape_same_test(single_hyper_sid,single_hyper_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_sid, single_hyper_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         /* Compare against copy of itself */
-        tmp_sid=H5Scopy(single_hyper_sid);
+        tmp_sid = H5Scopy(single_hyper_sid);
         CHECK(tmp_sid, FAIL, "H5Scopy");
 
-        check = H5S__select_shape_same_test(single_hyper_sid,tmp_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_sid, tmp_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         ret = H5Sclose(tmp_sid);
         CHECK(ret, FAIL, "H5Sclose");
 
         /* Compare against "all" selection */
-        check = H5S__select_shape_same_test(single_hyper_sid,all_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_sid, all_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "none" selection */
-        check = H5S__select_shape_same_test(single_hyper_sid,none_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_sid, none_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against single point selection */
-        check = H5S__select_shape_same_test(single_hyper_sid,single_pt_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_sid, single_pt_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against multiple point selection */
-        check = H5S__select_shape_same_test(single_hyper_sid,mult_pt_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_sid, mult_pt_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "all" single hyperslab selection */
-        check = H5S__select_shape_same_test(single_hyper_sid,single_hyper_all_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_sid, single_hyper_all_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "single point" single hyperslab selection */
-        check = H5S__select_shape_same_test(single_hyper_sid,single_hyper_pt_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_sid, single_hyper_pt_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against regular, strided hyperslab selection */
-        check = H5S__select_shape_same_test(single_hyper_sid,regular_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_sid, regular_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against irregular hyperslab selection */
-        check = H5S__select_shape_same_test(single_hyper_sid,irreg_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_sid, irreg_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "no" hyperslab selection */
-        check = H5S__select_shape_same_test(single_hyper_sid,none_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_sid, none_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
 #ifdef NOT_YET
 /* In theory, these two selections are the same shape, but the
- * H5S_select_shape_same() routine is just not this sophisticated yet and it
+ * H5Sselect_shape_same() routine is just not this sophisticated yet and it
  * would take too much effort to make this work.  The worst case is that the
  * non-optimized chunk mapping routines will be invoked instead of the more
  * optimized routines, so this only hurts performance, not correctness
@@ -8500,17 +8492,19 @@ test_shape_same(void)
             CHECK(tmp_sid, FAIL, "H5Screate_simple");
 
             /* Select sequence of points for point selection */
-            for(u=1; u<(SPACE9_DIM1-1); u++) {
-                for(v=1; v<(SPACE9_DIM2-1); v++) {
-                    coord2[v-1][0]=u; coord2[v-1][1]=v;
+            for(u = 1; u < (SPACE9_DIM1 - 1); u++) {
+                for(v = 1; v < (SPACE9_DIM2 - 1); v++) {
+                    coord2[v - 1][0] = u;
+                    coord2[v - 1][1] = v;
                 } /* end for */
-                ret = H5Sselect_elements(tmp_sid,H5S_SELECT_APPEND,(SPACE9_DIM2-2),coord2);
+
+                ret = H5Sselect_elements(tmp_sid, H5S_SELECT_APPEND, (SPACE9_DIM2 - 2), coord2);
                 CHECK(ret, FAIL, "H5Sselect_elements");
             } /* end for */
 
             /* Compare against hyperslab selection */
-            check = H5S__select_shape_same_test(single_hyper_sid,tmp_sid);
-            VERIFY(check, TRUE, "H5S__select_shape_same_test");
+            check = H5Sselect_shape_same(single_hyper_sid, tmp_sid);
+            VERIFY(check, TRUE, "H5Sselect_shape_same");
 
             ret = H5Sclose(tmp_sid);
             CHECK(ret, FAIL, "H5Sclose");
@@ -8526,80 +8520,80 @@ test_shape_same(void)
             CHECK(ret, FAIL, "H5Sselect_none");
 
             /* Select sequence of rows for hyperslab selection */
-            for(u=1; u<(SPACE9_DIM1-1); u++) {
-                start[0]=u; start[1]=1;
-                stride[0]=1; stride[1]=1;
-                count[0]=1; count[1]=1;
-                block[0]=1; block[1]=(SPACE9_DIM2-2);
-                ret = H5Sselect_hyperslab(tmp_sid,H5S_SELECT_OR,start,stride,count,block);
+            for(u = 1; u < (SPACE9_DIM1 - 1); u++) {
+                start[0] = u;  start[1] = 1;
+                stride[0] = 1; stride[1] = 1;
+                count[0] = 1;  count[1] = 1;
+                block[0] = 1;  block[1] = (SPACE9_DIM2 - 2);
+                ret = H5Sselect_hyperslab(tmp_sid, H5S_SELECT_OR, start, stride, count, block);
                 CHECK(ret, FAIL, "H5Sselect_hyperslab");
             } /* end for */
 
             /* Compare against hyperslab selection */
-            check = H5S__select_shape_same_test(single_hyper_sid,tmp_sid);
-            VERIFY(check, TRUE, "H5S__select_shape_same_test");
+            check = H5Sselect_shape_same(single_hyper_sid, tmp_sid);
+            VERIFY(check, TRUE, "H5Sselect_shape_same");
 
             ret = H5Sclose(tmp_sid);
             CHECK(ret, FAIL, "H5Sclose");
 
         /* Compare against scalar "all" hyperslab selection */
-        check = H5S__select_shape_same_test(single_hyper_sid, scalar_all_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_sid, scalar_all_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against scalar "none" hyperslab selection */
-        check = H5S__select_shape_same_test(single_hyper_sid, scalar_none_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_sid, scalar_none_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
     /* Compare single "all" hyperslab selection to all the selections created */
         /* Compare against itself */
-        check = H5S__select_shape_same_test(single_hyper_all_sid,single_hyper_all_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_all_sid, single_hyper_all_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         /* Compare against copy of itself */
-        tmp_sid=H5Scopy(single_hyper_all_sid);
+        tmp_sid = H5Scopy(single_hyper_all_sid);
         CHECK(tmp_sid, FAIL, "H5Scopy");
 
-        check = H5S__select_shape_same_test(single_hyper_all_sid,tmp_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_all_sid, tmp_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         ret = H5Sclose(tmp_sid);
         CHECK(ret, FAIL, "H5Sclose");
 
         /* Compare against "all" selection */
-        check = H5S__select_shape_same_test(single_hyper_all_sid,all_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_all_sid, all_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         /* Compare against "none" selection */
-        check = H5S__select_shape_same_test(single_hyper_all_sid,none_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_all_sid, none_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against single point selection */
-        check = H5S__select_shape_same_test(single_hyper_all_sid,single_pt_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_all_sid, single_pt_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against multiple point selection */
-        check = H5S__select_shape_same_test(single_hyper_all_sid,mult_pt_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_all_sid, mult_pt_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "plain" single hyperslab selection */
-        check = H5S__select_shape_same_test(single_hyper_all_sid,single_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_all_sid, single_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "single point" single hyperslab selection */
-        check = H5S__select_shape_same_test(single_hyper_all_sid,single_hyper_pt_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_all_sid, single_hyper_pt_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against regular, strided hyperslab selection */
-        check = H5S__select_shape_same_test(single_hyper_all_sid,regular_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_all_sid, regular_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against irregular hyperslab selection */
-        check = H5S__select_shape_same_test(single_hyper_all_sid,irreg_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_all_sid, irreg_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "no" hyperslab selection */
-        check = H5S__select_shape_same_test(single_hyper_all_sid,none_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_all_sid, none_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
 #ifdef NOT_YET
 /* In theory, these two selections are the same shape, but the
@@ -8614,17 +8608,18 @@ test_shape_same(void)
             CHECK(tmp_sid, FAIL, "H5Screate_simple");
 
             /* Select sequence of points for point selection */
-            for(u=0; u<SPACE9_DIM1; u++) {
-                for(v=0; v<SPACE9_DIM2; v++) {
-                    coord2[v][0]=u; coord2[v][1]=v;
+            for(u = 0; u < SPACE9_DIM1; u++) {
+                for(v = 0; v < SPACE9_DIM2; v++) {
+                    coord2[v][0] = u;
+                    coord2[v][1] = v;
                 } /* end for */
-                ret = H5Sselect_elements(tmp_sid,H5S_SELECT_APPEND,SPACE9_DIM2,coord2);
+                ret = H5Sselect_elements(tmp_sid, H5S_SELECT_APPEND, SPACE9_DIM2, coord2);
                 CHECK(ret, FAIL, "H5Sselect_elements");
             } /* end for */
 
             /* Compare against hyperslab selection */
-            check = H5S__select_shape_same_test(single_hyper_all_sid,tmp_sid);
-            VERIFY(check, TRUE, "H5S__select_shape_same_test");
+            check = H5Sselect_shape_same(single_hyper_all_sid, tmp_sid);
+            VERIFY(check, TRUE, "H5Sselect_shape_same");
 
             ret = H5Sclose(tmp_sid);
             CHECK(ret, FAIL, "H5Sclose");
@@ -8640,139 +8635,139 @@ test_shape_same(void)
             CHECK(ret, FAIL, "H5Sselect_none");
 
             /* Select sequence of rows for hyperslab selection */
-            for(u=0; u<SPACE9_DIM2; u++) {
-                start[0]=u; start[1]=0;
-                stride[0]=1; stride[1]=1;
-                count[0]=1; count[1]=1;
-                block[0]=1; block[1]=SPACE9_DIM2;
-                ret = H5Sselect_hyperslab(tmp_sid,H5S_SELECT_OR,start,stride,count,block);
+            for(u = 0; u < SPACE9_DIM2; u++) {
+                start[0] = u;  start[1] = 0;
+                stride[0] = 1; stride[1] = 1;
+                count[0] = 1;  count[1] = 1;
+                block[0] = 1;  block[1] = SPACE9_DIM2;
+                ret = H5Sselect_hyperslab(tmp_sid, H5S_SELECT_OR, start, stride, count, block);
                 CHECK(ret, FAIL, "H5Sselect_hyperslab");
             } /* end for */
 
             /* Compare against hyperslab selection */
-            check = H5S__select_shape_same_test(single_hyper_all_sid,tmp_sid);
-            VERIFY(check, TRUE, "H5S__select_shape_same_test");
+            check = H5Sselect_shape_same(single_hyper_all_sid, tmp_sid);
+            VERIFY(check, TRUE, "H5Sselect_shape_same");
 
             ret = H5Sclose(tmp_sid);
             CHECK(ret, FAIL, "H5Sclose");
 
         /* Compare against scalar "all" hyperslab selection */
-        check = H5S__select_shape_same_test(single_hyper_all_sid, scalar_all_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_all_sid, scalar_all_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against scalar "none" hyperslab selection */
-        check = H5S__select_shape_same_test(single_hyper_all_sid, scalar_none_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_all_sid, scalar_none_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
     /* Compare single "point" hyperslab selection to all the selections created */
         /* Compare against itself */
-        check = H5S__select_shape_same_test(single_hyper_pt_sid,single_hyper_pt_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_pt_sid, single_hyper_pt_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         /* Compare against copy of itself */
-        tmp_sid=H5Scopy(single_hyper_pt_sid);
+        tmp_sid = H5Scopy(single_hyper_pt_sid);
         CHECK(tmp_sid, FAIL, "H5Scopy");
 
-        check = H5S__select_shape_same_test(single_hyper_pt_sid,tmp_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_pt_sid, tmp_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         ret = H5Sclose(tmp_sid);
         CHECK(ret, FAIL, "H5Sclose");
 
         /* Compare against "all" selection */
-        check = H5S__select_shape_same_test(single_hyper_pt_sid,all_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_pt_sid, all_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "none" selection */
-        check = H5S__select_shape_same_test(single_hyper_pt_sid,none_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_pt_sid, none_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against single point selection */
-        check = H5S__select_shape_same_test(single_hyper_pt_sid,single_pt_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_pt_sid, single_pt_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         /* Compare against multiple point selection */
-        check = H5S__select_shape_same_test(single_hyper_pt_sid,mult_pt_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_pt_sid, mult_pt_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "plain" single hyperslab selection */
-        check = H5S__select_shape_same_test(single_hyper_pt_sid,single_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_pt_sid, single_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "all" single hyperslab selection */
-        check = H5S__select_shape_same_test(single_hyper_pt_sid,single_hyper_all_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_pt_sid, single_hyper_all_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against regular, strided hyperslab selection */
-        check = H5S__select_shape_same_test(single_hyper_pt_sid,regular_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_pt_sid, regular_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against irregular hyperslab selection */
-        check = H5S__select_shape_same_test(single_hyper_pt_sid,irreg_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_pt_sid, irreg_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "no" hyperslab selection */
-        check = H5S__select_shape_same_test(single_hyper_pt_sid,none_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_pt_sid, none_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against scalar "all" hyperslab selection */
-        check = H5S__select_shape_same_test(single_hyper_pt_sid, scalar_all_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_pt_sid, scalar_all_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         /* Compare against scalar "none" hyperslab selection */
-        check = H5S__select_shape_same_test(single_hyper_pt_sid, scalar_none_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(single_hyper_pt_sid, scalar_none_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
     /* Compare regular, strided hyperslab selection to all the selections created */
         /* Compare against itself */
-        check = H5S__select_shape_same_test(regular_hyper_sid,regular_hyper_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(regular_hyper_sid, regular_hyper_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         /* Compare against copy of itself */
-        tmp_sid=H5Scopy(regular_hyper_sid);
+        tmp_sid = H5Scopy(regular_hyper_sid);
         CHECK(tmp_sid, FAIL, "H5Scopy");
 
-        check = H5S__select_shape_same_test(regular_hyper_sid,tmp_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(regular_hyper_sid, tmp_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         ret = H5Sclose(tmp_sid);
         CHECK(ret, FAIL, "H5Sclose");
 
         /* Compare against "all" selection */
-        check = H5S__select_shape_same_test(regular_hyper_sid,all_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(regular_hyper_sid, all_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "none" selection */
-        check = H5S__select_shape_same_test(regular_hyper_sid,none_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(regular_hyper_sid, none_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against single point selection */
-        check = H5S__select_shape_same_test(regular_hyper_sid,single_pt_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(regular_hyper_sid, single_pt_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against multiple point selection */
-        check = H5S__select_shape_same_test(regular_hyper_sid,mult_pt_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(regular_hyper_sid, mult_pt_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "plain" single hyperslab selection */
-        check = H5S__select_shape_same_test(regular_hyper_sid,single_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(regular_hyper_sid, single_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "all" single hyperslab selection */
-        check = H5S__select_shape_same_test(regular_hyper_sid,single_hyper_all_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(regular_hyper_sid, single_hyper_all_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "single point" single hyperslab selection */
-        check = H5S__select_shape_same_test(regular_hyper_sid,single_hyper_pt_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(regular_hyper_sid, single_hyper_pt_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against irregular hyperslab selection */
-        check = H5S__select_shape_same_test(regular_hyper_sid,irreg_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(regular_hyper_sid, irreg_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "no" hyperslab selection */
-        check = H5S__select_shape_same_test(regular_hyper_sid,none_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(regular_hyper_sid, none_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Construct point selection which matches regular, strided hyperslab selection */
             /* Create dataspace for point selection */
@@ -8780,17 +8775,18 @@ test_shape_same(void)
             CHECK(tmp_sid, FAIL, "H5Screate_simple");
 
             /* Select sequence of points for point selection */
-            for(u=2; u<11; u+=2) {
-                for(v=0; v<2; v++) {
-                    coord2[v][0]=u; coord2[v][1]=(v*2)+2;
+            for(u = 2; u < 11; u += 2) {
+                for(v = 0; v < 2; v++) {
+                    coord2[v][0] = u;
+                    coord2[v][1] = (v * 2) + 2;
                 } /* end for */
                 ret = H5Sselect_elements(tmp_sid, H5S_SELECT_APPEND, (size_t)2, (const hsize_t *)coord2);
                 CHECK(ret, FAIL, "H5Sselect_elements");
             } /* end for */
 
             /* Compare against hyperslab selection */
-            check = H5S__select_shape_same_test(regular_hyper_sid,tmp_sid);
-            VERIFY(check, TRUE, "H5S__select_shape_same_test");
+            check = H5Sselect_shape_same(regular_hyper_sid, tmp_sid);
+            VERIFY(check, TRUE, "H5Sselect_shape_same");
 
             ret = H5Sclose(tmp_sid);
             CHECK(ret, FAIL, "H5Sclose");
@@ -8805,18 +8801,18 @@ test_shape_same(void)
             CHECK(ret, FAIL, "H5Sselect_none");
 
             /* Select sequence of rows for hyperslab selection */
-            for(u=2; u<11; u+=2) {
-                start[0]=u; start[1]=3;
-                stride[0]=1; stride[1]=2;
-                count[0]=1; count[1]=2;
-                block[0]=1; block[1]=1;
-                ret = H5Sselect_hyperslab(tmp_sid,H5S_SELECT_OR,start,stride,count,block);
+            for(u = 2; u < 11; u += 2) {
+                start[0] = u;  start[1] = 3;
+                stride[0] = 1; stride[1] = 2;
+                count[0] = 1;  count[1] = 2;
+                block[0] = 1;  block[1] = 1;
+                ret = H5Sselect_hyperslab(tmp_sid, H5S_SELECT_OR, start, stride, count, block);
                 CHECK(ret, FAIL, "H5Sselect_hyperslab");
             } /* end for */
 
             /* Compare against hyperslab selection */
-            check = H5S__select_shape_same_test(regular_hyper_sid,tmp_sid);
-            VERIFY(check, TRUE, "H5S__select_shape_same_test");
+            check = H5Sselect_shape_same(regular_hyper_sid, tmp_sid);
+            VERIFY(check, TRUE, "H5Sselect_shape_same");
 
             ret = H5Sclose(tmp_sid);
             CHECK(ret, FAIL, "H5Sclose");
@@ -8827,237 +8823,237 @@ test_shape_same(void)
             CHECK(tmp_sid, FAIL, "H5Screate_simple");
 
             /* Select regular, strided hyperslab selection at an offset */
-            start[0]=1; start[1]=1;
-            stride[0]=2; stride[1]=2;
-            count[0]=5; count[1]=2;
-            block[0]=1; block[1]=1;
-            ret = H5Sselect_hyperslab(tmp_sid,H5S_SELECT_SET,start,stride,count,block);
+            start[0] = 1;  start[1] = 1;
+            stride[0] = 2; stride[1] = 2;
+            count[0] = 5;  count[1] = 2;
+            block[0] = 1;  block[1] = 1;
+            ret = H5Sselect_hyperslab(tmp_sid, H5S_SELECT_SET, start, stride, count, block);
             CHECK(ret, FAIL, "H5Sselect_hyperslab");
 
             /* Compare against hyperslab selection */
-            check = H5S__select_shape_same_test(regular_hyper_sid,tmp_sid);
-            VERIFY(check, TRUE, "H5S__select_shape_same_test");
+            check = H5Sselect_shape_same(regular_hyper_sid, tmp_sid);
+            VERIFY(check, TRUE, "H5Sselect_shape_same");
 
             ret = H5Sclose(tmp_sid);
             CHECK(ret, FAIL, "H5Sclose");
 
         /* Compare against scalar "all" hyperslab selection */
-        check = H5S__select_shape_same_test(regular_hyper_sid, scalar_all_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(regular_hyper_sid, scalar_all_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against scalar "none" hyperslab selection */
-        check = H5S__select_shape_same_test(regular_hyper_sid, scalar_none_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(regular_hyper_sid, scalar_none_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
     /* Compare irregular hyperslab selection to all the selections created */
         /* Compare against itself */
-        check = H5S__select_shape_same_test(irreg_hyper_sid,irreg_hyper_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(irreg_hyper_sid, irreg_hyper_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         /* Compare against copy of itself */
-        tmp_sid=H5Scopy(irreg_hyper_sid);
+        tmp_sid = H5Scopy(irreg_hyper_sid);
         CHECK(tmp_sid, FAIL, "H5Scopy");
 
-        check = H5S__select_shape_same_test(irreg_hyper_sid,tmp_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(irreg_hyper_sid, tmp_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         ret = H5Sclose(tmp_sid);
         CHECK(ret, FAIL, "H5Sclose");
 
         /* Compare against "all" selection */
-        check = H5S__select_shape_same_test(irreg_hyper_sid,all_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(irreg_hyper_sid, all_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "none" selection */
-        check = H5S__select_shape_same_test(irreg_hyper_sid,none_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(irreg_hyper_sid, none_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against single point selection */
-        check = H5S__select_shape_same_test(irreg_hyper_sid,single_pt_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(irreg_hyper_sid, single_pt_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against multiple point selection */
-        check = H5S__select_shape_same_test(irreg_hyper_sid,mult_pt_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(irreg_hyper_sid, mult_pt_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "plain" single hyperslab selection */
-        check = H5S__select_shape_same_test(irreg_hyper_sid,single_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(irreg_hyper_sid, single_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "all" single hyperslab selection */
-        check = H5S__select_shape_same_test(irreg_hyper_sid,single_hyper_all_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(irreg_hyper_sid, single_hyper_all_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "single point" single hyperslab selection */
-        check = H5S__select_shape_same_test(irreg_hyper_sid,single_hyper_pt_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(irreg_hyper_sid, single_hyper_pt_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against regular, strided hyperslab selection */
-        check = H5S__select_shape_same_test(irreg_hyper_sid,regular_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(irreg_hyper_sid, regular_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "no" hyperslab selection */
-        check = H5S__select_shape_same_test(irreg_hyper_sid,none_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(irreg_hyper_sid, none_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Construct hyperslab selection which matches irregular hyperslab selection */
             /* Create dataspace for hyperslab selection */
             tmp_sid = H5Screate_simple(SPACE9_RANK, dims, NULL);
             CHECK(tmp_sid, FAIL, "H5Screate_simple");
 
-            start[0]=2; start[1]=2;
-            stride[0]=1; stride[1]=1;
-            count[0]=1; count[1]=1;
-            block[0]=1; block[1]=1;
-            ret = H5Sselect_hyperslab(tmp_sid,H5S_SELECT_SET,start,stride,count,block);
+            start[0] = 2;  start[1] = 2;
+            stride[0] = 1; stride[1] = 1;
+            count[0] = 1;  count[1] = 1;
+            block[0] = 1;  block[1] = 1;
+            ret = H5Sselect_hyperslab(tmp_sid, H5S_SELECT_SET, start, stride, count, block);
             CHECK(ret, FAIL, "H5Sselect_hyperslab");
 
             /* Select sequence of columns for hyperslab selection */
-            for(u=0; u<3; u++) {
-                start[0]=4; start[1]=u+4;
-                stride[0]=1; stride[1]=1;
-                count[0]=1; count[1]=1;
-                block[0]=3; block[1]=1;
-                ret = H5Sselect_hyperslab(tmp_sid,H5S_SELECT_OR,start,stride,count,block);
+            for(u = 0; u < 3; u++) {
+                start[0] = 4; start[1] = u + 4;
+                stride[0] = 1; stride[1] = 1;
+                count[0] = 1; count[1] = 1;
+                block[0] = 3; block[1] = 1;
+                ret = H5Sselect_hyperslab(tmp_sid, H5S_SELECT_OR, start, stride, count, block);
                 CHECK(ret, FAIL, "H5Sselect_hyperslab");
             } /* end for */
 
             /* Compare against hyperslab selection */
-            check = H5S__select_shape_same_test(irreg_hyper_sid,tmp_sid);
-            VERIFY(check, TRUE, "H5S__select_shape_same_test");
+            check = H5Sselect_shape_same(irreg_hyper_sid, tmp_sid);
+            VERIFY(check, TRUE, "H5Sselect_shape_same");
 
             ret = H5Sclose(tmp_sid);
             CHECK(ret, FAIL, "H5Sclose");
 
         /* Compare against scalar "all" hyperslab selection */
-        check = H5S__select_shape_same_test(irreg_hyper_sid, scalar_all_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(irreg_hyper_sid, scalar_all_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against scalar "none" hyperslab selection */
-        check = H5S__select_shape_same_test(irreg_hyper_sid, scalar_none_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(irreg_hyper_sid, scalar_none_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
 
     /* Compare scalar "all" dataspace with all selections created */
 
         /* Compare against itself */
-        check = H5S__select_shape_same_test(scalar_all_sid, scalar_all_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(scalar_all_sid, scalar_all_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         /* Compare against copy of itself */
         tmp_sid = H5Scopy(scalar_all_sid);
         CHECK(tmp_sid, FAIL, "H5Scopy");
 
-        check = H5S__select_shape_same_test(scalar_all_sid, tmp_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(scalar_all_sid, tmp_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         ret = H5Sclose(tmp_sid);
         CHECK(ret, FAIL, "H5Sclose");
 
         /* Compare against "all" selection */
-        check = H5S__select_shape_same_test(scalar_all_sid, all_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(scalar_all_sid, all_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "none" selection */
-        check = H5S__select_shape_same_test(scalar_all_sid, none_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(scalar_all_sid, none_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against single point selection */
-        check = H5S__select_shape_same_test(scalar_all_sid, single_pt_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(scalar_all_sid, single_pt_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         /* Compare against multiple point selection */
-        check = H5S__select_shape_same_test(scalar_all_sid, mult_pt_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(scalar_all_sid, mult_pt_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "plain" single hyperslab selection */
-        check = H5S__select_shape_same_test(scalar_all_sid, single_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(scalar_all_sid, single_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "all" single hyperslab selection */
-        check = H5S__select_shape_same_test(scalar_all_sid, single_hyper_all_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(scalar_all_sid, single_hyper_all_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "single point" single hyperslab selection */
-        check = H5S__select_shape_same_test(scalar_all_sid, single_hyper_pt_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(scalar_all_sid, single_hyper_pt_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         /* Compare against regular, strided hyperslab selection */
-        check = H5S__select_shape_same_test(scalar_all_sid, regular_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(scalar_all_sid, regular_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against irregular hyperslab selection */
-        check = H5S__select_shape_same_test(scalar_all_sid, irreg_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(scalar_all_sid, irreg_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "no" hyperslab selection */
-        check = H5S__select_shape_same_test(scalar_all_sid, none_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(scalar_all_sid, none_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against scalar "none" hyperslab selection */
-        check = H5S__select_shape_same_test(scalar_all_sid, scalar_none_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(scalar_all_sid, scalar_none_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
 
     /* Compare scalar "none" dataspace with all selections created */
 
         /* Compare against itself */
-        check = H5S__select_shape_same_test(scalar_none_sid, scalar_none_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(scalar_none_sid, scalar_none_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         /* Compare against copy of itself */
         tmp_sid = H5Scopy(scalar_none_sid);
         CHECK(tmp_sid, FAIL, "H5Scopy");
 
-        check = H5S__select_shape_same_test(scalar_none_sid, tmp_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(scalar_none_sid, tmp_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         ret = H5Sclose(tmp_sid);
         CHECK(ret, FAIL, "H5Sclose");
 
         /* Compare against "all" selection */
-        check = H5S__select_shape_same_test(scalar_none_sid, all_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(scalar_none_sid, all_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "none" selection */
-        check = H5S__select_shape_same_test(scalar_none_sid, none_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(scalar_none_sid, none_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         /* Compare against single point selection */
-        check = H5S__select_shape_same_test(scalar_none_sid, single_pt_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(scalar_none_sid, single_pt_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against multiple point selection */
-        check = H5S__select_shape_same_test(scalar_none_sid, mult_pt_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(scalar_none_sid, mult_pt_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "plain" single hyperslab selection */
-        check = H5S__select_shape_same_test(scalar_none_sid, single_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(scalar_none_sid, single_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "all" single hyperslab selection */
-        check = H5S__select_shape_same_test(scalar_none_sid, single_hyper_all_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(scalar_none_sid, single_hyper_all_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "single point" single hyperslab selection */
-        check = H5S__select_shape_same_test(scalar_none_sid, single_hyper_pt_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(scalar_none_sid, single_hyper_pt_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against regular, strided hyperslab selection */
-        check = H5S__select_shape_same_test(scalar_none_sid, regular_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(scalar_none_sid, regular_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against irregular hyperslab selection */
-        check = H5S__select_shape_same_test(scalar_none_sid, irreg_hyper_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(scalar_none_sid, irreg_hyper_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
         /* Compare against "no" hyperslab selection */
-        check = H5S__select_shape_same_test(scalar_none_sid, none_hyper_sid);
-        VERIFY(check, TRUE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(scalar_none_sid, none_hyper_sid);
+        VERIFY(check, TRUE, "H5Sselect_shape_same");
 
         /* Compare against scalar "all" hyperslab selection */
-        check = H5S__select_shape_same_test(scalar_none_sid, scalar_all_sid);
-        VERIFY(check, FALSE, "H5S__select_shape_same_test");
+        check = H5Sselect_shape_same(scalar_none_sid, scalar_all_sid);
+        VERIFY(check, FALSE, "H5Sselect_shape_same");
 
 
     /* Close dataspaces */
@@ -9091,26 +9087,26 @@ test_shape_same(void)
 **
 **  test_shape_same_dr__smoke_check_1():
 **
-**	Create a square, 2 D data space (10 X 10), and select
+**	Create a square, 2-D dataspace (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
+**      Similarly, create nine, 3-D dataspaces (10 X 10 X 10),
+**	and select (10 X 10 X 1) hyperslabs 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.
+**	H5Sselect_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 hyperslabs.
 **
-**	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
+**	Also create two additional 3-D dataspaces (10 X 10 X 10),
+**	and select a (10 X 10 X 2) hyperslab 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.
+**	H5Sselect_shape_same() should return FALSE when comparing
+**	each to the 2-D selection.
 **
 ****************************************************************/
 static void
@@ -9298,42 +9294,42 @@ test_shape_same_dr__smoke_check_1(void)
     /* 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 = H5Sselect_shape_same(small_cube_xy_slice_0_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5Sselect_shape_same");
 
-    check = H5S__select_shape_same_test(small_cube_xy_slice_1_sid, small_square_sid);
-    VERIFY(check, FALSE, "H5S__select_shape_same_test");
+    check = H5Sselect_shape_same(small_cube_xy_slice_1_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5Sselect_shape_same");
 
-    check = H5S__select_shape_same_test(small_cube_xy_slice_2_sid, small_square_sid);
-    VERIFY(check, FALSE, "H5S__select_shape_same_test");
+    check = H5Sselect_shape_same(small_cube_xy_slice_2_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5Sselect_shape_same");
 
 
     /* 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 = H5Sselect_shape_same(small_cube_xz_slice_0_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5Sselect_shape_same");
 
-    check = H5S__select_shape_same_test(small_cube_xz_slice_1_sid, small_square_sid);
-    VERIFY(check, FALSE, "H5S__select_shape_same_test");
+    check = H5Sselect_shape_same(small_cube_xz_slice_1_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5Sselect_shape_same");
 
-    check = H5S__select_shape_same_test(small_cube_xz_slice_2_sid, small_square_sid);
-    VERIFY(check, FALSE, "H5S__select_shape_same_test");
+    check = H5Sselect_shape_same(small_cube_xz_slice_2_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5Sselect_shape_same");
 
 
     /* 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 = H5Sselect_shape_same(small_cube_yz_slice_0_sid, small_square_sid);
+    VERIFY(check, TRUE, "H5Sselect_shape_same");
 
-    check = H5S__select_shape_same_test(small_cube_yz_slice_1_sid, small_square_sid);
-    VERIFY(check, TRUE, "H5S__select_shape_same_test");
+    check = H5Sselect_shape_same(small_cube_yz_slice_1_sid, small_square_sid);
+    VERIFY(check, TRUE, "H5Sselect_shape_same");
 
-    check = H5S__select_shape_same_test(small_cube_yz_slice_2_sid, small_square_sid);
-    VERIFY(check, TRUE, "H5S__select_shape_same_test");
+    check = H5Sselect_shape_same(small_cube_yz_slice_2_sid, small_square_sid);
+    VERIFY(check, TRUE, "H5Sselect_shape_same");
 
-    check = H5S__select_shape_same_test(small_cube_yz_slice_3_sid, small_square_sid);
-    VERIFY(check, FALSE, "H5S__select_shape_same_test");
+    check = H5Sselect_shape_same(small_cube_yz_slice_3_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5Sselect_shape_same");
 
-    check = H5S__select_shape_same_test(small_cube_yz_slice_4_sid, small_square_sid);
-    VERIFY(check, FALSE, "H5S__select_shape_same_test");
+    check = H5Sselect_shape_same(small_cube_yz_slice_4_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5Sselect_shape_same");
 
 
     /* Close dataspaces */
@@ -9382,8 +9378,8 @@ test_shape_same_dr__smoke_check_1(void)
 **
 **  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:
+**	Create a square, 2-D dataspace (10 X 10), and select
+**	a "checker board" hyperslab as follows:
 **
 **		* * - - * * - - * *
 **              * * - - * * - - * *
@@ -9399,25 +9395,25 @@ test_shape_same_dr__smoke_check_1(void)
 **	where asterisks indicate selected elements, and dashes
 **	indicate unselected elements.
 **
-**	Similarly, create nine, 3 D data spaces (10 X 10 X 10),
+**	Similarly, create nine, 3-D dataspaces (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
+**	H5Sselect_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 hyperslabs parallel to the xy
 **	or xz planes.
 **
-**	Also create an additional 3 D data spaces (10 X 10 X 10),
+**	Also create an additional 3-D dataspaces (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.
+**	H5Sselect_shape_same() should return FALSE when
+**	comparing this selection to the 2-D selection.
 **
 ****************************************************************/
 static void
@@ -9711,39 +9707,39 @@ test_shape_same_dr__smoke_check_2(void)
     /* 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 = H5Sselect_shape_same(small_cube_xy_slice_0_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5Sselect_shape_same");
 
-    check = H5S__select_shape_same_test(small_cube_xy_slice_1_sid, small_square_sid);
-    VERIFY(check, FALSE, "H5S__select_shape_same_test");
+    check = H5Sselect_shape_same(small_cube_xy_slice_1_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5Sselect_shape_same");
 
-    check = H5S__select_shape_same_test(small_cube_xy_slice_2_sid, small_square_sid);
-    VERIFY(check, FALSE, "H5S__select_shape_same_test");
+    check = H5Sselect_shape_same(small_cube_xy_slice_2_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5Sselect_shape_same");
 
 
     /* 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 = H5Sselect_shape_same(small_cube_xz_slice_0_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5Sselect_shape_same");
 
-    check = H5S__select_shape_same_test(small_cube_xz_slice_1_sid, small_square_sid);
-    VERIFY(check, FALSE, "H5S__select_shape_same_test");
+    check = H5Sselect_shape_same(small_cube_xz_slice_1_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5Sselect_shape_same");
 
-    check = H5S__select_shape_same_test(small_cube_xz_slice_2_sid, small_square_sid);
-    VERIFY(check, FALSE, "H5S__select_shape_same_test");
+    check = H5Sselect_shape_same(small_cube_xz_slice_2_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5Sselect_shape_same");
 
 
     /* 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 = H5Sselect_shape_same(small_cube_yz_slice_0_sid, small_square_sid);
+    VERIFY(check, TRUE, "H5Sselect_shape_same");
 
-    check = H5S__select_shape_same_test(small_cube_yz_slice_1_sid, small_square_sid);
-    VERIFY(check, TRUE, "H5S__select_shape_same_test");
+    check = H5Sselect_shape_same(small_cube_yz_slice_1_sid, small_square_sid);
+    VERIFY(check, TRUE, "H5Sselect_shape_same");
 
-    check = H5S__select_shape_same_test(small_cube_yz_slice_2_sid, small_square_sid);
-    VERIFY(check, TRUE, "H5S__select_shape_same_test");
+    check = H5Sselect_shape_same(small_cube_yz_slice_2_sid, small_square_sid);
+    VERIFY(check, TRUE, "H5Sselect_shape_same");
 
-    check = H5S__select_shape_same_test(small_cube_yz_slice_3_sid, small_square_sid);
-    VERIFY(check, FALSE, "H5S__select_shape_same_test");
+    check = H5Sselect_shape_same(small_cube_yz_slice_3_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5Sselect_shape_same");
 
 
     /* Close dataspaces */
@@ -9790,8 +9786,8 @@ test_shape_same_dr__smoke_check_2(void)
 **
 **  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:
+**	Create a square, 2-D dataspace (10 X 10), and select an
+**	irregular hyperslab as follows:
 **
 **		y
 **		9 - - - - - - - - - -
@@ -9809,19 +9805,19 @@ test_shape_same_dr__smoke_check_2(void)
 **	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
+**	Similarly, create nine, 3-D dataspaces (10 X 10 X 10),
+**	and select similar irregular hyperslabs 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
+**	H5Sselect_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
+**	to the yz plane in the 3-D space, and FALSE when
+**	comparing it against the irregular hyperslabs
 **	selections parallel to the xy or xz planes.
 **
 ****************************************************************/
@@ -10234,36 +10230,36 @@ test_shape_same_dr__smoke_check_3(void)
     /* 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 = H5Sselect_shape_same(small_cube_xy_slice_0_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5Sselect_shape_same");
 
-    check = H5S__select_shape_same_test(small_cube_xy_slice_1_sid, small_square_sid);
-    VERIFY(check, FALSE, "H5S__select_shape_same_test");
+    check = H5Sselect_shape_same(small_cube_xy_slice_1_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5Sselect_shape_same");
 
-    check = H5S__select_shape_same_test(small_cube_xy_slice_2_sid, small_square_sid);
-    VERIFY(check, FALSE, "H5S__select_shape_same_test");
+    check = H5Sselect_shape_same(small_cube_xy_slice_2_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5Sselect_shape_same");
 
 
     /* 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 = H5Sselect_shape_same(small_cube_xz_slice_0_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5Sselect_shape_same");
 
-    check = H5S__select_shape_same_test(small_cube_xz_slice_1_sid, small_square_sid);
-    VERIFY(check, FALSE, "H5S__select_shape_same_test");
+    check = H5Sselect_shape_same(small_cube_xz_slice_1_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5Sselect_shape_same");
 
-    check = H5S__select_shape_same_test(small_cube_xz_slice_2_sid, small_square_sid);
-    VERIFY(check, FALSE, "H5S__select_shape_same_test");
+    check = H5Sselect_shape_same(small_cube_xz_slice_2_sid, small_square_sid);
+    VERIFY(check, FALSE, "H5Sselect_shape_same");
 
 
     /* 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 = H5Sselect_shape_same(small_cube_yz_slice_0_sid, small_square_sid);
+    VERIFY(check, TRUE, "H5Sselect_shape_same");
 
-    check = H5S__select_shape_same_test(small_cube_yz_slice_1_sid, small_square_sid);
-    VERIFY(check, TRUE, "H5S__select_shape_same_test");
+    check = H5Sselect_shape_same(small_cube_yz_slice_1_sid, small_square_sid);
+    VERIFY(check, TRUE, "H5Sselect_shape_same");
 
-    check = H5S__select_shape_same_test(small_cube_yz_slice_2_sid, small_square_sid);
-    VERIFY(check, TRUE, "H5S__select_shape_same_test");
+    check = H5Sselect_shape_same(small_cube_yz_slice_2_sid, small_square_sid);
+    VERIFY(check, TRUE, "H5Sselect_shape_same");
 
 
     /* Close dataspaces */
@@ -10299,7 +10295,6 @@ test_shape_same_dr__smoke_check_3(void)
 
     ret = H5Sclose(small_cube_yz_slice_2_sid);
     CHECK(ret, FAIL, "H5Sclose");
-
 } /* test_shape_same_dr__smoke_check_3() */
 
 
@@ -10307,10 +10302,10 @@ test_shape_same_dr__smoke_check_3(void)
 **
 **  test_shape_same_dr__smoke_check_4():
 **
-**	Create a square, 2 D data space (10 X 10), and select
+**	Create a square, 2-D dataspace (10 X 10), and select
 **	the entire space.
 **
-**	Similarly, create 3 D and 4 D data spaces:
+**	Similarly, create 3-D and 4-D dataspaces:
 **
 **		(1 X 10 X 10)
 **		(10 X 1 X 10)
@@ -10327,8 +10322,8 @@ test_shape_same_dr__smoke_check_3(void)
 **
 **	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) &
+**	Compare the 2-D space against all the other spaces
+**	with H5Sselect_shape_same().  The (1 X 10 X 10) &
 **	(1 X 1 X 10 X 10) should return TRUE.  All others
 **	should return FALSE.
 **
@@ -10358,28 +10353,28 @@ test_shape_same_dr__smoke_check_4(void)
     square_sid = H5Screate_simple(2, dims, NULL);
     CHECK(square_sid, FAIL, "H5Screate_simple");
 
-    /* create (1 X 10 X 10) data space */
+    /* create (1 X 10 X 10) dataspace */
     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 */
+    /* create (10 X 1 X 10) dataspace */
     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 */
+    /* create (10 X 10 X 1) dataspace */
     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 */
+    /* create (10 X 10 X 10) dataspace */
     dims[0] = 10;
     dims[1] = 10;
     dims[2] = 10;
@@ -10387,7 +10382,7 @@ test_shape_same_dr__smoke_check_4(void)
     CHECK(three_d_space_3_sid, FAIL, "H5Screate_simple");
 
 
-    /* create (1 X 1 X 10 X 10) data space */
+    /* create (1 X 1 X 10 X 10) dataspace */
     dims[0] =  1;
     dims[1] =  1;
     dims[2] = 10;
@@ -10395,7 +10390,7 @@ test_shape_same_dr__smoke_check_4(void)
     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 */
+    /* create (1 X 10 X 1 X 10) dataspace */
     dims[0] =  1;
     dims[1] = 10;
     dims[2] =  1;
@@ -10403,7 +10398,7 @@ test_shape_same_dr__smoke_check_4(void)
     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 */
+    /* create (1 X 10 X 10 X 1) dataspace */
     dims[0] =  1;
     dims[1] = 10;
     dims[2] = 10;
@@ -10411,7 +10406,7 @@ test_shape_same_dr__smoke_check_4(void)
     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 */
+    /* create (10 X 1 X 1 X 10) dataspace */
     dims[0] = 10;
     dims[1] =  1;
     dims[2] =  1;
@@ -10419,7 +10414,7 @@ test_shape_same_dr__smoke_check_4(void)
     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 */
+    /* create (10 X 1 X 10 X 1) dataspace */
     dims[0] = 10;
     dims[1] =  1;
     dims[2] = 10;
@@ -10427,7 +10422,7 @@ test_shape_same_dr__smoke_check_4(void)
     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 */
+    /* create (10 X 10 X 1 X 1) dataspace */
     dims[0] = 10;
     dims[1] = 10;
     dims[2] =  1;
@@ -10435,7 +10430,7 @@ test_shape_same_dr__smoke_check_4(void)
     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 */
+    /* create (10 X 1 X 10 X 10) dataspace */
     dims[0] = 10;
     dims[1] =  1;
     dims[2] = 10;
@@ -10446,39 +10441,39 @@ test_shape_same_dr__smoke_check_4(void)
 
     /* 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 = H5Sselect_shape_same(three_d_space_0_sid, square_sid);
+    VERIFY(check, TRUE, "H5Sselect_shape_same");
 
-    check = H5S__select_shape_same_test(three_d_space_1_sid, square_sid);
-    VERIFY(check, FALSE, "H5S__select_shape_same_test");
+    check = H5Sselect_shape_same(three_d_space_1_sid, square_sid);
+    VERIFY(check, FALSE, "H5Sselect_shape_same");
 
-    check = H5S__select_shape_same_test(three_d_space_2_sid, square_sid);
-    VERIFY(check, FALSE, "H5S__select_shape_same_test");
+    check = H5Sselect_shape_same(three_d_space_2_sid, square_sid);
+    VERIFY(check, FALSE, "H5Sselect_shape_same");
 
-    check = H5S__select_shape_same_test(three_d_space_3_sid, square_sid);
-    VERIFY(check, FALSE, "H5S__select_shape_same_test");
+    check = H5Sselect_shape_same(three_d_space_3_sid, square_sid);
+    VERIFY(check, FALSE, "H5Sselect_shape_same");
 
 
-    check = H5S__select_shape_same_test(four_d_space_0_sid, square_sid);
-    VERIFY(check, TRUE, "H5S__select_shape_same_test");
+    check = H5Sselect_shape_same(four_d_space_0_sid, square_sid);
+    VERIFY(check, TRUE, "H5Sselect_shape_same");
 
-    check = H5S__select_shape_same_test(four_d_space_1_sid, square_sid);
-    VERIFY(check, FALSE, "H5S__select_shape_same_test");
+    check = H5Sselect_shape_same(four_d_space_1_sid, square_sid);
+    VERIFY(check, FALSE, "H5Sselect_shape_same");
 
-    check = H5S__select_shape_same_test(four_d_space_2_sid, square_sid);
-    VERIFY(check, FALSE, "H5S__select_shape_same_test");
+    check = H5Sselect_shape_same(four_d_space_2_sid, square_sid);
+    VERIFY(check, FALSE, "H5Sselect_shape_same");
 
-    check = H5S__select_shape_same_test(four_d_space_3_sid, square_sid);
-    VERIFY(check, FALSE, "H5S__select_shape_same_test");
+    check = H5Sselect_shape_same(four_d_space_3_sid, square_sid);
+    VERIFY(check, FALSE, "H5Sselect_shape_same");
 
-    check = H5S__select_shape_same_test(four_d_space_4_sid, square_sid);
-    VERIFY(check, FALSE, "H5S__select_shape_same_test");
+    check = H5Sselect_shape_same(four_d_space_4_sid, square_sid);
+    VERIFY(check, FALSE, "H5Sselect_shape_same");
 
-    check = H5S__select_shape_same_test(four_d_space_5_sid, square_sid);
-    VERIFY(check, FALSE, "H5S__select_shape_same_test");
+    check = H5Sselect_shape_same(four_d_space_5_sid, square_sid);
+    VERIFY(check, FALSE, "H5Sselect_shape_same");
 
-    check = H5S__select_shape_same_test(four_d_space_6_sid, square_sid);
-    VERIFY(check, FALSE, "H5S__select_shape_same_test");
+    check = H5Sselect_shape_same(four_d_space_6_sid, square_sid);
+    VERIFY(check, FALSE, "H5Sselect_shape_same");
 
 
     /* Close dataspaces */
@@ -10519,17 +10514,16 @@ test_shape_same_dr__smoke_check_4(void)
 
     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().
+**	of a full n-cube dataspace vs an n-dimensional slice of
+**	of an m-cube (m > n) in a call to H5Sselect_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
+**	H5Sselect_shape_same() should always return FALSE if
 **	they don't).
 **
 **	Per Quincey's suggestion, only test up to 5 dimensional
@@ -10634,15 +10628,15 @@ test_shape_same_dr__full_space_vs_slice(int test_num,
     block_ptr  = &(block[i]);
 
 
-    /* select the hyper slab */
+    /* select the hyperslab */
     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");
+    check = H5Sselect_shape_same(n_cube_0_sid, n_cube_1_sid);
+    VERIFY(check, expected_result, "H5Sselect_shape_same");
 
 
     /* Close dataspaces */
@@ -10651,7 +10645,6 @@ test_shape_same_dr__full_space_vs_slice(int test_num,
 
     ret = H5Sclose(n_cube_1_sid);
     CHECK(ret, FAIL, "H5Sclose");
-
 }   /* test_shape_same_dr__full_space_vs_slice() */
 
 
@@ -10659,10 +10652,10 @@ test_shape_same_dr__full_space_vs_slice(int test_num,
 **
 **  test_shape_same_dr__run_full_space_vs_slice_tests():
 **
-**	Run the est_shape_same_dr__full_space_vs_slice() test
+**	Run the test_shape_same_dr__full_space_vs_slice() test
 **	over a variety of ranks and offsets.
 **
-**	At present, we test H5S_select_shape_same() with
+**	At present, we test H5Sselect_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).
@@ -10670,7 +10663,7 @@ test_shape_same_dr__full_space_vs_slice(int test_num,
 **	sufficient.
 **
 **	All the n-cubes will have lengths of the same size, so
-**	H5S_select_shape_same() should return true iff:
+**	H5Sselect_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
@@ -10800,20 +10793,19 @@ test_shape_same_dr__run_full_space_vs_slice_tests(void)
             } 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
+**	"checker board" subset of a full n-cube dataspace vs
 ** 	a "checker board" n-dimensional slice of an m-cube (m > n).
-**	in a call to H5S_select_shape_same().
+**	in a call to H5Sselect_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
+**	H5Sselect_shape_same() should always return FALSE if
 **	they don't).
 **
 **	Per Quincey's suggestion, only test up to 5 dimensional
@@ -11016,8 +11008,8 @@ test_shape_same_dr__checkerboard(int test_num,
     /* 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
+     * boundaries of the target dataspace -- hence the following
+     * code to manually clip the selection back to the dataspace
      * proper.
      */
     for(i = 0; i < SS_DR_MAX_RANK; i++) {
@@ -11078,7 +11070,7 @@ test_shape_same_dr__checkerboard(int test_num,
     count_ptr  = &(count[i]);
     block_ptr  = &(block[i]);
 
-    /* select the hyper slab */
+    /* select the hyperslab */
     ret = H5Sselect_hyperslab(n_cube_1_sid, H5S_SELECT_SET,
                               start_ptr, stride_ptr, count_ptr, block_ptr);
     CHECK(ret, FAIL, "H5Sselect_hyperslab");
@@ -11117,8 +11109,8 @@ test_shape_same_dr__checkerboard(int test_num,
     /* 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
+     * boundaries of the target dataspace -- hence the following
+     * code to manually clip the selection back to the dataspace
      * proper.
      */
     for(i = 0; i < SS_DR_MAX_RANK; i++) {
@@ -11133,8 +11125,8 @@ test_shape_same_dr__checkerboard(int test_num,
     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");
+    check = H5Sselect_shape_same(n_cube_0_sid, n_cube_1_sid);
+    VERIFY(check, expected_result, "H5Sselect_shape_same");
 
 
     /* Close dataspaces */
@@ -11143,7 +11135,6 @@ test_shape_same_dr__checkerboard(int test_num,
 
     ret = H5Sclose(n_cube_1_sid);
     CHECK(ret, FAIL, "H5Sclose");
-
 }   /* test_shape_same_dr__checkerboard() */
 
 
@@ -11151,14 +11142,14 @@ test_shape_same_dr__checkerboard(int test_num,
 **
 **  test_shape_same_dr__run_checkerboard_tests():
 **
-**	In this set of tests, we test H5S_select_shape_same()
+**	In this set of tests, we test H5Sselect_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:
+**      H5Sselect_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
@@ -11414,7 +11405,6 @@ test_shape_same_dr__run_checkerboard_tests(void)
             } while((v < 2) && (large_rank >= 5));
         } /* end for */
     } /* end for */
-
 } /* test_shape_same_dr__run_checkerboard_tests() */
 
 
@@ -11423,13 +11413,13 @@ test_shape_same_dr__run_checkerboard_tests(void)
 **  test_shape_same_dr__irregular():
 **
 **	Tests selection of an "irregular" subset of a full
-**      n-cube data space vs an identical "irregular" subset
+**      n-cube dataspace vs an identical "irregular" subset
 **	of an n-dimensional slice of an m-cube (m > n).
-**	in a call to H5S_select_shape_same().
+**	in a call to H5Sselect_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
+**	H5Sselect_shape_same() should always return FALSE if
 **	they don't).
 **
 ****************************************************************/
@@ -11588,7 +11578,7 @@ test_shape_same_dr__irregular(int test_num,
      * 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.
+     * within the n-cube or hyperslab.
      */
 
     /* first, ensure that the small n-cube has no selection */
@@ -11664,13 +11654,13 @@ test_shape_same_dr__irregular(int test_num,
             } /* end else */
         } /* end for */
 
-        /* select the hyper slab */
+        /* select the hyperslab */
         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.
+    /* it is possible that the selection extends beyond the dataspace.
      * clip the selection to ensure that it doesn't.
      */
     ret = H5Sselect_hyperslab(n_cube_1_sid, H5S_SELECT_AND,
@@ -11679,8 +11669,8 @@ test_shape_same_dr__irregular(int test_num,
 
 
     /* 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");
+    check = H5Sselect_shape_same(n_cube_0_sid, n_cube_1_sid);
+    VERIFY(check, expected_result, "H5Sselect_shape_same");
 
 
     /* Close dataspaces */
@@ -11689,7 +11679,6 @@ test_shape_same_dr__irregular(int test_num,
 
     ret = H5Sclose(n_cube_1_sid);
     CHECK(ret, FAIL, "H5Sclose");
-
 }   /* test_shape_same_dr__irregular() */
 
 
@@ -11697,7 +11686,7 @@ test_shape_same_dr__irregular(int test_num,
 **
 **  test_shape_same_dr__run_irregular_tests():
 **
-**	In this set of tests, we test H5S_select_shape_same()
+**	In this set of tests, we test H5Sselect_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
@@ -11706,7 +11695,7 @@ test_shape_same_dr__irregular(int test_num,
 **	the n-cube and the slice.
 **
 **      All the irregular selections will be identical (modulo rank)
-**      so H5S_select_shape_same() should return true iff:
+**      so H5Sselect_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
@@ -11904,7 +11893,6 @@ test_shape_same_dr__run_irregular_tests(void)
             } while((v < 2 ) && (large_rank >= 5));
         } /* end for */
     } /* end for */
-
 } /* test_shape_same_dr__run_irregular_tests() */
 
 
@@ -11921,19 +11909,16 @@ 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() */
 
 
@@ -12042,8 +12027,8 @@ test_space_rebuild(void)
     } /* end if */
     if(ret != FAIL) {
        /* In this case, rebuild_check should be TRUE. */
-       rebuild_check = H5S__select_shape_same_test(sid_reg1,sid_reg_ori1);
-       CHECK(rebuild_check,FALSE,"H5S_hyper_rebuild");
+       rebuild_check = H5Sselect_shape_same(sid_reg1, sid_reg_ori1);
+       CHECK(rebuild_check, FALSE, "H5Sselect_shape_same");
     } /* end if */
 
     /* For irregular hyperslab */
@@ -12130,8 +12115,8 @@ test_space_rebuild(void)
     } /* end if */
     if(ret != FAIL) {
        /* In this case, rebuild_check should be TRUE. */
-       rebuild_check = H5S__select_shape_same_test(sid_reg2,sid_reg_ori2);
-       CHECK(rebuild_check,FALSE,"H5S_hyper_rebuild");
+       rebuild_check = H5Sselect_shape_same(sid_reg2, sid_reg_ori2);
+       CHECK(rebuild_check, FALSE, "H5Sselect_shape_same");
     } /* end if */
 
     /* 2-D irregular case */
@@ -12228,8 +12213,8 @@ test_space_rebuild(void)
     } /* end if */
     if(ret != FAIL) {
        /* In this case, rebuild_check should be TRUE. */
-       rebuild_check = H5S__select_shape_same_test(sid_reg3,sid_reg_ori3);
-       CHECK(rebuild_check,FALSE,"H5S_hyper_rebuild");
+       rebuild_check = H5Sselect_shape_same(sid_reg3, sid_reg_ori3);
+       CHECK(rebuild_check, FALSE, "H5Sselect_shape_same");
     } /* end if */
 
     sid_irreg3     = H5Screate_simple(SPACERE3_RANK,dims3,NULL);
@@ -12339,8 +12324,8 @@ test_space_rebuild(void)
     } /* end if */
     if(ret != FAIL) {
        /* In this case, rebuild_check should be TRUE. */
-       rebuild_check = H5S__select_shape_same_test(sid_reg4,sid_reg_ori4);
-       CHECK(rebuild_check,FALSE,"H5S_hyper_rebuild");
+       rebuild_check = H5Sselect_shape_same(sid_reg4, sid_reg_ori4);
+       CHECK(rebuild_check, FALSE, "H5Sselect_shape_same");
     } /* end if */
 
     /* Testing irregular selection */
@@ -12465,8 +12450,8 @@ test_space_rebuild(void)
     } /* end if */
     if(ret != FAIL) {
        /* In this case, rebuild_check should be TRUE. */
-       rebuild_check = H5S__select_shape_same_test(sid_reg5,sid_reg_ori5);
-       CHECK(rebuild_check,FALSE,"H5S_hyper_rebuild");
+       rebuild_check = H5Sselect_shape_same(sid_reg5, sid_reg_ori5);
+       CHECK(rebuild_check, FALSE, "H5Sselect_shape_same");
     } /* end if */
 
     sid_irreg5     = H5Screate_simple(SPACERE5_RANK,dims5,NULL);
@@ -15189,6 +15174,148 @@ test_sel_iter(void)
     CHECK(ret, FAIL, "H5Sclose");
 }   /* test_sel_iter() */
 
+/****************************************************************
+**
+**  test_select_intersect_block(): Test selections on dataspace,
+**	verify that "intersect block" routine is working correctly.
+**
+****************************************************************/
+static void
+test_select_intersect_block(void)
+{
+    hid_t       sid;            /* Dataspace ID */
+    hsize_t	dims1[] = {6, 12};  /* 2-D Dataspace dimensions */
+    hsize_t     block_start[] = {1, 3};   /* Start offset for block */
+    hsize_t     block_end[] = {2, 5}; /* End offset for block */
+    hsize_t     block_end2[] = {0, 5}; /* Bad end offset for block */
+    hsize_t     block_end3[] = {2, 2}; /* Another bad end offset for block */
+    hsize_t     block_end4[] = {1, 3}; /* End offset that makes a single element block */
+    hsize_t	coord[10][2];   /* Coordinates for point selection */
+    hsize_t	start[2];       /* Starting location of hyperslab */
+    hsize_t	stride[2];      /* Stride of hyperslab */
+    hsize_t	count[2];       /* Element count of hyperslab */
+    hsize_t	block[2];       /* Block size of hyperslab */
+    htri_t      status;         /* Intersection status */
+    herr_t	ret;		/* Generic return value	*/
+
+    /* Output message about test being performed */
+    MESSAGE(6, ("Testing Dataspace Selection Block Intersection\n"));
+
+    /* Create dataspace */
+    sid = H5Screate_simple(2, dims1, NULL);
+    CHECK(sid, FAIL, "H5Screate_simple");
+
+
+    /* Try intersection calls with bad parameters */
+    H5E_BEGIN_TRY {     /* Bad dataspace ID */
+        status = H5Sselect_intersect_block(H5I_INVALID_HID, block_start, block_end);
+    } H5E_END_TRY;
+    VERIFY(status, FAIL, "H5Sselect_intersect_block");
+    H5E_BEGIN_TRY {     /* Bad start pointer */
+        status = H5Sselect_intersect_block(sid, NULL, block_end);
+    } H5E_END_TRY;
+    VERIFY(status, FAIL, "H5Sselect_intersect_block");
+    H5E_BEGIN_TRY {     /* Bad end pointer */
+        status = H5Sselect_intersect_block(sid, block_start, NULL);
+    } H5E_END_TRY;
+    VERIFY(status, FAIL, "H5Sselect_intersect_block");
+    H5E_BEGIN_TRY {     /* Invalid block */
+        status = H5Sselect_intersect_block(sid, block_start, block_end2);
+    } H5E_END_TRY;
+    VERIFY(status, FAIL, "H5Sselect_intersect_block");
+    H5E_BEGIN_TRY {     /* Another invalid block */
+        status = H5Sselect_intersect_block(sid, block_start, block_end3);
+    } H5E_END_TRY;
+    VERIFY(status, FAIL, "H5Sselect_intersect_block");
+
+
+    /* Set selection to 'none' */
+    ret = H5Sselect_none(sid);
+    CHECK(ret, FAIL, "H5Sselect_none");
+
+    /* Test block intersection with 'none' selection (always false) */
+    status = H5Sselect_intersect_block(sid, block_start, block_end);
+    VERIFY(status, FALSE, "H5Sselect_intersect_block");
+
+
+    /* Set selection to 'all' */
+    ret = H5Sselect_all(sid);
+    CHECK(ret, FAIL, "H5Sselect_all");
+
+    /* Test block intersection with 'all' selection (always true) */
+    status = H5Sselect_intersect_block(sid, block_start, block_end);
+    VERIFY(status, TRUE, "H5Sselect_intersect_block");
+
+
+    /* Select sequence of ten points */
+    coord[0][0] = 0; coord[0][1] = 10;
+    coord[1][0] = 1; coord[1][1] = 2;
+    coord[2][0] = 2; coord[2][1] = 4;
+    coord[3][0] = 0; coord[3][1] = 6;
+    coord[4][0] = 1; coord[4][1] = 8;
+    coord[5][0] = 2; coord[5][1] = 11;
+    coord[6][0] = 0; coord[6][1] = 4;
+    coord[7][0] = 1; coord[7][1] = 0;
+    coord[8][0] = 2; coord[8][1] = 1;
+    coord[9][0] = 0; coord[9][1] = 3;
+    ret = H5Sselect_elements(sid, H5S_SELECT_SET, (size_t)10, (const hsize_t *)coord);
+    CHECK(ret, FAIL, "H5Sselect_elements");
+
+    /* Test block intersection with 'point' selection */
+    status = H5Sselect_intersect_block(sid, block_start, block_end);
+    VERIFY(status, TRUE, "H5Sselect_intersect_block");
+    status = H5Sselect_intersect_block(sid, block_start, block_end4);
+    VERIFY(status, FALSE, "H5Sselect_intersect_block");
+
+
+    /* Select single 4x6 hyperslab block at (2,1) */
+    start[0] = 2; start[1] = 1;
+    stride[0] = 1; stride[1] = 1;
+    count[0] = 4; count[1] = 6;
+    block[0] = 1; block[1] = 1;
+    ret = H5Sselect_hyperslab(sid, H5S_SELECT_SET, start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    /* Test block intersection with single 'hyperslab' selection */
+    status = H5Sselect_intersect_block(sid, block_start, block_end);
+    VERIFY(status, TRUE, "H5Sselect_intersect_block");
+    status = H5Sselect_intersect_block(sid, block_start, block_end4);
+    VERIFY(status, FALSE, "H5Sselect_intersect_block");
+
+    /* 'OR' another hyperslab block in, making an irregular hyperslab selection */
+    start[0] = 3; start[1] = 2;
+    stride[0] = 1; stride[1] = 1;
+    count[0] = 4; count[1] = 6;
+    block[0] = 1; block[1] = 1;
+    ret = H5Sselect_hyperslab(sid, H5S_SELECT_OR, start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    /* Test block intersection with 'hyperslab' selection */
+    status = H5Sselect_intersect_block(sid, block_start, block_end);
+    VERIFY(status, TRUE, "H5Sselect_intersect_block");
+    status = H5Sselect_intersect_block(sid, block_start, block_end4);
+    VERIFY(status, FALSE, "H5Sselect_intersect_block");
+
+    /* Select regular, strided hyperslab selection */
+    start[0] = 2; start[1] = 1;
+    stride[0] = 2; stride[1] = 2;
+    count[0] = 2; count[1] = 4;
+    block[0] = 1; block[1] = 1;
+    ret = H5Sselect_hyperslab(sid, H5S_SELECT_SET, start, stride, count, block);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    /* Test block intersection with single 'hyperslab' selection */
+    status = H5Sselect_intersect_block(sid, block_start, block_end);
+    VERIFY(status, TRUE, "H5Sselect_intersect_block");
+    status = H5Sselect_intersect_block(sid, block_start, block_end4);
+    VERIFY(status, FALSE, "H5Sselect_intersect_block");
+
+
+    /* Close dataspace */
+    ret = H5Sclose(sid);
+    CHECK(ret, FAIL, "H5Sclose");
+}   /* test_select_intersect_block() */
+
 
 /****************************************************************
 **
@@ -15369,6 +15496,9 @@ test_select(void)
 
     /* Test selection iterators */
     test_sel_iter();
+
+    /* Test selection intersection with block  */
+    test_select_intersect_block();
 }   /* test_select() */
 
 
@@ -15382,8 +15512,6 @@ test_select(void)
  * Programmer:	Albert Cheng
  *              July 2, 1998
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void
diff --git a/testpar/t_shapesame.c b/testpar/t_shapesame.c
index f5282bd..b65e219 100644
--- a/testpar/t_shapesame.c
+++ b/testpar/t_shapesame.c
@@ -110,10 +110,6 @@ struct hs_dr_pio_test_vars_t
  *
  * Programmer:    JRM -- 8/9/11
  *
- * Modifications:
- *
- *        None.
- *
  *-------------------------------------------------------------------------
  */
 
@@ -573,7 +569,7 @@ hs_dr_pio_test__setup(const int test_num,
                               tv_ptr->block);
     VRFY((ret >= 0), "H5Sselect_hyperslab(file_large_ds_sid_0, set) suceeded");
 
-    /* In passing, setup the process slice data spaces as well */
+    /* In passing, setup the process slice dataspaces as well */
 
     ret = H5Sselect_hyperslab(tv_ptr->mem_large_ds_process_slice_sid,
                               H5S_SELECT_SET,
@@ -685,10 +681,6 @@ hs_dr_pio_test__setup(const int test_num,
  *
  * Programmer:    JRM -- 9/18/09
  *
- * Modifications:
- *
- *        None.
- *
  *-------------------------------------------------------------------------
  */
 
@@ -791,22 +783,18 @@ hs_dr_pio_test__takedown( struct hs_dr_pio_test_vars_t * tv_ptr)
  *        selections of different rank in the parallel.
  *
  *        Verify that we can read from disk correctly using
- *        selections of different rank that H5S_select_shape_same()
+ *        selections of different rank that H5Sselect_shape_same()
  *        views as being of the same shape.
  *
  *              In this function, we test this by reading small_rank - 1
  *        slices from the on disk large cube, and verifying that the
- *        data read is correct.  Verify that H5S_select_shape_same()
+ *        data read is correct.  Verify that H5Sselect_shape_same()
  *        returns true on the memory and file selections.
  *
  * Return:    void
  *
  * Programmer:    JRM -- 9/10/11
  *
- * Modifications:
- *
- *        None.
- *
  *-------------------------------------------------------------------------
  */
 
@@ -831,7 +819,7 @@ contig_hs_dr_pio_test__d2m_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
     mpi_rank = tv_ptr->mpi_rank;
 
 
-    /* We have already done a H5Sselect_all() on the data space
+    /* We have already done a H5Sselect_all() on the dataspace
      * small_ds_slice_sid in the initialization phase, so no need to
      * call H5Sselect_all() again.
      */
@@ -945,12 +933,11 @@ contig_hs_dr_pio_test__d2m_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
                          "H5Sselect_hyperslab(file_large_cube_sid) succeeded");
 
 
-                    /* verify that H5S_select_shape_same() reports the two
+                    /* verify that H5Sselect_shape_same() reports the two
                      * selections as having the same shape.
                      */
-                    check = H5S__select_shape_same_test(tv_ptr->small_ds_slice_sid,
-                                                       tv_ptr->file_large_ds_sid_0);
-                    VRFY((check == TRUE), "H5S__select_shape_same_test passed");
+                    check = H5Sselect_shape_same(tv_ptr->small_ds_slice_sid, tv_ptr->file_large_ds_sid_0);
+                    VRFY((check == TRUE), "H5Sselect_shape_same passed");
 
 
                     /* Read selection from disk */
@@ -1032,7 +1019,7 @@ contig_hs_dr_pio_test__d2m_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
  *        selections of different rank in the parallel.
  *
  *        Verify that we can read from disk correctly using
- *        selections of different rank that H5S_select_shape_same()
+ *        selections of different rank that H5Sselect_shape_same()
  *        views as being of the same shape.
  *
  *        In this function, we test this by reading slices of the
@@ -1044,10 +1031,6 @@ contig_hs_dr_pio_test__d2m_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
  *
  * Programmer:    JRM -- 8/10/11
  *
- * Modifications:
- *
- *        None.
- *
  *-------------------------------------------------------------------------
  */
 
@@ -1213,12 +1196,11 @@ contig_hs_dr_pio_test__d2m_s2l(struct hs_dr_pio_test_vars_t * tv_ptr)
                          "H5Sselect_hyperslab(mem_large_ds_sid) succeeded");
 
 
-                    /* verify that H5S_select_shape_same() reports the two
+                    /* verify that H5Sselect_shape_same() reports the two
                      * selections as having the same shape.
                      */
-                    check = H5S__select_shape_same_test(tv_ptr->file_small_ds_sid_0,
-                                                       tv_ptr->mem_large_ds_sid);
-                    VRFY((check == TRUE), "H5S__select_shape_same_test passed");
+                    check = H5Sselect_shape_same(tv_ptr->file_small_ds_sid_0, tv_ptr->mem_large_ds_sid);
+                    VRFY((check == TRUE), "H5Sselect_shape_same passed");
 
 
                     /* Read selection from disk */
@@ -1315,24 +1297,20 @@ contig_hs_dr_pio_test__d2m_s2l(struct hs_dr_pio_test_vars_t * tv_ptr)
  *        selections of different rank in the parallel.
  *
  *        Verify that we can write from memory to file using
- *        selections of different rank that H5S_select_shape_same()
+ *        selections of different rank that H5Sselect_shape_same()
  *        views as being of the same shape.
  *
  *        Do this by writing small_rank - 1 dimensional slices from
  *        the in memory large data set to the on disk small cube
  *        dataset.  After each write, read the slice of the small
  *        dataset back from disk, and verify that it contains
- *              the expected data. Verify that H5S_select_shape_same()
+ *        the expected data. Verify that H5Sselect_shape_same()
  *        returns true on the memory and file selections.
  *
  * Return:    void
  *
  * Programmer:    JRM -- 8/10/11
  *
- * Modifications:
- *
- *        None.
- *
  *-------------------------------------------------------------------------
  */
 
@@ -1361,12 +1339,12 @@ contig_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
 
     /* 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.
+     * H5Sselect_shape_same() views as being of the same shape.
      *
      * Start by writing small_rank - 1 dimensional slices from the in memory large
      * data set to the on disk small cube dataset.  After each write, read the
      * slice of the small dataset back from disk, and verify that it contains
-     * the expected data. Verify that H5S_select_shape_same() returns true on
+     * the expected data. Verify that H5Sselect_shape_same() returns true on
      * the memory and file selections.
      */
 
@@ -1527,13 +1505,12 @@ contig_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
                          "H5Sselect_hyperslab() mem_large_ds_sid succeeded.");
 
 
-                    /* verify that H5S_select_shape_same() reports the in
+                    /* verify that H5Sselect_shape_same() reports the in
                      * memory slice through the cube selection and the
                      * on disk full square selections as having the same shape.
                      */
-                    check = H5S__select_shape_same_test(tv_ptr->file_small_ds_sid_0,
-                                                       tv_ptr->mem_large_ds_sid);
-                    VRFY((check == TRUE), "H5S__select_shape_same_test passed.");
+                    check = H5Sselect_shape_same(tv_ptr->file_small_ds_sid_0, tv_ptr->mem_large_ds_sid);
+                    VRFY((check == TRUE), "H5Sselect_shape_same passed.");
 
 
                     /* write the slice from the in memory large data set to the
@@ -1643,7 +1620,7 @@ contig_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
  *        selections of different rank in the parallel.
  *
  *        Verify that we can write from memory to file using
- *        selections of different rank that H5S_select_shape_same()
+ *        selections of different rank that H5Sselect_shape_same()
  *        views as being of the same shape.
  *
  *        Do this by writing the contents of the process's slice of
@@ -1652,17 +1629,13 @@ contig_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
  *        slice of the large data set back into memory, and verify
  *        that it contains the expected data.
  *
- *        Verify that H5S_select_shape_same() returns true on the
+ *        Verify that H5Sselect_shape_same() returns true on the
  *        memory and file selections.
  *
  * Return:    void
  *
  * Programmer:    JRM -- 8/10/11
  *
- * Modifications:
- *
- *        None
- *
  *-------------------------------------------------------------------------
  */
 
@@ -1692,7 +1665,7 @@ contig_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t * tv_ptr)
      * small data set to slices of the on disk large data set.  After
      * each write, read the process's slice of the large data set back
      * into memory, and verify that it contains the expected data.
-     * Verify that H5S_select_shape_same() returns true on the memory
+     * Verify that H5Sselect_shape_same() returns true on the memory
      * and file selections.
      */
 
@@ -1859,14 +1832,13 @@ contig_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t * tv_ptr)
                          "H5Sselect_hyperslab() target large ds slice succeeded");
 
 
-                    /* verify that H5S_select_shape_same() reports the in
+                    /* verify that H5Sselect_shape_same() reports the in
                      * memory small data set slice selection and the
                      * on disk slice through the large data set selection
                      * as having the same shape.
                      */
-                    check = H5S__select_shape_same_test(tv_ptr->mem_small_ds_sid,
-                                                       tv_ptr->file_large_ds_sid_0);
-                    VRFY((check == TRUE), "H5S__select_shape_same_test passed");
+                    check = H5Sselect_shape_same(tv_ptr->mem_small_ds_sid, tv_ptr->file_large_ds_sid_0);
+                    VRFY((check == TRUE), "H5Sselect_shape_same passed");
 
 
                     /* write the small data set slice from memory to the
@@ -1986,21 +1958,6 @@ contig_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t * tv_ptr)
  *
  * Programmer:    JRM -- 9/18/09
  *
- * Modifications:
- *
- *        JRM -- 9/16/10
- *        Added express_test parameter.  Use it to control whether
- *        we set up the chunks so that no chunk is shared between
- *        processes, and also whether we set an alignment when we
- *        create the test file.
- *
- *        JRM -- 8/11/11
- *        Refactored function heavily & broke it into six functions.
- *        Added the skips_ptr, max_skips, total_tests_ptr,
- *        tests_run_ptr, and tests_skiped_ptr parameters to support
- *        skipping portions of the test according to the express
- *        test value.
- *
  *-------------------------------------------------------------------------
  */
 
@@ -2108,12 +2065,12 @@ contig_hs_dr_pio_test__run_test(const int test_num,
 #endif /* CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG */
 
     /* first, verify that we can read from disk correctly using selections
-     * of different rank that H5S_select_shape_same() views as being of the
+     * of different rank that H5Sselect_shape_same() views as being of the
      * same shape.
      *
      * Start by reading small_rank - 1 dimensional slice from the on disk
      * large cube, and verifying that the data read is correct.  Verify that
-     * H5S_select_shape_same() returns true on the memory and file selections.
+     * H5Sselect_shape_same() returns true on the memory and file selections.
      */
 
 #if CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG
@@ -2139,12 +2096,12 @@ contig_hs_dr_pio_test__run_test(const int test_num,
 
     /* 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.
+     * H5Sselect_shape_same() views as being of the same shape.
      *
      * Start by writing small_rank - 1 D slices from the in memory large data
      * set to the on disk small cube dataset.  After each write, read the
      * slice of the small dataset back from disk, and verify that it contains
-     * the expected data. Verify that H5S_select_shape_same() returns true on
+     * the expected data. Verify that H5Sselect_shape_same() returns true on
      * the memory and file selections.
      */
 
@@ -2160,7 +2117,7 @@ contig_hs_dr_pio_test__run_test(const int test_num,
      * small data set to slices of the on disk large data set.  After
      * each write, read the process's slice of the large data set back
      * into memory, and verify that it contains the expected data.
-     * Verify that H5S_select_shape_same() returns true on the memory
+     * Verify that H5Sselect_shape_same() returns true on the memory
      * and file selections.
      */
 
@@ -2208,20 +2165,6 @@ contig_hs_dr_pio_test__run_test(const int test_num,
  *
  * Programmer:    JRM -- 9/18/09
  *
- * Modifications:
- *
- *          Modified function to take a sample of the run times
- *        of the different tests, and skip some of them if
- *        run times are too long.
- *
- *        We need to do this because Lustre runns very slowly
- *        if two or more processes are banging on the same
- *        block of memory.
- *                        JRM -- 9/10/10
- *              Break this one big test into 4 smaller tests according
- *              to {independent,collective}x{contigous,chunked} datasets.
- *        AKC -- 2010/01/14
- *
  *-------------------------------------------------------------------------
  */
 
@@ -2395,18 +2338,18 @@ contig_hs_dr_pio_test(ShapeSameTestMethods sstest_type)
 /****************************************************************
 **
 **  ckrbrd_hs_dr_pio_test__slct_ckrbrd():
-**    Given a data space of tgt_rank, and dimensions:
+**    Given a dataspace of tgt_rank, and dimensions:
 **
 **        (mpi_size + 1), edge_size, ... , edge_size
 **
 **    edge_size, and a checker_edge_size, select a checker
 **    board selection of a sel_rank (sel_rank < tgt_rank)
-**    dimensional slice through the data space parallel to the
+**    dimensional slice through the dataspace parallel to the
 **      sel_rank fastest changing indicies, with origin (in the
 **    higher indicies) as indicated by the start array.
 **
 **    Note that this function, like all its relatives, is
-**    hard coded to presume a maximum data space rank of 5.
+**    hard coded to presume a maximum dataspace 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.
@@ -2707,7 +2650,7 @@ ckrbrd_hs_dr_pio_test__slct_ckrbrd(const int mpi_rank,
               fcnName, mpi_rank, (int)H5Sget_select_npoints(tgt_sid));
 #endif /* CKRBRD_HS_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG */
 
-    /* Clip the selection back to the data space proper. */
+    /* Clip the selection back to the dataspace proper. */
 
     for ( i = 0; i < test_max_rank; i++ ) {
 
@@ -2956,22 +2899,18 @@ ckrbrd_hs_dr_pio_test__verify_data(uint32_t * buf_ptr,
  *
  *        Verify that we can read from disk correctly using checker
  *        board selections of different rank that
- *              H5S_select_shape_same() views as being of the same shape.
+ *        H5Sselect_shape_same() views as being of the same shape.
  *
- *              In this function, we test this by reading small_rank - 1
+ *        In this function, we test this by reading small_rank - 1
  *        checker board slices from the on disk large cube, and
  *        verifying that the data read is correct.  Verify that
- *        H5S_select_shape_same() returns true on the memory and
+ *        H5Sselect_shape_same() returns true on the memory and
  *        file selections.
  *
  * Return:    void
  *
  * Programmer:    JRM -- 9/15/11
  *
- * Modifications:
- *
- *        None.
- *
  *-------------------------------------------------------------------------
  */
 
@@ -2997,12 +2936,12 @@ ckrbrd_hs_dr_pio_test__d2m_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
 
 
     /* first, verify that we can read from disk correctly using selections
-     * of different rank that H5S_select_shape_same() views as being of the
+     * of different rank that H5Sselect_shape_same() views as being of the
      * same shape.
      *
      * Start by reading a (small_rank - 1)-D checker board slice from this
      * processes slice of the on disk large data set, and verifying that the
-     * data read is correct.  Verify that H5S_select_shape_same() returns
+     * data read is correct.  Verify that H5Sselect_shape_same() returns
      * true on the memory and file selections.
      *
      * The first step is to set up the needed checker board selection in the
@@ -3146,12 +3085,11 @@ ckrbrd_hs_dr_pio_test__d2m_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
                       tv_ptr->start
                     );
 
-                    /* verify that H5S_select_shape_same() reports the two
+                    /* verify that H5Sselect_shape_same() reports the two
                      * selections as having the same shape.
                      */
-                    check = H5S__select_shape_same_test(tv_ptr->small_ds_slice_sid,
-                                                       tv_ptr->file_large_ds_sid_0);
-                    VRFY((check == TRUE), "H5S__select_shape_same_test passed");
+                    check = H5Sselect_shape_same(tv_ptr->small_ds_slice_sid, tv_ptr->file_large_ds_sid_0);
+                    VRFY((check == TRUE), "H5Sselect_shape_same passed");
 
 
                     /* Read selection from disk */
@@ -3231,7 +3169,7 @@ ckrbrd_hs_dr_pio_test__d2m_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
  *        selections of different rank in the parallel.
  *
  *        Verify that we can read from disk correctly using
- *        selections of different rank that H5S_select_shape_same()
+ *        selections of different rank that H5Sselect_shape_same()
  *        views as being of the same shape.
  *
  *        In this function, we test this by reading checker board
@@ -3243,10 +3181,6 @@ ckrbrd_hs_dr_pio_test__d2m_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
  *
  * Programmer:    JRM -- 8/15/11
  *
- * Modifications:
- *
- *        None.
- *
  *-------------------------------------------------------------------------
  */
 
@@ -3412,12 +3346,11 @@ ckrbrd_hs_dr_pio_test__d2m_s2l(struct hs_dr_pio_test_vars_t * tv_ptr)
                     );
 
 
-                    /* verify that H5S_select_shape_same() reports the two
+                    /* verify that H5Sselect_shape_same() reports the two
                      * selections as having the same shape.
                      */
-                    check = H5S__select_shape_same_test(tv_ptr->file_small_ds_sid_0,
-                                                       tv_ptr->mem_large_ds_sid);
-                    VRFY((check == TRUE), "H5S__select_shape_same_test passed");
+                    check = H5Sselect_shape_same(tv_ptr->file_small_ds_sid_0, tv_ptr->mem_large_ds_sid);
+                    VRFY((check == TRUE), "H5Sselect_shape_same passed");
 
 
                     /* Read selection from disk */
@@ -3561,24 +3494,20 @@ ckrbrd_hs_dr_pio_test__d2m_s2l(struct hs_dr_pio_test_vars_t * tv_ptr)
  *
  *        Verify that we can write from memory to file using checker
  *        board selections of different rank that
- *        H5S_select_shape_same() views as being of the same shape.
+ *        H5Sselect_shape_same() views as being of the same shape.
  *
  *        Do this by writing small_rank - 1 dimensional checker
  *        board slices from the in memory large data set to the on
  *        disk small cube dataset.  After each write, read the
  *        slice of the small dataset back from disk, and verify
  *        that it contains the expected data. Verify that
- *        H5S_select_shape_same() returns true on the memory and
+ *        H5Sselect_shape_same() returns true on the memory and
  *        file selections.
  *
  * Return:    void
  *
  * Programmer:    JRM -- 8/15/11
  *
- * Modifications:
- *
- *        None.
- *
  *-------------------------------------------------------------------------
  */
 
@@ -3609,12 +3538,12 @@ ckrbrd_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
 
     /* 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.
+     * H5Sselect_shape_same() views as being of the same shape.
      *
      * Start by writing small_rank - 1 D slices from the in memory large data
      * set to the on disk small dataset.  After each write, read the slice of
      * the small dataset back from disk, and verify that it contains the
-     * expected data. Verify that H5S_select_shape_same() returns true on
+     * expected data. Verify that H5Sselect_shape_same() returns true on
      * the memory and file selections.
      */
 
@@ -3795,14 +3724,13 @@ ckrbrd_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
                     );
 
 
-                    /* verify that H5S_select_shape_same() reports the in
+                    /* verify that H5Sselect_shape_same() reports the in
                      * memory checkerboard selection of the slice through the
                      * large dataset and the checkerboard selection of the process
                      * slice of the small data set as having the same shape.
                      */
-                    check = H5S__select_shape_same_test(tv_ptr->file_small_ds_sid_1,
-                                                       tv_ptr->mem_large_ds_sid);
-                    VRFY((check == TRUE), "H5S__select_shape_same_test passed.");
+                    check = H5Sselect_shape_same(tv_ptr->file_small_ds_sid_1, tv_ptr->mem_large_ds_sid);
+                    VRFY((check == TRUE), "H5Sselect_shape_same passed.");
 
 
                     /* write the checker board selection of the slice from the in
@@ -3922,7 +3850,7 @@ ckrbrd_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
  *        board hyperslab selections of different rank in the parallel.
  *
  *        Verify that we can write from memory to file using
- *        selections of different rank that H5S_select_shape_same()
+ *        selections of different rank that H5Sselect_shape_same()
  *        views as being of the same shape.
  *
  *        Do this by writing checker board selections of the contents
@@ -3931,17 +3859,13 @@ ckrbrd_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
  *        read the process's slice of the large data set back into
  *        memory, and verify that it contains the expected data.
  *
- *        Verify that H5S_select_shape_same() returns true on the
+ *        Verify that H5Sselect_shape_same() returns true on the
  *        memory and file selections.
  *
  * Return:    void
  *
  * Programmer:    JRM -- 8/15/11
  *
- * Modifications:
- *
- *        None
- *
  *-------------------------------------------------------------------------
  */
 
@@ -3974,7 +3898,7 @@ ckrbrd_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t * tv_ptr)
      * small data set to slices of the on disk large data set.  After
      * each write, read the process's slice of the large data set back
      * into memory, and verify that it contains the expected data.
-     * Verify that H5S_select_shape_same() returns true on the memory
+     * Verify that H5Sselect_shape_same() returns true on the memory
      * and file selections.
      */
 
@@ -4150,14 +4074,13 @@ ckrbrd_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t * tv_ptr)
                     );
 
 
-                    /* verify that H5S_select_shape_same() reports the in
+                    /* verify that H5Sselect_shape_same() reports the in
                      * memory small data set slice selection and the
                      * on disk slice through the large data set selection
                      * as having the same shape.
                      */
-                    check = H5S__select_shape_same_test(tv_ptr->mem_small_ds_sid,
-                                                       tv_ptr->file_large_ds_sid_1);
-                    VRFY((check == TRUE), "H5S__select_shape_same_test passed");
+                    check = H5Sselect_shape_same(tv_ptr->mem_small_ds_sid, tv_ptr->file_large_ds_sid_1);
+                    VRFY((check == TRUE), "H5Sselect_shape_same passed");
 
 
                     /* write the small data set slice from memory to the
@@ -4287,14 +4210,6 @@ ckrbrd_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t * tv_ptr)
  *
  * Programmer:    JRM -- 10/10/09
  *
- * Modifications:
- *
- *        JRM -- 9/16/10
- *        Added the express_test parameter.  Use it to control
- *        whether we set an alignment, and whether we allocate
- *        chunks such that no two processes will normally touch
- *        the same chunk.
- *
  *-------------------------------------------------------------------------
  */
 
@@ -4409,12 +4324,12 @@ ckrbrd_hs_dr_pio_test__run_test(const int test_num,
 
 
     /* first, verify that we can read from disk correctly using selections
-     * of different rank that H5S_select_shape_same() views as being of the
+     * of different rank that H5Sselect_shape_same() views as being of the
      * same shape.
      *
      * Start by reading a (small_rank - 1)-D slice from this processes slice
      * of the on disk large data set, and verifying that the data read is
-     * correct.  Verify that H5S_select_shape_same() returns true on the
+     * correct.  Verify that H5Sselect_shape_same() returns true on the
      * memory and file selections.
      *
      * The first step is to set up the needed checker board selection in the
@@ -4434,12 +4349,12 @@ ckrbrd_hs_dr_pio_test__run_test(const int test_num,
 
     /* 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.
+     * H5Sselect_shape_same() views as being of the same shape.
      *
      * Start by writing small_rank - 1 D slices from the in memory large data
      * set to the on disk small dataset.  After each write, read the slice of
      * the small dataset back from disk, and verify that it contains the
-     * expected data. Verify that H5S_select_shape_same() returns true on
+     * expected data. Verify that H5Sselect_shape_same() returns true on
      * the memory and file selections.
      */
 
@@ -4450,7 +4365,7 @@ ckrbrd_hs_dr_pio_test__run_test(const int test_num,
      * small data set to slices of the on disk large data set.  After
      * each write, read the process's slice of the large data set back
      * into memory, and verify that it contains the expected data.
-     * Verify that H5S_select_shape_same() returns true on the memory
+     * Verify that H5Sselect_shape_same() returns true on the memory
      * and file selections.
      */
 
@@ -4494,20 +4409,6 @@ ckrbrd_hs_dr_pio_test__run_test(const int test_num,
  *
  * Programmer:    JRM -- 9/18/09
  *
- * Modifications:
- *
- *          Modified function to take a sample of the run times
- *        of the different tests, and skip some of them if
- *        run times are too long.
- *
- *        We need to do this because Lustre runns very slowly
- *        if two or more processes are banging on the same
- *        block of memory.
- *                        JRM -- 9/10/10
- *          Break this one big test into 4 smaller tests according
- *          to {independent,collective}x{contigous,chunked} datasets.
- *        AKC -- 2010/01/17
- *
  *-------------------------------------------------------------------------
  */
 
diff --git a/testpar/t_span_tree.c b/testpar/t_span_tree.c
index cc79af2..352a089 100644
--- a/testpar/t_span_tree.c
+++ b/testpar/t_span_tree.c
@@ -60,8 +60,6 @@ static void coll_read_test(int chunk_factor);
  * Programmer:    Unknown
  *        Dec 2nd, 2004
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void
@@ -87,8 +85,6 @@ coll_irregular_cont_write(void)
  * Programmer:    Unknown
  *        Dec 2nd, 2004
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void
@@ -113,8 +109,6 @@ coll_irregular_cont_read(void)
  * Programmer:    Unknown
  *        Dec 2nd, 2004
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void
@@ -140,8 +134,6 @@ coll_irregular_simple_chunk_write(void)
  * Programmer:    Unknown
  *        Dec 2nd, 2004
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void
@@ -165,8 +157,6 @@ coll_irregular_simple_chunk_read(void)
  * Programmer:    Unknown
  *        Dec 2nd, 2004
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void
@@ -192,8 +182,6 @@ coll_irregular_complex_chunk_write(void)
  * Programmer:    Unknown
  *        Dec 2nd, 2004
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void
@@ -219,8 +207,6 @@ coll_irregular_complex_chunk_read(void)
  * Programmer:    Unknown
  *        Dec 2nd, 2004
  *
- * Modifications: Oct 18th, 2005
- *
  *-------------------------------------------------------------------------
  */
 void coll_write_test(int chunk_factor)
@@ -694,9 +680,6 @@ void coll_write_test(int chunk_factor)
  * Programmer:    Unknown
  *        Dec 2nd, 2004
  *
- * Modifications: Oct 18th, 2005
- * Note:        This test must be used with the correpsonding
-                coll_write_test.
  *-------------------------------------------------------------------------
  */
 static void
@@ -948,18 +931,18 @@ coll_read_test(int chunk_factor)
 **
 **  lower_dim_size_comp_test__select_checker_board():
 **
-**    Given a data space of tgt_rank, and dimensions:
+**    Given a dataspace of tgt_rank, and dimensions:
 **
 **        (mpi_size + 1), edge_size, ... , edge_size
 **
 **    edge_size, and a checker_edge_size, select a checker
 **    board selection of a sel_rank (sel_rank < tgt_rank)
-**    dimensional slice through the data space parallel to the
+**    dimensional slice through the dataspace parallel to the
 **      sel_rank fastest changing indicies, with origin (in the
 **    higher indicies) as indicated by the start array.
 **
 **    Note that this function, is hard coded to presume a
-**    maximum data space rank of 5.
+**    maximum dataspace rank of 5.
 **
 **    While this maximum is declared as a constant, increasing
 **    it will require extensive coding in addition to changing
@@ -1304,7 +1287,7 @@ lower_dim_size_comp_test__select_checker_board(
     }
 #endif /* LOWER_DIM_SIZE_COMP_TEST__SELECT_CHECKER_BOARD__DEBUG */
 
-    /* Clip the selection back to the data space proper. */
+    /* Clip the selection back to the dataspace proper. */
 
     for ( i = 0; i < test_max_rank; i++ ) {
 
@@ -1564,15 +1547,13 @@ lower_dim_size_comp_test__verify_data(uint32_t * buf_ptr,
  * Function:    lower_dim_size_comp_test__run_test()
  *
  * Purpose:    Verify that a bug in the computation of the size of the
- *        lower dimensions of a data space in H5S_obtain_datatype()
+ *        lower dimensions of a dataspace in H5S_obtain_datatype()
  *        has been corrected.
  *
  * Return:    void
  *
  * Programmer:    JRM -- 11/11/09
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 
@@ -1763,7 +1744,7 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
     }
 #endif
 
-    /* create data spaces */
+    /* create dataspaces */
 
     full_mem_small_ds_sid = H5Screate_simple(5, small_dims, NULL);
     VRFY((full_mem_small_ds_sid != 0),
@@ -2177,7 +2158,7 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
 #endif /* LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG */
     }
 
-    /* try clipping the selection back to the large data space proper */
+    /* try clipping the selection back to the large dataspace proper */
     start[0] = start[1] = start[2] = start[3] = start[4] = (hsize_t)0;
 
     stride[0] = (hsize_t)(2 * (mpi_size + 1));
@@ -2331,12 +2312,11 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
                                                    large_sel_start);
 
 
-    /* verify that H5S_select_shape_same() reports the two
+    /* verify that H5Sselect_shape_same() reports the two
      * selections as having the same shape.
      */
-    check = H5S__select_shape_same_test(mem_large_ds_sid,
-                                       file_small_ds_sid);
-    VRFY((check == TRUE), "H5S__select_shape_same_test passed (1)");
+    check = H5Sselect_shape_same(mem_large_ds_sid, file_small_ds_sid);
+    VRFY((check == TRUE), "H5Sselect_shape_same passed (1)");
 
 
     ret = H5Dread(small_dataset,
@@ -2452,12 +2432,11 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
                                                    large_sel_start);
 
 
-    /* verify that H5S_select_shape_same() reports the two
+    /* verify that H5Sselect_shape_same() reports the two
      * selections as having the same shape.
      */
-    check = H5S__select_shape_same_test(mem_small_ds_sid,
-                                       file_large_ds_sid);
-    VRFY((check == TRUE), "H5S__select_shape_same_test passed (2)");
+    check = H5Sselect_shape_same(mem_small_ds_sid, file_large_ds_sid);
+    VRFY((check == TRUE), "H5Sselect_shape_same passed (2)");
 
 
     ret = H5Dread(large_dataset,
@@ -2613,8 +2592,6 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
  *
  * Programmer:    JRM -- 11/11/09
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 
@@ -2672,8 +2649,6 @@ lower_dim_size_comp_test(void)
  *
  * Programmer:    JRM -- 12/16/09
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 
@@ -2737,7 +2712,7 @@ link_chunk_collective_io_test(void)
     /* setup dims */
     dims[0] = ((hsize_t)mpi_size) * ((hsize_t)(LINK_CHUNK_COLLECTIVE_IO_TEST_CHUNK_SIZE));
 
-    /* setup mem and file data spaces */
+    /* setup mem and file dataspaces */
     write_mem_ds_sid = H5Screate_simple(1, chunk_dims, NULL);
     VRFY((write_mem_ds_sid != 0),
          "H5Screate_simple() write_mem_ds_sid succeeded");