[svn-r11558] Purpose:

    Bug fix

Description:
    Check in Kent's fixes to hyperslab rebuilding code that should correctly
detect situation when different sub-hyperslabs exist in a higher dimension.

Solution:
    Remember previous sub-hyperslab information and compare that with newly
generated sub-hyperslab to make certain they are the same.

Platforms tested:
    FreeBSD 4.11 (sleipnir)
    Too minor to require h5committest

4 files changed, 746 insertions, 15 deletions

diff --git a/src/H5Shyper.c b/src/H5Shyper.c
index 6cc6cdd..1f75af4 100644
--- a/src/H5Shyper.c
+++ b/src/H5Shyper.c
@@ -5371,7 +5371,8 @@ H5S_hyper_rebuild_helper(const H5S_hyper_span_t *span, H5S_hyper_dim_t span_slab
     hsize_t curr_start;
     hsize_t curr_low;
     int     outcount;
-    H5S_hyper_dim_t      canon_down_span_slab_info;
+    int     i;
+    H5S_hyper_dim_t      canon_down_span_slab_info[H5S_MAX_RANK];
     hbool_t ret_value = TRUE;
    
     FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5S_hyper_rebuild_helper)
@@ -5391,7 +5392,7 @@ H5S_hyper_rebuild_helper(const H5S_hyper_span_t *span, H5S_hyper_dim_t span_slab
             if(!H5S_hyper_rebuild_helper(span->down->head, span_slab_info, rank - 1))
                 HGOTO_DONE(FALSE)
 
-            canon_down_span_slab_info = span_slab_info[rank - 2];
+            HDmemcpy(canon_down_span_slab_info, span_slab_info, sizeof(H5S_hyper_dim_t) * rank);
         } /* end if */
 
         /* Assign the initial starting point & block size */
@@ -5410,19 +5411,22 @@ H5S_hyper_rebuild_helper(const H5S_hyper_span_t *span, H5S_hyper_dim_t span_slab
                     if(!H5S_hyper_rebuild_helper(span->down->head, span_slab_info, rank - 1))
                         HGOTO_DONE(FALSE)
 
-                    /* Point to hyperslab span information set up by recursive call */
-                    curr_down_span_slab_info = &span_slab_info[rank - 2];
-
-                    /* Compare the slab information of the adjacent spans in the down span tree.*/
-                    if(curr_down_span_slab_info->count > 0 && canon_down_span_slab_info.count > 0) {
-                        if(curr_down_span_slab_info->start != canon_down_span_slab_info.start
-                            || curr_down_span_slab_info->stride != canon_down_span_slab_info.stride
-                            || curr_down_span_slab_info->block != canon_down_span_slab_info.block
-                            || curr_down_span_slab_info->count != canon_down_span_slab_info.count)
-                        HGOTO_DONE(FALSE)
-                    } /* end if */
-                    else if (!((curr_down_span_slab_info->count == 0) && (canon_down_span_slab_info.count == 0)))
-                        HGOTO_DONE(FALSE)
+                    /* Compare the slab information of the adjacent spans in the down span tree.
+                       We have to compare all the sub-tree slab information with the canon_down_span_slab_info.*/
+
+                    for( i = 0; i < rank - 1; i++) {
+                       curr_down_span_slab_info = &span_slab_info[i];
+
+                       if(curr_down_span_slab_info->count > 0 && canon_down_span_slab_info[i].count > 0) {
+                          if(curr_down_span_slab_info->start != canon_down_span_slab_info[i].start
+                              || curr_down_span_slab_info->stride != canon_down_span_slab_info[i].stride
+                              || curr_down_span_slab_info->block != canon_down_span_slab_info[i].block
+                              || curr_down_span_slab_info->count != canon_down_span_slab_info[i].count)
+                          HGOTO_DONE(FALSE)
+                       } /* end if */
+                       else if (!((curr_down_span_slab_info->count == 0) && (canon_down_span_slab_info[i].count == 0)))
+                          HGOTO_DONE(FALSE)
+                    }
                 } /* end if */
             } /* end if */
 
diff --git a/src/H5Spkg.h b/src/H5Spkg.h
index c32032d..2cb8499 100644
--- a/src/H5Spkg.h
+++ b/src/H5Spkg.h
@@ -223,6 +223,7 @@ H5_DLL herr_t H5S_extent_copy(H5S_extent_t *dst, const H5S_extent_t *src);
 /* Testing functions */
 #ifdef H5S_TESTING
 H5_DLL htri_t H5S_select_shape_same_test(hid_t sid1, hid_t sid2);
+H5_DLL htri_t H5S_inquiry_rebuild_status(hid_t space_id);
 #endif /* H5S_TESTING */
 
 #endif /*_H5Spkg_H*/
diff --git a/src/H5Stest.c b/src/H5Stest.c
index 2eef919..83fbd96 100644
--- a/src/H5Stest.c
+++ b/src/H5Stest.c
@@ -71,3 +71,38 @@ done:
     FUNC_LEAVE_NOAPI(ret_value);
 }   /* H5S_select_shape_same_test() */
 
+/*--------------------------------------------------------------------------
+ NAME
+    H5S_inquiry_rebuild_status
+ PURPOSE
+    Determine the status of rebuild
+ USAGE
+    htri_t H5S_inquiry_rebuild_status(hid_t space_id)
+        hid_t space_id;          IN:  dataspace id
+ RETURNS
+    Non-negative TRUE/FALSE on success, negative on failure
+ DESCRIPTION
+    Query the status of rebuilding the hyperslab
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+    DO NOT USE THIS FUNCTION FOR ANYTHING EXCEPT TESTING H5P_get_class_path()
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+htri_t
+H5S_inquiry_rebuild_status(hid_t space_id)
+{
+    static htri_t ret_value = FAIL;        /* return value */
+
+    H5S_t	*space1 = NULL;      /* Pointer to 1st dataspace */
+
+    FUNC_ENTER_NOAPI(H5S_inquiry_rebuild_status, FAIL);
+     /* Get dataspace structures */                                                                         
+if (NULL == (space1=H5I_object_verify(space_id, H5I_DATASPACE)))                                               
+    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace");    
+
+    ret_value= space1->select.sel_info.hslab->diminfo_valid;
+   
+done:
+    FUNC_LEAVE_NOAPI(ret_value);
+}   /* H5S_inquiry_rebuild_status() */
diff --git a/test/tselect.c b/test/tselect.c
index 804e928..f24bd9c 100644
--- a/test/tselect.c
+++ b/test/tselect.c
@@ -138,6 +138,30 @@
 #define SPACE12_DIM0            25
 #define SPACE12_CHUNK_DIM0      5
 
+/* Information for Space rebuild test */
+#define SPACERE1_RANK            1
+#define SPACERE1_DIM0            20
+#define SPACERE2_RANK            2
+#define SPACERE2_DIM0            8
+#define SPACERE2_DIM1            12
+#define SPACERE3_RANK            3
+#define SPACERE3_DIM0            8
+#define SPACERE3_DIM1            12
+#define SPACERE3_DIM2            8 
+#define SPACERE4_RANK            4
+#define SPACERE4_DIM0            8
+#define SPACERE4_DIM1            12
+#define SPACERE4_DIM2            8
+#define SPACERE4_DIM3            12
+#define SPACERE5_RANK            5
+#define SPACERE5_DIM0            8
+#define SPACERE5_DIM1            12
+#define SPACERE5_DIM2            8
+#define SPACERE5_DIM3            12
+#define SPACERE5_DIM4            8
+
+
+
 /* Location comparison function */
 int compare_size_t(const void *s1, const void *s2);
 
@@ -6529,6 +6553,669 @@ test_shape_same(void)
     CHECK(ret, FAIL, "H5Sclose");
 }   /* test_shape_same() */
 
+
+/****************************************************************
+**
+**  test_space_rebuild(): Tests selection rebuild routine,
+**  We will test whether selection in span-tree form can be rebuilt
+**  into a regular selection. 
+**      
+**
+****************************************************************/
+static void
+test_space_rebuild(void)
+{
+
+   /* regular space IDs in span-tree form */
+   hid_t sid_reg1,sid_reg2,sid_reg3,sid_reg4,sid_reg5; 
+     
+   /* Original regular Space IDs */         
+   hid_t sid_reg_ori1,sid_reg_ori2,sid_reg_ori3,sid_reg_ori4,sid_reg_ori5; 
+
+   /* Irregular space IDs */ 
+   hid_t sid_irreg1,sid_irreg2,sid_irreg3,sid_irreg4,sid_irreg5;
+
+   /* rebuild status state */
+   htri_t rebuild_stat,rebuild_check;
+   herr_t ret;
+
+   /* dimensions of rank 1 to rank 5 */
+   hsize_t dims1[] ={SPACERE1_DIM0};
+   hsize_t dims2[] ={SPACERE2_DIM0,SPACERE2_DIM1};
+   hsize_t dims3[] ={SPACERE3_DIM0,SPACERE3_DIM1,SPACERE3_DIM2};
+   hsize_t dims4[] ={SPACERE4_DIM0,SPACERE4_DIM1,SPACERE4_DIM2,SPACERE4_DIM3};
+   hsize_t dims5[] ={SPACERE5_DIM0,SPACERE5_DIM1,SPACERE5_DIM2,SPACERE5_DIM3,SPACERE5_DIM4};
+
+   /* The start of the hyperslab */
+   hsize_t start1[SPACERE1_RANK],start2[SPACERE2_RANK],
+           start3[SPACERE3_RANK],start4[SPACERE4_RANK],
+           start5[SPACERE5_RANK];      
+
+   /* The stride of the hyperslab */
+   hsize_t stride1[SPACERE1_RANK],stride2[SPACERE2_RANK],
+           stride3[SPACERE3_RANK],stride4[SPACERE4_RANK],
+           stride5[SPACERE5_RANK];    
+
+   /* The number of blocks for the hyperslab */
+   hsize_t count1[SPACERE1_RANK],count2[SPACERE2_RANK],
+           count3[SPACERE3_RANK],count4[SPACERE4_RANK],
+           count5[SPACERE5_RANK];    
+
+   /* The size of each block for the hyperslab */
+   hsize_t block1[SPACERE1_RANK],block2[SPACERE2_RANK],
+           block3[SPACERE3_RANK],block4[SPACERE4_RANK],
+           block5[SPACERE5_RANK];       
+
+  /* Declarations for special test of rebuild */
+   hid_t sid_spec;
+
+
+    /* Output message about test being performed */
+    MESSAGE(6, ("Testing functionality to rebuild regular hyperslab selection\n"));
+   
+
+    MESSAGE(7, ("Testing functionality to rebuild 1-D hyperslab selection\n"));
+
+    /* Create 1-D dataspace */
+    sid_reg1       = H5Screate_simple(SPACERE1_RANK,dims1,NULL);
+    sid_reg_ori1   = H5Screate_simple(SPACERE1_RANK,dims1,NULL);
+
+    /* Build up the original one dimensional regular selection */
+    start1[0]  = 1; 
+    count1[0]  = 3;
+    stride1[0] = 5;
+    block1[0]  = 4;
+    ret = H5Sselect_hyperslab(sid_reg_ori1,H5S_SELECT_SET,start1,stride1,count1,block1);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    /* Build up one dimensional regular selection with H5_SELECT_OR,
+       inside HDF5, it will be treated as an irregular selection. */
+
+    start1[0]  = 1; 
+    count1[0]  = 2;
+    stride1[0] = 5;
+    block1[0]  = 4;
+    ret = H5Sselect_hyperslab(sid_reg1,H5S_SELECT_SET,start1,stride1,count1,block1);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");   
+
+    start1[0]  = 11; 
+    count1[0]  = 1;
+    stride1[0] = 5;
+    block1[0]  = 4;
+    ret = H5Sselect_hyperslab(sid_reg1,H5S_SELECT_OR,start1,stride1,count1,block1);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");   
+
+    rebuild_stat = FALSE;
+    rebuild_stat = H5S_inquiry_rebuild_status(sid_reg1);
+    assert(rebuild_stat!=FAIL);
+    /* In this case, rebuild_stat should be TRUE. */
+    if(!rebuild_stat){
+       ret = FAIL;
+       CHECK(ret,FAIL,"H5S_hyper_rebuild");
+    }
+    else {
+       /* 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");
+    }
+
+    /* For irregular hyperslab */
+    sid_irreg1     = H5Screate_simple(SPACERE1_RANK,dims1,NULL);
+    
+    /* Build up one dimensional irregular selection with H5_SELECT_OR */
+    start1[0]  = 1; 
+    count1[0]  = 2;
+    stride1[0] = 5;
+    block1[0]  = 4;
+    ret = H5Sselect_hyperslab(sid_irreg1,H5S_SELECT_SET,start1,stride1,count1,block1);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");   
+
+    start1[0]  = 12; /* Just one position switch */
+    count1[0]  = 1;
+    stride1[0] = 5;
+    block1[0]  = 4;
+    ret = H5Sselect_hyperslab(sid_irreg1,H5S_SELECT_OR,start1,stride1,count1,block1);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");   
+
+    rebuild_stat = TRUE;
+    rebuild_stat = H5S_inquiry_rebuild_status(sid_irreg1); 
+    assert(rebuild_stat!=FAIL);
+    /* In this case, rebuild_stat should be FALSE. */
+    if(rebuild_stat){
+       ret = FAIL;
+       CHECK(ret,FAIL,"H5S_hyper_rebuild");
+    }/* No need to do shape comparision */
+
+    
+    MESSAGE(7, ("Testing functionality to rebuild 2-D hyperslab selection\n"));
+    /* Create 2-D dataspace */
+    sid_reg2       = H5Screate_simple(SPACERE2_RANK,dims2,NULL);
+    sid_reg_ori2   = H5Screate_simple(SPACERE2_RANK,dims2,NULL);
+
+    /* Build up the original two dimensional regular selection */
+    start2[0]  = 2; 
+    count2[0]  = 2;
+    stride2[0] = 7;
+    block2[0]  = 5;
+    start2[1]  = 1;
+    count2[1]  = 3;
+    stride2[1] = 3;
+    block2[1]  = 2;
+
+    ret = H5Sselect_hyperslab(sid_reg_ori2,H5S_SELECT_SET,start2,stride2,count2,block2);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    /* Build up two dimensional regular selection with H5_SELECT_OR, inside HDF5,
+       it will be treated as an irregular selection. */
+
+    start2[1]  = 1;
+    count2[1]  = 2;
+    stride2[1] = 3;
+    block2[1]  = 2;
+
+    ret = H5Sselect_hyperslab(sid_reg2,H5S_SELECT_SET,start2,stride2,count2,block2);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");   
+
+    start2[1]  = 7; /* 7 = start(1) + count(2) * stride(3) */
+    count2[1]  = 1;
+    stride2[1] = 3;
+    block2[1]  = 2;
+
+    ret = H5Sselect_hyperslab(sid_reg2,H5S_SELECT_OR,start2,stride2,count2,block2);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");   
+
+    rebuild_stat = FALSE;
+    rebuild_stat = H5S_inquiry_rebuild_status(sid_reg2); 
+    assert(rebuild_stat!=FAIL);
+    /* In this case, rebuild_stat should be TRUE. */
+    if(!rebuild_stat){
+       ret = FAIL;
+       CHECK(ret,FAIL,"H5S_hyper_rebuild");
+    }
+    else {
+       /* 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");
+    }
+
+    /* 2-D irregular case */
+    sid_irreg2     = H5Screate_simple(SPACERE2_RANK,dims2,NULL);
+    /* Build up two dimensional irregular selection with H5_SELECT_OR */
+
+    start2[0]  = 2; 
+    count2[0]  = 2;
+    stride2[0] = 7;
+    block2[0]  = 5;
+    start2[1]  = 1;
+    count2[1]  = 1;
+    stride2[1] = 3;
+    block2[1]  = 2;
+    ret = H5Sselect_hyperslab(sid_irreg2,H5S_SELECT_SET,start2,stride2,count2,block2);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");   
+
+    start2[1]  = 4;
+    count2[1]  = 2; 
+    stride2[1] = 4;
+    block2[1]  = 3; /* Just add one element for the block */
+   
+    ret = H5Sselect_hyperslab(sid_irreg2,H5S_SELECT_OR,start2,stride2,count2,block2);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");   
+
+    rebuild_stat = TRUE;
+    rebuild_stat = H5S_inquiry_rebuild_status(sid_irreg2);
+    assert(rebuild_stat!=FAIL);
+    /* In this case, rebuild_stat should be FALSE. */
+    if(rebuild_stat){
+       ret = FAIL;
+       CHECK(ret,FAIL,"H5S_hyper_rebuild");
+    }/* No need to do shape comparision */
+
+    MESSAGE(7, ("Testing functionality to rebuild 3-D hyperslab selection\n"));
+
+    /* Create 3-D dataspace */
+    sid_reg3       = H5Screate_simple(SPACERE3_RANK,dims3,NULL);
+    sid_reg_ori3   = H5Screate_simple(SPACERE3_RANK,dims3,NULL);
+
+    /* Build up the original three dimensional regular selection */
+    start3[0]  = 2; 
+    count3[0]  = 2;
+    stride3[0] = 3;
+    block3[0]  = 2;
+    start3[1]  = 1;
+    count3[1]  = 3;
+    stride3[1] = 3;
+    block3[1]  = 2;
+
+    start3[2]  = 1;
+    count3[2]  = 2;
+    stride3[2] = 4;
+    block3[2]  = 2;
+    
+
+    ret = H5Sselect_hyperslab(sid_reg_ori3,H5S_SELECT_SET,start3,stride3,count3,block3);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    /* Build up three dimensional regular selection with H5_SELECT_OR, inside HDF5,
+       it will be treated as an irregular selection. */
+    start3[2]  = 1;
+    count3[2]  = 1;
+    stride3[2] = 4;
+    block3[2]  = 2;
+
+    ret = H5Sselect_hyperslab(sid_reg3,H5S_SELECT_SET,start3,stride3,count3,block3);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");   
+
+    start3[2]  = 5;
+    count3[2]  = 1;
+    stride3[2] = 4;
+    block3[2]  = 2;
+
+    ret = H5Sselect_hyperslab(sid_reg3,H5S_SELECT_OR,start3,stride3,count3,block3);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");   
+
+    rebuild_stat = FALSE;
+    rebuild_stat = H5S_inquiry_rebuild_status(sid_reg3);
+    assert(rebuild_stat!=FAIL);
+
+    /* In this case, rebuild_stat should be TRUE. */
+    if(!rebuild_stat){
+       ret = FAIL;
+       CHECK(ret,FAIL,"H5S_hyper_rebuild");
+    }
+    else {
+       /* 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");
+    }
+
+    sid_irreg3     = H5Screate_simple(SPACERE3_RANK,dims3,NULL);
+
+    /* Build up three dimensional irregular selection with H5_SELECT_OR */
+    start3[0]  = 2; 
+    count3[0]  = 2;
+    stride3[0] = 3;
+    block3[0]  = 2;
+    start3[1]  = 1;
+    count3[1]  = 3;
+    stride3[1] = 3;
+    block3[1]  = 2;
+
+    start3[2]  = 1;
+    count3[2]  = 2;
+    stride3[2] = 2;
+    block3[2]  = 1;
+
+    ret = H5Sselect_hyperslab(sid_irreg3,H5S_SELECT_SET,start3,stride3,count3,block3);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");   
+
+    start3[2]  = 3;
+    count3[2]  = 2; 
+    stride3[2] = 3; /* Just add one element for the stride */
+    block3[2]  = 1; 
+   
+    ret = H5Sselect_hyperslab(sid_irreg3,H5S_SELECT_OR,start3,stride3,count3,block3);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");   
+
+    rebuild_stat = TRUE;
+    rebuild_stat = H5S_inquiry_rebuild_status(sid_irreg3);
+    assert(rebuild_stat!=FAIL);
+    /* In this case, rebuild_stat should be FALSE. */
+    if(rebuild_stat){
+       ret = FAIL;
+       CHECK(ret,FAIL,"H5S_hyper_rebuild");
+    }/* No need to do shape comparision */
+
+    MESSAGE(7, ("Testing functionality to rebuild 4-D hyperslab selection\n"));
+
+    /* Create 4-D dataspace */
+    sid_reg4       = H5Screate_simple(SPACERE4_RANK,dims4,NULL);
+    sid_reg_ori4   = H5Screate_simple(SPACERE4_RANK,dims4,NULL);
+
+    /* Build up the original four dimensional regular selection */
+    start4[0]  = 2; 
+    count4[0]  = 2;
+    stride4[0] = 3;
+    block4[0]  = 2;
+
+    start4[1]  = 1;
+    count4[1]  = 3;
+    stride4[1] = 3;
+    block4[1]  = 2;
+
+    start4[2]  = 1;
+    count4[2]  = 2;
+    stride4[2] = 4;
+    block4[2]  = 2;
+
+    start4[3]  = 1;
+    count4[3]  = 2;
+    stride4[3] = 4;
+    block4[3]  = 2;
+    
+
+    ret = H5Sselect_hyperslab(sid_reg_ori4,H5S_SELECT_SET,start4,stride4,count4,block4);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    /* Build up four dimensional regular selection with H5_SELECT_OR, inside HDF5,
+       it will be treated as an irregular selection. */
+    start4[3]  = 1;
+    count4[3]  = 1;
+    stride4[3] = 4;
+    block4[3]  = 2;
+
+    ret = H5Sselect_hyperslab(sid_reg4,H5S_SELECT_SET,start4,stride4,count4,block4);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");   
+
+    start4[3]  = 5;
+    count4[3]  = 1;
+    stride4[3] = 4;
+    block4[3]  = 2;
+
+
+    ret = H5Sselect_hyperslab(sid_reg4,H5S_SELECT_OR,start4,stride4,count4,block4);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");   
+
+
+    rebuild_stat = FALSE;
+    rebuild_stat = H5S_inquiry_rebuild_status(sid_reg4);
+    assert(rebuild_stat!=FAIL);
+    /* In this case, rebuild_stat should be TRUE. */
+    if(!rebuild_stat){
+       ret = FAIL;
+       CHECK(ret,FAIL,"H5S_hyper_rebuild");
+    }
+    else {
+       /* 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");
+    }
+
+    /* Testing irregular selection */
+    sid_irreg4     = H5Screate_simple(SPACERE4_RANK,dims4,NULL);
+    
+    /* Build up four dimensional irregular selection with H5_SELECT_OR */
+    start4[0]  = 2; 
+    count4[0]  = 2;
+    stride4[0] = 3;
+    block4[0]  = 2;
+    start4[1]  = 1;
+    count4[1]  = 3;
+    stride4[1] = 3;
+    block4[1]  = 2;
+
+    start4[2]  = 1;
+    count4[2]  = 1;
+    stride4[2] = 4;
+    block4[2]  = 2;
+
+    start4[3]  = 1;
+    count4[3]  = 2;
+    stride4[3] = 4;
+    block4[3]  = 2; /* sub-block is one element difference */
+
+    ret = H5Sselect_hyperslab(sid_irreg4,H5S_SELECT_SET,start4,stride4,count4,block4);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");   
+
+    start4[2]  = 5;
+    count4[2]  = 1;
+    stride4[2] = 4;
+    block4[2]  = 2;
+
+    start4[3]  = 1;
+    count4[3]  = 2;
+    stride4[3] = 4;
+    block4[3]  = 3;  /* sub-block is one element difference */
+   
+    ret = H5Sselect_hyperslab(sid_irreg4,H5S_SELECT_OR,start4,stride4,count4,block4);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");   
+
+    rebuild_stat = TRUE;
+    rebuild_stat = H5S_inquiry_rebuild_status(sid_irreg4);
+    assert(rebuild_stat!=FAIL);
+    /* In this case, rebuild_stat should be FALSE. */
+    if(rebuild_stat){
+       ret = FAIL;
+       CHECK(ret,FAIL,"H5S_hyper_rebuild");
+    }/* No need to do shape comparision */
+
+    MESSAGE(7, ("Testing functionality to rebuild 5-D hyperslab selection\n"));
+
+    /* Create 5-D dataspace */
+    sid_reg5       = H5Screate_simple(SPACERE5_RANK,dims5,NULL);
+    sid_reg_ori5   = H5Screate_simple(SPACERE5_RANK,dims5,NULL);
+
+    /* Build up the original five dimensional regular selection */
+    start5[0]  = 2; 
+    count5[0]  = 2;
+    stride5[0] = 3;
+    block5[0]  = 2;
+
+    start5[1]  = 1;
+    count5[1]  = 3;
+    stride5[1] = 3;
+    block5[1]  = 2;
+
+    start5[2]  = 1;
+    count5[2]  = 2;
+    stride5[2] = 4;
+    block5[2]  = 2;
+
+    start5[3]  = 1;
+    count5[3]  = 2;
+    stride5[3] = 4;
+    block5[3]  = 2;
+    
+    start5[4]  = 1;
+    count5[4]  = 2;
+    stride5[4] = 4;
+    block5[4]  = 2;
+
+    ret = H5Sselect_hyperslab(sid_reg_ori5,H5S_SELECT_SET,start5,stride5,count5,block5);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+    /* Build up four dimensional regular selection with H5_SELECT_OR, inside HDF5,
+       it will be treated as an irregular selection. */
+    start5[4]  = 1;
+    count5[4]  = 1;
+    stride5[4] = 4;
+    block5[4]  = 2;
+
+    ret = H5Sselect_hyperslab(sid_reg5,H5S_SELECT_SET,start5,stride5,count5,block5);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");   
+
+    start5[4]  = 5;
+    count5[4]  = 1;
+    stride5[4] = 4;
+    block5[4]  = 2;
+
+
+    ret = H5Sselect_hyperslab(sid_reg5,H5S_SELECT_OR,start5,stride5,count5,block5);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");   
+
+
+    rebuild_stat = FALSE;
+    rebuild_stat = H5S_inquiry_rebuild_status(sid_reg5);
+    assert(rebuild_stat!=FAIL);
+    /* In this case, rebuild_stat should be TRUE. */
+    if(!rebuild_stat){
+       ret = FAIL;
+       CHECK(ret,FAIL,"H5S_hyper_rebuild");
+    }
+    else {
+       /* 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");
+    }
+
+    sid_irreg5     = H5Screate_simple(SPACERE5_RANK,dims5,NULL);
+    
+    /* Build up five dimensional irregular selection with H5_SELECT_OR */
+    start5[0]  = 2; 
+    count5[0]  = 2;
+    stride5[0] = 3;
+    block5[0]  = 2;
+
+    start5[1]  = 1;
+    count5[1]  = 3;
+    stride5[1] = 3;
+    block5[1]  = 2;
+
+    start5[2]  = 1;
+    count5[2]  = 2;
+    stride5[2] = 4;
+    block5[2]  = 2;
+
+    start5[3]  = 1;
+    count5[3]  = 1;
+    stride5[3] = 4;
+    block5[3]  = 2; 
+
+    start5[4]  = 2; /* One element difference */
+    count5[4]  = 1;
+    stride5[4] = 4;
+    block5[4]  = 2; 
+
+    ret = H5Sselect_hyperslab(sid_irreg5,H5S_SELECT_SET,start5,stride5,count5,block5);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");   
+
+    start5[3]  = 5;
+    count5[3]  = 1;
+    stride5[3] = 4;
+    block5[3]  = 2;
+
+    start5[4]  = 1; /* One element difference */
+    count5[4]  = 2;
+    stride5[4] = 4;
+    block5[4]  = 2;  
+   
+    ret = H5Sselect_hyperslab(sid_irreg5,H5S_SELECT_OR,start5,stride5,count5,block5);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");   
+
+    rebuild_stat = TRUE;
+    rebuild_stat = H5S_inquiry_rebuild_status(sid_irreg5);
+    assert(rebuild_stat!=FAIL);
+    /* In this case, rebuild_stat should be FALSE. */
+    if(rebuild_stat){
+       ret = FAIL;
+       CHECK(ret,FAIL,"H5S_hyper_rebuild");
+    }/* No need to do shape comparision */
+
+   /* We use 5-D to test a special case with 
+      rebuilding routine TRUE, FALSE and TRUE */
+    sid_spec   = H5Screate_simple(SPACERE5_RANK,dims5,NULL);
+
+    /* Build up the original five dimensional regular selection */
+    start5[0]  = 2; 
+    count5[0]  = 2;
+    stride5[0] = 3;
+    block5[0]  = 2;
+
+    start5[1]  = 1;
+    count5[1]  = 3;
+    stride5[1] = 3;
+    block5[1]  = 2;
+
+    start5[2]  = 1;
+    count5[2]  = 2;
+    stride5[2] = 4;
+    block5[2]  = 2;
+
+    start5[3]  = 1;
+    count5[3]  = 2;
+    stride5[3] = 4;
+    block5[3]  = 2;
+    
+    start5[4]  = 1;
+    count5[4]  = 1;
+    stride5[4] = 4;
+    block5[4]  = 2;
+
+    ret = H5Sselect_hyperslab(sid_spec,H5S_SELECT_SET,start5,stride5,count5,block5);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");
+    rebuild_stat = FALSE;
+    rebuild_stat = H5S_inquiry_rebuild_status(sid_spec); 
+    /* In this case, rebuild_stat should be TRUE. */
+    if(!rebuild_stat){
+       ret = FAIL;
+       CHECK(ret,FAIL,"H5S_hyper_rebuild");
+    }/* No need to do shape comparision */
+
+    /* Adding some selections to make it real irregular */
+    start5[3]  = 1;
+    count5[3]  = 1;
+    stride5[3] = 4;
+    block5[3]  = 2;
+    
+    start5[4]  = 5;
+    count5[4]  = 1;
+    stride5[4] = 4;
+    block5[4]  = 2;
+
+    ret = H5Sselect_hyperslab(sid_spec,H5S_SELECT_OR,start5,stride5,count5,block5);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");   
+
+    rebuild_stat = TRUE;
+    rebuild_stat = H5S_inquiry_rebuild_status(sid_spec);
+    assert(rebuild_stat!=FAIL);
+    /* In this case, rebuild_stat should be FALSE. */
+    if(rebuild_stat){
+       ret = FAIL;
+       CHECK(ret,FAIL,"H5S_hyper_rebuild");
+    }/* No need to do shape comparision */
+
+    start5[3]  = 5;
+    count5[3]  = 1;
+    stride5[3] = 4;
+    block5[3]  = 2;
+    
+    start5[4]  = 5;
+    count5[4]  = 1;
+    stride5[4] = 4;
+    block5[4]  = 2;
+
+    ret = H5Sselect_hyperslab(sid_spec,H5S_SELECT_OR,start5,stride5,count5,block5);
+    CHECK(ret, FAIL, "H5Sselect_hyperslab");   
+
+    rebuild_stat = FALSE;
+    rebuild_stat = H5S_inquiry_rebuild_status(sid_spec);
+    assert(rebuild_stat!=FAIL);
+    /* In this case, rebuild_stat should be FALSE. */
+    if(!rebuild_stat){
+       ret = FAIL;
+       CHECK(ret,FAIL,"H5S_hyper_rebuild");
+    }/* No need to do shape comparision */
+
+    H5Sclose(sid_reg1);
+    CHECK(ret, FAIL, "H5Sclose");
+    H5Sclose(sid_irreg1);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    H5Sclose(sid_reg2);
+    CHECK(ret, FAIL, "H5Sclose");
+    H5Sclose(sid_irreg2);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    H5Sclose(sid_reg3);
+    CHECK(ret, FAIL, "H5Sclose");
+    H5Sclose(sid_irreg3);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    H5Sclose(sid_reg4);
+    CHECK(ret, FAIL, "H5Sclose");
+    H5Sclose(sid_irreg4);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    H5Sclose(sid_reg5);
+    CHECK(ret, FAIL, "H5Sclose");
+    H5Sclose(sid_irreg5);
+    CHECK(ret, FAIL, "H5Sclose");
+
+    H5Sclose(sid_spec);
+    CHECK(ret, FAIL, "H5Sclose");
+
+}   
+   
+
 /****************************************************************
 **
 **  test_select_hyper_chunk_offset(): Tests selections on dataspace,
@@ -7181,6 +7868,10 @@ test_select(void)
 
     /* Test "same shape" routine */
     test_shape_same();
+ 
+    /* Test "re-build" routine */
+    test_space_rebuild();
+    
 
     /* Test point selections in chunked datasets */
     test_select_point_chunk();