Updated new API functions

Description:
    - Addressed additional review comments
    - Moved the test function test_get_chunk_info from dsets.c to chunk_info.c
      because chunk_info.c was created for the purpose of testing chunk information.
Platforms tested:
    Linux/64 (jelly)
    Linux/64 (platypus)
    Darwin (osx1011test)

4 files changed, 432 insertions, 64 deletions

diff --git a/src/H5Dchunk.c b/src/H5Dchunk.c
index 7e7a94c..7aaea74 100644
--- a/src/H5Dchunk.c
+++ b/src/H5Dchunk.c
@@ -265,7 +265,7 @@ static herr_t H5D__chunk_io_term(const H5D_chunk_map_t *fm);
 static herr_t H5D__chunk_dest(H5D_t *dset);
 
 /* Chunk query operation callbacks */
-static int H5D__get_num_chunks_cb(const H5D_chunk_rec_t H5_ATTR_UNUSED *chunk_rec, void *_udata);
+static int H5D__get_num_chunks_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata);
 static int H5D__get_chunk_info_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata);
 static int H5D__get_chunk_info_by_coord_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata);
 
@@ -6827,7 +6827,7 @@ H5D__get_num_chunks(const H5D_t *dset, const H5S_t H5_ATTR_UNUSED *space, hsize_
     idx_info.storage = &dset->shared->layout.storage.u.chunk;
 
     /* If the dataset is not written, number of chunks will be 0 */
-    if (idx_info.storage->idx_addr == HADDR_UNDEF) {
+    if(!H5F_addr_defined(idx_info.storage->idx_addr)) {
         *nchunks = 0;
         HGOTO_DONE(SUCCEED);
     }
@@ -6938,14 +6938,15 @@ H5D__get_chunk_info(const H5D_t *dset, const H5S_t H5_ATTR_UNUSED *space, hsize_
     idx_info.layout = &dset->shared->layout.u.chunk;
     idx_info.storage = &dset->shared->layout.storage.u.chunk;
 
-    /* If the dataset is not written, return the address as undefined */
-    if (idx_info.storage->idx_addr == HADDR_UNDEF) {
-        if (addr)
-            *addr = HADDR_UNDEF;
-        if (size)
-            *size = 0;
+    /* Set addr & size for when dset is not written or queried chunk is not found */
+    if (addr)
+        *addr = HADDR_UNDEF;
+    if (size)
+        *size = 0;
+
+    /* If the dataset is not written, return without error */
+    if(!H5F_addr_defined(idx_info.storage->idx_addr))
         HGOTO_DONE(SUCCEED);
-    }
 
     /* Initialize before iteration */
     udata.chunk_idx = index;
@@ -6972,13 +6973,6 @@ H5D__get_chunk_info(const H5D_t *dset, const H5S_t H5_ATTR_UNUSED *space, hsize_
             for (ii = 0; ii < udata.ndims; ii++)
                 offset[ii] = udata.scaled[ii] * dset->shared->layout.u.chunk.dim[ii];
     }
-    /* otherwise, return HADDR_UNDEF for address and 0 for size */
-    else {
-        if (addr)
-            *addr = HADDR_UNDEF;
-        if (size)
-            *size = 0;
-    }
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -7083,12 +7077,14 @@ H5D__get_chunk_info_by_coord(const H5D_t *dset, const hsize_t *offset, unsigned*
     idx_info.layout = &dset->shared->layout.u.chunk;
     idx_info.storage = &dset->shared->layout.storage.u.chunk;
 
-    /* If the dataset is not written, return the address as undefined */
-    if (idx_info.storage->idx_addr == HADDR_UNDEF) {
-        if (addr)
-            *addr = HADDR_UNDEF;
-        if (size)
-            *size = 0;
+    /* Set addr & size for when dset is not written or queried chunk is not found */
+    if (addr)
+        *addr = HADDR_UNDEF;
+    if (size)
+        *size = 0;
+
+    /* If the dataset is not written, return without errors */
+    if(!H5F_addr_defined(idx_info.storage->idx_addr)) {
         HGOTO_DONE(SUCCEED);
     }
 
@@ -7115,13 +7111,6 @@ H5D__get_chunk_info_by_coord(const H5D_t *dset, const hsize_t *offset, unsigned*
             *addr = udata.chunk_addr;
         if (size)
             *size = udata.nbytes;
-    } else {
-    /* Otherwise, return the address as undefined */
-        if (addr)
-            *addr = HADDR_UNDEF;
-        if (size)
-            *size = 0;
-        HGOTO_DONE(SUCCEED);
     }
 done:
     FUNC_LEAVE_NOAPI_TAG(ret_value)
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index c8119fe..2aedc82 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -197,6 +197,7 @@ set (H5_TESTS
     page_buffer
     dtypes
     dsets
+    chunk_info
     cmpd_dset
     filter_fail
     extend
diff --git a/test/Makefile.am b/test/Makefile.am
index d4db6d0..5b210a9 100644
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -55,8 +55,8 @@ TEST_PROG= testhdf5 \
            cache cache_api cache_image cache_tagging lheap ohdr stab gheap \
            evict_on_close farray earray btree2 fheap \
            pool accum hyperslab istore bittests dt_arith page_buffer \
-           dtypes dsets cmpd_dset filter_fail extend direct_chunk external efc \
-           objcopy links unlink twriteorder big mtime fillval mount \
+           dtypes dsets chunk_info cmpd_dset filter_fail extend direct_chunk \
+           external efc objcopy links unlink twriteorder big mtime fillval mount \
            flush1 flush2 app_ref enum set_extent ttsafe enc_dec_plist \
            enc_dec_plist_cross_platform getname vfd ntypes dangle dtransform \
            reserved cross_read freespace mf vds file_image unregister \
diff --git a/test/chunk_info.c b/test/chunk_info.c
index e3006cc..8a569d6 100644
--- a/test/chunk_info.c
+++ b/test/chunk_info.c
@@ -15,23 +15,374 @@
  * Programmer:  Pedro Vicente <pvn@hdfgroup.edu>
  *              April 7, 2008
  *
- * Purpose:     Tests the H5Dget_chunk_info API function
- *              This program writes a 4x4 dataset by iterating on 2x2 chunks
- *               at a time
+ * Purpose:     Tests chunk query API functions
  */
 
-
 #include "h5test.h"
 
-#define PRINT_DATA
+ /* #define PRINT_DATA
+ */ 
 #define H5FILE_NAME "chunk_info.h5"
 #define DATASETNAME "2d"
 #define RANK         2
+#define FILENAME_BUF_SIZE       1024
+
+/* Parameters for testing chunk querying */
+#define FILENAME                "tchunk_info"
+#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);
+
+/*-------------------------------------------------------------------------
+ * Function:    read_each_chunk (helper function)
+ *
+ * Purpose:     Reads the chunk specified by its offset and verifies that
+ *              it contains the same data as what was written.  This function
+ *              is used in test_get_chunk_info.
+ *
+ * Return:      Success:    SUCCEED
+ *              Failure:    FAIL
+ *
+ * Date:        September 2018
+ *
+ *-------------------------------------------------------------------------
+ */
+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;
+
+    /* 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);
+
+    /* Verify that read chunk is the same as the corresponding written one */
+    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);
+    }
 
+    return(SUCCEED);
+}
 
-int main( void )
+/*-------------------------------------------------------------------------
+ * Function:    reinit_vars (helper function)
+ *
+ * Purpose:     Helper function to wipe out variables for the next use,
+ *              used in test_get_chunk_info.
+ *
+ * Return:      Won't fail
+ *
+ * Date:        September 2018
+ *
+ *-------------------------------------------------------------------------
+ */
+void reinit_vars(unsigned *read_filter_mask, haddr_t *addr, hsize_t *size)
 {
+    if (read_filter_mask)
+        *read_filter_mask = 0;
+    if (addr)
+        *addr = 0;
+    if (size)
+        *size = 0;
+}
 
+/*-------------------------------------------------------------------------
+ * Function:	test_get_chunk_info
+ *
+ * Purpose:	    Test getting various chunk information
+ *
+ * Return:	    Success:	0
+ *		        Failure:	1
+ *
+ * Description:
+ *              This function tests the new API functions added for EED-343:
+ *              H5Dget_num_chunks, H5Dget_chunk_info, and H5Dget_chunk_info_by_coord.
+ *
+ * Date:        September 2018
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+test_get_chunk_info(void)
+{
+    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 */
+
+    TESTING("getting chunk information");
+
+    /* Create a copy of file access property list */
+    if((fapl = H5Pcreate(H5P_FILE_ACCESS)) < 0) TEST_ERROR
+
+    /* Set high bound to V18 */
+    low = H5F_LIBVER_EARLIEST;
+    high = H5F_LIBVER_V18;
+    if (H5Pset_libver_bounds(fapl, low, high) < 0)
+        TEST_ERROR;
+
+    /* Create a file */
+    h5_fixname(FILENAME, fapl, filename, sizeof filename);
+    if((chunkfile = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+        TEST_ERROR
+
+    /* Create the data space */
+    if((fspace = H5Screate_simple(RANK, dims, maxdims)) < 0)
+        TEST_ERROR
+
+    if((mspace = H5Screate_simple(RANK, chunk_dims, NULL)) < 0)
+        TEST_ERROR
+
+    /* Modify dataset creation properties, i.e. enable chunking and compression */
+    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)
+        TEST_ERROR
+
+    if (H5Pset_fill_value(cparms, H5T_NATIVE_INT, &fillvalue) < 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
+
+    if((dxpl = H5Pcreate(H5P_DATASET_XFER)) < 0)
+        TEST_ERROR
+
+    /* Indicate skipping the compression filter.     */
+    filter_mask = 0x00000001;
+
+    /* Initialize the array of chunk data, that is for all 16 chunks */
+    for(n = 0; n < 16; 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) */
+    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
+        }
+
+    /* 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, mspace, &nchunks) < 0) TEST_ERROR;
+    if (nchunks != NUM_CHUNKS_WRITTEN) TEST_ERROR;
+
+    /* Read the entire dataset back */
+    if(H5Dread(dset, H5T_NATIVE_INT, fspace, fspace, H5P_DEFAULT, out_buf) < 0)
+        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)
+        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;
+
+    /* 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)
+        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;
+
+    /* 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)
+        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;
+
+    /* 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)
+        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;
+
+    /* 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)
+        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;
+
+    /* 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;
+
+    /* 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;
+
+    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;
+
+    /* 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 */
+    if((dset = H5Dcreate2(chunkfile, DSET_EMPTY, H5T_NATIVE_INT, fspace,
+            H5P_DEFAULT, cparms, H5P_DEFAULT)) < 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, mspace, &nchunks) < 0) TEST_ERROR;
+    if (nchunks != 0) TEST_ERROR;
+
+    /* Attempt to get info of a chunk from an empty dataset, verify the
+       returned address and size */
+    index = 0;
+    reinit_vars(&read_filter_mask, &addr, &size);
+    if (H5Dget_chunk_info(dset, fspace, index, out_offset, &read_filter_mask, &addr, &size) < 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;
+    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;
+
+    /* 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
+
+    PASSED();
+    return SUCCEED;
+
+error:
+    H5E_BEGIN_TRY {
+        H5Dclose(dset);
+        H5Sclose(mspace);
+        H5Sclose(fspace);
+        H5Pclose(cparms);
+        H5Pclose(dxpl);
+        H5Fclose(chunkfile);
+    } H5E_END_TRY;
+
+    H5_FAILED();
+    return FAIL;
+} /* test_get_chunk_info() */
+
+/*-------------------------------------------------------------------------
+ * Function:    create_4x4_dset
+ *
+ * Purpose:     Tests functions related to chunk information
+ *
+ * Return:      Success:    SUCCEED
+ *              Failure:    FAIL
+ *
+ * Description:
+ *              The code in this create_4x4_dset function was originally written by
+ *              Pedro in main() that writes a 4x4 dataset by iterating on
+ *              2x2 chunks at a time, with the intention of making a frame
+ *              work to test H5Dget_chunk_info, which was not in the library,
+ *              until now.  For the work in EED-343, the test function
+ *              test_get_chunk_info was added to test the new query chunk
+ *              API functions: H5Dget_num_chunk, H5Dget_chunk_info, and
+ *              H5Dget_chunk_info_by_coord.  This code can be used at a
+ *              later time, so it is kept here.
+ *              -BMR, November 5, 2018
+ *
+ * Programmer:  Pedro Vicente <pvn@hdfgroup.edu>
+ *              April 7, 2008
+ *
+ *-------------------------------------------------------------------------
+ */
+int
+create_4x4_dset(void)
+{
     hid_t   fid;      /* file ID */
     hid_t   did;      /* dataset ID */
     hid_t   f_sid;    /* file space ID */
@@ -43,20 +394,20 @@ int main( void )
     int     chunk_data[2][2] = { {1, 1}, {1, 1} };
     int     buf[4][4];
     int     fillvalue = 0;
-    int     i, j, ii, jj;
+    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;
+
     /* create the file space */
     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;
     start[0] = 0;
     start[1] = 0;
     if (H5Sselect_hyperslab(m_sid, H5S_SELECT_SET, start, NULL, chunk_dims, NULL) < 0) TEST_ERROR;
 
-    TESTING("chunk info");
-
    /*-------------------------------------------------------------------------
     * create a dataset
     *-------------------------------------------------------------------------
@@ -77,16 +428,12 @@ int main( void )
     */
 
     /* iterate in dim 0 */
-    for (j = 0; j < chunk_dims[0]; j++)
-    {
-
+    for (j = 0; j < chunk_dims[0]; j++) {
         /* reset start in dim 1 */
         start[1] = 0;
 
         /* iterate in dim 1 */
-        for (i = 0; i < chunk_dims[1]; i++)
-        {
-
+        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;
 
@@ -96,7 +443,6 @@ int main( void )
             /* read back and display complete dataset 4x4 */
             if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf) < 0) TEST_ERROR;
 
-
 #if defined (PRINT_DATA)
             printf("\n");
             printf("dataset: \n");
@@ -105,25 +451,17 @@ int main( void )
                 printf("\n");
             }
 #endif
-
-
             /* increment start in dim 1 */
             start[1] += 2;
-
-
         }
-
         /* increment start in dim 0 */
         start[0] += 2;
     }
 
-
-
    /*-------------------------------------------------------------------------
     * close
     *-------------------------------------------------------------------------
     */
-
     if (H5Dclose(did) < 0) TEST_ERROR
     if (H5Sclose(f_sid) < 0) TEST_ERROR
     if (H5Sclose(m_sid) < 0) TEST_ERROR
@@ -132,18 +470,58 @@ int main( void )
 
     PASSED();
 
-    puts("All chunk info tests passed.");
-    return 0;
+    return SUCCEED;
+
+/* this will be removed once the existing code is moved out of main */
+error:
+    H5Dclose(did);
+    H5Sclose(f_sid);
+    H5Sclose(m_sid);
+    H5Pclose(pid);
+    H5Fclose(fid);
 
+    return FAIL;
+} /* end create_4x4_dset */
+
+/*-------------------------------------------------------------------------
+ * Function:    main
+ *
+ * Purpose:     Tests functions related to chunk information
+ *
+ * Return:      Success:    SUCCEED
+ *              Failure:    FAIL
+ *
+ * Programmer:  Binh-Minh Ribler
+ *              November 5, 2018
+ *
+ *-------------------------------------------------------------------------
+ */
+int
+main(void)
+{
+    int     nerrors = 0;
+
+    /* Tests getting chunk information */
+    nerrors += (test_get_chunk_info() < 0 ? 1 : 0);
+
+    /* Create a 4x4 dataset (using the existing code to avoid compilation
+       warnings for now) */
+    nerrors += (create_4x4_dset() < 0 ? 1 : 0);
+
+    if(nerrors) {
+        goto error;
+
+    } /* end if */
+
+    HDprintf("All chunk query tests passed.\n");
+
+    return SUCCEED;
 
 error:
-    H5Dclose( did );
-    H5Sclose( f_sid );
-    H5Sclose( m_sid );
-    H5Pclose( pid  );
-    H5Fclose( fid );
-    H5_FAILED();
-    return 1;
+    nerrors = MAX(1, nerrors);
+    HDprintf("***** %d QUERY CHUNK INFO TEST%s FAILED! *****\n",
+              nerrors, 1 == nerrors ? "" : "S");
+    return FAIL;
 }