Merge branch 'hdf5_1_10' of https://bitbucket.hdfgroup.org/scm/~jake.smith/hdf5 into dset_ohdr_minimize_110

1 files changed, 1356 insertions, 175 deletions

diff --git a/test/chunk_info.c b/test/chunk_info.c
index 9c84953..f5a6fdc 100644
--- a/test/chunk_info.c
+++ b/test/chunk_info.c
@@ -16,29 +16,63 @@
  *              April 7, 2008
  *
  * Purpose:     Tests chunk query API functions
+ *
+ * Modification:
+ *              Many tests were added for HDFFV-10615. -BMR, October 2018
+ *
+ * Test structure:
+ *          main()
+ *              test_get_chunk_info_highest18()
+ *              test_get_chunk_info_110()
+ *                  test_chunk_info_single_chunk()
+ *                  test_chunk_info_implicit()
+ *                  test_chunk_info_fixed_array()
+ *                  test_chunk_info_extensible_array()
+ *                  test_chunk_info_version2_btrees()
+ *
  */
+#define H5D_FRIEND
+#define H5D_TESTING     /* to use H5D__ functions */
+#include "H5Dpkg.h"
 
-#include "h5test.h"
+#include "testhdf5.h"
 
- /* #define PRINT_DATA
- */ 
-#define H5FILE_NAME "chunk_info.h5"
+/* Test file names */
+const char *FILENAME[] = {
+        "tchunk_info_18",
+        "tchunk_info_110",
+        "chunk_info",
+        NULL
+};
+
+/* From original test */
 #define DATASETNAME "2d"
-#define RANK         2
-#define FILENAME_BUF_SIZE       1024
 
 /* Parameters for testing chunk querying */
-#define FILENAME                "tchunk_info"
+#define RANK                    2
+#define FILENAME_BUF_SIZE       1024
 #define DSET_SIMPLE_CHUNKED     "Chunked Dataset"
 #define DSET_EMPTY              "Empty Dataset"
-#define NX          16
-#define NY          16
-#define CHUNK_NX     4
-#define CHUNK_NY     4
-#define CHUNK_SIZE  64
-#define NUM_CHUNKS_WRITTEN  4
-
-void reinit_vars(unsigned *read_filter_mask, haddr_t *addr, hsize_t *size);
+#define DSET_EMPTY_ALLOC        "Empty Dataset with ALLOC_TIME_EARLY"
+#define DSET_SINGLE_CHUNK       "Single Chunk Index Dataset"
+#define DSET_IMPLICIT_INDEX     "Implicit Index Dataset"
+#define DSET_FIXED_ARR_INDEX    "Fixed Array Index Dataset"
+#define DSET_EXT_ARR_INDEX      "Extensible Array Index Dataset"
+#define DSET_V2_BTREE_INDEX     "Version 2 B-Tree Index Dataset"
+#define NX                      24
+#define NY                      16
+#define CHUNK_NX                6
+#define CHUNK_NY                4
+#define SINGLE_CHUNK_SIZE       (NX*NY*sizeof(int))
+#define CHUNK_SIZE              96
+#define NUM_CHUNKS              16
+#define NUM_CHUNKS_WRITTEN      4
+
+/* Artifact of original file, maybe removed */
+/* #define PRINT_DATA */
+
+/* Utility function to initialize arguments */
+void reinit_vars(unsigned *read_flt_msk, haddr_t *addr, hsize_t *size);
 
 /*-------------------------------------------------------------------------
  * Function:    read_each_chunk (helper function)
@@ -54,21 +88,23 @@ void reinit_vars(unsigned *read_filter_mask, haddr_t *addr, hsize_t *size);
  *
  *-------------------------------------------------------------------------
  */
+//EIP - May be this function should take a pointer to an array of chunk dimensions
+//EIP  and its size, so it is not restricted to 2 dims only?
 static herr_t read_each_chunk(hid_t dset_id, hsize_t offset1, hsize_t offset2, void *direct_buf)
 {
     int      read_buf[CHUNK_NX][CHUNK_NY];
     hsize_t  offset[2] = {offset1, offset2};
-    unsigned read_filter_mask = 0;
+    unsigned read_flt_msk = 0;
+    herr_t  ret;                        /* Return value */
 
-    /* Read the raw chunk back */
     HDmemset(&read_buf, 0, sizeof(read_buf));
 
     /* Read the chunk specified by its offset */
-    if (H5Dread_chunk(dset_id, H5P_DEFAULT, offset, &read_filter_mask, read_buf) < 0)
-        return(FAIL);
+    ret = H5Dread_chunk(dset_id, H5P_DEFAULT, offset, &read_flt_msk, read_buf);
+    if(ret < 0) return(FAIL);
 
     /* Verify that read chunk is the same as the corresponding written one */
-    if (HDmemcmp(direct_buf, read_buf, CHUNK_NX*CHUNK_NY) != 0)
+    if(HDmemcmp(direct_buf, read_buf, CHUNK_NX*CHUNK_NY) != 0)
     {
         HDfprintf(stderr, "Read chunk differs from written chunk at offset (%d,%d)\n", offset1, offset2);
         return(FAIL);
@@ -89,18 +125,18 @@ static herr_t read_each_chunk(hid_t dset_id, hsize_t offset1, hsize_t offset2, v
  *
  *-------------------------------------------------------------------------
  */
-void reinit_vars(unsigned *read_filter_mask, haddr_t *addr, hsize_t *size)
+void reinit_vars(unsigned *read_flt_msk, haddr_t *addr, hsize_t *size)
 {
-    if (read_filter_mask)
-        *read_filter_mask = 0;
-    if (addr)
+    if(read_flt_msk)
+        *read_flt_msk = 0;
+    if(addr)
         *addr = 0;
-    if (size)
+    if(size)
         *size = 0;
 }
 
 /*-------------------------------------------------------------------------
- * Function:	test_get_chunk_info
+ * Function:	test_get_chunk_info_highest18
  *
  * Purpose:	    Test getting various chunk information
  *
@@ -112,226 +148,1277 @@ void reinit_vars(unsigned *read_filter_mask, haddr_t *addr, hsize_t *size)
  *              will be implemented in the next version.
  *
  * Description:
- *              This function tests the new API functions added for HDFFV-10615:
- *              H5Dget_num_chunks, H5Dget_chunk_info, and H5Dget_chunk_info_by_coord.
+ *              This function tests the new API functions added for EED-343:
+ *              H5Dget_num_chunks, H5Dget_chunk_info, and
+ *              H5Dget_chunk_info_by_coord for high bound up to 1.8.
  *
  * Date:        September 2018
  *
  *-------------------------------------------------------------------------
  */
 static herr_t
-test_get_chunk_info(void)
+test_get_chunk_info_highest18(hid_t fapl)
 {
-    hid_t       chunkfile = -1, fapl = -1;
-    hid_t       fspace = -1, dset = -1;
-    hid_t       mspace = -1;
-    hid_t       cparms = -1, dxpl = -1;
-    hsize_t     dims[2]  = {NX, NY};
-    hsize_t     maxdims[2] = {H5S_UNLIMITED, H5S_UNLIMITED};
-    hsize_t     chunk_dims[2] ={CHUNK_NX, CHUNK_NY};
-    int         fillvalue = -1;
-    char        filename[FILENAME_BUF_SIZE];
-    unsigned    filter_mask = 0;
-    int         direct_buf[16][CHUNK_NX][CHUNK_NY];
-    int         out_buf[NX][NY];
-    size_t      buf_size = CHUNK_NX*CHUNK_NY*sizeof(int);
-    int         aggression = 9;         /* Compression aggression setting */
-    unsigned    read_filter_mask = 0;   /* filter mask after direct read */
-    H5F_libver_t low, high;             /* File format bounds */
-    hsize_t offset[2];
-    hsize_t out_offset[2] = {0, 0};
-    hsize_t size = 0;
-    hsize_t nchunks = 0;
-    haddr_t addr = 0;
-    hsize_t index = 0;
-    hsize_t i, j;
-    int     n; /* for use on buffer, to avoid conversion warning */
+    char     filename[FILENAME_BUF_SIZE];
+    hid_t    chunkfile = -1;     /* File ID */
+    hid_t    dspace = -1;        /* Dataspace ID */
+    hid_t    dset = -1;          /* Dataset ID */
+    hid_t    cparms = -1;        /* Creation plist */
+    hsize_t  dims[2]  = {NX, NY};/* Dataset dimensions */
+    hsize_t  maxdims[2] = {H5S_UNLIMITED, H5S_UNLIMITED};
+    hsize_t  chunk_dims[2] = {CHUNK_NX, CHUNK_NY};      /* Chunk dimensions */
+    int      direct_buf[NUM_CHUNKS][CHUNK_NX][CHUNK_NY];/* Data in chunks */
+    int      out_buf[NX][NY];    /* Buffer to read data in */
+    size_t   buf_size = CHUNK_NX*CHUNK_NY*sizeof(int);  /* Buffer size of a chk */
+    unsigned filter_mask = 0;    /* Filter mask */
+    unsigned read_flt_msk = 0;   /* Filter mask after direct read */
+    int      fillvalue = -1;     /* Fill value */
+    int      aggression = 9;     /* Compression aggression setting */
+    H5F_libver_t low, high;      /* File format bounds */
+    hsize_t  offset[2];          /* Offset coordinates of a chunk */
+    hsize_t  out_offset[2] = {0, 0}; /* Buffer to get offset coordinates */
+    hsize_t  size = 0;           /* Size of an allocated/written chunk */
+    hsize_t  nchunks = 0;        /* Number of chunks */
+    haddr_t  addr = 0;           /* Address of an allocated/written chunk */
+    hsize_t  index = 0;          /* Index of a chunk */
+    int      n;                  /* Used on buffer, to avoid conversion warning */
+    hsize_t  i, j;
+    herr_t   ret;
+
+    TESTING("getting chunk information in file with version prior to 1.10");
+
+    /* Create the file */
+    h5_fixname(FILENAME[0], fapl, filename, sizeof filename);
+
+    /* Set high bound to V18 to test chunked dataset that use B-tree v1
+       structures to index chunks */
+    high = H5F_LIBVER_V18;
+
+    /* Low bound can be anything below 1.10, which was when the new chunk storage
+       was introduced */
+    low = H5F_LIBVER_EARLIEST;
+
+    /* Set version bounds for creating the file */
+    if(H5Pset_libver_bounds(fapl, low, high) < 0)
+        TEST_ERROR
+
+    chunkfile = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl);
+    if(chunkfile < 0)
+        TEST_ERROR
+
+    /* Create the file and memory dataspaces */
+    if((dspace = H5Screate_simple(RANK, dims, maxdims)) < 0)
+        TEST_ERROR
+
+    /* Set dset creation properties with chunking, compression, and fillvalue */
+    if((cparms = H5Pcreate(H5P_DATASET_CREATE)) < 0) TEST_ERROR
+    if(H5Pset_chunk(cparms, RANK, chunk_dims) < 0) TEST_ERROR
+
+#ifdef H5_HAVE_FILTER_DEFLATE
+    if(H5Pset_deflate(cparms, (unsigned)aggression) < 0) TEST_ERROR
+#endif /* end H5_HAVE_FILTER_DEFLATE */
+
+    /* Set fill value */
+    if(H5Pset_fill_value(cparms, H5T_NATIVE_INT, &fillvalue) < 0) TEST_ERROR
+
+    /* Create a new dataset using cparms creation properties */
+    dset = H5Dcreate2(chunkfile, DSET_SIMPLE_CHUNKED, H5T_NATIVE_INT, dspace, H5P_DEFAULT, cparms, H5P_DEFAULT);
+    if(dset < 0) TEST_ERROR
+
+    /* Indicate skipping the compression filter */
+    filter_mask = 0x00000001;
+
+    /* Initialize the array of chunk data for all NUM_CHUNKS chunks */
+    for(n = 0; n < NUM_CHUNKS; n++)
+        for(i = 0; i < CHUNK_NX; i++)
+            for(j = 0; j < CHUNK_NY; j++)
+                direct_buf[n][i][j] = n + 1;
+
+    /* Write only NUM_CHUNKS_WRITTEN chunks at the following logical coords:
+       (0,2) (0,3) (1,2) (1,3) */
+    n = 0;
+    for (i = 0; i < 2; i++)
+        for (j = 2; j < 4; j++, n++)
+        {
+            offset[0] = i * CHUNK_NX;
+            offset[1] = j * CHUNK_NY;
+            ret = H5Dwrite_chunk(dset, H5P_DEFAULT, filter_mask, offset, buf_size, (void*)direct_buf[n]);
+            if(ret < 0) TEST_ERROR
+        }
+
+    if(H5Fflush(dset, H5F_SCOPE_LOCAL) < 0)
+        goto error;
+
+    /* Close the dataset then... */
+    if(H5Dclose(dset) < 0) TEST_ERROR
+
+    /* ...open it again to test the chunk query functions */
+    if((dset = H5Dopen2(chunkfile, DSET_SIMPLE_CHUNKED, H5P_DEFAULT)) < 0)
+        TEST_ERROR
+
+    /* Get and verify the number of chunks written */
+    if(H5Dget_num_chunks(dset, dspace, &nchunks) < 0) TEST_ERROR
+    if(nchunks != NUM_CHUNKS_WRITTEN) TEST_ERROR
+
+    /* Read the entire dataset back */
+    ret = H5Dread(dset, H5T_NATIVE_INT, dspace, dspace, H5P_DEFAULT, out_buf);
+    if(ret < 0) TEST_ERROR
+
+    /* Get and verify info of the first chunk */
+    index = 0;
+    reinit_vars(&read_flt_msk, &addr, &size);
+    out_offset[0] = out_offset[1] = 0;
+    ret = H5Dget_chunk_info(dset, dspace, index, out_offset, &read_flt_msk, &addr, &size);
+    if(ret < 0) TEST_ERROR
+    if(read_flt_msk != filter_mask) TEST_ERROR
+    if(size != CHUNK_SIZE) TEST_ERROR
+    if(out_offset[0] != 0 || out_offset[1] != 8) TEST_ERROR
+
+    /* Get and verify info of the second chunk */
+    index = 1;
+    reinit_vars(&read_flt_msk, &addr, &size);
+    out_offset[0] = out_offset[1] = 0;
+    ret = H5Dget_chunk_info(dset, dspace, index, out_offset, &read_flt_msk, &addr, &size);
+    if(ret < 0) TEST_ERROR
+    if(read_flt_msk != filter_mask) TEST_ERROR
+    if(size != CHUNK_SIZE) TEST_ERROR
+    if(out_offset[0] != 0 || out_offset[1] != 12) TEST_ERROR
+
+    /* Get and verify info of the third chunk */
+    index = 2;
+    reinit_vars(&read_flt_msk, &addr, &size);
+    out_offset[0] = out_offset[1] = 0;
+    ret = H5Dget_chunk_info(dset, dspace, index, out_offset, &read_flt_msk, &addr, &size);
+    if(ret < 0) TEST_ERROR
+ 
+    if(read_flt_msk != filter_mask) TEST_ERROR
+    if(size != CHUNK_SIZE) TEST_ERROR
+    if(out_offset[0] != 6 || out_offset[1] != 8) TEST_ERROR
+
+    /* Get and verify info of the last chunk */
+    index = 3;
+    reinit_vars(&read_flt_msk, &addr, &size);
+    out_offset[0] = out_offset[1] = 0;
+    ret = H5Dget_chunk_info(dset, dspace, index, out_offset, &read_flt_msk, &addr, &size);
+    if(ret < 0) TEST_ERROR
+    if(read_flt_msk != filter_mask) TEST_ERROR
+    if(size != CHUNK_SIZE) TEST_ERROR
+    if(out_offset[0] != 6 || out_offset[1] != 12) TEST_ERROR
+
+    /* Attempt to get info of empty chunk and verify the returned address and size */
+    index = 5;
+    reinit_vars(&read_flt_msk, &addr, &size);
+    out_offset[0] = out_offset[1] = 0;
+    ret = H5Dget_chunk_info(dset, dspace, index, out_offset, &read_flt_msk, &addr, &size);
+    if(ret < 0) TEST_ERROR
+    if(addr != HADDR_UNDEF) TEST_ERROR
+    if(size != 0) TEST_ERROR
+
+    /* Get info of the chunk at logical coordinates (0,2) */
+    offset[0] = 0;
+    offset[1] = 2 * CHUNK_NY;
+    ret = H5Dget_chunk_info_by_coord(dset, offset, &read_flt_msk, &addr, &size);
+    if(ret < 0) TEST_ERROR
+    if(read_flt_msk != filter_mask) TEST_ERROR
+    if(size != CHUNK_SIZE) TEST_ERROR
+
+    /* Get info of the chunk at logical coordinates (1,3) */
+    offset[0] = 1 * CHUNK_NX;
+    offset[1] = 3 * CHUNK_NY;
+    ret = H5Dget_chunk_info_by_coord(dset, offset, &read_flt_msk, &addr, &size);
+    if(ret < 0) TEST_ERROR
+    if(read_flt_msk != filter_mask) TEST_ERROR
+    if(size != CHUNK_SIZE) TEST_ERROR
+
+    /* Attempt to get info of empty chunks, verify the returned addr and size */
+    offset[0] = 0;
+    offset[1] = 0;
+    ret = H5Dget_chunk_info_by_coord(dset, offset, &read_flt_msk, &addr, &size);
+    if(ret < 0) TEST_ERROR
+    if(addr != HADDR_UNDEF) TEST_ERROR
+    if(size != 0) TEST_ERROR
 
-    TESTING("getting chunk information");
+    offset[0] = 3 * CHUNK_NX;
+    offset[1] = 3 * CHUNK_NY;
+    ret = H5Dget_chunk_info_by_coord(dset, offset, &read_flt_msk, &addr, &size);
+    if(ret < 0) TEST_ERROR
+    if(addr != HADDR_UNDEF) TEST_ERROR
+    if(size != 0) TEST_ERROR
+
+    /* Read each chunk and verify the values */
+    n = 0;
+    for (i = 0; i < 2; i++)
+        for (j = 2; j < 4; j++, n++)
+            if(read_each_chunk(dset, i*CHUNK_NX, j*CHUNK_NY, (void*)direct_buf[n]) < 0)
+                TEST_ERROR
+
+    /* Close the first dataset */
+    if(H5Dclose(dset) < 0) TEST_ERROR
+
+    /* Create an empty dataset and close it */
+    dset = H5Dcreate2(chunkfile, DSET_EMPTY, H5T_NATIVE_INT, dspace, H5P_DEFAULT, cparms, H5P_DEFAULT);
+    if(dset < 0) TEST_ERROR
+    if(H5Dclose(dset) < 0) TEST_ERROR
+
+    /* Reopen the empty dataset to verify the chunk query functions on it */
+    if((dset = H5Dopen2(chunkfile, DSET_EMPTY, H5P_DEFAULT)) < 0)
+        TEST_ERROR
+
+    /* Verify that the number of chunks is 0 */
+    if(H5Dget_num_chunks(dset, dspace, &nchunks) < 0) TEST_ERROR
+    if(nchunks != 0) TEST_ERROR
 
-    /* Create a file */
-    h5_fixname(FILENAME, H5P_DEFAULT, filename, sizeof filename);
-    if((chunkfile = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+    /* Attempt to get info of a chunk from an empty dataset, verify the
+       returned address and size */
+    index = 0;
+    reinit_vars(&read_flt_msk, &addr, &size);
+    ret = H5Dget_chunk_info(dset, dspace, index, out_offset, &read_flt_msk, &addr, &size);
+    if(ret < 0) TEST_ERROR
+    if(addr != HADDR_UNDEF) TEST_ERROR
+    if(size != 0) TEST_ERROR
+
+    /* Attempt to get info of a chunk given its coords from an empty dataset,
+       verify the returned address and size */
+    offset[0] = 0;
+    offset[1] = 0;
+    ret = H5Dget_chunk_info_by_coord(dset, offset, &read_flt_msk, &addr, &size);
+    if(ret < 0) TEST_ERROR
+    if(addr != HADDR_UNDEF) TEST_ERROR
+    if(size != 0) TEST_ERROR
+
+    if(H5Dclose(dset) < 0) TEST_ERROR
+
+    /************************************************************************
+     * Test empty dataset with H5P_ALLOC_TIME_EARLY                         *
+     ************************************************************************/
+
+    /* Set space allocation to early so that chunk query functions will
+       retrieve chunk information even though the dataset is empty */
+    if(H5Pset_alloc_time(cparms, H5D_ALLOC_TIME_EARLY) < 0)
         TEST_ERROR
 
-    /* Create the data space */
-    if((fspace = H5Screate_simple(RANK, dims, maxdims)) < 0)
+    /* Create an empty dataset and close it */
+    dset = H5Dcreate2(chunkfile, DSET_EMPTY_ALLOC, H5T_NATIVE_INT, dspace, H5P_DEFAULT, cparms, H5P_DEFAULT);
+    if(dset < 0) TEST_ERROR
+    if(H5Dclose(dset) < 0) TEST_ERROR
+
+    /* Reopen the empty dataset to verify the chunk query functions on it */
+    if((dset = H5Dopen2(chunkfile, DSET_EMPTY_ALLOC, H5P_DEFAULT)) < 0)
+        TEST_ERROR
+
+    /* Verify that the number of chunks is NUM_CHUNKS */
+    if(H5Dget_num_chunks(dset, dspace, &nchunks) < 0) TEST_ERROR
+    if(nchunks != NUM_CHUNKS) TEST_ERROR
+
+    /* Attempt to get info of a chunk from an empty dataset, verify the
+       returned address and size */
+    index = 0;
+    reinit_vars(&read_flt_msk, &addr, &size);
+    ret = H5Dget_chunk_info(dset, dspace, index, out_offset, &read_flt_msk, &addr, &size);
+    if(ret < 0) TEST_ERROR
+
+    /* Because of H5P_ALLOC_TIME_EARLY, addr cannot be HADDR_UNDEF and size not 0 */
+    if(addr == HADDR_UNDEF) TEST_ERROR
+    if(size == 0) TEST_ERROR
+
+    index = 10;
+    reinit_vars(&read_flt_msk, &addr, &size);
+    ret = H5Dget_chunk_info(dset, dspace, index, out_offset, &read_flt_msk, &addr, &size);
+    if(ret < 0) TEST_ERROR
+
+    /* Because of H5P_ALLOC_TIME_EARLY, addr cannot be HADDR_UNDEF and size not 0 */
+    if(addr == HADDR_UNDEF) TEST_ERROR
+    if(size == 0) TEST_ERROR
+
+    /* Attempt to get info of a chunk given its coords from an empty dataset,
+       verify the returned address and size */
+    offset[0] = 0;
+    offset[1] = 0;
+    if(H5Dget_chunk_info_by_coord(dset, offset, &read_flt_msk, &addr, &size) < 0)
         TEST_ERROR
+    /* Because of H5P_ALLOC_TIME_EARLY, addr cannot be HADDR_UNDEF and size not 0 */
+    if(addr == HADDR_UNDEF) TEST_ERROR
+    if(size == 0) TEST_ERROR
+
+    if(H5Dclose(dset) < 0) TEST_ERROR
+
+    /* Close/release resources. */
+    if(H5Sclose(dspace) < 0) TEST_ERROR
+    if(H5Pclose(cparms) < 0) TEST_ERROR
+    if(H5Fclose(chunkfile) < 0) TEST_ERROR
+
+    PASSED();
+    return SUCCEED;
 
-    if((mspace = H5Screate_simple(RANK, chunk_dims, NULL)) < 0)
+error:
+    H5E_BEGIN_TRY {
+        H5Dclose(dset);
+        H5Sclose(dspace);
+        H5Pclose(cparms);
+        H5Fclose(chunkfile);
+    } H5E_END_TRY;
+
+    H5_FAILED();
+    return FAIL;
+} /* test_get_chunk_info_highest18() */
+
+/*-------------------------------------------------------------------------
+ * Function:	test_chunk_info_single_chunk
+ *
+ * Purpose:	    Test getting various chunk information when Single Chunk
+ *              index type is used
+ *
+ * Return:	    Success:	SUCCEED
+ *		        Failure:	FAIL
+ *
+ * Note:        Note that the dataspace argument in these new functions are
+ *              currently not used.  The functionality involved the dataspace
+ *              will be implemented in the next version.
+ *
+ * Date:        November 2018
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+test_chunk_info_single_chunk(char *filename, hid_t fapl)
+{
+    hid_t    chunkfile = -1;     /* File ID */
+    hid_t    dspace = -1;        /* Dataspace ID */
+    hid_t    dset = -1;          /* Dataset ID */
+    hid_t    cparms = -1;        /* Creation plist */
+    hsize_t  dims[2]  = {NX, NY};/* Dataset dimensions */
+    hsize_t  chunk_dims[2] = {NX, NY};      /* Chunk dimensions */
+    int      in_buf[NX][NY];     /* Input buffer */
+    unsigned filter_mask = 0;    /* Filter mask */
+    unsigned read_flt_msk = 0;   /* Filter mask after direct read */
+    H5D_chunk_index_t idx_type;  /* Dataset chunk index type */
+    hsize_t  offset[2];          /* Offset coordinates of a chunk */
+    hsize_t  out_offset[2] = {0, 0}; /* Buffer to get offset coordinates */
+    hsize_t  size = 0;           /* Size of an allocated/written chunk */
+    hsize_t  nchunks = 0;        /* Number of chunks */
+    haddr_t  addr = 0;           /* Address of an allocated/written chunk */
+    hsize_t  index = 0;          /* Index of a chunk */
+    int      i, j;
+
+    TESTING("   Single Chunk index");
+
+    /* Open the file for reading/writing */
+    if((chunkfile = H5Fopen(filename, H5F_ACC_RDWR, fapl)) < 0)
+        TEST_ERROR
+ 
+    /* Create dataspace */
+    if((dspace = H5Screate_simple(RANK, dims, NULL)) < 0)
         TEST_ERROR
 
-    /* Modify dataset creation properties, i.e. enable chunking and compression */
+    /* Enable chunking */
     if((cparms = H5Pcreate(H5P_DATASET_CREATE)) < 0)
         TEST_ERROR
 
     if(H5Pset_chunk(cparms, RANK, chunk_dims) < 0)
         TEST_ERROR
 
-    if(H5Pset_deflate(cparms, (unsigned ) aggression) < 0)
+    /* Create a new dataset using cparms creation properties */
+    dset = H5Dcreate2(chunkfile, DSET_SINGLE_CHUNK, H5T_NATIVE_INT, dspace, H5P_DEFAULT, cparms, H5P_DEFAULT);
+    if(dset < 0) TEST_ERROR
+
+    /* Ensure we're using the correct chunk indexing scheme */
+    if(H5D__layout_idx_type_test(dset, &idx_type) < 0)
+        TEST_ERROR
+    if(idx_type != H5D_CHUNK_IDX_SINGLE)
+        FAIL_PUTS_ERROR("should be using Single Chunk index type");
+
+    /* Close the dataset then... */
+    if(H5Dclose(dset) < 0) TEST_ERROR
+
+    /* ...open it again to test the chunk query functions on a single empty
+       chunk */
+    if((dset = H5Dopen2(chunkfile, DSET_SINGLE_CHUNK, H5P_DEFAULT)) < 0)
+        TEST_ERROR
+
+    /* Get the number of chunks and verify that no chunk has been written */
+    if(H5Dget_num_chunks(dset, dspace, &nchunks) < 0) TEST_ERROR
+    if(nchunks != 0) TEST_ERROR
+
+    /* Initialize the array of chunk data for the single chunk */
+    for(i = 0; i < NX; i++)
+        for(j = 0; j < NY; j++)
+            in_buf[i][j] = (i*j);
+
+    /* Write the chunk */
+    if(H5Dwrite(dset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, in_buf) < 0)
+        TEST_ERROR
+
+    /* Get and verify that one chunk had been written */
+    if(H5Dget_num_chunks(dset, dspace, &nchunks) < 0) TEST_ERROR
+    if(nchunks != 1) TEST_ERROR
+
+    /* Get and verify info of the first and only chunk */
+    index = 0;
+    reinit_vars(&read_flt_msk, &addr, &size);
+    if(H5Dget_chunk_info(dset, dspace, index, out_offset, &read_flt_msk, &addr, &size) < 0)
+        TEST_ERROR
+    if(read_flt_msk != filter_mask) TEST_ERROR
+    if(size != SINGLE_CHUNK_SIZE) TEST_ERROR
+    if(out_offset[0] != 0 || out_offset[1] != 0) TEST_ERROR
+
+    /* Get info of the chunk at logical coordinates (0,0) */
+    offset[0] = 0;
+    offset[1] = 0;
+    if(H5Dget_chunk_info_by_coord(dset, offset, &read_flt_msk, &addr, &size) < 0)
+        TEST_ERROR
+    if (read_flt_msk != filter_mask) TEST_ERROR
+    if (size != SINGLE_CHUNK_SIZE) TEST_ERROR
+
+    /* Release resourse */
+    if(H5Dclose(dset) < 0) TEST_ERROR
+    if(H5Sclose(dspace) < 0) TEST_ERROR
+    if(H5Fclose(chunkfile) < 0) TEST_ERROR
+
+    PASSED();
+    return SUCCEED;
+
+error:
+    H5E_BEGIN_TRY {
+        H5Dclose(dset);
+        H5Sclose(dspace);
+        H5Pclose(cparms);
+        H5Fclose(chunkfile);
+    } H5E_END_TRY;
+
+    H5_FAILED();
+    return FAIL;
+} /* test_chunk_info_single_chunk() */
+        
+/*-------------------------------------------------------------------------
+ * Function:	test_chunk_info_implicit
+ *
+ * Purpose:	    Test getting various chunk information when Implicit
+ *              index type is used
+ *
+ * Return:	    Success:	SUCCEED
+ *		        Failure:	FAIL
+ *
+ * Note:        Note that the dataspace argument in these new functions are
+ *              currently not used.  The functionality involved the dataspace
+ *              will be implemented in the next version.
+ *
+ * Date:        November 2018
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+test_chunk_info_implicit(char *filename, hid_t fapl)
+{
+    hid_t    chunkfile = -1;     /* File ID */
+    hid_t    dspace = -1;        /* Dataspace ID */
+    hid_t    dset = -1;          /* Dataset ID */
+    hid_t    cparms = -1;        /* Creation plist */
+    hsize_t  dims[2]  = {NX, NY};/* Dataset dimensions */
+    hsize_t  chunk_dims[2] = {CHUNK_NX, CHUNK_NY};      /* Chunk dimensions */
+    int      direct_buf[NUM_CHUNKS][CHUNK_NX][CHUNK_NY];/* Data in chunks */
+    int      out_buf[NX][NY];    /* Buffer to read data in */
+    size_t   buf_size = CHUNK_NX*CHUNK_NY*sizeof(int);  /* Buffer size of a chk */
+    unsigned filter_mask = 0;    /* Filter mask */
+    unsigned read_flt_msk = 0;   /* Filter mask after direct read */
+    H5D_chunk_index_t idx_type;  /* Dataset chunk index type */
+    hsize_t  offset[2];          /* Offset coordinates of a chunk */
+    hsize_t  out_offset[2] = {0, 0}; /* Buffer to get offset coordinates */
+    hsize_t  size = 0;           /* Size of an allocated/written chunk */
+    hsize_t  nchunks = 0;        /* Number of chunks */
+    haddr_t  addr = 0;           /* Address of an allocated/written chunk */
+    hsize_t  index = 0;          /* Index of a chunk */
+    int      n;                  /* Used on buffer, to avoid conversion warning */
+    hsize_t  i, j;
+    herr_t   ret;
+
+    TESTING("   Implicit index");
+
+    /* Open the file for reading/writing */
+    if((chunkfile = H5Fopen(filename, H5F_ACC_RDWR, fapl)) < 0)
+        TEST_ERROR
+ 
+    /* Create dataspace */
+    if((dspace = H5Screate_simple(RANK, dims, NULL)) < 0)
+        TEST_ERROR
+
+    /* Enable chunking */
+    if((cparms = H5Pcreate(H5P_DATASET_CREATE)) < 0)
         TEST_ERROR
 
-    if (H5Pset_fill_value(cparms, H5T_NATIVE_INT, &fillvalue) < 0)
-        TEST_ERROR;
+    if(H5Pset_chunk(cparms, RANK, chunk_dims) < 0)
+        TEST_ERROR
+
+    if(H5Pset_alloc_time(cparms, H5D_ALLOC_TIME_EARLY) < 0)
+        TEST_ERROR
 
     /* Create a new dataset using cparms creation properties */
-    if((dset = H5Dcreate2(chunkfile, DSET_SIMPLE_CHUNKED, H5T_NATIVE_INT, fspace,
-            H5P_DEFAULT, cparms, H5P_DEFAULT)) < 0) TEST_ERROR
+    dset = H5Dcreate2(chunkfile, DSET_IMPLICIT_INDEX, H5T_NATIVE_INT, dspace, H5P_DEFAULT, cparms, H5P_DEFAULT);
+    if(dset < 0) TEST_ERROR
 
-    if((dxpl = H5Pcreate(H5P_DATASET_XFER)) < 0)
+    /* Ensure we're using the correct chunk indexing scheme */
+    if(H5D__layout_idx_type_test(dset, &idx_type) < 0)
         TEST_ERROR
+    if(idx_type != H5D_CHUNK_IDX_NONE) /* Implicit: No Index */
+        FAIL_PUTS_ERROR("should be using Implicit index type");
 
-    /* Indicate skipping the compression filter.     */
-    filter_mask = 0x00000001;
+    /* Close the dataset then... */
+    if(H5Dclose(dset) < 0) TEST_ERROR
+
+    /* ...open it again to test the chunk query functions */
+    if((dset = H5Dopen2(chunkfile, DSET_IMPLICIT_INDEX, H5P_DEFAULT)) < 0)
+        TEST_ERROR
+
+    /* Get and verify the number of chunks */
+    if(H5Dget_num_chunks(dset, dspace, &nchunks) < 0) TEST_ERROR
 
-    /* Initialize the array of chunk data, that is for all 16 chunks */
-    for(n = 0; n < 16; n++)
+    /* All chunks because of H5D_ALLOC_TIME_EARLY */
+    if(nchunks != NUM_CHUNKS) TEST_ERROR
+
+    /* Initialize the array of chunk data for all NUM_CHUNKS chunks */
+    for(n = 0; n < NUM_CHUNKS; n++)
         for(i = 0; i < CHUNK_NX; i++)
             for(j = 0; j < CHUNK_NY; j++)
                 direct_buf[n][i][j] = n + 1;
 
-    /* Write NUM_CHUNKS_WRITTEN chunks: (0,2) (0,3) (1,2) (1,3) */
+    /* Write only NUM_CHUNKS_WRITTEN chunks at the following logical coords:
+       (0,2) (0,3) (1,2) (1,3) */
     n = 0;
     for (i = 0; i < 2; i++)
         for (j = 2; j < 4; j++, n++)
         {
             offset[0] = i * CHUNK_NX;
             offset[1] = j * CHUNK_NY;
-            if (H5Dwrite_chunk(dset, dxpl, filter_mask, offset, buf_size, (void*)direct_buf[n]) < 0)
-                TEST_ERROR
+            ret = H5Dwrite_chunk(dset, H5P_DEFAULT, filter_mask, offset, buf_size, (void*)direct_buf[n]);
+            if(ret < 0) TEST_ERROR
         }
 
+    /* Get and verify the number of chunks written */
+    if(H5Dget_num_chunks(dset, dspace, &nchunks) < 0) TEST_ERROR
+
+    /* Should still be all chunks, because of H5D_ALLOC_TIME_EARLY */
+    if(nchunks != NUM_CHUNKS) TEST_ERROR
+
+    /* Read the entire dataset back */
+    if(H5Dread(dset, H5T_NATIVE_INT, dspace, dspace, H5P_DEFAULT, out_buf) < 0)
+        TEST_ERROR
+
+    /* Get and verify info of the first chunk */
+    index = 0;
+    reinit_vars(&read_flt_msk, &addr, &size);
+    out_offset[0] = out_offset[1] = 0;
+    if(H5Dget_chunk_info(dset, dspace, index, out_offset, &read_flt_msk, &addr, &size) < 0)
+        TEST_ERROR
+    if(read_flt_msk != filter_mask) TEST_ERROR
+    if(size != CHUNK_SIZE) TEST_ERROR
+    if(out_offset[0] != 0 || out_offset[1] != 0) TEST_ERROR
+
+    /* Get and verify info of the second chunk */
+    index = 1;
+    reinit_vars(&read_flt_msk, &addr, &size);
+    out_offset[0] = out_offset[1] = 0;
+    if(H5Dget_chunk_info(dset, dspace, index, out_offset, &read_flt_msk, &addr, &size) < 0)
+        TEST_ERROR
+    if(read_flt_msk != filter_mask) TEST_ERROR
+    if(size != CHUNK_SIZE) TEST_ERROR
+    if(out_offset[0] != 0 || out_offset[1] != 4) TEST_ERROR
+
+    /* Get and verify info of the third chunk */
+    index = 2;
+    reinit_vars(&read_flt_msk, &addr, &size);
+    out_offset[0] = out_offset[1] = 0;
+    if(H5Dget_chunk_info(dset, dspace, index, out_offset, &read_flt_msk, &addr, &size) < 0)
+        TEST_ERROR
+ 
+    if(read_flt_msk != filter_mask) TEST_ERROR
+    if(size != CHUNK_SIZE) TEST_ERROR
+    if(out_offset[0] != 0 || out_offset[1] != 8) TEST_ERROR
+
+    /* Get and verify info of the last chunk */
+    index = 3;
+    reinit_vars(&read_flt_msk, &addr, &size);
+    out_offset[0] = out_offset[1] = 0;
+    if(H5Dget_chunk_info(dset, dspace, index, out_offset, &read_flt_msk, &addr, &size) < 0)
+        TEST_ERROR
+    if(read_flt_msk != filter_mask) TEST_ERROR
+    if(size != CHUNK_SIZE) TEST_ERROR
+    if(out_offset[0] != 0 || out_offset[1] != 12) TEST_ERROR
+
+    /* Attempt to get info of empty chunk and verify the returned address and size */
+    index = 5;
+    reinit_vars(&read_flt_msk, &addr, &size);
+    out_offset[0] = out_offset[1] = 0;
+    if(H5Dget_chunk_info(dset, dspace, index, out_offset, &read_flt_msk, &addr, &size) < 0)
+        TEST_ERROR
+    if(addr == HADDR_UNDEF) TEST_ERROR
+    if(size != CHUNK_SIZE) TEST_ERROR
+    if(out_offset[0] != 6 || out_offset[1] != 4) TEST_ERROR
+
+    /* Get info of the chunk at logical coordinates (0,2) */
+    offset[0] = 0;
+    offset[1] = 2 * CHUNK_NY;
+    if(H5Dget_chunk_info_by_coord(dset, offset, &read_flt_msk, &addr, &size) < 0)
+        TEST_ERROR
+    if(read_flt_msk != filter_mask) TEST_ERROR
+    if(size != CHUNK_SIZE) TEST_ERROR
+
+    /* Get info of the chunk at logical coordinates (1,3) */
+    offset[0] = 1 * CHUNK_NX;
+    offset[1] = 3 * CHUNK_NY;
+    if(H5Dget_chunk_info_by_coord(dset, offset, &read_flt_msk, &addr, &size) < 0)
+        TEST_ERROR
+    if(read_flt_msk != filter_mask) TEST_ERROR
+
+    /* Attempt to get info of empty chunks, verify the returned address and size */
+    offset[0] = 0;
+    offset[1] = 0;
+    if(H5Dget_chunk_info_by_coord(dset, offset, &read_flt_msk, &addr, &size) < 0)
+        TEST_ERROR
+    /* Because of H5P_ALLOC_TIME_EARLY, addr cannot be HADDR_UNDEF */
+    if(addr == HADDR_UNDEF) TEST_ERROR
+    if(size != CHUNK_SIZE) TEST_ERROR
+
+    offset[0] = 3 * CHUNK_NX;
+    offset[1] = 3 * CHUNK_NY;
+    if(H5Dget_chunk_info_by_coord(dset, offset, &read_flt_msk, &addr, &size) < 0)
+        TEST_ERROR
+    /* Because of H5P_ALLOC_TIME_EARLY, addr cannot be HADDR_UNDEF */
+    if(addr == HADDR_UNDEF) TEST_ERROR
+    if(size != CHUNK_SIZE) TEST_ERROR
+
+    /* Read each chunk and verify the values */
+    n = 0;
+    for (i = 0; i < 2; i++)
+        for (j = 2; j < 4; j++, n++)
+            if(read_each_chunk(dset, i*CHUNK_NX, j*CHUNK_NY, (void*)direct_buf[n]) < 0)
+                TEST_ERROR
+
+    /* Release resourse */
+    if(H5Dclose(dset) < 0) TEST_ERROR
+    if(H5Sclose(dspace) < 0) TEST_ERROR
+    if(H5Fclose(chunkfile) < 0) TEST_ERROR
+
+    PASSED();
+    return SUCCEED;
+
+error:
+    H5E_BEGIN_TRY {
+        H5Dclose(dset);
+        H5Sclose(dspace);
+        H5Pclose(cparms);
+        H5Fclose(chunkfile);
+    } H5E_END_TRY;
+
+    H5_FAILED();
+    return FAIL;
+} /* test_chunk_info_implicit() */
+        
+/*-------------------------------------------------------------------------
+ * Function:	test_chunk_info_fixed_array
+ *
+ * Purpose:	    Test getting various chunk information when Fixed Array
+ *              index type is used
+ *
+ * Return:	    Success:	SUCCEED
+ *		        Failure:	FAIL
+ *
+ * Note:        Note that the dataspace argument in these new functions are
+ *              currently not used.  The functionality involved the dataspace
+ *              will be implemented in the next version.
+ *
+ * Date:        November 2018
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+test_chunk_info_fixed_array(char *filename, hid_t fapl)
+{
+    hid_t    chunkfile = -1;     /* File ID */
+    hid_t    dspace = -1;        /* Dataspace ID */
+    hid_t    dset = -1;          /* Dataset ID */
+    hid_t    cparms = -1;        /* Creation plist */
+    hsize_t  dims[2]  = {NX, NY};/* Dataset dimensions */
+    hsize_t  chunk_dims[2] = {CHUNK_NX, CHUNK_NY};      /* Chunk dimensions */
+    int      direct_buf[NUM_CHUNKS][CHUNK_NX][CHUNK_NY];/* Data in chunks */
+    int      out_buf[NX][NY];    /* Buffer to read data in */
+    size_t   buf_size = CHUNK_NX*CHUNK_NY*sizeof(int);  /* Buffer size of a chk */
+    unsigned filter_mask = 0;    /* Filter mask */
+    unsigned read_flt_msk = 0;   /* Filter mask after direct read */
+    H5D_chunk_index_t idx_type;  /* Dataset chunk index type */
+    hsize_t  offset[2];          /* Offset coordinates of a chunk */
+    hsize_t  out_offset[2] = {0, 0}; /* Buffer to get offset coordinates */
+    hsize_t  size = 0;           /* Size of an allocated/written chunk */
+    hsize_t  nchunks = 0;        /* Number of chunks */
+    haddr_t  addr = 0;           /* Address of an allocated/written chunk */
+    hsize_t  index = 0;          /* Index of a chunk */
+    int      n;                  /* Used on buffer, to avoid conversion warning */
+    hsize_t  i, j;
+    herr_t   ret;
+
+    TESTING("   Fixed Array index");
+
+    /* Open the file for reading/writing */
+    if((chunkfile = H5Fopen(filename, H5F_ACC_RDWR, fapl)) < 0)
+        TEST_ERROR
+ 
+    /* Create dataspace */
+    if((dspace = H5Screate_simple(RANK, dims, NULL)) < 0)
+        TEST_ERROR
+
+    /* Enable chunking */
+    if((cparms = H5Pcreate(H5P_DATASET_CREATE)) < 0)
+        TEST_ERROR
+
+    if(H5Pset_chunk(cparms, RANK, chunk_dims) < 0)
+        TEST_ERROR
+
+    /* Create a new dataset using cparms creation properties */
+    dset = H5Dcreate2(chunkfile, DSET_FIXED_ARR_INDEX, H5T_NATIVE_INT, dspace, H5P_DEFAULT, cparms, H5P_DEFAULT);
+    if(dset < 0) TEST_ERROR
+
+    /* Ensure we're using the correct chunk indexing scheme */
+    if(H5D__layout_idx_type_test(dset, &idx_type) < 0)
+        TEST_ERROR
+    if(idx_type != H5D_CHUNK_IDX_FARRAY)
+        FAIL_PUTS_ERROR("should be using Fixed Array index type");
+
     /* Close the dataset then... */
     if(H5Dclose(dset) < 0) TEST_ERROR
 
     /* ...open it again to test the chunk query functions */
-    if((dset = H5Dopen2(chunkfile, DSET_SIMPLE_CHUNKED, H5P_DEFAULT)) < 0) TEST_ERROR
+    if((dset = H5Dopen2(chunkfile, DSET_FIXED_ARR_INDEX, H5P_DEFAULT)) < 0)
+        TEST_ERROR
 
-    /* Get and verify the number of chunks written */
-    if (H5Dget_num_chunks(dset, mspace, &nchunks) < 0) TEST_ERROR;
-    if (nchunks != NUM_CHUNKS_WRITTEN) TEST_ERROR;
+    /* Get the number of chunks and verify that no chunk has been written */
+    if(H5Dget_num_chunks(dset, dspace, &nchunks) < 0) TEST_ERROR
+    if(nchunks != 0) TEST_ERROR
+
+    /* Initialize the array of chunk data for all NUM_CHUNKS chunks */
+    for(n = 0; n < NUM_CHUNKS; n++)
+        for(i = 0; i < CHUNK_NX; i++)
+            for(j = 0; j < CHUNK_NY; j++)
+                direct_buf[n][i][j] = n + 1;
+
+    /* Write only NUM_CHUNKS_WRITTEN chunks at the following logical coords:
+       (0,2) (0,3) (1,2) (1,3) */
+    n = 0;
+    for (i = 0; i < 2; i++)
+        for (j = 2; j < 4; j++, n++)
+        {
+            offset[0] = i * CHUNK_NX;
+            offset[1] = j * CHUNK_NY;
+            ret = H5Dwrite_chunk(dset, H5P_DEFAULT, filter_mask, offset, buf_size, (void*)direct_buf[n]);
+            if(ret < 0) TEST_ERROR
+        }
 
     /* Read the entire dataset back */
-    if(H5Dread(dset, H5T_NATIVE_INT, fspace, fspace, H5P_DEFAULT, out_buf) < 0)
+    if(H5Dread(dset, H5T_NATIVE_INT, dspace, dspace, H5P_DEFAULT, out_buf) < 0)
+        TEST_ERROR
+
+    /* Get and verify the number of chunks written */
+    if(H5Dget_num_chunks(dset, dspace, &nchunks) < 0) TEST_ERROR
+    if(nchunks != NUM_CHUNKS_WRITTEN) TEST_ERROR
+
+    /* Get and verify info of the first chunk */
+    index = 0;
+    reinit_vars(&read_flt_msk, &addr, &size);
+    out_offset[0] = out_offset[1] = 0;
+    if(H5Dget_chunk_info(dset, dspace, index, out_offset, &read_flt_msk, &addr, &size) < 0)
+        TEST_ERROR
+    if(read_flt_msk != filter_mask) TEST_ERROR
+    if(size != CHUNK_SIZE) TEST_ERROR
+    if(out_offset[0] != 0 || out_offset[1] != 8) TEST_ERROR
+
+    /* Get and verify info of the second chunk */
+    index = 1;
+    reinit_vars(&read_flt_msk, &addr, &size);
+    out_offset[0] = out_offset[1] = 0;
+    if(H5Dget_chunk_info(dset, dspace, index, out_offset, &read_flt_msk, &addr, &size) < 0)
+        TEST_ERROR
+    if(read_flt_msk != filter_mask) TEST_ERROR
+    if(size != CHUNK_SIZE) TEST_ERROR
+    if(out_offset[0] != 0 || out_offset[1] != 12) TEST_ERROR
+
+    /* Get and verify info of the third chunk */
+    index = 2;
+    reinit_vars(&read_flt_msk, &addr, &size);
+    out_offset[0] = out_offset[1] = 0;
+    if(H5Dget_chunk_info(dset, dspace, index, out_offset, &read_flt_msk, &addr, &size) < 0)
+        TEST_ERROR
+    if(read_flt_msk != filter_mask) TEST_ERROR
+    if(size != CHUNK_SIZE) TEST_ERROR
+    if(out_offset[0] != 6 || out_offset[1] != 8) TEST_ERROR
+
+    /* Get and verify info of the last chunk */
+    index = 3;
+    reinit_vars(&read_flt_msk, &addr, &size);
+    out_offset[0] = out_offset[1] = 0;
+    if(H5Dget_chunk_info(dset, dspace, index, out_offset, &read_flt_msk, &addr, &size) < 0)
+        TEST_ERROR
+    if(read_flt_msk != filter_mask) TEST_ERROR
+    if(size != CHUNK_SIZE) TEST_ERROR
+    if(out_offset[0] != 6 || out_offset[1] != 12) TEST_ERROR
+
+    /* Attempt to get info of empty chunk and verify the returned address and size */
+    index = 5;
+    reinit_vars(&read_flt_msk, &addr, &size);
+    out_offset[0] = out_offset[1] = 0;
+    if(H5Dget_chunk_info(dset, dspace, index, out_offset, &read_flt_msk, &addr, &size) < 0)
+        TEST_ERROR
+    if(addr != HADDR_UNDEF) TEST_ERROR
+    if(size != 0) TEST_ERROR
+
+    /* Get info of the chunk at logical coordinates (0,2) */
+    offset[0] = 0;
+    offset[1] = 2 * CHUNK_NY;
+    if(H5Dget_chunk_info_by_coord(dset, offset, &read_flt_msk, &addr, &size) < 0) TEST_ERROR
+    if(read_flt_msk != filter_mask) TEST_ERROR
+    if(size != CHUNK_SIZE) TEST_ERROR
+
+    /* Get info of the chunk at logical coordinates (1,3) */
+    offset[0] = 1 * CHUNK_NX;
+    offset[1] = 3 * CHUNK_NY;
+    if(H5Dget_chunk_info_by_coord(dset, offset, &read_flt_msk, &addr, &size) < 0) TEST_ERROR
+    if(read_flt_msk != filter_mask) TEST_ERROR
+    if(size != CHUNK_SIZE) TEST_ERROR
+
+    /* Attempt to get info of empty chunks, verify the returned address and size */
+    offset[0] = 0;
+    offset[1] = 0;
+    if(H5Dget_chunk_info_by_coord(dset, offset, &read_flt_msk, &addr, &size) < 0) TEST_ERROR
+    if(addr != HADDR_UNDEF) TEST_ERROR
+    if(size != 0) TEST_ERROR
+
+    offset[0] = 3 * CHUNK_NX;
+    offset[1] = 3 * CHUNK_NY;
+    if(H5Dget_chunk_info_by_coord(dset, offset, &read_flt_msk, &addr, &size) < 0) TEST_ERROR
+    if(addr != HADDR_UNDEF) TEST_ERROR
+    if(size != 0) TEST_ERROR
+
+    /* Read each chunk and verify the values */
+    n = 0;
+    for (i = 0; i < 2; i++)
+        for (j = 2; j < 4; j++, n++)
+            if(read_each_chunk(dset, i*CHUNK_NX, j*CHUNK_NY, (void*)direct_buf[n]) < 0)
+                TEST_ERROR
+
+    /* Release resourse */
+    if(H5Dclose(dset) < 0) TEST_ERROR
+    if(H5Sclose(dspace) < 0) TEST_ERROR
+    if(H5Fclose(chunkfile) < 0) TEST_ERROR
+
+    PASSED();
+    return SUCCEED;
+
+error:
+    H5E_BEGIN_TRY {
+        H5Dclose(dset);
+        H5Sclose(dspace);
+        H5Pclose(cparms);
+        H5Fclose(chunkfile);
+    } H5E_END_TRY;
+
+    H5_FAILED();
+    return FAIL;
+} /* test_chunk_info_fixed_array() */
+        
+/*-------------------------------------------------------------------------
+ * Function:	test_chunk_info_extensible_array
+ *
+ * Purpose:	    Test getting various chunk information when Extensible Array
+ *              index type is used
+ *
+ * Return:	    Success:	SUCCEED
+ *		        Failure:	FAIL
+ *
+ * Note:        Note that the dataspace argument in these new functions are
+ *              currently not used.  The functionality involved the dataspace
+ *              will be implemented in the next version.
+ *
+ * Date:        November 2018
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+test_chunk_info_extensible_array(char *filename, hid_t fapl)
+{
+    hid_t    chunkfile = -1;     /* File ID */
+    hid_t    dspace = -1;        /* Dataspace ID */
+    hid_t    dset = -1;          /* Dataset ID */
+    hid_t    cparms = -1;        /* Creation plist */
+    hsize_t  dims[2]  = {NX, NY};/* Dataset dimensions */
+    hsize_t  chunk_dims[2] = {CHUNK_NX, CHUNK_NY};      /* Chunk dimensions */
+    hsize_t  maxdims[2] = {H5S_UNLIMITED, NY}; /* One unlimited dimension */
+    int      direct_buf[NUM_CHUNKS][CHUNK_NX][CHUNK_NY];/* Data in chunks */
+    int      out_buf[NX][NY];    /* Buffer to read data in */
+    size_t   buf_size = CHUNK_NX*CHUNK_NY*sizeof(int);  /* Buffer size of a chk */
+    unsigned filter_mask = 0;    /* Filter mask */
+    unsigned read_flt_msk = 0;   /* Filter mask after direct read */
+    H5D_chunk_index_t idx_type;  /* Dataset chunk index type */
+    hsize_t  offset[2];          /* Offset coordinates of a chunk */
+    hsize_t  out_offset[2] = {0, 0}; /* Buffer to get offset coordinates */
+    hsize_t  size = 0;           /* Size of an allocated/written chunk */
+    hsize_t  nchunks = 0;        /* Number of chunks */
+    haddr_t  addr = 0;           /* Address of an allocated/written chunk */
+    hsize_t  index = 0;          /* Index of a chunk */
+    int      n;                  /* Used on buffer, to avoid conversion warning */
+    hsize_t  i, j;
+    herr_t   ret;
+
+    TESTING("   Extensible Array index");
+
+    /* Open the file for reading/writing */
+    if((chunkfile = H5Fopen(filename, H5F_ACC_RDWR, fapl)) < 0)
+        TEST_ERROR
+ 
+    /* Create dataspace */
+    if((dspace = H5Screate_simple(RANK, dims, maxdims)) < 0)
+        TEST_ERROR
+
+    /* Enable chunking */
+    if((cparms = H5Pcreate(H5P_DATASET_CREATE)) < 0)
+        TEST_ERROR
+
+    if(H5Pset_chunk(cparms, RANK, chunk_dims) < 0)
+        TEST_ERROR
+
+    /* Create a new dataset using cparms creation properties */
+    dset = H5Dcreate2(chunkfile, DSET_EXT_ARR_INDEX, H5T_NATIVE_INT, dspace, H5P_DEFAULT, cparms, H5P_DEFAULT);
+    if(dset < 0) TEST_ERROR
+
+    /* Ensure we're using the correct chunk indexing scheme */
+    if(H5D__layout_idx_type_test(dset, &idx_type) < 0)
         TEST_ERROR
+    if(idx_type != H5D_CHUNK_IDX_EARRAY)
+        FAIL_PUTS_ERROR("should be using Extensible Array index type");
+
+    /* Close the dataset then... */
+    if(H5Dclose(dset) < 0) TEST_ERROR
+
+    /* ...open it again to test the chunk query functions */
+    if((dset = H5Dopen2(chunkfile, DSET_EXT_ARR_INDEX, H5P_DEFAULT)) < 0)
+        TEST_ERROR
+
+    /* Get the number of chunks and verify that no chunk has been written */
+    if(H5Dget_num_chunks(dset, dspace, &nchunks) < 0) TEST_ERROR
+    if(nchunks != 0) TEST_ERROR
+
+    /* Initialize the array of chunk data for all NUM_CHUNKS chunks */
+    for(n = 0; n < NUM_CHUNKS; n++)
+        for(i = 0; i < CHUNK_NX; i++)
+            for(j = 0; j < CHUNK_NY; j++)
+                direct_buf[n][i][j] = n + 1;
+
+    /* Write only NUM_CHUNKS_WRITTEN chunks at the following logical coords:
+       (0,2) (0,3) (1,2) (1,3) */
+    n = 0;
+    for (i = 0; i < 2; i++)
+        for (j = 2; j < 4; j++, n++)
+        {
+            offset[0] = i * CHUNK_NX;
+            offset[1] = j * CHUNK_NY;
+            ret = H5Dwrite_chunk(dset, H5P_DEFAULT, filter_mask, offset, buf_size, (void*)direct_buf[n]);
+            if(ret < 0) TEST_ERROR
+        }
+
+    /* Get and verify the number of chunks written */
+    if(H5Dget_num_chunks(dset, dspace, &nchunks) < 0) TEST_ERROR
+    if(nchunks != NUM_CHUNKS_WRITTEN) TEST_ERROR
 
     /* Get and verify info of the first chunk */
     index = 0;
-    reinit_vars(&read_filter_mask, &addr, &size);
-    if (H5Dget_chunk_info(dset, fspace, index, out_offset, &read_filter_mask, &addr, &size) < 0)
+    reinit_vars(&read_flt_msk, &addr, &size);
+    out_offset[0] = out_offset[1] = 0;
+    if(H5Dget_chunk_info(dset, dspace, index, out_offset, &read_flt_msk, &addr, &size) < 0)
         TEST_ERROR
-    if (read_filter_mask != filter_mask) TEST_ERROR;
-    if (size != CHUNK_SIZE) TEST_ERROR;
-    if (out_offset[0] != 0 || out_offset[1] != 8) TEST_ERROR;
+    if(read_flt_msk != filter_mask) TEST_ERROR
+    if(size != CHUNK_SIZE) TEST_ERROR
+    if(out_offset[0] != 0 || out_offset[1] != 8) TEST_ERROR
 
     /* Get and verify info of the second chunk */
     index = 1;
-    reinit_vars(&read_filter_mask, &addr, &size);
-    if (H5Dget_chunk_info(dset, fspace, index, out_offset, &read_filter_mask, &addr, &size) < 0)
+    reinit_vars(&read_flt_msk, &addr, &size);
+    out_offset[0] = out_offset[1] = 0;
+    if(H5Dget_chunk_info(dset, dspace, index, out_offset, &read_flt_msk, &addr, &size) < 0)
         TEST_ERROR
-    if (read_filter_mask != filter_mask) TEST_ERROR;
-    if (size != CHUNK_SIZE) TEST_ERROR;
-    if (out_offset[0] != 0 || out_offset[1] != 12) TEST_ERROR;
+    if(read_flt_msk != filter_mask) TEST_ERROR
+    if(size != CHUNK_SIZE) TEST_ERROR
+    if(out_offset[0] != 0 || out_offset[1] != 12) TEST_ERROR
 
     /* Get and verify info of the third chunk */
     index = 2;
-    reinit_vars(&read_filter_mask, &addr, &size);
-    if (H5Dget_chunk_info(dset, fspace, index, out_offset, &read_filter_mask, &addr, &size) < 0)
+    reinit_vars(&read_flt_msk, &addr, &size);
+    out_offset[0] = out_offset[1] = 0;
+    if(H5Dget_chunk_info(dset, dspace, index, out_offset, &read_flt_msk, &addr, &size) < 0)
         TEST_ERROR
  
-    if (read_filter_mask != filter_mask) TEST_ERROR;
-    if (size != CHUNK_SIZE) TEST_ERROR;
-    if (out_offset[0] != 4 || out_offset[1] != 8) TEST_ERROR;
+    if(read_flt_msk != filter_mask) TEST_ERROR
+    if(size != CHUNK_SIZE) TEST_ERROR
+    if(out_offset[0] != 6 || out_offset[1] != 8) TEST_ERROR
 
     /* Get and verify info of the last chunk */
     index = 3;
-    reinit_vars(&read_filter_mask, &addr, &size);
-    if (H5Dget_chunk_info(dset, fspace, index, out_offset, &read_filter_mask, &addr, &size) < 0)
+    reinit_vars(&read_flt_msk, &addr, &size);
+    out_offset[0] = out_offset[1] = 0;
+    if(H5Dget_chunk_info(dset, dspace, index, out_offset, &read_flt_msk, &addr, &size) < 0)
         TEST_ERROR
-    if (read_filter_mask != filter_mask) TEST_ERROR;
-    if (size != CHUNK_SIZE) TEST_ERROR;
-    if (out_offset[0] != 4 || out_offset[1] != 12) TEST_ERROR;
+    if(read_flt_msk != filter_mask) TEST_ERROR
+    if(size != CHUNK_SIZE) TEST_ERROR
+    if(out_offset[0] != 6 || out_offset[1] != 12) TEST_ERROR
 
     /* Attempt to get info of empty chunk and verify the returned address and size */
     index = 5;
-    reinit_vars(&read_filter_mask, &addr, &size);
-    if (H5Dget_chunk_info(dset, fspace, index, out_offset, &read_filter_mask, &addr, &size) < 0)
+    reinit_vars(&read_flt_msk, &addr, &size);
+    out_offset[0] = out_offset[1] = 0;
+    if(H5Dget_chunk_info(dset, dspace, index, out_offset, &read_flt_msk, &addr, &size) < 0)
         TEST_ERROR
-    if (addr != HADDR_UNDEF) TEST_ERROR;
-    if (size != 0) TEST_ERROR;
+    if(addr != HADDR_UNDEF) TEST_ERROR
+    if(size != 0) TEST_ERROR
 
     /* Get info of the chunk at logical coordinates (0,2) */
     offset[0] = 0;
     offset[1] = 2 * CHUNK_NY;
-    if (H5Dget_chunk_info_by_coord(dset, offset, &read_filter_mask, &addr, &size) < 0) TEST_ERROR;
-    if (read_filter_mask != filter_mask) TEST_ERROR;
-    if (size != CHUNK_SIZE) TEST_ERROR;
+    if(H5Dget_chunk_info_by_coord(dset, offset, &read_flt_msk, &addr, &size) < 0) TEST_ERROR
+    if(read_flt_msk != filter_mask) TEST_ERROR
+    if(size != CHUNK_SIZE) TEST_ERROR
 
     /* Get info of the chunk at logical coordinates (1,3) */
     offset[0] = 1 * CHUNK_NX;
     offset[1] = 3 * CHUNK_NY;
-    if (H5Dget_chunk_info_by_coord(dset, offset, &read_filter_mask, &addr, &size) < 0) TEST_ERROR;
-    if (read_filter_mask != filter_mask) TEST_ERROR;
-    if (size != CHUNK_SIZE) TEST_ERROR;
+    if(H5Dget_chunk_info_by_coord(dset, offset, &read_flt_msk, &addr, &size) < 0) TEST_ERROR
+    if(read_flt_msk != filter_mask) TEST_ERROR
+    if(size != CHUNK_SIZE) TEST_ERROR
 
     /* Attempt to get info of empty chunks, verify the returned address and size */
     offset[0] = 0;
     offset[1] = 0;
-    if (H5Dget_chunk_info_by_coord(dset, offset, &read_filter_mask, &addr, &size) < 0) TEST_ERROR;
-    if (addr != HADDR_UNDEF) TEST_ERROR;
-    if (size != 0) TEST_ERROR;
+    if(H5Dget_chunk_info_by_coord(dset, offset, &read_flt_msk, &addr, &size) < 0) TEST_ERROR
+    if(addr != HADDR_UNDEF) TEST_ERROR
+    if(size != 0) TEST_ERROR
 
     offset[0] = 3 * CHUNK_NX;
     offset[1] = 3 * CHUNK_NY;
-    if (H5Dget_chunk_info_by_coord(dset, offset, &read_filter_mask, &addr, &size) < 0) TEST_ERROR;
-    if (addr != HADDR_UNDEF) TEST_ERROR;
-    if (size != 0) TEST_ERROR;
+    if(H5Dget_chunk_info_by_coord(dset, offset, &read_flt_msk, &addr, &size) < 0) TEST_ERROR
+    if(addr != HADDR_UNDEF) TEST_ERROR
+    if(size != 0) TEST_ERROR
 
     /* Read each chunk and verify the values */
     n = 0;
     for (i = 0; i < 2; i++)
         for (j = 2; j < 4; j++, n++)
-            if (read_each_chunk(dset, i*CHUNK_NX, j*CHUNK_NY, (void*)direct_buf[n]) < 0)
+            if(read_each_chunk(dset, i*CHUNK_NX, j*CHUNK_NY, (void*)direct_buf[n]) < 0)
                 TEST_ERROR
 
-    /* Close the first dataset */
-    if (H5Dclose(dset) < 0) TEST_ERROR
+    /* Release resourse */
+    if(H5Dclose(dset) < 0) TEST_ERROR
+    if(H5Sclose(dspace) < 0) TEST_ERROR
+    if(H5Fclose(chunkfile) < 0) TEST_ERROR
 
-    /* Create an empty dataset */
-    if((dset = H5Dcreate2(chunkfile, DSET_EMPTY, H5T_NATIVE_INT, fspace,
-            H5P_DEFAULT, cparms, H5P_DEFAULT)) < 0) TEST_ERROR
-    if (H5Dclose(dset) < 0) TEST_ERROR
+    PASSED();
+    return SUCCEED;
 
-    /* Reopen the empty dataset to verify the chunk query functions on it */
-    if((dset = H5Dopen2(chunkfile, DSET_EMPTY, H5P_DEFAULT)) < 0) TEST_ERROR
+error:
+    H5E_BEGIN_TRY {
+        H5Dclose(dset);
+        H5Sclose(dspace);
+        H5Pclose(cparms);
+        H5Fclose(chunkfile);
+    } H5E_END_TRY;
 
-    /* Verify that the number of chunks is 0 */
-    if (H5Dget_num_chunks(dset, mspace, &nchunks) < 0) TEST_ERROR;
-    if (nchunks != 0) TEST_ERROR;
+    H5_FAILED();
+    return FAIL;
+} /* test_chunk_info_extensible_array() */
 
-    /* Attempt to get info of a chunk from an empty dataset, verify the
-       returned address and size */
+/*-------------------------------------------------------------------------
+ * Function:	test_chunk_info_version2_btrees
+ *
+ * Purpose:	    Test getting various chunk information when Version 2 B-trees
+ *              index type is used
+ *
+ * Return:	    Success:	SUCCEED
+ *		        Failure:	FAIL
+ *
+ * Note:        Note that the dataspace argument in these new functions are
+ *              currently not used.  The functionality involved the dataspace
+ *              will be implemented in the next version.
+ *
+ * Date:        November 2018
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+test_chunk_info_version2_btrees(char *filename, hid_t fapl)
+{
+    hid_t    chunkfile = -1;     /* File ID */
+    hid_t    dspace = -1;        /* Dataspace ID */
+    hid_t    dset = -1;          /* Dataset ID */
+    hid_t    cparms = -1;        /* Creation plist */
+    hsize_t  dims[2]  = {NX, NY};/* Dataset dimensions */
+    hsize_t  chunk_dims[2] = {CHUNK_NX, CHUNK_NY};      /* Chunk dimensions */
+    hsize_t  maxdims[2] = {H5S_UNLIMITED, H5S_UNLIMITED}; /* Two unlimited dims */
+    int      direct_buf[NUM_CHUNKS][CHUNK_NX][CHUNK_NY];/* Data in chunks */
+    int      out_buf[NX][NY];    /* Buffer to read data in */
+    size_t   buf_size = CHUNK_NX*CHUNK_NY*sizeof(int);  /* Buffer size of a chk */
+    unsigned filter_mask = 0;    /* Filter mask */
+    unsigned read_flt_msk = 0;   /* Filter mask after direct read */
+    H5D_chunk_index_t idx_type;  /* Dataset chunk index type */
+    hsize_t  offset[2];          /* Offset coordinates of a chunk */
+    hsize_t  out_offset[2] = {0, 0}; /* Buffer to get offset coordinates */
+    hsize_t  size = 0;           /* Size of an allocated/written chunk */
+    hsize_t  nchunks = 0;        /* Number of chunks */
+    haddr_t  addr = 0;           /* Address of an allocated/written chunk */
+    hsize_t  index = 0;          /* Index of a chunk */
+    int      n;                  /* Used on buffer, to avoid conversion warning */
+    hsize_t  i, j;
+    herr_t   ret;
+
+    TESTING("   Version 2 B-trees index");
+
+    /* Open the file for reading/writing */
+    if((chunkfile = H5Fopen(filename, H5F_ACC_RDWR, fapl)) < 0)
+        TEST_ERROR
+ 
+    /* Create dataspace */
+    if((dspace = H5Screate_simple(RANK, dims, maxdims)) < 0)
+        TEST_ERROR
+
+    /* Enable chunking */
+    if((cparms = H5Pcreate(H5P_DATASET_CREATE)) < 0)
+        TEST_ERROR
+
+    if(H5Pset_chunk(cparms, RANK, chunk_dims) < 0)
+        TEST_ERROR
+
+    /* Create a new dataset using cparms creation properties */
+    dset = H5Dcreate2(chunkfile, DSET_V2_BTREE_INDEX, H5T_NATIVE_INT, dspace, H5P_DEFAULT, cparms, H5P_DEFAULT);
+    if(dset < 0) TEST_ERROR
+
+    /* Ensure we're using the correct chunk indexing scheme */
+    if(H5D__layout_idx_type_test(dset, &idx_type) < 0)
+        TEST_ERROR
+    if(idx_type != H5D_CHUNK_IDX_BT2)
+        FAIL_PUTS_ERROR("should be using Version 2 B-tree index type");
+
+    /* Close the dataset then... */
+    if(H5Dclose(dset) < 0) TEST_ERROR
+
+    /* ...open it again to test the chunk query functions */
+    if((dset = H5Dopen2(chunkfile, DSET_V2_BTREE_INDEX, H5P_DEFAULT)) < 0)
+        TEST_ERROR
+
+    /* Get the number of chunks and verify that no chunk has been written */
+    if(H5Dget_num_chunks(dset, dspace, &nchunks) < 0) TEST_ERROR
+    if(nchunks != 0) TEST_ERROR
+
+    /* Initialize the array of chunk data for all NUM_CHUNKS chunks */
+    for(n = 0; n < NUM_CHUNKS; n++)
+        for(i = 0; i < CHUNK_NX; i++)
+            for(j = 0; j < CHUNK_NY; j++)
+                direct_buf[n][i][j] = n + 1;
+
+    /* Write only NUM_CHUNKS_WRITTEN chunks at the following logical coords:
+       (0,2) (0,3) (1,2) (1,3) */
+    n = 0;
+    for (i = 0; i < 2; i++)
+        for (j = 2; j < 4; j++, n++)
+        {
+            offset[0] = i * CHUNK_NX;
+            offset[1] = j * CHUNK_NY;
+            ret = H5Dwrite_chunk(dset, H5P_DEFAULT, filter_mask, offset, buf_size, (void*)direct_buf[n]);
+            if(ret < 0) TEST_ERROR
+        }
+
+    /* Get and verify the number of chunks written */
+    if(H5Dget_num_chunks(dset, dspace, &nchunks) < 0) TEST_ERROR
+    if(nchunks != NUM_CHUNKS_WRITTEN) TEST_ERROR
+
+    /* Get and verify info of the first chunk */
     index = 0;
-    reinit_vars(&read_filter_mask, &addr, &size);
-    if (H5Dget_chunk_info(dset, fspace, index, out_offset, &read_filter_mask, &addr, &size) < 0)
+    reinit_vars(&read_flt_msk, &addr, &size);
+    out_offset[0] = out_offset[1] = 0;
+    if(H5Dget_chunk_info(dset, dspace, index, out_offset, &read_flt_msk, &addr, &size) < 0)
         TEST_ERROR
-    if (addr != HADDR_UNDEF) TEST_ERROR;
-    if (size != 0) TEST_ERROR;
+    if(read_flt_msk != filter_mask) TEST_ERROR
+    if(size != CHUNK_SIZE) TEST_ERROR
+    if(out_offset[0] != 0 || out_offset[1] != 8) TEST_ERROR
 
-    /* Attempt to get info of a chunk given its coords from an empty dataset,
-       verify the returned address and size */
+    /* Get and verify info of the second chunk */
+    index = 1;
+    reinit_vars(&read_flt_msk, &addr, &size);
+    out_offset[0] = out_offset[1] = 0;
+    if(H5Dget_chunk_info(dset, dspace, index, out_offset, &read_flt_msk, &addr, &size) < 0)
+        TEST_ERROR
+    if(read_flt_msk != filter_mask) TEST_ERROR
+    if(size != CHUNK_SIZE) TEST_ERROR
+    if(out_offset[0] != 0 || out_offset[1] != 12) TEST_ERROR
+
+    /* Get and verify info of the third chunk */
+    index = 2;
+    reinit_vars(&read_flt_msk, &addr, &size);
+    out_offset[0] = out_offset[1] = 0;
+    if(H5Dget_chunk_info(dset, dspace, index, out_offset, &read_flt_msk, &addr, &size) < 0)
+        TEST_ERROR
+ 
+    if(read_flt_msk != filter_mask) TEST_ERROR
+    if(size != CHUNK_SIZE) TEST_ERROR
+    if(out_offset[0] != 6 || out_offset[1] != 8) TEST_ERROR
+
+    /* Get and verify info of the last chunk */
+    index = 3;
+    reinit_vars(&read_flt_msk, &addr, &size);
+    out_offset[0] = out_offset[1] = 0;
+    if(H5Dget_chunk_info(dset, dspace, index, out_offset, &read_flt_msk, &addr, &size) < 0)
+        TEST_ERROR
+    if(read_flt_msk != filter_mask) TEST_ERROR
+    if(size != CHUNK_SIZE) TEST_ERROR
+    if(out_offset[0] != 6 || out_offset[1] != 12) TEST_ERROR
+
+    /* Attempt to get info of empty chunk and verify the returned address and size */
+    index = 5;
+    reinit_vars(&read_flt_msk, &addr, &size);
+    out_offset[0] = out_offset[1] = 0;
+    if(H5Dget_chunk_info(dset, dspace, index, out_offset, &read_flt_msk, &addr, &size) < 0)
+        TEST_ERROR
+    if(addr != HADDR_UNDEF) TEST_ERROR
+    if(size != 0) TEST_ERROR
+
+    /* Get info of the chunk at logical coordinates (0,2) */
+    offset[0] = 0;
+    offset[1] = 2 * CHUNK_NY;
+    if(H5Dget_chunk_info_by_coord(dset, offset, &read_flt_msk, &addr, &size) < 0) TEST_ERROR
+    if(read_flt_msk != filter_mask) TEST_ERROR
+    if(size != CHUNK_SIZE) TEST_ERROR
+
+    /* Get info of the chunk at logical coordinates (1,3) */
+    offset[0] = 1 * CHUNK_NX;
+    offset[1] = 3 * CHUNK_NY;
+    if(H5Dget_chunk_info_by_coord(dset, offset, &read_flt_msk, &addr, &size) < 0) TEST_ERROR
+    if(read_flt_msk != filter_mask) TEST_ERROR
+    if(size != CHUNK_SIZE) TEST_ERROR
+
+    /* Attempt to get info of empty chunks, verify the returned address and size */
     offset[0] = 0;
     offset[1] = 0;
-    if (H5Dget_chunk_info_by_coord(dset, offset, &read_filter_mask, &addr, &size) < 0) TEST_ERROR;
-    if (addr != HADDR_UNDEF) TEST_ERROR;
-    if (size != 0) TEST_ERROR;
+    if(H5Dget_chunk_info_by_coord(dset, offset, &read_flt_msk, &addr, &size) < 0) TEST_ERROR
+    if(addr != HADDR_UNDEF) TEST_ERROR
+    if(size != 0) TEST_ERROR
 
-    /* Close/release resources. */
-    if (H5Sclose(mspace) < 0) TEST_ERROR
-    if (H5Sclose(fspace) < 0) TEST_ERROR
-    if (H5Pclose(cparms) < 0) TEST_ERROR
-    if (H5Pclose(dxpl) < 0) TEST_ERROR
-    if (H5Fclose(chunkfile) < 0) TEST_ERROR
+    offset[0] = 3 * CHUNK_NX;
+    offset[1] = 3 * CHUNK_NY;
+    if(H5Dget_chunk_info_by_coord(dset, offset, &read_flt_msk, &addr, &size) < 0) TEST_ERROR
+    if(addr != HADDR_UNDEF) TEST_ERROR
+    if(size != 0) TEST_ERROR
+
+    /* Read each chunk and verify the values */
+    n = 0;
+    for (i = 0; i < 2; i++)
+        for (j = 2; j < 4; j++, n++)
+            if(read_each_chunk(dset, i*CHUNK_NX, j*CHUNK_NY, (void*)direct_buf[n]) < 0)
+                TEST_ERROR
+
+    /* Release resourse */
+    if(H5Dclose(dset) < 0) TEST_ERROR
+    if(H5Sclose(dspace) < 0) TEST_ERROR
+    if(H5Fclose(chunkfile) < 0) TEST_ERROR
 
     PASSED();
     return SUCCEED;
@@ -339,16 +1426,92 @@ test_get_chunk_info(void)
 error:
     H5E_BEGIN_TRY {
         H5Dclose(dset);
-        H5Sclose(mspace);
-        H5Sclose(fspace);
+        H5Sclose(dspace);
         H5Pclose(cparms);
-        H5Pclose(dxpl);
         H5Fclose(chunkfile);
     } H5E_END_TRY;
 
     H5_FAILED();
     return FAIL;
-} /* test_get_chunk_info() */
+} /* test_chunk_info_version2_btrees() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	test_get_chunk_info_110
+ *
+ * Purpose:	    Test getting various chunk information in version 1.10.
+ *
+ * Return:	    Success:	SUCCEED
+ *		        Failure:	FAIL
+ *
+ * Note:        Note that the dataspace argument in these new functions are
+ *              currently not used.  The functionality involved the dataspace
+ *              will be implemented in the next version.
+ *
+ * Description:
+ *              This function tests the new API functions added for EED-343:
+ *              H5Dget_num_chunks, H5Dget_chunk_info, and H5Dget_chunk_info_by_coord
+ *              for high bound beyond 1.8.
+ *
+ * Date:        October 2018
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+test_get_chunk_info_110(hid_t fapl)
+{
+    hid_t        chunkfile = -1; /* File ID */
+    char         filename[FILENAME_BUF_SIZE];
+    H5F_libver_t low, high;      /* File format bounds */
+
+    TESTING("getting chunk information in file with versions 1.10");
+    HDprintf("\n"); /* to list sub-tests */
+
+    /* Create the file */
+    h5_fixname(FILENAME[1], fapl, filename, sizeof filename);
+    chunkfile = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+    if(chunkfile < 0) TEST_ERROR
+
+    /* Close the file, individual tests will re-open the file with different
+       libvers via the fapl */
+    if(H5Fclose(chunkfile) < 0) TEST_ERROR
+
+    /* Set high bound to the current latest version */
+    high = H5F_LIBVER_LATEST;
+
+    /* Test getting info of chunked datasets in version combo up to 1.10 */
+    for (low = H5F_LIBVER_V110; low <= H5F_LIBVER_LATEST; low++) {
+        /* Set version bounds for creating file */
+        if(H5Pset_libver_bounds(fapl, low, high) < 0)
+            TEST_ERROR
+        
+        /* Test getting chunk info when Single Chunk index type is used */
+        if(test_chunk_info_single_chunk(filename, fapl) < 0)
+            TEST_ERROR
+        
+        /* Test getting chunk info when Implicit index type is used */
+        if(test_chunk_info_implicit(filename, fapl) < 0)
+            TEST_ERROR
+        
+        /* Test getting chunk info when Fixed Array index type is used */
+        if(test_chunk_info_fixed_array(filename, fapl) < 0)
+            TEST_ERROR
+        
+        /* Test getting chunk info when Extensible Array index type is used */
+        if(test_chunk_info_extensible_array(filename, fapl) < 0)
+            TEST_ERROR
+
+        /* Test getting chunk info when Version 2 B-trees index type is used */
+        if(test_chunk_info_version2_btrees(filename, fapl) < 0)
+            TEST_ERROR
+    } /* for low libver bound */
+
+    return SUCCEED;
+
+error:
+    H5_FAILED();
+    return FAIL;
+} /* test_get_chunk_info_110() */
 
 /*-------------------------------------------------------------------------
  * Function:    create_4x4_dset
@@ -375,8 +1538,8 @@ error:
  *
  *-------------------------------------------------------------------------
  */
-int
-create_4x4_dset(void)
+static int
+create_4x4_dset(hid_t fapl)
 {
     hid_t   fid;      /* file ID */
     hid_t   did;      /* dataset ID */
@@ -389,19 +1552,21 @@ create_4x4_dset(void)
     int     chunk_data[2][2] = { {1, 1}, {1, 1} };
     int     buf[4][4];
     int     fillvalue = 0;
+    char    filename[FILENAME_BUF_SIZE];
     hsize_t i, j;
 
     /* create a new file using default properties. */
-    if ((fid = H5Fcreate(H5FILE_NAME, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR;
+    h5_fixname(FILENAME[2], fapl, filename, sizeof filename);
+    if((fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
 
     /* create the file space */
-    if ((f_sid = H5Screate_simple(RANK, dims, dims)) < 0) TEST_ERROR;
+    if((f_sid = H5Screate_simple(RANK, dims, dims)) < 0) TEST_ERROR
 
     /* create the memory space with chunk dimensions */
-    if ((m_sid = H5Screate_simple(RANK, chunk_dims, chunk_dims)) < 0) TEST_ERROR;
+    if((m_sid = H5Screate_simple(RANK, chunk_dims, chunk_dims)) < 0) TEST_ERROR
     start[0] = 0;
     start[1] = 0;
-    if (H5Sselect_hyperslab(m_sid, H5S_SELECT_SET, start, NULL, chunk_dims, NULL) < 0) TEST_ERROR;
+    if(H5Sselect_hyperslab(m_sid, H5S_SELECT_SET, start, NULL, chunk_dims, NULL) < 0) TEST_ERROR
 
    /*-------------------------------------------------------------------------
     * create a dataset
@@ -409,13 +1574,13 @@ create_4x4_dset(void)
     */
 
     /* modify dataset creation properties, i.e. enable chunking. */
-    if ((pid = H5Pcreate (H5P_DATASET_CREATE)) < 0) TEST_ERROR;
-    if (H5Pset_chunk(pid, RANK, chunk_dims) < 0) TEST_ERROR;
-    if (H5Pset_fill_value(pid, H5T_NATIVE_INT, &fillvalue) < 0) TEST_ERROR;
+    if((pid = H5Pcreate (H5P_DATASET_CREATE)) < 0) TEST_ERROR
+    if(H5Pset_chunk(pid, RANK, chunk_dims) < 0) TEST_ERROR
+    if(H5Pset_fill_value(pid, H5T_NATIVE_INT, &fillvalue) < 0) TEST_ERROR
 
     /* create a new dataset */
-    if((did = H5Dcreate2(fid , DATASETNAME, H5T_NATIVE_INT, f_sid, H5P_DEFAULT, pid, H5P_DEFAULT)) < 0) TEST_ERROR;
-
+    did = H5Dcreate2(fid , DATASETNAME, H5T_NATIVE_INT, f_sid, H5P_DEFAULT, pid, H5P_DEFAULT);
+    if(did < 0) TEST_ERROR
 
    /*-------------------------------------------------------------------------
     * write the dataset in 2x2 chunks
@@ -430,13 +1595,13 @@ create_4x4_dset(void)
         /* iterate in dim 1 */
         for (i = 0; i < chunk_dims[1]; i++) {
             /* select file hyperslab to save a 2x2 chunk */
-            if (H5Sselect_hyperslab(f_sid, H5S_SELECT_SET, start, NULL, chunk_dims, NULL) < 0) TEST_ERROR;
+            if(H5Sselect_hyperslab(f_sid, H5S_SELECT_SET, start, NULL, chunk_dims, NULL) < 0) TEST_ERROR
 
             /* write the data to the hyperslab. */
-            if (H5Dwrite(did, H5T_NATIVE_INT, m_sid, f_sid, H5P_DEFAULT, chunk_data) < 0) TEST_ERROR;
+            if(H5Dwrite(did, H5T_NATIVE_INT, m_sid, f_sid, H5P_DEFAULT, chunk_data) < 0) TEST_ERROR
 
             /* read back and display complete dataset 4x4 */
-            if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf) < 0) TEST_ERROR;
+            if(H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf) < 0) TEST_ERROR
 
 #if defined (PRINT_DATA)
             printf("\n");
@@ -457,11 +1622,11 @@ create_4x4_dset(void)
     * close
     *-------------------------------------------------------------------------
     */
-    if (H5Dclose(did) < 0) TEST_ERROR
-    if (H5Sclose(f_sid) < 0) TEST_ERROR
-    if (H5Sclose(m_sid) < 0) TEST_ERROR
-    if (H5Pclose(pid) < 0) TEST_ERROR
-    if (H5Fclose(fid) < 0) TEST_ERROR
+    if(H5Dclose(did) < 0) TEST_ERROR
+    if(H5Sclose(f_sid) < 0) TEST_ERROR
+    if(H5Sclose(m_sid) < 0) TEST_ERROR
+    if(H5Pclose(pid) < 0) TEST_ERROR
+    if(H5Fclose(fid) < 0) TEST_ERROR
 
     return SUCCEED;
 
@@ -491,22 +1656,31 @@ error:
 int
 main(void)
 {
-    int     nerrors = 0;
+    hid_t fapl = -1;    /* File access property list */
+    int   nerrors = 0;  /* Number of errors so far */
+
+    h5_reset();
+
+    /* Create a copy of file access property list */
+    if((fapl = H5Pcreate(H5P_FILE_ACCESS)) < 0) TEST_ERROR
 
-    /* Tests getting chunk information */
-    nerrors += (test_get_chunk_info() < 0 ? 1 : 0);
+    /* Tests getting chunk information of version 1.8 and prior */
+    nerrors += test_get_chunk_info_highest18(fapl) < 0 ? 1 : 0;
+
+    /* Tests getting chunk information of version 1.10 */
+    nerrors += test_get_chunk_info_110(fapl) < 0 ? 1 : 0;
 
     /* Create a 4x4 dataset (using the existing code to avoid compilation
        warnings for now) */
-    nerrors += (create_4x4_dset() < 0 ? 1 : 0);
+    nerrors += create_4x4_dset(fapl) < 0 ? 1 : 0;
 
-    if(nerrors) {
+    if(nerrors)
         goto error;
 
-    } /* end if */
-
     HDprintf("All chunk query tests passed.\n");
 
+    h5_cleanup(FILENAME, fapl);
+
     return SUCCEED;
 
 error:
@@ -516,5 +1690,12 @@ error:
     return FAIL;
 }
 
+/****************************************************************************
+ Additional tests to be added:
+- create/write to a dataset, do the query before closing the dataset
+- do the query when extending the dataset (shrink or expand)
+- verify that invalid input parameters are handled properly
+- do the query on a non-chunked dataset...
+- test for filter or non-filter
 
-
+****************************************************************************/