[svn-r16230]

Bug fixes: chunks on the btree were not deleted for the case when the new dimension was on the boundary of the  chunk offset (comparison of offset > chunk instead of offset >= chunk). In extending the space, the new size was wrongly compared with the maximum extend possible
Modified H5Dset_extent so that it fails when called for compact datasets and contiguous with no external storage
new test program as 1.8 and 1.9: It adds tests for several ranks, use of fill value or not, compression, different fill value allocation times, use of different storage layouts, and external files

tested: windows, linux

1 files changed, 2272 insertions, 315 deletions

diff --git a/test/set_extent.c b/test/set_extent.c
index 7279f28..1d6d814 100644
--- a/test/set_extent.c
+++ b/test/set_extent.c
@@ -20,529 +20,2486 @@
  * Purpose:     Tests the H5Dset_extent call
  */
 
-
 #include "hdf5.h"
 #include "h5test.h"
 
-
 /*-------------------------------------------------------------------------
  *
- * Tests the function H5Dset_extent. In the current version of the library
- * the dataset MUST be chunked.
+ * Tests the function H5Dset_extent.
  *
  *-------------------------------------------------------------------------
  */
 
-#define RANK 2
-#define ISTORE_IK       64
+#define RANK1 1
+#define RANK2 2
+#define RANK3 3
+#define DIM0  4
+#define DIM1  4
+#define DIM2  4
+#define DIMS0 2
+#define DIMS1 2
+#define DIMS2 2
+#define DIME0 7
+#define DIME1 7
+#define DIME2 7
+#define ISTORE_IK  64
+
+static int do_ranks( void );
+static int do_layouts( void );
+
+static int test_rank1( hbool_t do_compress, 
+                       hbool_t do_fill_value, 
+                       hbool_t set_istore_k,
+                       H5D_fill_time_t fill_time);
+static int test_rank2( hbool_t do_compress, 
+                       hbool_t do_fill_value, 
+                       hbool_t set_istore_k,
+                       H5D_fill_time_t fill_time);
+static int test_rank3( hbool_t do_compress, 
+                       hbool_t do_fill_value, 
+                       hbool_t set_istore_k,
+                       H5D_fill_time_t fill_time);
+
+static int test_external( void );
+static int test_layouts( H5D_layout_t layout );
+
+
+
+
+/*-------------------------------------------------------------------------
+ * main
+ *-------------------------------------------------------------------------
+ */
 
 
 int main( void )
 {
+    if ( do_ranks() < 0 )
+    {
+        goto error;
+    } 
+    
+    if ( test_external() < 0 )
+    {
+        goto error;
+    } 
+    
+    if ( do_layouts() < 0 )
+    {
+        goto error;
+    }  
+    
+        
+    puts("All set_extent tests passed.");
+    return 0;
+    
+    
+error:
+  
+    
+    H5_FAILED();
+    return 1;
+}
 
-    hid_t   file_id;
-    hid_t   dataset_id=(-1);
-    hid_t   space_id=(-1);
-    hid_t   plist_id=(-1);
-    hid_t   fcpl;               /* File creation property list */
-    hsize_t dims[RANK] = { 90, 90 };
-    hsize_t dims_new[RANK] = { 70, 70 };
-    hsize_t dims_chunk[RANK] = { 20, 20 };
-    hsize_t dims_out[RANK];
-    hsize_t dims3[RANK];
-    hsize_t maxdims[RANK] = { H5S_UNLIMITED, H5S_UNLIMITED };
-    int     data[ 90 ][ 90 ];
-    int     buf1[ 70 ][ 70 ];
-    int     buf2[ 90 ][ 90 ];
-    int     i, j, n = 0;
-    int     fillvalue = 1;   /* Fill value for the dataset */
 
 
-    for( i = 0; i < 90; i++ )
-        for( j = 0; j < 90; j++ )
-            data[i][j] = n++;
+/*-------------------------------------------------------------------------
+* test with several ranks
+*-------------------------------------------------------------------------
+*/
+static int do_ranks( void )
+{
 
-    /*-------------------------------------------------------------------------
-    * Test H5Dset_extent with chunks on the raw data cache
-    *-------------------------------------------------------------------------
-    */
+    hbool_t do_compress = 0;
+    hbool_t do_fillvalue = 0;
+    hbool_t set_istore_k = 0;
+      
+      
+    TESTING("with fill value, no compression");
+
+    do_fillvalue = 1;
+
+    if (test_rank1( do_compress, do_fillvalue, set_istore_k, H5D_FILL_TIME_ALLOC ) < 0)
+    {
+        goto error;
+    } 
+    if (test_rank1( do_compress, do_fillvalue, set_istore_k, H5D_FILL_TIME_IFSET ) < 0)
+    {
+        goto error;
+    } 
+    if (test_rank2( do_compress, do_fillvalue, set_istore_k, H5D_FILL_TIME_ALLOC ) < 0)
+    {
+        goto error;
+    } 
+    if (test_rank2( do_compress, do_fillvalue, set_istore_k, H5D_FILL_TIME_IFSET ) < 0)
+    {
+        goto error;
+    } 
+    if (test_rank3( do_compress, do_fillvalue, set_istore_k, H5D_FILL_TIME_ALLOC ) < 0)
+    {
+        goto error;
+    } 
+    if (test_rank3( do_compress, do_fillvalue, set_istore_k, H5D_FILL_TIME_IFSET ) < 0)
+    {
+        goto error;
+    } 
+   
+
+
+    PASSED();
+
+
+    TESTING("no fill value, no compression");
+
+    do_fillvalue = 0;
+
+    if (test_rank1( do_compress, do_fillvalue, set_istore_k, H5D_FILL_TIME_ERROR  ) < 0)
+    {
+        goto error;
+    }
+    if (test_rank2( do_compress, do_fillvalue, set_istore_k, H5D_FILL_TIME_ERROR  ) < 0)
+    {
+        goto error;
+    }
+    if (test_rank3( do_compress, do_fillvalue, set_istore_k, H5D_FILL_TIME_ERROR  ) < 0)
+    {
+        goto error;
+    }
+   
+   
 
+    PASSED();
+    
+    TESTING("with fill value, with compression");
+
+#ifdef H5_HAVE_FILTER_DEFLATE
+
+    do_compress = 1;
+    do_fillvalue = 1;
+
+    if (test_rank1( do_compress, do_fillvalue, set_istore_k, H5D_FILL_TIME_ALLOC ) < 0)
+    {
+        goto error;
+    }
+    if (test_rank1( do_compress, do_fillvalue, set_istore_k, H5D_FILL_TIME_IFSET ) < 0)
+    {
+        goto error;
+    }
+    if (test_rank2( do_compress, do_fillvalue, set_istore_k, H5D_FILL_TIME_ALLOC ) < 0)
+    {
+        goto error;
+    }
+    if (test_rank2( do_compress, do_fillvalue, set_istore_k, H5D_FILL_TIME_IFSET ) < 0)
+    {
+        goto error;
+    }
+    if (test_rank3( do_compress, do_fillvalue, set_istore_k, H5D_FILL_TIME_ALLOC ) < 0)
+    {
+        goto error;
+    }
+    if (test_rank3( do_compress, do_fillvalue, set_istore_k, H5D_FILL_TIME_IFSET ) < 0)
+    {
+        goto error;
+    }
+  
+     
+    PASSED();
+#else
+    SKIPPED();
+#endif
 
-    /* Create a new file using default properties. */
-    if ((file_id = H5Fcreate( "set_extent_create.h5", H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT ))<0) TEST_ERROR;
+    TESTING("no fill value, with compression");
 
-    TESTING("extend dataset create with fill value");
+#ifdef H5_HAVE_FILTER_DEFLATE
 
-    /* Create the data space with unlimited dimensions. */
-    if ((space_id = H5Screate_simple( RANK, dims, maxdims ))<0) TEST_ERROR;
+    do_fillvalue = 0;
 
-    /* Modify dataset creation properties, i.e. enable chunking. */
-    if ((plist_id = H5Pcreate (H5P_DATASET_CREATE ))<0) TEST_ERROR;
-    if (H5Pset_chunk( plist_id, RANK, dims_chunk )<0) TEST_ERROR;
-    if (H5Pset_fill_value( plist_id, H5T_NATIVE_INT, &fillvalue )<0) TEST_ERROR;
+    if (test_rank1( do_compress, do_fillvalue, set_istore_k, H5D_FILL_TIME_ERROR ) < 0)
+    {
+        goto error;
+    }
+    if (test_rank2( do_compress, do_fillvalue, set_istore_k, H5D_FILL_TIME_ERROR ) < 0)
+    {
+        goto error;
+    }
+    if (test_rank3( do_compress, do_fillvalue, set_istore_k, H5D_FILL_TIME_ERROR ) < 0)
+    {
+        goto error;
+    }
+     
+    PASSED();
+#else
+    SKIPPED();
+#endif
+
+    TESTING("with non-default indexed storage B-tree");
+
+    do_fillvalue = 1;
+    set_istore_k = 1;
+
+    if (test_rank2( do_compress, do_fillvalue, set_istore_k, H5D_FILL_TIME_ALLOC ) < 0)
+    {
+        goto error;
+    }
+    
+
+    PASSED();
+   
+    
+    return 0;
+    
+    
+error:  
+    return -1;
+}
+
+
+/*-------------------------------------------------------------------------
+* test with different storage layouts
+*-------------------------------------------------------------------------
+*/
+static int do_layouts( void )
+{
+    
+    TESTING("storage layout use");
+ 
+    if (test_layouts( H5D_COMPACT ) < 0)
+    {
+        goto error;
+    } 
+    
+    if (test_layouts( H5D_CONTIGUOUS ) < 0)
+    {
+        goto error;
+    } 
+    
+    PASSED();
+    
+    return 0;
+    
+error:
+    return -1;
+}
+
+
+/*-------------------------------------------------------------------------
+ * test usage with a 2D rank
+ *-------------------------------------------------------------------------
+ */
+
+static int test_rank2( hbool_t do_compress, 
+                       hbool_t do_fill_value, 
+                       hbool_t set_istore_k,
+                       H5D_fill_time_t fill_time)
+{
+
+    hid_t   fid;          
+    hid_t   did;
+    hid_t   sid;
+    hid_t   dcpl;
+    hid_t   fcpl;
+    hsize_t dims_o[RANK2] = {DIM0,DIM1};    /* original dimensions */ 
+    hsize_t dims_s[RANK2] = {DIMS0,DIMS1};  /* shrinking dimensions */ 
+    hsize_t dims_e[RANK2] = {DIME0,DIME1};  /* extended dimensions */ 
+    hsize_t dims_c[RANK2] = {2,2};          /* chunk dimensions */ 
+    hsize_t dims_r[RANK2];                  /* read dimensions */ 
+    hsize_t maxdims[RANK2] = {H5S_UNLIMITED,H5S_UNLIMITED};
+    int     buf_o[DIM0][DIM1];
+    int     buf_s[DIMS0][DIMS1];
+    int     buf_e[DIME0][DIME1];
+    int     buf_r[DIM0][DIM1];
+    int     i, j;
+    int     fillvalue = 1; 
+    int     comp_value; 
+       
+    if ( do_fill_value )
+    {
+        comp_value = fillvalue;
+    }
+    else
+    {
+        comp_value = 0;
+    }
+
+        
+    for( i = 0; i < DIM0; i++ )
+    {
+        for( j = 0; j < DIM1; j++ )
+        {
+            buf_o[i][j] = 2;
+        }
+    }
+
+    /* create a file creation property list */
+    if ((fcpl = H5Pcreate(H5P_FILE_CREATE)) < 0) 
+    {
+        goto error;
+    }
+    
+    if  ( set_istore_k )
+    {
+        /* set non-default indexed storage B-tree internal 'K' value */
+        if (H5Pset_istore_k(fcpl,ISTORE_IK) < 0) 
+        {
+            goto error;
+        }
+        
+    }
+    /* create a new file */
+    if ((fid = H5Fcreate("set_extent1.h5", H5F_ACC_TRUNC, fcpl, H5P_DEFAULT)) < 0) 
+    {
+        goto error;
+    }
 
+    /* close property list */
+    if(H5Pclose(fcpl) < 0) 
+    {
+        goto error;
+    }
+    
+    /* create the data space with unlimited dimensions. */
+    if ((sid = H5Screate_simple(RANK2, dims_o, maxdims)) < 0) 
+    {
+        goto error;
+    }
+    
+    /* modify dataset creation properties, i.e. enable chunking. */
+    if ((dcpl = H5Pcreate (H5P_DATASET_CREATE)) < 0)
+    {
+        goto error;
+    }
+    if (H5Pset_chunk(dcpl, RANK2, dims_c) < 0)
+    {
+        goto error;
+    }
+    if ( do_fill_value )
+    {
+        if (H5Pset_fill_value(dcpl, H5T_NATIVE_INT, &fillvalue) < 0)
+        {
+            goto error;
+        }
 
+        if(H5Pset_fill_time(dcpl, fill_time) < 0) 
+        {
+            goto error;
+        }
+    }
+    else
+    {
+        
+        if(H5Pset_fill_time(dcpl, H5D_FILL_TIME_ALLOC) < 0) 
+        {
+            goto error;
+        }
+        
+    }
+    if (do_compress)
+    {
+        if(H5Pset_deflate(dcpl, 9) < 0) 
+        {
+            goto error;
+        }
+    }
+    
     /*-------------------------------------------------------------------------
-    * Create and write one dataset
+    * Procedure 1
+    * a.	Write an array AxB. These are the dimensions for creating the dataset
+    * b.	Define a greater array CxD where C > A and D > B
+    * c.	Read data back 
+    * d.	Verify if new dimensions are C and D
+    * e.	Verify if data from A to C and B to D is what it is to be expected
+    *
+    * original data is
+    *
+    *  2 2 2 2
+    *  2 2 2 2
+    *  2 2 2 2
+    *  2 2 2 2
+    *
     *-------------------------------------------------------------------------
     */
+    
+    /* create a dataset */
+    if ((did = H5Dcreate(fid , "dset1", H5T_NATIVE_INT, sid, dcpl)) < 0) 
+    {
+        goto error;
+    }
+    
+    /* write */
+    if (H5Dwrite(did , H5T_NATIVE_INT, sid, H5S_ALL, H5P_DEFAULT, buf_o) < 0) 
+    {
+        goto error;
+    }
+    
+    
+#if defined (H5_SET_EXTENT_DEBUG2)
+    printf("\n");
+    for (i = 0; i < (int)dims_o[0]; i++ )
+    {
+        for (j = 0; j < (int)dims_o[1]; j++ )
+        {
+            printf("%d ", buf_o[i][j]);
+        }
+        printf("\n");
+    }
+#endif  
+
 
-    /* Create a new dataset */
-    if ((dataset_id = H5Dcreate( file_id , "Dataset1", H5T_NATIVE_INT, space_id, plist_id ))<0) TEST_ERROR;
+    
+    if (H5Sclose(sid) < 0)
+    {
+        goto error;
+    }
+    
+    /*-------------------------------------------------------------------------
+    * set new dimensions for the array; expand it
+    * data is now, extended space was initialized with fill value or default value
+    *
+    *  2 2 2 2 1 1 1
+    *  2 2 2 2 1 1 1
+    *  2 2 2 2 1 1 1
+    *  2 2 2 2 1 1 1
+    *  1 1 1 1 1 1 1
+    *  1 1 1 1 1 1 1
+    *  1 1 1 1 1 1 1
+    *
+    *-------------------------------------------------------------------------
+    */
+    
+    /* set new dimensions for the array. */
+    if (H5Dset_extent(did , dims_e) < 0)
+    {
+        goto error;
+    }
+    
+    /* get the space */
+    if ((sid = H5Dget_space(did)) < 0)
+    {
+        goto error;
+    }
+    
+    /* get dimensions */
+    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0) 
+    {
+        goto error;
+    }
+    
+    if (H5Sclose(sid) < 0)
+    {
+        goto error;
+    }
+    
+    
+    /* check dimensions */
+    for( i = 0; i < RANK2; i++ )
+    {
+        if (dims_r[i] != dims_e[i]) 
+            goto error;
+    }
+    
+    /* read */
+    if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_e) < 0) 
+        goto error;
 
-    /* Write the data. */
-    if (H5Dwrite( dataset_id , H5T_NATIVE_INT, space_id, H5S_ALL, H5P_DEFAULT, data )<0) TEST_ERROR;
+   
+    
+#if defined (H5_SET_EXTENT_DEBUG2)
+    printf("\n");
+    for (i = 0; i < (int)dims_r[0]; i++ )
+    {
+        for (j = 0; j < (int)dims_r[1]; j++ )
+        {
+            printf("%d ", buf_e[i][j]);
+        }
+        printf("\n");
+    }
+#endif  
 
+    
+    
+    
+    /* compare the read array with the expanded array */
+    for (i = 0; i < (int)dims_r[0]; i++ )
+    {
+        for (j = 0; j < (int)dims_r[1]; j++ )
+        {
+            if ( i >= DIM0 || j >= DIM1 ) 
+            {
+                if(buf_e[i][j] != comp_value) 
+                {
+                    printf("buf_e[%d][%d] = %d\n", i, j, buf_e[i][j]);
+                    printf("value = %d\n", comp_value);
+                    goto error;
+                } 
+            } 
+            else 
+            {
+                if(buf_e[i][j] != buf_o[i][j]) 
+                    goto error;
+            }
+        }
+    }
+    
+    
+  
+    
     /*-------------------------------------------------------------------------
-    * Set new dimensions for the array; shrink it
+    *
+    * Procedure 2
+    * a.	Define a smaller array ExF where E < A and F < B
+    * b.	Read data back 
+    * c.	Verify if new dimensions are E and F
+    * d.	Verify if data up until E and F is what to be expected
+    *
+    * data is now
+    *
+    *  2 2
+    *  2 2
+    *
     *-------------------------------------------------------------------------
     */
+    
+    /* set new dimensions for the array. */
+    if (H5Dset_extent(did , dims_s) < 0)
+    {
+        goto error;
+    }
+    
+    /* get the space */
+    if ((sid = H5Dget_space(did)) < 0)
+    {
+        goto error;
+    }
+    
+    /* get dimensions */
+    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0) 
+    {
+        goto error;
+    }
+    
+    if (H5Sclose(sid) < 0)
+    {
+        goto error;
+    }
+    
+    /* check dimensions */
+    for( i = 0; i < RANK2; i++ )
+    {
+        if (dims_r[i] != dims_s[i]) 
+            goto error;
+    }
 
-    /* Set new dimensions for the array. */
-    if (H5Dset_extent( dataset_id , dims_new )<0) TEST_ERROR;
 
-    /* Get the space. */
-    if ((space_id = H5Dget_space( dataset_id ))<0) TEST_ERROR;
 
-    /* Get dimensions. */
-    if (H5Sget_simple_extent_dims( space_id, dims_out, NULL )<0) TEST_ERROR;
+    /* for this case we close and reopen file */
+    if ( set_istore_k )
+    {
+        
+        if (H5Dclose(did) < 0) 
+        {
+            goto error;
+        }
+        if (H5Fclose(fid) < 0)
+        {
+            goto error;
+        }
 
-    if ( dims_out[0] != dims_new[0] ) TEST_ERROR;
-    if ( dims_out[1] != dims_new[1] ) TEST_ERROR;
+        if ((fid = H5Fopen( "set_extent1.h5", H5F_ACC_RDWR, H5P_DEFAULT ))<0) 
+        {
+            goto error;
+        }
+        
+        if ((did = H5Dopen( fid , "dset1" ))<0) 
+        {
+            goto error;
+        }
+        
+        
+        
+    }
+    
+    
+    /*-------------------------------------------------------------------------
+    * read
+    *-------------------------------------------------------------------------
+    */
+    
+    /* read */
+    if (H5Dread( did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_s ) < 0) 
+    {
+        goto error;
+    }
+    
+#if defined (H5_SET_EXTENT_DEBUG2)
+    printf("\n");
+    for (i = 0; i < (int)dims_r[0]; i++ )
+    {
+        for (j = 0; j < (int)dims_r[1]; j++ )
+        {
+            printf("%d ", buf_s[i][j]);
+        }
+        printf("\n");
+    }
+#endif  
 
 
+    
+    
+    /* compare the read array with the shrinked array */
+    for( i = 0; i < (int)dims_r[0]; i++ )
+    {
+        for( j = 0; j < (int)dims_r[1]; j++ )
+        {
+            if (  buf_s[i][j] != buf_o[i][j] ) 
+            {
+                printf("buf_s[%d][%d] = %d\n", i, j, buf_s[i][j]);
+                printf("buf_o[%d][%d] = %d\n", i, j, buf_o[i][j]);
+                goto error;
+            } 
+        }
+    }
+    
+    
     /*-------------------------------------------------------------------------
-    * Read
+    * set new dimensions for the array; expand it back to original size
+    * data is now, extended space was initialized with fill value or default value
+    *
+    *  2 2 1 1
+    *  2 2 1 1
+    *  1 1 1 1
+    *  1 1 1 1
+    *
     *-------------------------------------------------------------------------
     */
+    
+    /* set new dimensions for the array */
+    if (H5Dset_extent(did, dims_o) < 0)
+    {
+        goto error;
+    }
+    
+    /* get the space */
+    if ((sid = H5Dget_space(did)) < 0) 
+    {
+        goto error;
+    }
+    
+    /* get dimensions. */
+    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0)
+    {
+        goto error;
+    }
+    
+    /* check dimensions */
+    for( i = 0; i < RANK2; i++ )
+    {
+        if (dims_r[i] != dims_o[i]) 
+            goto error;
+    }
+    
+    
+    /*-------------------------------------------------------------------------
+    * read
+    *-------------------------------------------------------------------------
+    */
+    
+    /* read */
+    if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_r) < 0) 
+        goto error;
+    
+#if defined (H5_SET_EXTENT_DEBUG2)
+    printf("\n");
+    for (i = 0; i < (int)dims_r[0]; i++ )
+    {
+        for (j = 0; j < (int)dims_r[1]; j++ )
+        {
+            printf("%d ", buf_r[i][j]);
+        }
+        printf("\n");
+    }
+#endif  
 
-    /* Read the new dataset. */
-    if (H5Dread( dataset_id, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf1 )<0) TEST_ERROR;
 
+    
+    /* compare the read array with the original array */
+    for (i = 0; i < (int)dims_r[0]; i++ )
+    {
+        for (j = 0; j < (int)dims_r[1]; j++ )
+        {
+            if (i >= DIMS0 || j >= DIMS1) 
+            {
+                if(buf_r[i][j] != comp_value) 
+                {
+                    printf("buf_r[%d][%d] = %d\n", i, j, buf_r[i][j]);
+                    printf("value = %d\n", comp_value);
+                    goto error;
+                } 
+            } 
+            else 
+            {
+                if(buf_r[i][j] != buf_o[i][j]) 
+                    goto error;
+            }
+        }
+    }
+    
+    
+    /*-------------------------------------------------------------------------
+    * close dataset and space
+    *-------------------------------------------------------------------------
+    */
+    
+    if (H5Dclose(did) < 0) 
+    {
+        goto error;
+    }
+    if (H5Sclose(sid) < 0)
+    {
+        goto error;
+    }
+    
+    
+   
+    
+    
+     /*-------------------------------------------------------------------------
+    * test a dataset with non initialized chunks
+    *-------------------------------------------------------------------------
+    */
+    
+      
+    if ((sid = H5Screate_simple(RANK2, dims_o, maxdims)) < 0) 
+    {
+        goto error;
+    }
+    if ((did = H5Dcreate(fid , "dset3", H5T_NATIVE_INT, sid, dcpl)) < 0) 
+    {
+        goto error;
+    }
+    /* set new dimensions for the array */
+    dims_o[ 0 ] = 0;
+    dims_o[ 1 ] = 0;
+    if (H5Dset_extent( did , dims_o ) < 0) 
+    {
+        goto error;
+    }
 
-    /* Compare the read array with the original array */
-    for( i = 0; i < (int)dims_out[0]; i++ )
-        for( j = 0; j < (int)dims_out[1]; j++ )
-            if (  buf1[i][j] != data[i][j] ) {
-                printf("buf1[%d][%d]=%d\n",i,j,buf1[i][j]);
-                printf("data[%d][%d]=%d\n",i,j,data[i][j]);
-                TEST_ERROR;
-            } /* end if */
 
 
+    if (H5Dclose(did) < 0) 
+    {
+        goto error;
+    }
+    if (H5Sclose(sid) < 0)
+    {
+        goto error;
+    }
+
+    
+    
+    
     /*-------------------------------------------------------------------------
-    * Set new dimensions for the array; expand it again
+    * close property list
     *-------------------------------------------------------------------------
     */
+    
+    
+    if (H5Pclose(dcpl) < 0) 
+    {
+        goto error;
+    }
 
-    /* Set new dimensions for the array. */
-    if (H5Dset_extent( dataset_id , dims )<0) TEST_ERROR;
+    if (H5Fclose( fid ) < 0)
+    {
+        goto error;
+    }
 
-    /* Get the space. */
-    if ((space_id = H5Dget_space( dataset_id ))<0) TEST_ERROR;
 
-    /* Get dimensions. */
-    if (H5Sget_simple_extent_dims( space_id, dims_out, NULL )<0) TEST_ERROR;
+    return 0;
+    
+    
+    
+error:
+    
+    H5E_BEGIN_TRY 
+    {
+        H5Dclose( did );
+        H5Sclose( sid );
+        H5Pclose( dcpl  );
+        H5Pclose( fcpl  );
+        H5Fclose( fid );
+    } H5E_END_TRY;
+    return -1;
+    
+}
+
+/*-------------------------------------------------------------------------
+ * test usage with a 1D rank
+ *-------------------------------------------------------------------------
+ */
+
+static int test_rank1( hbool_t do_compress, 
+                       hbool_t do_fill_value, 
+                       hbool_t set_istore_k,
+                       H5D_fill_time_t fill_time)
+{
 
-    if ( dims_out[0] != dims[0] ) TEST_ERROR;
+    hid_t   fid;          
+    hid_t   did;
+    hid_t   sid;
+    hid_t   dcpl;
+    hid_t   fcpl;
+    hsize_t dims_o[RANK1] = {DIM0};   /* original dimensions */ 
+    hsize_t dims_s[RANK1] = {DIMS0};  /* shrinking dimensions */ 
+    hsize_t dims_e[RANK1] = {DIME0};  /* extended dimensions */ 
+    hsize_t dims_c[RANK1] = {2};      /* chunk dimensions */ 
+    hsize_t dims_r[RANK1];            /* read dimensions */ 
+    hsize_t maxdims[RANK1] = {H5S_UNLIMITED};
+    int     buf_o[DIM0];
+    int     buf_s[DIMS0];
+    int     buf_e[DIME0];
+    int     buf_r[DIM0];
+    int     i;
+    int     fillvalue = 1; 
+    int     comp_value; 
+       
+    if ( do_fill_value )
+    {
+        comp_value = fillvalue;
+    }
+    else
+    {
+        comp_value = 0;
+    }
+
+        
+    for( i = 0; i < DIM0; i++ )
+    {
+        
+        buf_o[i] = 2;
+    }
+
+    /* create a file creation property list */
+    if ((fcpl = H5Pcreate(H5P_FILE_CREATE)) < 0) 
+    {
+        goto error;
+    }
+    
+    if  ( set_istore_k )
+    {
+        /* set non-default indexed storage B-tree internal 'K' value */
+        if (H5Pset_istore_k(fcpl,ISTORE_IK) < 0) 
+        {
+            goto error;
+        }
+        
+    }
+    /* create a new file */
+    if ((fid = H5Fcreate("set_extent1.h5", H5F_ACC_TRUNC, fcpl, H5P_DEFAULT)) < 0) 
+    {
+        goto error;
+    }
 
+    /* close property list */
+    if(H5Pclose(fcpl) < 0) 
+    {
+        goto error;
+    }
+    
+    /* create the data space with unlimited dimensions. */
+    if ((sid = H5Screate_simple(RANK1, dims_o, maxdims)) < 0) 
+    {
+        goto error;
+    }
+    
+    /* modify dataset creation properties, i.e. enable chunking. */
+    if ((dcpl = H5Pcreate (H5P_DATASET_CREATE)) < 0)
+    {
+        goto error;
+    }
+    if (H5Pset_chunk(dcpl, RANK1, dims_c) < 0)
+    {
+        goto error;
+    }
+    if ( do_fill_value )
+    {
+        if (H5Pset_fill_value(dcpl, H5T_NATIVE_INT, &fillvalue) < 0)
+        {
+            goto error;
+        }
 
+        if(H5Pset_fill_time(dcpl, fill_time) < 0) 
+        {
+            goto error;
+        }
+    }
+    else
+    {
+        
+        if(H5Pset_fill_time(dcpl, H5D_FILL_TIME_ALLOC) < 0) 
+        {
+            goto error;
+        }
+        
+    }
+    if (do_compress)
+    {
+        if(H5Pset_deflate(dcpl, 9) < 0) 
+        {
+            goto error;
+        }
+    }
+    
     /*-------------------------------------------------------------------------
-    * Read
+    * create, write dataset
     *-------------------------------------------------------------------------
     */
+    
+    /* create a dataset */
+    if ((did = H5Dcreate(fid , "dset1", H5T_NATIVE_INT, sid, dcpl)) < 0) 
+    {
+        goto error;
+    }
+    
+    /* write */
+    if (H5Dwrite(did , H5T_NATIVE_INT, sid, H5S_ALL, H5P_DEFAULT, buf_o) < 0) 
+    {
+        goto error;
+    }
+    
+    
+#if defined (H5_SET_EXTENT_DEBUG1)
+    printf("\n");
+    for (i = 0; i < (int)dims_o[0]; i++ )
+    {
+        
+        printf("%d ", buf_o[i]);
+        
+    }
+    printf("\n");
+#endif  
 
-    /* Read the new dataset. */
-    if (H5Dread( dataset_id, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf2 )<0) TEST_ERROR;
 
-    /* Compare the read array with the original array */
-    for( i = 0; i < (int)dims_out[0]; i++ ) {
-        for( j = 0; j < (int)dims_out[1]; j++ ) {
-            if ( i >= 70 || j >= 70 ) {
-                if (  buf2[i][j] != fillvalue ) TEST_ERROR;
-            }
-            else {
-                if (  buf2[i][j] != data[i][j] ) TEST_ERROR;
-            }
-        }
+    
+    if (H5Sclose(sid) < 0)
+    {
+        goto error;
+    }
+    
+    /*-------------------------------------------------------------------------
+    * set new dimensions for the array; expand it
+    *-------------------------------------------------------------------------
+    */
+    
+    /* set new dimensions for the array. */
+    if (H5Dset_extent(did , dims_e) < 0)
+    {
+        goto error;
     }
+    
+    /* get the space */
+    if ((sid = H5Dget_space(did)) < 0)
+    {
+        goto error;
+    }
+    
+    /* get dimensions */
+    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0) 
+    {
+        goto error;
+    }
+    
+    if (H5Sclose(sid) < 0)
+    {
+        goto error;
+    }
+    
+    
+    /* check dimensions */
+    for( i = 0; i < RANK1; i++ )
+    {
+        if (dims_r[i] != dims_e[i]) 
+            goto error;
+    }
+    
+    /* read */
+    if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_e) < 0) 
+        goto error;
 
+   
+    
+#if defined (H5_SET_EXTENT_DEBUG1)
+    printf("\n");
+    for (i = 0; i < (int)dims_r[0]; i++ )
+    {
+        
+        printf("%d ", buf_e[i]);
+        
+    }
+    printf("\n");
+#endif  
 
+    
+    
+    
+    /* compare the read array with the expanded array */
+    for (i = 0; i < (int)dims_r[0]; i++ )
+    {
+        
+        if ( i >= DIM0  ) 
+        {
+            if(buf_e[i] != comp_value) 
+            {
+                printf("buf_e[%d] = %d\n", i, buf_e[i]);
+                printf("value = %d\n", comp_value);
+                goto error;
+            } 
+        } 
+        else 
+        {
+            if(buf_e[i] != buf_o[i]) 
+                goto error;
+        }
+    }
+    
+    
+  
+    
     /*-------------------------------------------------------------------------
-    * Close/release resources
+    * shrink 
+    *
     *-------------------------------------------------------------------------
     */
+    
+    /* set new dimensions for the array. */
+    if (H5Dset_extent(did , dims_s) < 0)
+    {
+        goto error;
+    }
+    
+    /* get the space */
+    if ((sid = H5Dget_space(did)) < 0)
+    {
+        goto error;
+    }
+    
+    /* get dimensions */
+    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0) 
+    {
+        goto error;
+    }
+    
+    if (H5Sclose(sid) < 0)
+    {
+        goto error;
+    }
+    
+    /* check dimensions */
+    for( i = 0; i < RANK1; i++ )
+    {
+        if (dims_r[i] != dims_s[i]) 
+            goto error;
+    }
 
-    H5Dclose( dataset_id );
-    H5Sclose( space_id );
-    H5Pclose( plist_id  );
-
-    PASSED();
-    TESTING("extend dataset create without fill value");
 
-    /* Create the data space with unlimited dimensions. */
-    if ((space_id = H5Screate_simple( RANK, dims, maxdims ))<0) TEST_ERROR;
 
-    /* Modify dataset creation properties, i.e. enable chunking. */
-    if ((plist_id = H5Pcreate (H5P_DATASET_CREATE ))<0) TEST_ERROR;
-    if (H5Pset_chunk( plist_id, RANK, dims_chunk )<0) TEST_ERROR;
-    if (H5Pset_fill_time( plist_id, H5D_FILL_TIME_ALLOC)<0) TEST_ERROR;
+    /* for this case we close and reopen file */
+    if ( set_istore_k )
+    {
+        
+        if (H5Dclose(did) < 0) 
+        {
+            goto error;
+        }
+        if (H5Fclose(fid) < 0)
+        {
+            goto error;
+        }
 
+        if ((fid = H5Fopen( "set_extent1.h5", H5F_ACC_RDWR, H5P_DEFAULT ))<0) 
+        {
+            goto error;
+        }
+        
+        if ((did = H5Dopen( fid , "dset1" ))<0) 
+        {
+            goto error;
+        }
+        
+        
+        
+    }
+    
+    
     /*-------------------------------------------------------------------------
-    * Create and write one dataset
+    * read
     *-------------------------------------------------------------------------
     */
+    
+    /* read */
+    if (H5Dread( did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_s ) < 0) 
+    {
+        goto error;
+    }
+    
+#if defined (H5_SET_EXTENT_DEBUG1)
+    printf("\n");
+    for (i = 0; i < (int)dims_r[0]; i++ )
+    {
+        
+        printf("%d ", buf_s[i]);
+    }
+    printf("\n");
 
-    /* Create a new dataset */
-    if ((dataset_id = H5Dcreate( file_id , "Dataset2", H5T_NATIVE_INT, space_id, plist_id ))<0) TEST_ERROR;
+#endif  
 
-    /* Write the data. */
-    if (H5Dwrite( dataset_id , H5T_NATIVE_INT, space_id, H5S_ALL, H5P_DEFAULT, data )<0) TEST_ERROR;
 
+    
+    
+    /* compare the read array with the shrinked array */
+    for( i = 0; i < (int)dims_r[0]; i++ )
+    {
+        
+        if (  buf_s[i] != buf_o[i] ) 
+        {
+            printf("buf_s[%d] = %d\n", i, buf_s[i]);
+            printf("buf_o[%d] = %d\n", i, buf_o[i]);
+            goto error;
+        } 
+    }
+    
+    
     /*-------------------------------------------------------------------------
-    * Set new dimensions for the array; shrink it
+    * expand it back to original size
     *-------------------------------------------------------------------------
     */
+    
+    /* set new dimensions for the array */
+    if (H5Dset_extent(did, dims_o) < 0)
+    {
+        goto error;
+    }
+    
+    /* get the space */
+    if ((sid = H5Dget_space(did)) < 0) 
+    {
+        goto error;
+    }
+    
+    /* get dimensions. */
+    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0)
+    {
+        goto error;
+    }
+    
+    /* check dimensions */
+    for( i = 0; i < RANK1; i++ )
+    {
+        if (dims_r[i] != dims_o[i]) 
+            goto error;
+    }
+    
+       
+    /* read */
+    if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_r) < 0) 
+        goto error;
+    
+#if defined (H5_SET_EXTENT_DEBUG1)
+    printf("\n");
+    for (i = 0; i < (int)dims_r[0]; i++ )
+    {
+        
+        printf("%d ", buf_r[i]);
+        
+    }
+    printf("\n");
+#endif  
 
-    /* Set new dimensions for the array. */
-    if (H5Dset_extent( dataset_id , dims_new )<0) TEST_ERROR;
 
-    /* Get the space. */
-    if ((space_id = H5Dget_space( dataset_id ))<0) TEST_ERROR;
+    
+    /* compare the read array with the original array */
+    for (i = 0; i < (int)dims_r[0]; i++ )
+    {
+        
+        if (i >= DIMS0 ) 
+        {
+            if(buf_r[i] != comp_value) 
+            {
+                printf("buf_r[%d] = %d\n", i, buf_r[i] );
+                printf("value = %d\n", comp_value);
+                goto error;
+            } 
+        } 
+        else 
+        {
+            if(buf_r[i] != buf_o[i]) 
+                goto error;
+        }
+    }
+    
+    
+    /*-------------------------------------------------------------------------
+    * close dataset and space
+    *-------------------------------------------------------------------------
+    */
+    
+    if (H5Dclose(did) < 0) 
+    {
+        goto error;
+    }
+    if (H5Sclose(sid) < 0)
+    {
+        goto error;
+    }
+    
+    
+   
+    
+    
+     /*-------------------------------------------------------------------------
+    * test a dataset with non initialized chunks
+    *-------------------------------------------------------------------------
+    */
+    
+      
+    if ((sid = H5Screate_simple(RANK1, dims_o, maxdims)) < 0) 
+    {
+        goto error;
+    }
+    if ((did = H5Dcreate(fid , "dset3", H5T_NATIVE_INT, sid, dcpl)) < 0) 
+    {
+        goto error;
+    }
+    /* set new dimensions for the array */
+    dims_o[ 0 ] = 0;
+    if (H5Dset_extent( did , dims_o ) < 0) 
+    {
+        goto error;
+    }
 
-    /* Get dimensions. */
-    if (H5Sget_simple_extent_dims( space_id, dims_out, NULL )<0) TEST_ERROR;
 
-    if ( dims_out[0] != dims_new[0] ) TEST_ERROR;
 
+    if (H5Dclose(did) < 0) 
+    {
+        goto error;
+    }
+    if (H5Sclose(sid) < 0)
+    {
+        goto error;
+    }
 
+    
+    
+    
     /*-------------------------------------------------------------------------
-    * Read
+    * close property list
     *-------------------------------------------------------------------------
     */
+    
+    
+    if (H5Pclose(dcpl) < 0) 
+    {
+        goto error;
+    }
 
-    /* Read the new dataset. */
-    if (H5Dread( dataset_id, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf1 )<0) TEST_ERROR;
+    if (H5Fclose( fid ) < 0)
+    {
+        goto error;
+    }
 
 
-    /* Compare the read array with the original array */
-    for( i = 0; i < (int)dims_out[0]; i++ )
-        for( j = 0; j < (int)dims_out[1]; j++ )
-            if (  buf1[i][j] != data[i][j] ) TEST_ERROR;
+    return 0;
+    
+    
+    
+error:
+    
+    H5E_BEGIN_TRY 
+    {
+        H5Dclose( did );
+        H5Sclose( sid );
+        H5Pclose( dcpl  );
+        H5Pclose( fcpl  );
+        H5Fclose( fid );
+    } H5E_END_TRY;
+    return -1;
+    
+}
 
 
-    /*-------------------------------------------------------------------------
-    * Set new dimensions for the array; expand it again
-    *-------------------------------------------------------------------------
-    */
+/*-------------------------------------------------------------------------
+ * test usage with a 3D rank
+ *-------------------------------------------------------------------------
+ */
 
-    /* Set new dimensions for the array. */
-    if (H5Dset_extent( dataset_id , dims )<0) TEST_ERROR;
+static int test_rank3( hbool_t do_compress, 
+                       hbool_t do_fill_value, 
+                       hbool_t set_istore_k,
+                       H5D_fill_time_t fill_time)
+{
 
-    /* Get the space. */
-    if ((space_id = H5Dget_space( dataset_id ))<0) TEST_ERROR;
+    hid_t   fid;          
+    hid_t   did;
+    hid_t   sid;
+    hid_t   dcpl;
+    hid_t   fcpl;
+    hsize_t dims_o[RANK3] = {DIM0,DIM1,DIM2};    /* original dimensions */ 
+    hsize_t dims_s[RANK3] = {DIMS0,DIMS1,DIMS2}; /* shrinking dimensions */ 
+    hsize_t dims_e[RANK3] = {DIME0,DIME1,DIME2}; /* extended dimensions */ 
+    hsize_t dims_c[RANK3] = {2,2,2};             /* chunk dimensions */ 
+    hsize_t dims_r[RANK3];                       /* read dimensions */ 
+    hsize_t maxdims[RANK3] = {H5S_UNLIMITED,H5S_UNLIMITED,H5S_UNLIMITED};
+    int     buf_o[DIM0][DIM1][DIM2];
+    int     buf_s[DIMS0][DIMS1][DIMS2];
+    int     buf_e[DIME0][DIME1][DIME2];
+    int     buf_r[DIM0][DIM1][DIM2];
+    int     i, j, k;
+    int     fillvalue = 1; 
+    int     comp_value; 
+       
+    if ( do_fill_value )
+    {
+        comp_value = fillvalue;
+    }
+    else
+    {
+        comp_value = 0;
+    }
 
-    /* Get dimensions. */
-    if (H5Sget_simple_extent_dims( space_id, dims_out, NULL )<0) TEST_ERROR;
+        
+    for( i = 0; i < DIM0; i++ )
+    {
+        for( j = 0; j < DIM1; j++ )
+        {
+            for( k = 0; k < DIM2; k++ )
+            {
+                buf_o[i][j][k] = 2;
+            }
+        }
+    }
 
-    if ( dims_out[0] != dims[0] ) TEST_ERROR;
+    /* create a file creation property list */
+    if ((fcpl = H5Pcreate(H5P_FILE_CREATE)) < 0) 
+    {
+        goto error;
+    }
+    
+    if  ( set_istore_k )
+    {
+        /* set non-default indexed storage B-tree internal 'K' value */
+        if (H5Pset_istore_k(fcpl,ISTORE_IK) < 0) 
+        {
+            goto error;
+        }
+        
+    }
+    /* create a new file */
+    if ((fid = H5Fcreate("set_extent1.h5", H5F_ACC_TRUNC, fcpl, H5P_DEFAULT)) < 0) 
+    {
+        goto error;
+    }
 
+    /* close property list */
+    if(H5Pclose(fcpl) < 0) 
+    {
+        goto error;
+    }
+    
+    /* create the data space with unlimited dimensions. */
+    if ((sid = H5Screate_simple(RANK3, dims_o, maxdims)) < 0) 
+    {
+        goto error;
+    }
+    
+    /* modify dataset creation properties, i.e. enable chunking. */
+    if ((dcpl = H5Pcreate (H5P_DATASET_CREATE)) < 0)
+    {
+        goto error;
+    }
+    if (H5Pset_chunk(dcpl, RANK3, dims_c) < 0)
+    {
+        goto error;
+    }
+    if ( do_fill_value )
+    {
+        if (H5Pset_fill_value(dcpl, H5T_NATIVE_INT, &fillvalue) < 0)
+        {
+            goto error;
+        }
 
+        if(H5Pset_fill_time(dcpl, fill_time) < 0) 
+        {
+            goto error;
+        }
+    }
+    else
+    {
+        
+        if(H5Pset_fill_time(dcpl, H5D_FILL_TIME_ALLOC) < 0) 
+        {
+            goto error;
+        }
+        
+    }
+    if (do_compress)
+    {
+        if(H5Pset_deflate(dcpl, 9) < 0) 
+        {
+            goto error;
+        }
+    }
+    
     /*-------------------------------------------------------------------------
-    * Read
+    * create, write array
     *-------------------------------------------------------------------------
     */
-
-    /* Read the new dataset. */
-    if (H5Dread( dataset_id, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf2 )<0) TEST_ERROR;
-
-    /* Compare the read array with the original array */
-    for( i = 0; i < (int)dims_out[0]; i++ ) {
-        for( j = 0; j < (int)dims_out[1]; j++ ) {
-            if ( i >= 70 || j >= 70 ) {
-                if (  buf2[i][j] != 0 ) TEST_ERROR;
-            }
-            else {
-                if (  buf2[i][j] != data[i][j] ) TEST_ERROR;
+    
+    /* create a dataset */
+    if ((did = H5Dcreate(fid , "dset1", H5T_NATIVE_INT, sid, dcpl)) < 0) 
+    {
+        goto error;
+    }
+    
+    /* write */
+    if (H5Dwrite(did , H5T_NATIVE_INT, sid, H5S_ALL, H5P_DEFAULT, buf_o) < 0) 
+    {
+        goto error;
+    }
+    
+    
+#if defined (H5_SET_EXTENT_DEBUG3)
+    printf("\n");
+    for (i = 0; i < (int)dims_o[0]; i++ )
+    {
+        for (j = 0; j < (int)dims_o[1]; j++ )
+        {
+            for( k = 0; k < (int)dims_o[2]; k++ )
+            {
+                printf("%d ", buf_o[i][j][k]);
             }
+            printf("[%d] ", j);
         }
+        printf("\n");
+        
     }
+    printf("\n");
+#endif  
 
 
+    
+    if (H5Sclose(sid) < 0)
+    {
+        goto error;
+    }
+    
     /*-------------------------------------------------------------------------
-    * Close/release resources
+    * set new dimensions for the array; expand it
+    *
     *-------------------------------------------------------------------------
     */
+    
+    /* set new dimensions for the array. */
+    if (H5Dset_extent(did , dims_e) < 0)
+    {
+        goto error;
+    }
+    
+    /* get the space */
+    if ((sid = H5Dget_space(did)) < 0)
+    {
+        goto error;
+    }
+    
+    /* get dimensions */
+    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0) 
+    {
+        goto error;
+    }
+    
+    if (H5Sclose(sid) < 0)
+    {
+        goto error;
+    }
+    
+    
+    /* check dimensions */
+    for( i = 0; i < RANK3; i++ )
+    {
+        if (dims_r[i] != dims_e[i]) 
+            goto error;
+    }
+    
+    /* read */
+    if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_e) < 0) 
+        goto error;
 
-    H5Dclose( dataset_id );
-    H5Sclose( space_id );
-    H5Pclose( plist_id  );
+   
+    
+#if defined (H5_SET_EXTENT_DEBUG3)
+    printf("\n");
+    for (i = 0; i < (int)dims_r[0]; i++ )
+    {
+        for (j = 0; j < (int)dims_r[1]; j++ )
+        {
+            for( k = 0; k < (int)dims_r[2]; k++ )
+            {
+                printf("%d ", buf_e[i][j][k]);
+            }
+            printf("[%d] ", j);
+        }
+        printf("\n");
+        
+    }
+    printf("\n");
+#endif  
 
-    H5Fclose( file_id );
+    
+    
+    
+    /* compare the read array with the expanded array */
+    for (i = 0; i < (int)dims_r[0]; i++ )
+    {
+        for (j = 0; j < (int)dims_r[1]; j++ )
+        {
+            for( k = 0; k < (int)dims_r[2]; k++ )
+            {
+                if ( i >= DIM0 || j >= DIM1 || k >= DIM2 ) 
+                {
+                    if(buf_e[i][j][k] != comp_value) 
+                    {
+                        printf("buf_e[%d][%d][%d] = %d\n", i, j, k, buf_e[i][j][k] );
+                        printf("value = %d\n", comp_value);
+                        goto error;
+                    } 
+                } 
+                else 
+                {
+                    if(buf_e[i][j][k] != buf_o[i][j][k] ) 
+                        goto error;
+                }
+            }
+        }
+    }
+    
+    
+  
+    
+    /*-------------------------------------------------------------------------
+    * shrink
+    *-------------------------------------------------------------------------
+    */
+    
+    /* set new dimensions for the array. */
+    if (H5Dset_extent(did , dims_s) < 0)
+    {
+        goto error;
+    }
+    
+    /* get the space */
+    if ((sid = H5Dget_space(did)) < 0)
+    {
+        goto error;
+    }
+    
+    /* get dimensions */
+    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0) 
+    {
+        goto error;
+    }
+    
+    if (H5Sclose(sid) < 0)
+    {
+        goto error;
+    }
+    
+    /* check dimensions */
+    for( i = 0; i < RANK3; i++ )
+    {
+        if (dims_r[i] != dims_s[i]) 
+            goto error;
+    }
 
-    PASSED();
 
 
+    /* for this case we close and reopen file */
+    if ( set_istore_k )
+    {
+        
+        if (H5Dclose(did) < 0) 
+        {
+            goto error;
+        }
+        if (H5Fclose(fid) < 0)
+        {
+            goto error;
+        }
 
+        if ((fid = H5Fopen( "set_extent1.h5", H5F_ACC_RDWR, H5P_DEFAULT ))<0) 
+        {
+            goto error;
+        }
+        
+        if ((did = H5Dopen( fid , "dset1" ))<0) 
+        {
+            goto error;
+        }
+        
+        
+        
+    }
+    
+    
     /*-------------------------------------------------------------------------
-    * Test H5Dset_extent with chunks written to file
+    * read
     *-------------------------------------------------------------------------
     */
+    
+    /* read */
+    if (H5Dread( did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_s ) < 0) 
+    {
+        goto error;
+    }
+    
+#if defined (H5_SET_EXTENT_DEBUG3)
+    printf("\n");
+    for (i = 0; i < (int)dims_r[0]; i++ )
+    {
+        for (j = 0; j < (int)dims_r[1]; j++ )
+        {
+            for( k = 0; k < (int)dims_r[2]; k++ )
+            {
+                printf("%d ", buf_s[i][j][k]);
+            }
+             printf("[%d] ", j);
+        }
+        printf("\n");
+        
+    }
+    printf("\n");
+#endif  
 
-    /* Create a file creation property list */
-    if((fcpl = H5Pcreate(H5P_FILE_CREATE))<0) TEST_ERROR;
-
-    /* Set non-default indexed storage B-tree internal 'K' value */
-    if(H5Pset_istore_k(fcpl,ISTORE_IK)<0) TEST_ERROR;
 
-    /* Create a new file using properties. */
-    if ((file_id = H5Fcreate( "set_extent_read.h5", H5F_ACC_TRUNC, fcpl, H5P_DEFAULT ))<0) TEST_ERROR;
+    
+    
+    /* compare the read array with the shrinked array */
+    for( i = 0; i < (int)dims_r[0]; i++ )
+    {
+        for( j = 0; j < (int)dims_r[1]; j++ )
+        {
+            for( k = 0; k < (int)dims_r[2]; k++ )
+            {
+                if (  buf_s[i][j][k] != buf_o[i][j][k] ) 
+                {
+                    printf("buf_s[%d][%d][%d] = %d\n", i, j, k, buf_s[i][j][k] );
+                    printf("buf_o[%d][%d][%d] = %d\n", i, j, k, buf_o[i][j][k] );
+                    goto error;
+                } 
+            }
+        }
+    }
+    
+    
+    /*-------------------------------------------------------------------------
+    * set new dimensions for the array; expand it back to original size
+    *-------------------------------------------------------------------------
+    */
+    
+    /* set new dimensions for the array */
+    if (H5Dset_extent(did, dims_o) < 0)
+    {
+        goto error;
+    }
+    
+    /* get the space */
+    if ((sid = H5Dget_space(did)) < 0) 
+    {
+        goto error;
+    }
+    
+    /* get dimensions. */
+    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0)
+    {
+        goto error;
+    }
+    
+    /* check dimensions */
+    for( i = 0; i < RANK3; i++ )
+    {
+        if (dims_r[i] != dims_o[i]) 
+            goto error;
+    }
+    
+    /* read */
+    if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_r) < 0) 
+        goto error;
+    
+#if defined (H5_SET_EXTENT_DEBUG3)
+    printf("\n");
+    for (i = 0; i < (int)dims_r[0]; i++ )
+    {
+        for (j = 0; j < (int)dims_r[1]; j++ )
+        {
+            for( k = 0; k < (int)dims_r[2]; k++ )
+            {
+                
+                printf("%d ", buf_r[i][j][k]);
+            }
+             printf("[%d] ", j);
+        }
+        printf("\n");
+        
+    }
+    printf("\n");
+#endif  
 
-    /* Close property list */
-    if(H5Pclose(fcpl)<0) TEST_ERROR;
 
-    TESTING("extend dataset read with fill value");
+    
+    /* compare the read array with the original array */
+    for (i = 0; i < (int)dims_r[0]; i++ )
+    {
+        for (j = 0; j < (int)dims_r[1]; j++ )
+        {
+            for( k = 0; k < (int)dims_r[2]; k++ )
+            {
+                if (i >= DIMS0 || j >= DIMS1 || k >= DIMS2 ) 
+                {
+                    if( buf_r[i][j][k] != comp_value ) 
+                    {
+                        printf("buf_r[%d][%d][%d] = %d\n", i, j, k, buf_r[i][j][k] );
+                        printf("value = %d\n", comp_value);
+                        goto error;
+                    } 
+                } 
+                else 
+                {
+                    if(buf_r[i][j][k] != buf_o[i][j][k]) 
+                        goto error;
+                }
+            }
+        }
+    }
+    
+    
+    /*-------------------------------------------------------------------------
+    * close dataset and space
+    *-------------------------------------------------------------------------
+    */
+    
+    if (H5Dclose(did) < 0) 
+    {
+        goto error;
+    }
+    if (H5Sclose(sid) < 0)
+    {
+        goto error;
+    }
+    
+    
+   
+    
+    
+     /*-------------------------------------------------------------------------
+    * test a dataset with non initialized chunks
+    *-------------------------------------------------------------------------
+    */
+    
+      
+    if ((sid = H5Screate_simple(RANK3, dims_o, maxdims)) < 0) 
+    {
+        goto error;
+    }
+    if ((did = H5Dcreate(fid , "dset3", H5T_NATIVE_INT, sid, dcpl )) < 0) 
+    {
+        goto error;
+    }
+    /* set new dimensions for the array */
+    dims_o[ 0 ] = 0;
+    dims_o[ 1 ] = 0;
+    dims_o[ 2 ] = 0;
+    if (H5Dset_extent( did , dims_o ) < 0) 
+    {
+        goto error;
+    }
 
-    /* Create the data space with unlimited dimensions. */
-    if ((space_id = H5Screate_simple( RANK, dims, maxdims ))<0) TEST_ERROR;
 
-    /* Modify dataset creation properties, i.e. enable chunking. */
-    if ((plist_id = H5Pcreate (H5P_DATASET_CREATE ))<0) TEST_ERROR;
-    if (H5Pset_chunk( plist_id, RANK, dims_chunk )<0) TEST_ERROR;
-    if (H5Pset_fill_value( plist_id, H5T_NATIVE_INT, &fillvalue )<0) TEST_ERROR;
 
-    /* Create a new dataset within the file using cparms creation properties. */
-    if ((dataset_id = H5Dcreate( file_id , "Dataset1", H5T_NATIVE_INT, space_id, plist_id ))<0) TEST_ERROR;
+    if (H5Dclose(did) < 0) 
+    {
+        goto error;
+    }
+    if (H5Sclose(sid) < 0)
+    {
+        goto error;
+    }
 
-    /* Write the data. */
-    if (H5Dwrite( dataset_id , H5T_NATIVE_INT, space_id, H5S_ALL, H5P_DEFAULT, data )<0) TEST_ERROR;
+    
+    
+    
+    /*-------------------------------------------------------------------------
+    * close property list
+    *-------------------------------------------------------------------------
+    */
+    
+    
+    if (H5Pclose(dcpl) < 0) 
+    {
+        goto error;
+    }
 
-    /* Close/release resources. */
-    H5Dclose( dataset_id );
-    H5Sclose( space_id );
-    H5Pclose( plist_id  );
-    H5Fclose( file_id );
+    if (H5Fclose( fid ) < 0)
+    {
+        goto error;
+    }
 
 
-    /* Open the file */
-    if ((file_id = H5Fopen( "set_extent_read.h5", H5F_ACC_RDWR, H5P_DEFAULT ))<0) TEST_ERROR;
+    return 0;
+    
+    
+    
+error:
+    
+    H5E_BEGIN_TRY 
+    {
+        H5Dclose( did );
+        H5Sclose( sid );
+        H5Pclose( dcpl  );
+        H5Pclose( fcpl  );
+        H5Fclose( fid );
+    } H5E_END_TRY;
+    return -1;
+    
+}
 
-    /* Open the dataset */
-    if ((dataset_id = H5Dopen( file_id , "Dataset1" ))<0) TEST_ERROR;
 
-    /* Set new dimensions for the array. */
-    if (H5Dset_extent( dataset_id, dims_new )<0) TEST_ERROR;
+/*-------------------------------------------------------------------------
+ * test usage with external storage
+ *-------------------------------------------------------------------------
+ */
+static int test_external()
+{
 
-    /* Get the space. */
-    if ((space_id = H5Dget_space( dataset_id ))<0) TEST_ERROR;
+    hid_t   fid;          
+    hid_t   did;
+    hid_t   sid;
+    hid_t   dcpl;
+    hsize_t dims_o[RANK2] = {DIM0,DIM1};    /* original dimensions */ 
+    hsize_t dims_s[RANK2] = {DIMS0,DIMS1};  /* shrinking dimensions */ 
+    hsize_t dims_e[RANK2] = {DIME0,DIM1};   /* extended dimensions, dimension 1 is the original */ 
+    hsize_t dims_c[RANK2] = {2,2};          /* chunk dimensions */ 
+    hsize_t dims_r[RANK2];                  /* read dimensions */ 
+    hsize_t maxdims[RANK2] = {DIME0,DIM1};  /* only the first dimension can be extendible */
+    int     buf_o[DIM0][DIM1];              /* original buffer, for writing */  
+    int     buf_s[DIMS0][DIMS1];            /* shrinked buffer, for reading */  
+    int     buf_e[DIME0][DIM1];             /* extended buffer, for writing, dimension 1 is the original */    
+    int     buf_ro[DIM0][DIM1];             /* original buffer for reading */    
+    int     i, j;
+    int     comp_value = 0;
+   
+
+    hsize_t size;        /* number of bytes reserved in the file for the data */
+    hsize_t max_size[2];	
+    
+    max_size[0] = dims_e[0];
+    max_size[1] = dims_e[1];
+    size = max_size[0] * max_size[1] * sizeof(int) / 2;
+    
+      
+    for( i = 0; i < DIM0; i++ )
+    {
+        for( j = 0; j < DIM1; j++ )
+        {
+            buf_o[i][j] = 2;
+        }
+    }
 
-    /* Get dimensions. */
-    if (H5Sget_simple_extent_dims( space_id, dims_out, NULL )<0) TEST_ERROR;
+    TESTING("external file use");
+  
+    /* create a new file */
+    if ((fid = H5Fcreate("set_extent2.h5", H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0) 
+    {
+        goto error;
+    }
+  
+    /* modify dataset creation properties */
+    if ((dcpl = H5Pcreate (H5P_DATASET_CREATE)) < 0)
+    {
+        goto error;
+    }
+    
+    if(H5Pset_external(dcpl, "ext1.bin", (off_t)0, size) < 0)
+    {
+        goto error;
+    }
 
-    if ( dims_out[0] != dims_new[0] ) TEST_ERROR;
+    if(H5Pset_external(dcpl, "ext2.bin", (off_t)0, size) < 0)
+    {
+        goto error;
+    }
+    
+    {
+        
+        char	name[256];		/*external file name		*/
+        off_t	file_offset;    /*external file offset		*/
+        hsize_t	file_size;		/*sizeof external file segment	*/
+        
+        if(H5Pget_external(dcpl, 0, sizeof(name), name, &file_offset,
+            &file_size) < 0) goto error;
+        
+    }
 
-    /* Read the new dataset. */
-    if (H5Dread( dataset_id, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf1 )<0) TEST_ERROR;
 
-    /* Compare the read array with the original array */
-    for( i = 0; i < (int)dims_out[0]; i++ )
-        for( j = 0; j < (int)dims_out[1]; j++ )
-            if (  buf1[i][j] != data[i][j] )    TEST_ERROR;
 
     /*-------------------------------------------------------------------------
-    * Set new dimensions for the array; expand it again
+    * Write an array AxB. These are the dimensions for creating the dataset
+    *
+    * original data is
+    *
+    *  2 2 2 2
+    *  2 2 2 2
+    *  2 2 2 2
+    *  2 2 2 2
+    *
     *-------------------------------------------------------------------------
     */
 
-    /* Set new dimensions for the array. */
-    if (H5Dset_extent( dataset_id , dims )<0) TEST_ERROR;
 
-    /* Get the space. */
-    if ((space_id = H5Dget_space( dataset_id ))<0) TEST_ERROR;
-
-    /* Get dimensions. */
-    if (H5Sget_simple_extent_dims( space_id, dims_out, NULL )<0) TEST_ERROR;
+    /* create the data space with unlimited dimensions. */
+    if ((sid = H5Screate_simple(RANK2, dims_o, maxdims)) < 0) 
+    {
+        goto error;
+    }
+    if ((did = H5Dcreate(fid , "dset1", H5T_NATIVE_INT, sid, dcpl )) < 0) 
+    {
+        goto error;
+    }
+    if (H5Dwrite(did , H5T_NATIVE_INT, sid, H5S_ALL, H5P_DEFAULT, buf_o) < 0) 
+    {
+        goto error;
+    }
+    if (H5Sclose(sid) < 0)
+    {
+        goto error;
+    }
 
-    if ( dims_out[0] != dims[0] ) TEST_ERROR;
 
-    /* Read the new dataset. */
-    if (H5Dread( dataset_id, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf2 )<0) TEST_ERROR;
+    /*-------------------------------------------------------------------------
+    * read
+    *-------------------------------------------------------------------------
+    */
 
-    /* Compare the read array with the original array */
-    for( i = 0; i < (int)dims_out[0]; i++ ) {
-        for( j = 0; j < (int)dims_out[1]; j++ ) {
-            if ( i >= 70 || j >= 70 ) {
-                if (  buf2[i][j] != fillvalue ) TEST_ERROR;
-            }
-            else {
-                if (  buf2[i][j] != data[i][j] ) TEST_ERROR;
-            }
+     /* read */
+    if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_ro) < 0) 
+        goto error;
+    
+#if defined (H5_SET_EXTENT_DEBUG5)
+    printf("\n");
+    for (i = 0; i < (int)dims_o[0]; i++ )
+    {
+        for (j = 0; j < (int)dims_o[1]; j++ )
+        {
+            printf("%d ", buf_ro[i][j]);
         }
+        printf("\n");
     }
+#endif  
 
 
+    
     /*-------------------------------------------------------------------------
-    * Close/release resources
+    * expand
     *-------------------------------------------------------------------------
     */
 
-    H5Dclose( dataset_id );
-    H5Sclose( space_id );
+     /*-------------------------------------------------------------------------
+    * set new dimensions for the array; expand it
+    * data is now, extended space was initialized with default value
+    *
+    *  2 2 2 2 
+    *  2 2 2 2 
+    *  2 2 2 2 
+    *  2 2 2 2 
+    *  0 0 0 0 
+    *  0 0 0 0 
+    *  0 0 0 0 
+    *
+    *-------------------------------------------------------------------------
+    */
 
-    PASSED();
+    /* set new dimensions for the array. */
+    if (H5Dset_extent(did , dims_e) < 0)
+    {
+        goto error;
+    }
 
+     /* get the space */
+    if ((sid = H5Dget_space(did)) < 0)
+    {
+        goto error;
+    }
+    
+    /* get dimensions */
+    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0) 
+    {
+        goto error;
+    }
+    
+    if (H5Sclose(sid) < 0)
+    {
+        goto error;
+    }
+    
+    
+    /* check dimensions */
+    for( i = 0; i < RANK2; i++ )
+    {
+        if (dims_r[i] != dims_e[i]) 
+            goto error;
+    }
+    
+    /* read */
+    if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_e) < 0) 
+        goto error;
+
+   
+    
+#if defined (H5_SET_EXTENT_DEBUG5)
+    printf("\n");
+    for (i = 0; i < (int)dims_r[0]; i++ )
+    {
+        for (j = 0; j < (int)dims_r[1]; j++ )
+        {
+            printf("%d ", buf_e[i][j]);
+        }
+        printf("\n");
+    }
+#endif  
 
-    TESTING("extend dataset read without fill value");
+    
+    
+    
+    /* compare the read array with the expanded array */
+    for (i = 0; i < (int)dims_r[0]; i++ )
+    {
+        for (j = 0; j < (int)dims_r[1]; j++ )
+        {
+            if ( i >= DIM0 || j >= DIM1 ) 
+            {
+                if(buf_e[i][j] != comp_value) 
+                {
+                    printf("buf_e[%d][%d] = %d\n", i, j, buf_e[i][j]);
+                    printf("value = %d\n", comp_value);
+                    goto error;
+                } 
+            } 
+            else 
+            {
+                if(buf_e[i][j] != buf_o[i][j]) 
+                    goto error;
+            }
+        }
+    }
+    
 
-    /* Create the data space with unlimited dimensions. */
-    if ((space_id = H5Screate_simple( RANK, dims, maxdims ))<0) TEST_ERROR;
 
-    /* Modify dataset creation properties, i.e. enable chunking. */
-    if ((plist_id = H5Pcreate (H5P_DATASET_CREATE ))<0) TEST_ERROR;
-    if (H5Pset_chunk( plist_id, RANK, dims_chunk )<0) TEST_ERROR;
-    if (H5Pset_fill_time( plist_id, H5D_FILL_TIME_ALLOC)<0) TEST_ERROR;
+     /*-------------------------------------------------------------------------
+    * shrink
+    *
+    * data is now
+    *
+    *  2 2
+    *  2 2
+    *
+    *-------------------------------------------------------------------------
+    */
+    
+    /* set new dimensions for the array. */
+    if (H5Dset_extent(did , dims_s) < 0)
+    {
+        goto error;
+    }
+    
+    /* get the space */
+    if ((sid = H5Dget_space(did)) < 0)
+    {
+        goto error;
+    }
+    
+    /* get dimensions */
+    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0) 
+    {
+        goto error;
+    }
+    
+    if (H5Sclose(sid) < 0)
+    {
+        goto error;
+    }
+    
+    /* check dimensions */
+    for( i = 0; i < RANK2; i++ )
+    {
+        if (dims_r[i] != dims_s[i]) 
+            goto error;
+    }
 
-    /* Create a new dataset within the file using cparms creation properties. */
-    if ((dataset_id = H5Dcreate( file_id , "Dataset2", H5T_NATIVE_INT, space_id, plist_id ))<0) TEST_ERROR;
 
-    /* Write the data. */
-    if (H5Dwrite( dataset_id , H5T_NATIVE_INT, space_id, H5S_ALL, H5P_DEFAULT, data )<0) TEST_ERROR;
+    
+    
+    /*-------------------------------------------------------------------------
+    * read
+    *-------------------------------------------------------------------------
+    */
+    
+    /* read */
+    if (H5Dread( did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_s ) < 0) 
+    {
+        goto error;
+    }
+    
+#if defined (H5_SET_EXTENT_DEBUG5)
+    printf("\n");
+    for (i = 0; i < (int)dims_r[0]; i++ )
+    {
+        for (j = 0; j < (int)dims_r[1]; j++ )
+        {
+            printf("%d ", buf_s[i][j]);
+        }
+        printf("\n");
+    }
+#endif  
 
-    /* Close/release resources. */
-    H5Dclose( dataset_id );
-    H5Sclose( space_id );
-    H5Pclose( plist_id  );
-    H5Fclose( file_id );
 
+    
+    
+    /* compare the read array with the shrinked array */
+    for( i = 0; i < (int)dims_r[0]; i++ )
+    {
+        for( j = 0; j < (int)dims_r[1]; j++ )
+        {
+            if (  buf_s[i][j] != buf_o[i][j] ) 
+            {
+                printf("buf_s[%d][%d] = %d\n", i, j, buf_s[i][j]);
+                printf("buf_o[%d][%d] = %d\n", i, j, buf_o[i][j]);
+                goto error;
+            } 
+        }
+    }
 
-    /* Open the file */
-    if ((file_id = H5Fopen( "set_extent_read.h5", H5F_ACC_RDWR, H5P_DEFAULT ))<0) TEST_ERROR;
 
-    /* Open the dataset */
-    if ((dataset_id = H5Dopen( file_id , "Dataset2" ))<0) TEST_ERROR;
+    /*-------------------------------------------------------------------------
+    * negative test
+    * try to extend dimension above maximum
+    *-------------------------------------------------------------------------
+    */
 
-    /* Set new dimensions for the array. */
-    if (H5Dset_extent( dataset_id, dims_new )<0) TEST_ERROR;
 
-    /* Get the space. */
-    if ((space_id = H5Dget_space( dataset_id ))<0) TEST_ERROR;
+    dims_e[1] = DIME1;
 
-    /* Get dimensions. */
-    if (H5Sget_simple_extent_dims( space_id, dims_out, NULL )<0) TEST_ERROR;
 
-    if ( dims_out[0] != dims_new[0] ) TEST_ERROR;
+    H5E_BEGIN_TRY 
+    {
+        
+        
+        /* set new dimensions for the array. */
+        if (H5Dset_extent(did , dims_e) == SUCCEED)
+        {
+            goto error;
+        }
+        
+    } H5E_END_TRY;
 
-    /* Read the new dataset. */
-    if (H5Dread( dataset_id, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf1 )<0) TEST_ERROR;
 
-    /* Compare the read array with the original array */
-    for( i = 0; i < (int)dims_out[0]; i++ )
-        for( j = 0; j < (int)dims_out[1]; j++ )
-            if (  buf1[i][j] != data[i][j] ) TEST_ERROR;
 
     /*-------------------------------------------------------------------------
-    * Set new dimensions for the array; expand it again
+    * close property list
     *-------------------------------------------------------------------------
     */
+    
+    
+    if (H5Pclose(dcpl) < 0) 
+    {
+        goto error;
+    }
+
+    if (H5Fclose( fid ) < 0)
+    {
+        goto error;
+    }
+
+    PASSED();
 
-    /* Set new dimensions for the array. */
-    if (H5Dset_extent( dataset_id , dims )<0) TEST_ERROR;
 
-    /* Get the space. */
-    if ((space_id = H5Dget_space( dataset_id ))<0) TEST_ERROR;
+    return 0;
+    
+    
+    
+error:
+    
+    H5E_BEGIN_TRY 
+    {
+        H5Dclose( did );
+        H5Sclose( sid );
+        H5Pclose( dcpl );
+        H5Fclose( fid );
+    } H5E_END_TRY;
+    return -1;
+    
+}
 
-    /* Get dimensions. */
-    if (H5Sget_simple_extent_dims( space_id, dims_out, NULL )<0) TEST_ERROR;
 
-    if ( dims_out[0] != dims[0] ) TEST_ERROR;
+/*-------------------------------------------------------------------------
+ * test usage with layouts compact and contiguous
+ *-------------------------------------------------------------------------
+ */
+static int test_layouts( H5D_layout_t layout )
+{
 
-    /* Read the new dataset. */
-    if (H5Dread( dataset_id, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf2 )<0) TEST_ERROR;
+    hid_t   fid;          
+    hid_t   did;
+    hid_t   sid;
+    hid_t   dcpl;
+    hsize_t dims_o[RANK2] = {DIM0,DIM1};    /* original dimensions */ 
+    hsize_t dims_s[RANK2] = {DIMS0,DIMS1};  /* shrinking dimensions */ 
+    hsize_t dims_e[RANK2] = {DIME0,DIME1};  /* extended dimensions */ 
+    hsize_t dims_c[RANK2] = {2,2};          /* chunk dimensions */ 
+    hsize_t dims_r[RANK2];                  /* read dimensions */ 
+    int     buf_o[DIM0][DIM1];
+    int     buf_r[DIM0][DIM1];
+    int     i, j;    
+   
+    for( i = 0; i < DIM0; i++ )
+    {
+        for( j = 0; j < DIM1; j++ )
+        {
+            buf_o[i][j] = 2;
+        }
+    }
 
-    /* Compare the read array with the original array */
-    for( i = 0; i < (int)dims_out[0]; i++ ) {
-        for( j = 0; j < (int)dims_out[1]; j++ ) {
-            if ( i >= 70 || j >= 70 ) {
-                if (  buf2[i][j] != 0 ) TEST_ERROR;
-            }
-            else {
-                if (  buf2[i][j] != data[i][j] ) TEST_ERROR;
-            }
+  
+    /* create a new file */
+    if ((fid = H5Fcreate("set_extent3.h5", H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0) 
+    {
+        goto error;
+    }
+
+    /* create the data space with unlimited dimensions. */
+    if ((sid = H5Screate_simple(RANK2, dims_o, NULL)) < 0) 
+    {
+        goto error;
+    }
+    
+    /* modify dataset creation properties */
+    if ((dcpl = H5Pcreate (H5P_DATASET_CREATE)) < 0)
+    {
+        goto error;
+    }
+    
+    if (H5Pset_layout (dcpl, layout) < 0)
+    {
+        goto error;
+    }
+         
+    /* create a dataset */
+    if ((did = H5Dcreate(fid , "dset1", H5T_NATIVE_INT, sid, dcpl )) < 0) 
+    {
+        goto error;
+    }
+    
+    /* write */
+    if (H5Dwrite(did , H5T_NATIVE_INT, sid, H5S_ALL, H5P_DEFAULT, buf_o) < 0) 
+    {
+        goto error;
+    }
+    
+    
+#if defined (H5_SET_EXTENT_DEBUG4)
+    printf("\n");
+    for (i = 0; i < (int)dims_o[0]; i++ )
+    {
+        for (j = 0; j < (int)dims_o[1]; j++ )
+        {
+            printf("%d ", buf_o[i][j]);
         }
+        printf("\n");
     }
+#endif  
 
 
+    
+    if (H5Sclose(sid) < 0)
+    {
+        goto error;
+    }
+    
     /*-------------------------------------------------------------------------
-    * Close/release resources
+    * negative test
+    * try to extend dimension 
     *-------------------------------------------------------------------------
     */
 
-    H5Dclose( dataset_id );
-    H5Sclose( space_id );
-
-
-    H5Fclose( file_id );
+    H5E_BEGIN_TRY 
+    {
+     
+        if (H5Dset_extent(did , dims_e) == SUCCEED)
+        {
+            goto error;
+        }
+        
+    } H5E_END_TRY;
 
-    PASSED();
+    
+  
+    
+    /* get the space */
+    if ((sid = H5Dget_space(did)) < 0)
+    {
+        goto error;
+    }
+    
+    /* get dimensions */
+    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0) 
+    {
+        goto error;
+    }
+    
+    if (H5Sclose(sid) < 0)
+    {
+        goto error;
+    }
+    
+    
+    /* check dimensions */
+    for( i = 0; i < RANK2; i++ )
+    {
+        if (dims_r[i] != dims_o[i]) 
+            goto error;
+    }
+    
+    /* read */
+    if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_r) < 0) 
+        goto error;
 
+   
+    
+#if defined (H5_SET_EXTENT_DEBUG4)
+    printf("\n");
+    for (i = 0; i < (int)dims_r[0]; i++ )
+    {
+        for (j = 0; j < (int)dims_r[1]; j++ )
+        {
+            printf("%d ", buf_r[i][j]);
+        }
+        printf("\n");
+    }
+#endif  
 
+     
     
     /*-------------------------------------------------------------------------
-    * test a dataset with initialized chunks
+    * negative test
+    * try to shrink dimension 
     *-------------------------------------------------------------------------
     */
+
+    H5E_BEGIN_TRY 
+    {
+     
+        if (H5Dset_extent(did , dims_s) == SUCCEED)
+        {
+            goto error;
+        }
+        
+    } H5E_END_TRY;
+
     
-    TESTING("initialized chunks");
+    /* get the space */
+    if ((sid = H5Dget_space(did)) < 0)
+    {
+        goto error;
+    }
     
-    dims3[ 0 ] = 90;
-    dims3[ 1 ] = 90;
+    /* get dimensions */
+    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0) 
+    {
+        goto error;
+    }
     
-    if ((file_id = H5Fopen("set_extent_create.h5", H5F_ACC_RDWR, H5P_DEFAULT)) < 0) 
-        TEST_ERROR;
-    if ((space_id = H5Screate_simple(RANK, dims3, maxdims)) < 0) 
-        TEST_ERROR;
-    if ((plist_id = H5Pcreate (H5P_DATASET_CREATE)) < 0) 
-        TEST_ERROR;
-    if (H5Pset_chunk(plist_id, RANK, dims_chunk) < 0) 
-        TEST_ERROR;
+    if (H5Sclose(sid) < 0)
+    {
+        goto error;
+    }
     
-    /* create a new dataset */
-    if ((dataset_id = H5Dcreate( file_id , "Dataset3", H5T_NATIVE_INT, space_id, plist_id ))<0) 
-       TEST_ERROR;
+    /* check dimensions */
+    for( i = 0; i < RANK2; i++ )
+    {
+        if (dims_r[i] != dims_o[i]) 
+            goto error;
+    }
 
     
-    /* set new dimensions for the array */
-    dims3[ 0 ] = 0;
-    dims3[ 1 ] = 0;
-    if (H5Dset_extent( dataset_id , dims3 ) < 0) 
-        TEST_ERROR;
-    
-    
-    if (H5Dclose(dataset_id) < 0) 
-        TEST_ERROR
-    if (H5Sclose(space_id) < 0) 
-        TEST_ERROR
-    if (H5Pclose(plist_id) < 0)  
-        TEST_ERROR
-    if (H5Fclose( file_id ) < 0) 
-        TEST_ERROR
-                    
-        
-    PASSED();
-
+    /*-------------------------------------------------------------------------
+    * read
+    *-------------------------------------------------------------------------
+    */
+    
+    /* read */
+    if (H5Dread( did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_r ) < 0) 
+    {
+        goto error;
+    }
+    
+#if defined (H5_SET_EXTENT_DEBUG4)
+    printf("\n");
+    for (i = 0; i < (int)dims_r[0]; i++ )
+    {
+        for (j = 0; j < (int)dims_r[1]; j++ )
+        {
+            printf("%d ", buf_r[i][j]);
+        }
+        printf("\n");
+    }
+#endif  
 
 
+     
+    /*-------------------------------------------------------------------------
+    * close 
+    *-------------------------------------------------------------------------
+    */
+    
+    if (H5Dclose(did) < 0) 
+    {
+        goto error;
+    }
+      
+    if (H5Pclose(dcpl) < 0) 
+    {
+        goto error;
+    }
 
-    puts("All set_extent tests passed.");
-    return 0;
+    if (H5Fclose( fid ) < 0)
+    {
+        goto error;
+    }
 
 
+    return 0;
+    
+    
+    
 error:
-    H5Dclose( dataset_id );
-    H5Sclose( space_id );
-    H5Pclose( plist_id  );
-    H5Fclose( file_id );
-    H5_FAILED();
-    return 1;
+    
+    H5E_BEGIN_TRY 
+    {
+        H5Dclose( did );
+        H5Sclose( sid );
+        H5Pclose( dcpl  );
+        H5Fclose( fid );
+    } H5E_END_TRY;
+    return -1;
+    
 }
 
+
+ 
+