diff options
| -rwxr-xr-x | bin/trace | 2 | ||||
| -rw-r--r-- | release_docs/RELEASE.txt | 3 | ||||
| -rw-r--r-- | src/H5Dpublic.h | 13 | ||||
| -rw-r--r-- | src/H5Dscatgath.c | 204 | ||||
| -rw-r--r-- | test/dsets.c | 1028 |
5 files changed, 1249 insertions, 1 deletions
@@ -96,7 +96,9 @@ $Source = ""; "H5A_operator2_t" => "x", "H5A_info_t" => "x", "H5AC_cache_config_t" => "x", + "H5D_gather_func_t" => "x", "H5D_operator_t" => "x", + "H5D_scatter_func_t" => "x", "H5E_auto_t" => "x", "H5E_auto1_t" => "x", "H5E_auto2_t" => "x", diff --git a/release_docs/RELEASE.txt b/release_docs/RELEASE.txt index 3084849..641b985 100644 --- a/release_docs/RELEASE.txt +++ b/release_docs/RELEASE.txt @@ -63,6 +63,9 @@ New Features Library ------- + - Added new API functions H5Dscatter and H5Dgather to scatter data to and + and gather data from a selection within a memory buffer. + (NAF - 2013/02/05) - The library now supports the data conversion from enumeration to numeric (integer and floating-point number) datatypes. See Issue 8221. (SLU - 2012/10/23) diff --git a/src/H5Dpublic.h b/src/H5Dpublic.h index 523f2b2..484b176 100644 --- a/src/H5Dpublic.h +++ b/src/H5Dpublic.h @@ -107,6 +107,15 @@ extern "C" { typedef herr_t (*H5D_operator_t)(void *elem, hid_t type_id, unsigned ndim, const hsize_t *point, void *operator_data); +/* Define the operator function pointer for H5Dscatter() */ +typedef herr_t (*H5D_scatter_func_t)(void **src_buf/*out*/, + size_t *src_buf_bytes_used/*out*/, + void *op_data); + +/* Define the operator function pointer for H5Dgather() */ +typedef herr_t (*H5D_gather_func_t)(const void *dst_buf, + size_t dst_buf_bytes_used, void *op_data); + H5_DLL hid_t H5Dcreate2(hid_t loc_id, const char *name, hid_t type_id, hid_t space_id, hid_t lcpl_id, hid_t dcpl_id, hid_t dapl_id); H5_DLL hid_t H5Dcreate_anon(hid_t file_id, hid_t type_id, hid_t space_id, @@ -131,6 +140,10 @@ H5_DLL herr_t H5Dvlen_get_buf_size(hid_t dataset_id, hid_t type_id, hid_t space_ H5_DLL herr_t H5Dfill(const void *fill, hid_t fill_type, void *buf, hid_t buf_type, hid_t space); H5_DLL herr_t H5Dset_extent(hid_t dset_id, const hsize_t size[]); +H5_DLL herr_t H5Dscatter(H5D_scatter_func_t op, void *op_data, hid_t type_id, + hid_t dst_space_id, void *dst_buf); +H5_DLL herr_t H5Dgather(hid_t src_space_id, void *src_buf, hid_t type_id, + size_t dst_buf_size, void *dst_buf, H5D_gather_func_t op, void *op_data); H5_DLL herr_t H5Ddebug(hid_t dset_id); /* Symbols defined for compatibility with previous versions of the HDF5 API. diff --git a/src/H5Dscatgath.c b/src/H5Dscatgath.c index 49b6132..60a8800 100644 --- a/src/H5Dscatgath.c +++ b/src/H5Dscatgath.c @@ -27,6 +27,7 @@ #include "H5Dpkg.h" /* Dataset functions */ #include "H5Eprivate.h" /* Error handling */ #include "H5FLprivate.h" /* Free Lists */ +#include "H5Iprivate.h" /* IDs */ /****************/ @@ -361,7 +362,7 @@ done: * copies them into the gather buffer TGATH_BUF. * Each element is ELMT_SIZE bytes and arranged in application * memory according to SPACE. - * The caller is requesting that at most NELMTS be gathered. + * The caller is requesting that exactly NELMTS be gathered. * * Return: Success: Number of elements copied. * Failure: 0 @@ -899,3 +900,204 @@ H5D__compound_opt_write(size_t nelmts, const H5D_type_info_t *type_info) FUNC_LEAVE_NOAPI(SUCCEED) } /* end H5D__compound_opt_write() */ + +/*------------------------------------------------------------------------- + * Function: H5Dscatter + * + * Purpose: Scatters data provided by the callback op to the + * destination buffer dst_buf, where the dimensions of + * dst_buf and the selection to be scattered to are specified + * by the dataspace dst_space_id. The type of the data to be + * scattered is specified by type_id. + * + * Return: Non-negative on success/Negative on failure + * + * Programmer: Neil Fortner + * 14 Jan 2013 + * + *------------------------------------------------------------------------- + */ +herr_t +H5Dscatter(H5D_scatter_func_t op, void *op_data, hid_t type_id, + hid_t dst_space_id, void *dst_buf) +{ + H5T_t *type; /* Datatype */ + H5S_t *dst_space; /* Dataspace */ + H5S_sel_iter_t iter; /* Selection iteration info*/ + hbool_t iter_init = FALSE; /* Selection iteration info has been initialized */ + void *src_buf = NULL; /* Source (contiguous) data buffer */ + size_t src_buf_nbytes = 0; /* Size of src_buf */ + size_t type_size; /* Datatype element size */ + hssize_t nelmts; /* Number of remaining elements in selection */ + size_t nelmts_scatter = 0; /* Number of elements to scatter to dst_buf */ + H5D_dxpl_cache_t _dxpl_cache; /* Data transfer property cache buffer */ + H5D_dxpl_cache_t *dxpl_cache = &_dxpl_cache; /* Data transfer property cache */ + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_API(FAIL) + H5TRACE5("e", "x*xii*x", op, op_data, type_id, dst_space_id, dst_buf); + + /* Check args */ + if(op == NULL) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid callback function pointer") + if(NULL == (type = (H5T_t *)H5I_object_verify(type_id, H5I_DATATYPE))) + HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a datatype") + if(NULL == (dst_space= (H5S_t *)H5I_object_verify(dst_space_id, H5I_DATASPACE))) + HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace") + if(dst_buf == NULL) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no destination buffer provided") + + /* Fill the DXPL cache values for later use */ + if(H5D__get_dxpl_cache(H5P_DATASET_XFER_DEFAULT, &dxpl_cache) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't fill dxpl cache") + + /* Get datatype element size */ + if(0 == (type_size = H5T_GET_SIZE(type))) + HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get datatype size") + + /* Get number of elements in dataspace */ + if((nelmts = (hssize_t)H5S_GET_SELECT_NPOINTS(dst_space)) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTCOUNT, FAIL, "unable to get number of elements in selection") + + /* Initialize selection iterator */ + if(H5S_select_iter_init(&iter, dst_space, type_size) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to initialize selection iterator information") + iter_init = TRUE; + + /* Loop until all data has been scattered */ + while(nelmts > 0) { + /* Make callback to retrieve data */ + if(op(&src_buf, &src_buf_nbytes, op_data) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CALLBACK, FAIL, "callback operator returned failure") + + /* Calculate number of elements */ + nelmts_scatter = src_buf_nbytes / type_size; + + /* Check callback results */ + if(!src_buf) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "callback did not return a buffer") + if(src_buf_nbytes == 0) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "callback returned a buffer size of 0") + if(src_buf_nbytes % type_size) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "buffer size is not a multiple of datatype size") + if(nelmts_scatter > (size_t)nelmts) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "callback returned more elements than in selection") + + /* Scatter data */ + if(H5D__scatter_mem(src_buf, dst_space, &iter, nelmts_scatter, dxpl_cache, dst_buf) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTCOPY, FAIL, "scatter failed") + + nelmts -= (hssize_t)nelmts_scatter; + } /* end while */ + +done: + /* Release selection iterator */ + if(iter_init) { + if(H5S_SELECT_ITER_RELEASE(&iter) < 0) + HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator") + } /* end if */ + + FUNC_LEAVE_API(ret_value) +} /* H5Dscatter() */ + + +/*------------------------------------------------------------------------- + * Function: H5Dgather + * + * Purpose: Gathers data provided from the source buffer src_buf to + * contiguous buffer dst_buf, then calls the callback op. + * The dimensions of src_buf and the selection to be gathered + * are specified by the dataspace src_space_id. The type of + * the data to be gathered is specified by type_id. + * + * Return: Non-negative on success/Negative on failure + * + * Programmer: Neil Fortner + * 16 Jan 2013 + * + *------------------------------------------------------------------------- + */ +herr_t +H5Dgather(hid_t src_space_id, void *src_buf, hid_t type_id, size_t dst_buf_size, + void *dst_buf, H5D_gather_func_t op, void *op_data) +{ + H5T_t *type; /* Datatype */ + H5S_t *src_space; /* Dataspace */ + H5S_sel_iter_t iter; /* Selection iteration info*/ + hbool_t iter_init = FALSE; /* Selection iteration info has been initialized */ + size_t type_size; /* Datatype element size */ + hssize_t nelmts; /* Number of remaining elements in selection */ + size_t dst_buf_nelmts; /* Number of elements that can fit in dst_buf */ + size_t nelmts_gathered; /* Number of elements gathered from src_buf */ + H5D_dxpl_cache_t _dxpl_cache; /* Data transfer property cache buffer */ + H5D_dxpl_cache_t *dxpl_cache = &_dxpl_cache; /* Data transfer property cache */ + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_API(FAIL) + H5TRACE7("e", "i*xiz*xx*x", src_space_id, src_buf, type_id, dst_buf_size, + dst_buf, op, op_data); + + /* Check args */ + if(NULL == (src_space= (H5S_t *)H5I_object_verify(src_space_id, H5I_DATASPACE))) + HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace") + if(src_buf == NULL) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no source buffer provided") + if(NULL == (type = (H5T_t *)H5I_object_verify(type_id, H5I_DATATYPE))) + HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a datatype") + if(dst_buf_size == 0) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "destination buffer size is 0") + if(dst_buf == NULL) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no destination buffer provided") + + /* Fill the DXPL cache values for later use */ + if(H5D__get_dxpl_cache(H5P_DATASET_XFER_DEFAULT, &dxpl_cache) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't fill dxpl cache") + + /* Get datatype element size */ + if(0 == (type_size = H5T_GET_SIZE(type))) + HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get datatype size") + + /* Get number of elements in dst_buf_size */ + dst_buf_nelmts = dst_buf_size / type_size; + if(dst_buf_nelmts == 0) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "destination buffer is not large enough to hold one element") + + /* Get number of elements in dataspace */ + if((nelmts = (hssize_t)H5S_GET_SELECT_NPOINTS(src_space)) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTCOUNT, FAIL, "unable to get number of elements in selection") + + /* If dst_buf is not large enough to hold all the elements, make sure there + * is a callback */ + if(((size_t)nelmts > dst_buf_nelmts) && (op == NULL)) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no callback supplied and destination buffer too small") + + /* Initialize selection iterator */ + if(H5S_select_iter_init(&iter, src_space, type_size) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to initialize selection iterator information") + iter_init = TRUE; + + /* Loop until all data has been scattered */ + while(nelmts > 0) { + /* Gather data */ + if(0 == (nelmts_gathered = H5D__gather_mem(src_buf, src_space, &iter, MIN(dst_buf_nelmts, (size_t)nelmts), dxpl_cache, dst_buf))) + HGOTO_ERROR(H5E_IO, H5E_CANTCOPY, FAIL, "gather failed") + HDassert(nelmts_gathered == MIN(dst_buf_nelmts, (size_t)nelmts)); + + /* Make callback to process dst_buf */ + if(op && op(dst_buf, nelmts_gathered * type_size, op_data) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CALLBACK, FAIL, "callback operator returned failure") + + nelmts -= (hssize_t)nelmts_gathered; + HDassert(op || (nelmts == 0)); + } /* end while */ + +done: + /* Release selection iterator */ + if(iter_init) { + if(H5S_SELECT_ITER_RELEASE(&iter) < 0) + HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator") + } /* end if */ + + FUNC_LEAVE_API(ret_value) +} /* H5Dgather() */ + diff --git a/test/dsets.c b/test/dsets.c index 7283aae..abbbe2c 100644 --- a/test/dsets.c +++ b/test/dsets.c @@ -8251,6 +8251,1028 @@ error: /*------------------------------------------------------------------------- + * Function: test_scatter + * + * Purpose: Tests H5Dscatter with a variety of different selections + * and source buffer sizes. + * + * Return: Success: 0 + * Failure: -1 + * + * Programmer: Neil Fortner + * Wednesday, January 16, 2013 + * + *------------------------------------------------------------------------- + */ +typedef struct scatter_info_t { + int *src_buf; /* Source data buffer */ + size_t block; /* Maximum number of elements to return to H5Dscatter() */ + size_t size; /* Remaining number of elements to return */ +} scatter_info_t; + +#define TEST_SCATTER_CHECK_ARR(ARR, EXP) \ + for(i=0; i<(int)(sizeof(ARR)/sizeof(ARR[0])); i++) \ + for(j=0; j<(int)(sizeof(ARR[0])/sizeof(ARR[0][0])); j++) \ + for(k=0; k<(int)(sizeof(ARR[0][0])/sizeof(ARR[0][0][0])); k++) \ + if(ARR[i][j][k] != EXP[i][j][k]) { \ + H5_FAILED(); AT(); \ + printf(" " #ARR "[%d][%d][%d] == %d, " #EXP "[%d][%d][%d] == %d\n", i, j, k, ARR[i][j][k], i, j, k, EXP[i][j][k]); \ + goto error; \ + } + +static herr_t +scatter_cb(void **src_buf/*out*/, size_t *src_buf_bytes_used/*out*/, + void *_scatter_info) +{ + scatter_info_t *scatter_info = (scatter_info_t *)_scatter_info; + size_t nelmts; /* Number of elements to return in src_buf */ + + /* Calculate number of elements */ + nelmts = MIN(scatter_info->block, scatter_info->size); + HDassert(nelmts > 0); + + /* Set output variables */ + *src_buf = (void *)scatter_info->src_buf; + *src_buf_bytes_used = nelmts * sizeof(scatter_info->src_buf[0]); + + /* Update scatter_info */ + scatter_info->src_buf += nelmts; + scatter_info->size -= nelmts; + + return SUCCEED; +} + +static herr_t +test_scatter(void) +{ + hid_t sid = -1; /* Dataspace ID */ + hsize_t dim[3] = {8, 5, 8}; /* Dataspace dimensions */ + hsize_t start[3] = {0, 0, 0}; + hsize_t stride[3] = {0, 0, 0}; + hsize_t count[3] = {0, 0, 0}; + hsize_t block[3] = {0, 0, 0}; + hsize_t start2[3] = {0, 0, 0}; + hsize_t count2[3] = {0, 0, 0}; + hsize_t point[4][3] = {{2, 3, 2}, {3, 0, 2}, {7, 2, 0}, {0, 1, 5}}; + size_t src_buf_size; + int src_buf[36]; /* Source data buffer */ + int dst_buf[8][5][8]; /* Destination data buffer */ + int expect_dst_buf[8][5][8]; /* Expected destination data buffer */ + scatter_info_t scatter_info; /* Operator data for callback */ + int i, j, k, src_i; /* Local index variables */ + + TESTING("H5Dscatter()"); + + /* Create dataspace */ + if((sid = H5Screate_simple(3, dim, NULL)) < 0) TEST_ERROR + + /* Initialize src_buf */ + for(i=0; i<(int)(sizeof(src_buf)/sizeof(src_buf[0])); i++) + src_buf[i] = i + 1; + + + /* + * Test 1: Simple case + */ + /* Select hyperslab */ + count[0] = 1; + count[1] = 1; + count[2] = 8; + if(H5Sselect_hyperslab(sid, H5S_SELECT_SET, start, NULL ,count, NULL) < 0) + TEST_ERROR + + /* Initialize dst_buf and expect_dst_buf */ + (void)HDmemset(expect_dst_buf, 0, sizeof(expect_dst_buf)); + for(i=0; i<8; i++) + expect_dst_buf[0][0][i] = src_buf[i]; + + /* Loop over buffer sizes */ + for(src_buf_size=1; src_buf_size<=9; src_buf_size++) { + /* Reset dst_buf */ + (void)HDmemset(dst_buf, 0, sizeof(dst_buf)); + + /* Set up scatter info */ + scatter_info.src_buf = src_buf; + scatter_info.block = src_buf_size; + scatter_info.size = 8; + + /* Scatter data */ + if(H5Dscatter(scatter_cb, &scatter_info, H5T_NATIVE_INT, sid, dst_buf) < 0) + TEST_ERROR + + /* Verify data */ + TEST_SCATTER_CHECK_ARR(dst_buf, expect_dst_buf) + } /* end for */ + + + /* + * Test 2: Single block in dataset + */ + /* Select hyperslab */ + start[0] = 3; + start[1] = 2; + start[2] = 4; + count[0] = 2; + count[1] = 3; + count[2] = 2; + if(H5Sselect_hyperslab(sid, H5S_SELECT_SET, start, NULL ,count, NULL) < 0) + TEST_ERROR + + /* Initialize expect_dst_buf */ + (void)HDmemset(expect_dst_buf, 0, sizeof(expect_dst_buf)); + src_i = 0; + for(i=3; i<5; i++) + for(j=2; j<5; j++) + for(k=4; k<6; k++) + expect_dst_buf[i][j][k] = src_buf[src_i++]; + + /* Loop over buffer sizes */ + for(src_buf_size=1; src_buf_size<=13; src_buf_size++) { + /* Reset dst_buf */ + (void)HDmemset(dst_buf, 0, sizeof(dst_buf)); + + /* Set up scatter info */ + scatter_info.src_buf = src_buf; + scatter_info.block = src_buf_size; + scatter_info.size = 12; + + /* Scatter data */ + if(H5Dscatter(scatter_cb, &scatter_info, H5T_NATIVE_INT, sid, dst_buf) < 0) + TEST_ERROR + + /* Verify data */ + TEST_SCATTER_CHECK_ARR(dst_buf, expect_dst_buf) + } /* end for */ + + + /* + * Test 3: Multiple blocks + */ + /* Select hyperslab */ + start[0] = 1; + start[1] = 1; + start[2] = 1; + stride[0] = 3; + stride[1] = 4; + stride[2] = 5; + count[0] = 3; + count[1] = 1; + count[2] = 2; + block[0] = 1; + block[1] = 3; + block[2] = 2; + if(H5Sselect_hyperslab(sid, H5S_SELECT_SET, start, stride ,count, block) < 0) + TEST_ERROR + + /* Initialize expect_dst_buf */ + /* Iterate over block containing selection, checking if each element is in + * selection. Note that the algorithm used here (if statement) would not + * work for overlapping hyperslabs. */ + (void)HDmemset(expect_dst_buf, 0, sizeof(expect_dst_buf)); + src_i = 0; + for(i=1; i<8; i++) + for(j=1; j<4; j++) + for(k=1; k<8; k++) + if((hsize_t)i >= start[0] + && ((hsize_t)i - start[0]) % stride[0] < block[0] + && ((hsize_t)i - start[0]) / stride[0] < count[0] + && (hsize_t)j >= start[1] + && ((hsize_t)j - start[1]) % stride[1] < block[1] + && ((hsize_t)j - start[1]) / stride[1] < count[1] + && (hsize_t)k >= start[2] + && ((hsize_t)k - start[2]) % stride[2] < block[2] + && ((hsize_t)k - start[2]) / stride[2] < count[2]) + expect_dst_buf[i][j][k] = src_buf[src_i++]; + + /* Loop over buffer sizes */ + for(src_buf_size=1; src_buf_size<=37; src_buf_size++) { + /* Reset dst_buf */ + (void)HDmemset(dst_buf, 0, sizeof(dst_buf)); + + /* Set up scatter info */ + scatter_info.src_buf = src_buf; + scatter_info.block = src_buf_size; + scatter_info.size = 36; + + /* Scatter data */ + if(H5Dscatter(scatter_cb, &scatter_info, H5T_NATIVE_INT, sid, dst_buf) < 0) + TEST_ERROR + + /* Verify data */ + TEST_SCATTER_CHECK_ARR(dst_buf, expect_dst_buf) + } /* end for */ + + + /* + * Test 4: Compound selection + */ + /* Select hyperslabs */ + start[0] = 2; + start[1] = 1; + start[2] = 1; + count[0] = 2; + count[1] = 3; + count[2] = 2; + if(H5Sselect_hyperslab(sid, H5S_SELECT_SET, start, NULL ,count, NULL) < 0) + TEST_ERROR + start2[0] = 1; + start2[1] = 2; + start2[2] = 2; + count2[0] = 3; + count2[1] = 2; + count2[2] = 2; + if(H5Sselect_hyperslab(sid, H5S_SELECT_XOR, start2, NULL ,count2, NULL) < 0) + TEST_ERROR + + /* Initialize expect_dst_buf */ + /* Iterate over block containing selection, checking if each element is in + * selection. */ + (void)HDmemset(expect_dst_buf, 0, sizeof(expect_dst_buf)); + src_i = 0; + for(i=1; i<4; i++) + for(j=1; j<4; j++) + for(k=1; k<4; k++) + if(!(((hsize_t)i >= start[0] && (hsize_t)i < start[0] + count[0]) + && ((hsize_t)j >= start[1] && (hsize_t)j < start[1] + count[1]) + && ((hsize_t)k >= start[2] && (hsize_t)k < start[2] + count[2])) + != !(((hsize_t)i >= start2[0] && (hsize_t)i < start2[0] + count2[0]) + && ((hsize_t)j >= start2[1] && (hsize_t)j < start2[1] + count2[1]) + && ((hsize_t)k >= start2[2] && (hsize_t)k < start2[2] + count2[2]))) + expect_dst_buf[i][j][k] = src_buf[src_i++]; + + /* Loop over buffer sizes */ + for(src_buf_size=1; src_buf_size<=17; src_buf_size++) { + /* Reset dst_buf */ + (void)HDmemset(dst_buf, 0, sizeof(dst_buf)); + + /* Set up scatter info */ + scatter_info.src_buf = src_buf; + scatter_info.block = src_buf_size; + scatter_info.size = 16; + + /* Scatter data */ + if(H5Dscatter(scatter_cb, &scatter_info, H5T_NATIVE_INT, sid, dst_buf) < 0) + TEST_ERROR + + /* Verify data */ + TEST_SCATTER_CHECK_ARR(dst_buf, expect_dst_buf) + } /* end for */ + + + /* + * Test 5: Point selection + */ + /* Select hyperslabs */ + if(H5Sselect_elements(sid, H5S_SELECT_SET, sizeof(point) / sizeof(point[0]), (hsize_t *)point) < 0) + TEST_ERROR + + /* Initialize expect_dst_buf */ + /* Iterate over block containing selection, checking if each element is in + * selection. */ + (void)HDmemset(expect_dst_buf, 0, sizeof(expect_dst_buf)); + for(i=0; i<(int)(sizeof(point) / sizeof(point[0])); i++) + expect_dst_buf[point[i][0]][point[i][1]][point[i][2]] + = src_buf[i]; + + /* Loop over buffer sizes */ + for(src_buf_size=1; src_buf_size<=5; src_buf_size++) { + /* Reset dst_buf */ + (void)HDmemset(dst_buf, 0, sizeof(dst_buf)); + + /* Set up scatter info */ + scatter_info.src_buf = src_buf; + scatter_info.block = src_buf_size; + scatter_info.size = 4; + + /* Scatter data */ + if(H5Dscatter(scatter_cb, &scatter_info, H5T_NATIVE_INT, sid, dst_buf) < 0) + TEST_ERROR + + /* Verify data */ + TEST_SCATTER_CHECK_ARR(dst_buf, expect_dst_buf) + } /* end for */ + + + /* Close everything */ + if(H5Sclose(sid) < 0) TEST_ERROR + + PASSED(); + + return 0; + +error: + H5E_BEGIN_TRY { + H5Sclose(sid); + } H5E_END_TRY; + return -1; +} /* end test_scatter() */ + + +/*------------------------------------------------------------------------- + * Function: test_gather + * + * Purpose: Tests H5Dgather with a variety of different selections and + * destination buffer sizes. + * + * Return: Success: 0 + * Failure: -1 + * + * Programmer: Neil Fortner + * Wednesday, January 16, 2013 + * + *------------------------------------------------------------------------- + */ +typedef struct gather_info_t { + int *expect_dst_buf; /* Expected destination data buffer */ + size_t max_nelmts; /* Maximum number of elements passed to callback */ + hbool_t last_call; /* Whether this should be the last time the callback is called */ +} gather_info_t; + +static herr_t +gather_cb(const void *dst_buf, size_t dst_buf_bytes_used, + void *_gather_info) +{ + gather_info_t *gather_info = (gather_info_t *)_gather_info; + size_t nelmts; /* Number of elements in src_buf */ + int i; /* Local index variable */ + + HDassert(dst_buf_bytes_used > 0); + + /* Calculate number of elements */ + nelmts = dst_buf_bytes_used / sizeof(gather_info->expect_dst_buf[0]); + + /* Make sure the number of bytes is a multiple of the number of elements */ + if(nelmts * sizeof(gather_info->expect_dst_buf[0]) != dst_buf_bytes_used) + TEST_ERROR + + /* Make sure we weren't passed more data than we requested to be passed at + * once */ + if(nelmts > gather_info->max_nelmts) + TEST_ERROR + + /* If we were passed less data than requested, make sure this is the last + * time the callback was called */ + if(gather_info->last_call) + TEST_ERROR + if(nelmts < gather_info->max_nelmts) + gather_info->last_call = TRUE; + + /* Compare data and expected data */ + for(i=0; i<(int)nelmts; i++) + if(((const int *)dst_buf)[i] != *((gather_info->expect_dst_buf)++)) + TEST_ERROR + + return SUCCEED; + +error: + return FAIL; +} + +static herr_t +test_gather(void) +{ + hid_t sid = -1; /* Dataspace ID */ + hsize_t dim[3] = {8, 5, 8}; /* Dataspace dimensions */ + hsize_t start[3] = {0, 0, 0}; + hsize_t stride[3] = {0, 0, 0}; + hsize_t count[3] = {0, 0, 0}; + hsize_t block[3] = {0, 0, 0}; + hsize_t start2[3] = {0, 0, 0}; + hsize_t count2[3] = {0, 0, 0}; + hsize_t point[4][3] = {{2, 3, 2}, {3, 0, 2}, {7, 2, 0}, {0, 1, 5}}; + size_t dst_buf_size; + int src_buf[8][5][8]; /* Source data buffer */ + int dst_buf[36]; /* Destination data buffer */ + int expect_dst_buf[36]; /* Expected destination data buffer */ + gather_info_t gather_info; /* Operator data for callback */ + int i, j, k, dst_i; /* Local index variables */ + + TESTING("H5Dgather()"); + + /* Create dataspace */ + if((sid = H5Screate_simple(3, dim, NULL)) < 0) TEST_ERROR + + /* Initialize src_buf */ + for(i=0; i<(int)(sizeof(src_buf)/sizeof(src_buf[0])); i++) + for(j=0; j<(int)(sizeof(src_buf[0])/sizeof(src_buf[0][0])); j++) + for(k=0; k<(int)(sizeof(src_buf[0][0])/sizeof(src_buf[0][0][0])); k++) + src_buf[i][j][k] = 1 + k + + (int)(sizeof(src_buf[0][0]) / sizeof(src_buf[0][0][0])) * j + + (int)(sizeof(src_buf[0]) / sizeof(src_buf[0][0][0])) * i; + + + /* + * Test 1: Simple case + */ + /* Select hyperslab */ + count[0] = 1; + count[1] = 1; + count[2] = 8; + if(H5Sselect_hyperslab(sid, H5S_SELECT_SET, start, NULL ,count, NULL) < 0) + TEST_ERROR + + /* Initialize expect_dst_buf */ + (void)HDmemset(expect_dst_buf, 0, sizeof(expect_dst_buf)); + for(i=0; i<8; i++) + expect_dst_buf[i] = src_buf[0][0][i]; + + /* Loop over buffer sizes */ + for(dst_buf_size=1; dst_buf_size<=9; dst_buf_size++) { + /* Reset dst_buf */ + (void)HDmemset(dst_buf, 0, sizeof(dst_buf)); + + /* Initialize gather_info */ + gather_info.expect_dst_buf = expect_dst_buf; + gather_info.max_nelmts = dst_buf_size; + gather_info.last_call = FALSE; + + /* Gather data */ + if(H5Dgather(sid, src_buf, H5T_NATIVE_INT, dst_buf_size * sizeof(dst_buf[0]), dst_buf, gather_cb, &gather_info) < 0) + TEST_ERROR + + /* Verify that all data has been gathered (and verified) */ + if(gather_info.expect_dst_buf - expect_dst_buf != 8) TEST_ERROR + } /* end for */ + + /* Test without a callback */ + /* Loop over buffer sizes */ + for(dst_buf_size=8; dst_buf_size<=9; dst_buf_size++) { + /* Reset dst_buf */ + (void)HDmemset(dst_buf, 0, sizeof(dst_buf)); + + /* Gather data */ + if(H5Dgather(sid, src_buf, H5T_NATIVE_INT, dst_buf_size * sizeof(dst_buf[0]), dst_buf, NULL, NULL) < 0) + TEST_ERROR + + /* Verify data */ + for(i=0; i<(int)(sizeof(dst_buf)/sizeof(dst_buf[0])); i++) + if(dst_buf[i] != expect_dst_buf[i]) + TEST_ERROR + } /* end for */ + + /* Test with a dst_buf_size that is not a multiple of the datatype size */ + /* Reset dst_buf */ + dst_buf_size = 7; + (void)HDmemset(dst_buf, 0, sizeof(dst_buf)); + + /* Initialize gather_info */ + gather_info.expect_dst_buf = expect_dst_buf; + gather_info.max_nelmts = dst_buf_size - 1; + gather_info.last_call = FALSE; + + /* Gather data */ + if(H5Dgather(sid, src_buf, H5T_NATIVE_INT, dst_buf_size * sizeof(dst_buf[0]) - 1, dst_buf, gather_cb, &gather_info) < 0) + TEST_ERROR + + /* Verify that all data has been gathered (and verified) */ + if(gather_info.expect_dst_buf - expect_dst_buf != 8) TEST_ERROR + + + /* + * Test 2: Single block in dataset + */ + /* Select hyperslab */ + start[0] = 3; + start[1] = 2; + start[2] = 4; + count[0] = 2; + count[1] = 3; + count[2] = 2; + if(H5Sselect_hyperslab(sid, H5S_SELECT_SET, start, NULL ,count, NULL) < 0) + TEST_ERROR + + /* Initialize expect_dst_buf */ + (void)HDmemset(expect_dst_buf, 0, sizeof(expect_dst_buf)); + dst_i = 0; + for(i=3; i<5; i++) + for(j=2; j<5; j++) + for(k=4; k<6; k++) + expect_dst_buf[dst_i++] = src_buf[i][j][k]; + + /* Loop over buffer sizes */ + for(dst_buf_size=1; dst_buf_size<=13; dst_buf_size++) { + /* Reset dst_buf */ + (void)HDmemset(dst_buf, 0, sizeof(dst_buf)); + + /* Initialize gather_info */ + gather_info.expect_dst_buf = expect_dst_buf; + gather_info.max_nelmts = dst_buf_size; + gather_info.last_call = FALSE; + + /* Gather data */ + if(H5Dgather(sid, src_buf, H5T_NATIVE_INT, dst_buf_size * sizeof(dst_buf[0]), dst_buf, gather_cb, &gather_info) < 0) + TEST_ERROR + + /* Verify that all data has been gathered (and verified) */ + if(gather_info.expect_dst_buf - expect_dst_buf != 12) TEST_ERROR + } /* end for */ + + + /* + * Test 3: Multiple blocks + */ + /* Select hyperslab */ + start[0] = 1; + start[1] = 1; + start[2] = 1; + stride[0] = 3; + stride[1] = 4; + stride[2] = 5; + count[0] = 3; + count[1] = 1; + count[2] = 2; + block[0] = 1; + block[1] = 3; + block[2] = 2; + if(H5Sselect_hyperslab(sid, H5S_SELECT_SET, start, stride ,count, block) < 0) + TEST_ERROR + + /* Initialize expect_dst_buf */ + /* Iterate over block containing selection, checking if each element is in + * selection. Note that the algorithm used here (if statement) would not + * work for overlapping hyperslabs. */ + (void)HDmemset(expect_dst_buf, 0, sizeof(expect_dst_buf)); + dst_i = 0; + for(i=1; i<8; i++) + for(j=1; j<4; j++) + for(k=1; k<8; k++) + if((hsize_t)i >= start[0] + && ((hsize_t)i - start[0]) % stride[0] < block[0] + && ((hsize_t)i - start[0]) / stride[0] < count[0] + && (hsize_t)j >= start[1] + && ((hsize_t)j - start[1]) % stride[1] < block[1] + && ((hsize_t)j - start[1]) / stride[1] < count[1] + && (hsize_t)k >= start[2] + && ((hsize_t)k - start[2]) % stride[2] < block[2] + && ((hsize_t)k - start[2]) / stride[2] < count[2]) + expect_dst_buf[dst_i++] = src_buf[i][j][k]; + + /* Loop over buffer sizes */ + for(dst_buf_size=1; dst_buf_size<=37; dst_buf_size++) { + /* Reset dst_buf */ + (void)HDmemset(dst_buf, 0, sizeof(dst_buf)); + + /* Initialize gather_info */ + gather_info.expect_dst_buf = expect_dst_buf; + gather_info.max_nelmts = dst_buf_size; + gather_info.last_call = FALSE; + + /* Gather data */ + if(H5Dgather(sid, src_buf, H5T_NATIVE_INT, dst_buf_size * sizeof(dst_buf[0]), dst_buf, gather_cb, &gather_info) < 0) + TEST_ERROR + + /* Verify that all data has been gathered (and verified) */ + if(gather_info.expect_dst_buf - expect_dst_buf != 36) TEST_ERROR + } /* end for */ + + + /* + * Test 4: Compound selection + */ + /* Select hyperslabs */ + start[0] = 2; + start[1] = 1; + start[2] = 1; + count[0] = 2; + count[1] = 3; + count[2] = 2; + if(H5Sselect_hyperslab(sid, H5S_SELECT_SET, start, NULL ,count, NULL) < 0) + TEST_ERROR + start2[0] = 1; + start2[1] = 2; + start2[2] = 2; + count2[0] = 3; + count2[1] = 2; + count2[2] = 2; + if(H5Sselect_hyperslab(sid, H5S_SELECT_XOR, start2, NULL ,count2, NULL) < 0) + TEST_ERROR + + /* Initialize expect_dst_buf */ + /* Iterate over block containing selection, checking if each element is in + * selection. */ + (void)HDmemset(expect_dst_buf, 0, sizeof(expect_dst_buf)); + dst_i = 0; + for(i=1; i<4; i++) + for(j=1; j<4; j++) + for(k=1; k<4; k++) + if(!(((hsize_t)i >= start[0] && (hsize_t)i < start[0] + count[0]) + && ((hsize_t)j >= start[1] && (hsize_t)j < start[1] + count[1]) + && ((hsize_t)k >= start[2] && (hsize_t)k < start[2] + count[2])) + != !(((hsize_t)i >= start2[0] && (hsize_t)i < start2[0] + count2[0]) + && ((hsize_t)j >= start2[1] && (hsize_t)j < start2[1] + count2[1]) + && ((hsize_t)k >= start2[2] && (hsize_t)k < start2[2] + count2[2]))) + expect_dst_buf[dst_i++] = src_buf[i][j][k]; + + /* Loop over buffer sizes */ + for(dst_buf_size=1; dst_buf_size<=17; dst_buf_size++) { + /* Reset dst_buf */ + (void)HDmemset(dst_buf, 0, sizeof(dst_buf)); + + /* Initialize gather_info */ + gather_info.expect_dst_buf = expect_dst_buf; + gather_info.max_nelmts = dst_buf_size; + gather_info.last_call = FALSE; + + /* Gather data */ + if(H5Dgather(sid, src_buf, H5T_NATIVE_INT, dst_buf_size * sizeof(dst_buf[0]), dst_buf, gather_cb, &gather_info) < 0) + TEST_ERROR + + /* Verify that all data has been gathered (and verified) */ + if(gather_info.expect_dst_buf - expect_dst_buf != 16) TEST_ERROR + } /* end for */ + + + /* + * Test 5: Point selection + */ + /* Select hyperslabs */ + if(H5Sselect_elements(sid, H5S_SELECT_SET, sizeof(point) / sizeof(point[0]), (hsize_t *)point) < 0) + TEST_ERROR + + /* Initialize expect_dst_buf */ + /* Iterate over block containing selection, checking if each element is in + * selection. */ + (void)HDmemset(expect_dst_buf, 0, sizeof(expect_dst_buf)); + for(i=0; i<(int)(sizeof(point) / sizeof(point[0])); i++) + expect_dst_buf[i] = src_buf[point[i][0]][point[i][1]][point[i][2]]; + + /* Loop over buffer sizes */ + for(dst_buf_size=1; dst_buf_size<=5; dst_buf_size++) { + /* Reset dst_buf */ + (void)HDmemset(dst_buf, 0, sizeof(dst_buf)); + + /* Initialize gather_info */ + gather_info.expect_dst_buf = expect_dst_buf; + gather_info.max_nelmts = dst_buf_size; + gather_info.last_call = FALSE; + + /* Gather data */ + if(H5Dgather(sid, src_buf, H5T_NATIVE_INT, dst_buf_size * sizeof(dst_buf[0]), dst_buf, gather_cb, &gather_info) < 0) + TEST_ERROR + + /* Verify that all data has been gathered (and verified) */ + if(gather_info.expect_dst_buf - expect_dst_buf != 4) TEST_ERROR + } /* end for */ + + + /* Close everything */ + if(H5Sclose(sid) < 0) TEST_ERROR + + PASSED(); + + return 0; + +error: + H5E_BEGIN_TRY { + H5Sclose(sid); + } H5E_END_TRY; + return -1; +} /* end test_gather() */ + + +/*------------------------------------------------------------------------- + * Function: test_scatter_error + * + * Purpose: Tests H5Dscatter with a variety of different conditions + * that should cause errors. + * + * Return: Success: 0 + * Failure: -1 + * + * Programmer: Neil Fortner + * Monday, February 4, 2013 + * + *------------------------------------------------------------------------- + */ +static herr_t +scatter_error_cb_fail(void **src_buf/*out*/, size_t *src_buf_bytes_used/*out*/, + void *_scatter_info) +{ + scatter_info_t *scatter_info = (scatter_info_t *)_scatter_info; + size_t nelmts; /* Number of elements to return in src_buf */ + + /* Calculate number of elements */ + nelmts = MIN(scatter_info->block, scatter_info->size); + HDassert(nelmts > 0); + + /* Set output variables */ + *src_buf = (void *)scatter_info->src_buf; + *src_buf_bytes_used = nelmts * sizeof(scatter_info->src_buf[0]); + + return FAIL; +} + +static herr_t +scatter_error_cb_null(void **src_buf/*out*/, size_t *src_buf_bytes_used/*out*/, + void *_scatter_info) +{ + scatter_info_t *scatter_info = (scatter_info_t *)_scatter_info; + size_t nelmts; /* Number of elements to return in src_buf */ + + /* Calculate number of elements */ + nelmts = MIN(scatter_info->block, scatter_info->size); + HDassert(nelmts > 0); + + /* Set output variables */ + *src_buf = NULL; + *src_buf_bytes_used = nelmts * sizeof(scatter_info->src_buf[0]); + + return SUCCEED; +} + +static herr_t +scatter_error_cb_unalign(void **src_buf/*out*/, size_t *src_buf_bytes_used/*out*/, + void *_src_buf_bytes_used) +{ + /* Set output variables */ + *src_buf = _src_buf_bytes_used; + *src_buf_bytes_used = *(size_t *)_src_buf_bytes_used; + + return SUCCEED; +} + +static herr_t +test_scatter_error(void) +{ + hid_t sid = -1; /* Dataspace ID */ + hsize_t dim[1] = {10}; /* Dataspace dimensions */ + hsize_t start[3] = {2}; + hsize_t count[3] = {6}; + int src_buf[7]; /* Source data buffer */ + int dst_buf[10]; /* Destination data buffer */ + scatter_info_t scatter_info; /* Operator data for callback */ + size_t cb_unalign_nbytes; /* Number of bytes to return for unaligned test */ + herr_t ret; /* Return value */ + int i; /* Local index variable */ + + TESTING("H5Dscatter() error conditions"); + + /* Create dataspace */ + if((sid = H5Screate_simple(1, dim, NULL)) < 0) TEST_ERROR + + /* Initialize src_buf */ + for(i=0; i<(int)(sizeof(src_buf)/sizeof(src_buf[0])); i++) + src_buf[i] = i + 1; + + /* Select hyperslab */ + if(H5Sselect_hyperslab(sid, H5S_SELECT_SET, start, NULL ,count, NULL) < 0) + TEST_ERROR + + /* Verify that base configuration passes */ + scatter_info.src_buf = src_buf; + scatter_info.block = sizeof(src_buf)/sizeof(src_buf[0]); + scatter_info.size = 6; + if(H5Dscatter(scatter_cb, &scatter_info, H5T_NATIVE_INT, sid, dst_buf) < 0) + TEST_ERROR + + + /* + * Test invalid parameters + */ + scatter_info.src_buf = src_buf; + scatter_info.size = 6; + H5E_BEGIN_TRY { + ret = H5Dscatter(NULL, NULL, H5T_NATIVE_INT, sid, dst_buf); + } H5E_END_TRY + if(ret >= 0) TEST_ERROR + + scatter_info.src_buf = src_buf; + scatter_info.size = 6; + H5E_BEGIN_TRY { + ret = H5Dscatter(scatter_cb, &scatter_info, sid, sid, dst_buf); + } H5E_END_TRY + if(ret >= 0) TEST_ERROR + + scatter_info.src_buf = src_buf; + scatter_info.size = 6; + H5E_BEGIN_TRY { + ret = H5Dscatter(scatter_cb, &scatter_info, H5T_NATIVE_INT, H5T_NATIVE_INT, dst_buf); + } H5E_END_TRY + if(ret >= 0) TEST_ERROR + + scatter_info.src_buf = src_buf; + scatter_info.size = 6; + H5E_BEGIN_TRY { + ret = H5Dscatter(scatter_cb, &scatter_info, H5T_NATIVE_INT, sid, NULL); + } H5E_END_TRY + if(ret >= 0) TEST_ERROR + + + /* + * Test returning too many elements in callback + */ + scatter_info.src_buf = src_buf; + scatter_info.size = 7; + H5E_BEGIN_TRY { + ret = H5Dscatter(scatter_cb, &scatter_info, H5T_NATIVE_INT, sid, dst_buf); + } H5E_END_TRY + if(ret >= 0) TEST_ERROR + + + /* + * Test callback returns failure + */ + scatter_info.src_buf = src_buf; + scatter_info.size = 6; + H5E_BEGIN_TRY { + ret = H5Dscatter(scatter_error_cb_fail, &scatter_info, H5T_NATIVE_INT, sid, dst_buf); + } H5E_END_TRY + if(ret >= 0) TEST_ERROR + + + /* + * Test callback returns NULL buffer + */ + scatter_info.src_buf = src_buf; + scatter_info.size = 6; + H5E_BEGIN_TRY { + ret = H5Dscatter(scatter_error_cb_null, &scatter_info, H5T_NATIVE_INT, sid, dst_buf); + } H5E_END_TRY + if(ret >= 0) TEST_ERROR + + + /* + * Test callback returns 0 for src_buf_bytes_used + */ + cb_unalign_nbytes = 0; + H5E_BEGIN_TRY { + ret = H5Dscatter(scatter_error_cb_unalign, &cb_unalign_nbytes, H5T_NATIVE_INT, sid, dst_buf); + } H5E_END_TRY + if(ret >= 0) TEST_ERROR + + + /* + * Test callback returns src_buf_bytes_used that is not a multiple of + * datatype size + */ + cb_unalign_nbytes = sizeof(src_buf[0]) - 1; + H5E_BEGIN_TRY { + ret = H5Dscatter(scatter_error_cb_unalign, &cb_unalign_nbytes, H5T_NATIVE_INT, sid, dst_buf); + } H5E_END_TRY + if(ret >= 0) TEST_ERROR + + cb_unalign_nbytes = sizeof(src_buf[0]) + 1; + H5E_BEGIN_TRY { + ret = H5Dscatter(scatter_error_cb_unalign, &cb_unalign_nbytes, H5T_NATIVE_INT, sid, dst_buf); + } H5E_END_TRY + if(ret >= 0) TEST_ERROR + + + /* Close everything */ + if(H5Sclose(sid) < 0) TEST_ERROR + + PASSED(); + + return 0; + +error: + H5E_BEGIN_TRY { + H5Sclose(sid); + } H5E_END_TRY; + return -1; +} /* end test_scatter_error() */ + + +/*------------------------------------------------------------------------- + * Function: test_gather_error + * + * Purpose: Tests H5Dgather with a variety of different conditions + * that should cause errors. + * + * Return: Success: 0 + * Failure: -1 + * + * Programmer: Neil Fortner + * Monday, February 4, 2013 + * + *------------------------------------------------------------------------- + */ +static herr_t +gather_error_cb_fail(const void UNUSED *dst_buf, + size_t UNUSED dst_buf_bytes_used, void UNUSED *op_data) +{ + return FAIL; +} + +static herr_t +test_gather_error(void) +{ + hid_t sid = -1; /* Dataspace ID */ + hsize_t dim[1] = {10}; /* Dataspace dimensions */ + hsize_t start[1] = {2}; + hsize_t count[1] = {6}; + int src_buf[10]; /* Source data buffer */ + int dst_buf[6]; /* Destination data buffer */ + int expect_dst_buf[6]; /* Expected destination data buffer */ + gather_info_t gather_info; /* Operator data for callback */ + herr_t ret; /* Return value */ + int i; /* Local index variable */ + + TESTING("H5Dgather() error conditions"); + + /* Create dataspace */ + if((sid = H5Screate_simple(1, dim, NULL)) < 0) TEST_ERROR + + /* Initialize src_buf */ + for(i=0; i<(int)(sizeof(src_buf)/sizeof(src_buf[0])); i++) + src_buf[i] = 1 + i; + + /* Select hyperslab */ + if(H5Sselect_hyperslab(sid, H5S_SELECT_SET, start, NULL ,count, NULL) < 0) + TEST_ERROR + + /* Initialize expect_dst_buf */ + (void)HDmemset(expect_dst_buf, 0, sizeof(expect_dst_buf)); + for(i=0; i<6; i++) + expect_dst_buf[i] = src_buf[i + 2]; + + /* Verify that base configuration passes */ + gather_info.expect_dst_buf = expect_dst_buf; + gather_info.max_nelmts = 6; + gather_info.last_call = FALSE; + if(H5Dgather(sid, src_buf, H5T_NATIVE_INT, 6 * sizeof(dst_buf[0]), dst_buf, gather_cb, &gather_info) < 0) + TEST_ERROR + + /* + * Test invalid parameters + */ + gather_info.expect_dst_buf = expect_dst_buf; + gather_info.last_call = FALSE; + H5E_BEGIN_TRY { + ret = H5Dgather(H5T_NATIVE_INT, src_buf, H5T_NATIVE_INT, 6 * sizeof(dst_buf[0]), dst_buf, gather_cb, &gather_info); + } H5E_END_TRY + if(ret >= 0) TEST_ERROR + + gather_info.expect_dst_buf = expect_dst_buf; + gather_info.last_call = FALSE; + H5E_BEGIN_TRY { + ret = H5Dgather(sid, NULL, H5T_NATIVE_INT, 6 * sizeof(dst_buf[0]), dst_buf, gather_cb, &gather_info); + } H5E_END_TRY + if(ret >= 0) TEST_ERROR + + gather_info.expect_dst_buf = expect_dst_buf; + gather_info.last_call = FALSE; + H5E_BEGIN_TRY { + ret = H5Dgather(sid, src_buf, sid, 6 * sizeof(dst_buf[0]), dst_buf, gather_cb, &gather_info); + } H5E_END_TRY + if(ret >= 0) TEST_ERROR + + gather_info.expect_dst_buf = expect_dst_buf; + gather_info.last_call = FALSE; + H5E_BEGIN_TRY { + ret = H5Dgather(sid, src_buf, H5T_NATIVE_INT, 0, dst_buf, gather_cb, &gather_info); + } H5E_END_TRY + if(ret >= 0) TEST_ERROR + + gather_info.expect_dst_buf = expect_dst_buf; + gather_info.last_call = FALSE; + H5E_BEGIN_TRY { + ret = H5Dgather(sid, src_buf, H5T_NATIVE_INT, 1, dst_buf, gather_cb, &gather_info); + } H5E_END_TRY + if(ret >= 0) TEST_ERROR + + gather_info.expect_dst_buf = expect_dst_buf; + gather_info.last_call = FALSE; + H5E_BEGIN_TRY { + ret = H5Dgather(sid, src_buf, H5T_NATIVE_INT, 6 * sizeof(dst_buf[0]), NULL, gather_cb, &gather_info); + } H5E_END_TRY + if(ret >= 0) TEST_ERROR + + gather_info.expect_dst_buf = expect_dst_buf; + gather_info.last_call = FALSE; + H5E_BEGIN_TRY { + ret = H5Dgather(sid, src_buf, H5T_NATIVE_INT, 5 * sizeof(dst_buf[0]), dst_buf, NULL, &gather_info); + } H5E_END_TRY + if(ret >= 0) TEST_ERROR + + + /* + * Test callback returns failure + */ + gather_info.expect_dst_buf = expect_dst_buf; + gather_info.last_call = FALSE; + H5E_BEGIN_TRY { + ret = H5Dgather(sid, src_buf, H5T_NATIVE_INT, 6 * sizeof(dst_buf[0]), dst_buf, gather_error_cb_fail, NULL); + } H5E_END_TRY + if(ret >= 0) TEST_ERROR + + + /* Close everything */ + if(H5Sclose(sid) < 0) TEST_ERROR + + PASSED(); + + return 0; + +error: + H5E_BEGIN_TRY { + H5Sclose(sid); + } H5E_END_TRY; + return -1; +} /* end test_gather_error() */ + + +/*------------------------------------------------------------------------- * Function: main * * Purpose: Tests the dataset interface (H5D) @@ -8386,6 +9408,12 @@ main(void) /* Close 2nd FAPL */ if(H5Pclose(fapl2) < 0) TEST_ERROR + /* Tests that do not use files */ + nerrors += (test_scatter() < 0 ? 1 : 0); + nerrors += (test_gather() < 0 ? 1 : 0); + nerrors += (test_scatter_error() < 0 ? 1 : 0); + nerrors += (test_gather_error() < 0 ? 1 : 0); + /* Verify symbol table messages are cached */ nerrors += (h5_verify_cached_stabs(FILENAME, fapl) < 0 ? 1 : 0); |