int main(void)
{
char filename[1024];
unsigned nerrors = 0;
h5_reset();
TESTING("reading data created on OpenVMS");
h5_fixname(FILENAME[0], H5P_DEFAULT, filename, sizeof filename);
nerrors += read_data(filename);
TESTING("reading data created on Linux");
h5_fixname(FILENAME[1], H5P_DEFAULT, filename, sizeof filename);
nerrors += read_data(filename);
TESTING("reading data created on Solaris");
h5_fixname(FILENAME[2], H5P_DEFAULT, filename, sizeof filename);
nerrors += read_data(filename);
if (nerrors) {
printf("***** %u FAILURE%s! *****\n",
nerrors, 1==nerrors?"":"S");
HDexit(1);
}
printf("All data type tests passed.\n");
return 0;
}
/*-------------------------------------------------------------------------
* Function: test_read_with_filters
*
* Purpose: Tests reading dataset created with dynamically loaded filters
*
* Return: Success: 0
* Failure: -1
*
* Programmer: Raymond Lu
* 14 March 2013
*
*-------------------------------------------------------------------------
*/
static herr_t
test_read_with_filters(hid_t file)
{
hid_t dset; /* Dataset ID */
/*----------------------------------------------------------
* STEP 1: Test deflation by itself.
*----------------------------------------------------------
*/
#ifdef H5_HAVE_FILTER_DEFLATE
TESTING("Testing deflate filter");
if(H5Zfilter_avail(H5Z_FILTER_DEFLATE) != TRUE) TEST_ERROR
if((dset = H5Dopen2(file,DSET_DEFLATE_NAME,H5P_DEFAULT)) < 0) TEST_ERROR
if(test_read_data(dset, (int *)points_deflate) < 0) TEST_ERROR
if(H5Dclose(dset) < 0) TEST_ERROR
/* Clean up objects used for this test */
#else /* H5_HAVE_FILTER_DEFLATE */
TESTING("deflate filter");
SKIPPED();
puts(" Deflate filter not enabled");
#endif /* H5_HAVE_FILTER_DEFLATE */
/*----------------------------------------------------------
* STEP 2: Test DYNLIB1 by itself.
*----------------------------------------------------------
*/
TESTING("Testing DYNLIB1 filter");
if((dset = H5Dopen2(file,DSET_DYNLIB1_NAME,H5P_DEFAULT)) < 0) TEST_ERROR
if(test_read_data(dset, (int *)points_dynlib1) < 0) TEST_ERROR
if(H5Dclose(dset) < 0) TEST_ERROR
/*----------------------------------------------------------
* STEP 3: Test Bogus2 by itself.
*----------------------------------------------------------
*/
TESTING("Testing DYNLIB2 filter");
if((dset = H5Dopen2(file,DSET_DYNLIB2_NAME,H5P_DEFAULT)) < 0) TEST_ERROR
if(test_read_data(dset, (int *)points_dynlib2) < 0) TEST_ERROR
if(H5Dclose(dset) < 0) TEST_ERROR
return 0;
error:
return -1;
}
/*-------------------------------------------------------------------------
* Function: test_filter_write_failure
*
* Purpose: Tests the library's behavior when a mandate filter returns
* failure. There're only 5 chunks with each of them having
* 2 integers. The filter will fail in the last chunk. The
* dataset should release all resources even though the last
* chunk can't be flushed to file. The file should close
* successfully.
*
* Return:
* Success: 0
* Failure: -1
*
* Programmer: Raymond Lu
* 25 August 2010
*
* Modifications:
* Raymond Lu
* 5 Oct 2010
* Test when the chunk cache is enable and disabled to make
* sure the library behaves properly.
*-------------------------------------------------------------------------
*/
static herr_t
test_filter_write(char *file_name, hid_t my_fapl, hbool_t cache_enabled)
{
hid_t file = -1;
hid_t dataset=-1; /* dataset ID */
hid_t sid=-1; /* dataspace ID */
hid_t dcpl=-1; /* dataset creation property list ID */
hsize_t dims[1]={DIM}; /* dataspace dimension - 10*/
hsize_t chunk_dims[1]={FILTER_CHUNK_DIM}; /* chunk dimension - 2*/
int points[DIM]; /* Data */
herr_t ret; /* generic return value */
int i;
if(cache_enabled) {
TESTING("data writing when a mandatory filter fails and chunk cache is enabled");
} else {
TESTING("data writing when a mandatory filter fails and chunk cache is disabled");
}
/* Create file */
if((file = H5Fcreate(file_name, H5F_ACC_TRUNC, H5P_DEFAULT, my_fapl)) < 0) TEST_ERROR
/* create the data space */
if((sid = H5Screate_simple(1, dims, NULL)) < 0) TEST_ERROR
/* Create dcpl and register the filter */
if((dcpl = H5Pcreate(H5P_DATASET_CREATE)) < 0) TEST_ERROR
if(H5Pset_chunk(dcpl, 1, chunk_dims) < 0) TEST_ERROR
if(H5Zregister (H5Z_FAIL_TEST) < 0) TEST_ERROR
/* Check that the filter was registered */
if(TRUE != H5Zfilter_avail(H5Z_FILTER_FAIL_TEST)) FAIL_STACK_ERROR
/* Enable the filter as mandatory */
if(H5Pset_filter(dcpl, H5Z_FILTER_FAIL_TEST, 0, (size_t)0, NULL) < 0)
TEST_ERROR
/* create a dataset */
if((dataset = H5Dcreate2(file, DSET_NAME, H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0) TEST_ERROR
/* Initialize the write buffer */
for(i = 0; i < DIM; i++)
points[i] = i;
/* Write data. If the chunk cache is enabled, H5Dwrite should succeed. If it is
* diabled, H5Dwrite should fail. */
if(cache_enabled) {
if(H5Dwrite(dataset, H5T_NATIVE_INT, H5S_ALL, sid, H5P_DEFAULT, points) < 0)
TEST_ERROR
} else {
/*-------------------------------------------------------------------------
* Function: test_1c
*
* Purpose: Test a single external file which is large enough to
* represent the current data and large enough to represent the
* eventual size of the data.
*
* Return: Success: 0
*
* Failure: number of errors
*
* Programmer: Robb Matzke
* Monday, November 23, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static int
test_1c(hid_t file)
{
hid_t dcpl=-1; /*dataset creation properties */
hid_t space=-1; /*data space */
hid_t dset=-1; /*dataset */
hsize_t cur_size[1]; /*current data space size */
hsize_t max_size[1]; /*maximum data space size */
TESTING("extendible dataspace, exact external size");
if((dcpl = H5Pcreate (H5P_DATASET_CREATE)) < 0) goto error;
cur_size[0] = 100;
max_size[0] = 200;
if(H5Pset_external(dcpl, "ext1.data", (off_t)0,
(hsize_t)(max_size[0] * sizeof(int))) < 0) goto error;
if((space = H5Screate_simple(1, cur_size, max_size)) < 0) goto error;
if((dset = H5Dcreate2(file, "dset3", H5T_NATIVE_INT, space, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0)
goto error;
if(H5Dclose(dset) < 0) goto error;
if(H5Sclose(space) < 0) goto error;
if(H5Pclose(dcpl) < 0) goto error;
PASSED();
return 0;
error:
H5E_BEGIN_TRY {
H5Dclose(dset);
H5Pclose(dcpl);
H5Sclose(space);
} H5E_END_TRY;
return 1;
}
/*-------------------------------------------------------------------------
* test_open
*
* Tests opening and closing a FL packet table
*
*-------------------------------------------------------------------------
*/
static int test_open(hid_t fid)
{
herr_t err;
hid_t table;
TESTING("H5PTopen");
/* Open the table */
table = H5PTopen(fid, PT_NAME);
if( H5PTis_valid(table) < 0)
goto out;
#ifdef VLPT_REMOVED
if( H5PTis_varlen(table) != 0)
goto out;
#endif /* VLPT_REMOVED */
/* Close the table */
err = H5PTclose(table);
if( err < 0)
goto out;
PASSED();
return 0;
out:
H5_FAILED();
return -1;
}
static int test_create_close(hid_t fid)
{
herr_t err;
hid_t table;
hid_t part_t;
TESTING("H5PTcreate_fl and H5PTclose");
/* Create a datatype for the particle struct */
part_t = make_particle_type();
HDassert(part_t != -1);
/* Create the table */
table = H5PTcreate_fl(fid, PT_NAME, part_t, (hsize_t)100, -1);
H5Tclose(part_t);
if( H5PTis_valid(table) < 0)
goto out;
#ifdef VLPT_REMOVED
if( H5PTis_varlen(table) != 0)
goto out;
#endif /* VLPT_REMOVED */
/* Close the table */
err = H5PTclose(table);
if( err < 0)
goto out;
PASSED();
return 0;
out:
H5_FAILED();
return -1;
}
/*-------------------------------------------------------------------------
* Function: test_noread_with_filters
*
* Purpose: Tests reading dataset created with dynamically loaded filters disabled
*
* Return: Success: 0
* Failure: -1
*
*-------------------------------------------------------------------------
*/
static herr_t
test_noread_with_filters(hid_t file)
{
hid_t dset; /* Dataset ID */
unsigned plugin_state; /* status of plugins */
TESTING("Testing DYNLIB1 filter with plugins disabled");
/* disable filter plugin */
if(H5PLget_loading_state(&plugin_state) < 0) TEST_ERROR
plugin_state = plugin_state & ~H5PL_FILTER_PLUGIN;
if(H5PLset_loading_state(plugin_state) < 0) TEST_ERROR
if((dset = H5Dopen2(file,DSET_DYNLIB1_NAME,H5P_DEFAULT)) < 0) TEST_ERROR
if(test_noread_data(dset) < 0) TEST_ERROR
if(H5Dclose(dset) < 0) TEST_ERROR
/* re-enable filter plugin */
plugin_state = plugin_state | H5PL_FILTER_PLUGIN;
if(H5PLset_loading_state(plugin_state) < 0) TEST_ERROR
return 0;
error:
/* re-enable filter plugin */
plugin_state = plugin_state | H5PL_FILTER_PLUGIN;
if(H5PLset_loading_state(plugin_state) < 0) TEST_ERROR
return -1;
}
/*-------------------------------------------------------------------------
* Function: test_allocate_many_small
*
* Purpose: Tests allocating many small blocks in a pool
*
* Return: Success: 0
*
* Failure: 1
*
* Programmer: Quincey Koziol
* Tuesday, May 6, 2005
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static int
test_allocate_many_small(void)
{
H5MP_pool_t *mp; /* Memory pool */
size_t free_size; /* Free size in pool */
void *spc[MPOOL_NUM_SMALL_BLOCKS]; /* Pointers to space allocated */
int i; /* Local index variable */
/*
* Test memory pool allocation
*/
TESTING("allocating many small blocks");
/* Create a memory pool */
if(NULL == (mp = H5MP_create((size_t)MPOOL_PAGE_SIZE, MPOOL_FLAGS)))
TEST_ERROR
/* Allocate space in pool */
for(i = 0; i < MPOOL_NUM_SMALL_BLOCKS; i++)
if(NULL == (spc[i] = H5MP_malloc(mp, (size_t)MPOOL_SMALL_BLOCK)))
TEST_ERROR
/* Check pool's free space */
if(H5MP_get_pool_free_size(mp, &free_size) < 0)
TEST_ERROR;
if(free_size != MPOOL_PAGE_SIZE - (((H5MP_BLOCK_ALIGN(MPOOL_SMALL_BLOCK) + H5MP_BLOCK_ALIGN(sizeof(H5MP_page_blk_t))) * MPOOL_NUM_SMALL_BLOCKS) + H5MP_BLOCK_ALIGN(sizeof(H5MP_page_t))))
TEST_ERROR
/* Check that free space totals match */
if (H5MP_pool_is_free_size_correct(mp) <= 0)
TEST_ERROR;
/* Free blocks in pool */
/* (Tests free block merging with block after it */
for(i = (MPOOL_NUM_SMALL_BLOCKS - 1); i >= 0; i--)
H5MP_free(mp, spc[i]);
/* Check pool's free space */
if (H5MP_get_pool_free_size(mp, &free_size) < 0)
TEST_ERROR;
if(free_size != MPOOL_PAGE_SIZE - H5MP_BLOCK_ALIGN(sizeof(H5MP_page_t)))
TEST_ERROR
/* Check that free space totals match */
if (H5MP_pool_is_free_size_correct(mp) <= 0)
TEST_ERROR;
/* Close the memory pool */
if (H5MP_close(mp) < 0)
TEST_ERROR
PASSED();
return 0;
error:
H5E_BEGIN_TRY {
} H5E_END_TRY;
return 1;
} /* test_allocate_many_small() */
/*-------------------------------------------------------------------------
* Function: test_create
*
* Purpose: Creates a named object that refers to indexed storage of raw
* data. No raw data is stored.
*
* Return: Success: SUCCEED
*
* Failure: FAIL
*
* Programmer: Robb Matzke
* Wednesday, October 15, 1997
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static herr_t
test_create(hid_t f, const char *prefix)
{
hid_t dataset; /* Dataset ID */
hsize_t dims[H5O_LAYOUT_NDIMS+1]; /* Dimensions of dataset */
hsize_t my_chunk_dims[H5O_LAYOUT_NDIMS+1]; /* Dimensions of chunks */
char name[256]; /* Dataset name */
unsigned u; /* Local index variable */
TESTING("istore create");
dims[0] = my_chunk_dims[0] = 1;
for (u = 1; u <= H5S_MAX_RANK; u++) {
/* Initialize the dimension size in this new dimension */
dims[u] = my_chunk_dims[u] = 2;
/* Create chunked dataset of this dimensionality */
HDsnprintf(name, sizeof name, "%s_%02u", prefix, u);
if ((dataset=new_object(f, name, (int)u, dims, my_chunk_dims)) < 0)
return FAIL;
/* Close dataset created */
if(H5Dclose(dataset) < 0)
return FAIL;
}
PASSED();
return SUCCEED;
}
static int test_create_close(hid_t fid)
{
herr_t err;
hid_t table;
hid_t part_t;
TESTING("H5PTcreate_fl and H5PTclose");
/* Create a datatype for the particle struct */
part_t = make_particle_type();
HDassert(part_t != -1);
/* Create the table */
table = H5PTcreate_fl(fid, PT_NAME, part_t, (hsize_t)100, -1);
H5Tclose(part_t);
if( H5PTis_valid(table) < 0)
goto error;
if( H5PTis_varlen(table) != 0)
goto error;
/* Close the table */
err = H5PTclose(table);
if( err < 0)
goto error;
PASSED();
return SUCCEED;
error:
H5_FAILED();
return FAIL;
}
/* Test driver for testing the API SDgetdatasize. */
extern int test_datasizes()
{
int32 fid;
intn status;
int num_errs = 0;
/* Output message about test being performed */
TESTING("getting data size of special data (tdatasizes.c)");
/* Open the file and initialize the SD interface */
fid = SDstart(FILE_NAME, DFACC_CREATE);
CHECK(fid, FAIL, "test_datasizes: SDstart");
/* Test nonspecial SDSs */
num_errs = num_errs + test_nonspecial_SDSs(fid);
/* Test compressed SDSs */
num_errs = num_errs + test_compressed_SDSs(fid);
/* Test chunked empty SDSs */
num_errs = num_errs + test_empty_SDSs(fid);
/* Test chunked_partial SDSs */
num_errs = num_errs + test_chunked_partial(fid);
/* Test chunked SDSs */
num_errs = num_errs + test_chkcmp_SDSs(fid);
/* Test extendable SDSs */
num_errs = num_errs + test_extend_SDSs(fid);
/* Close the file */
status = SDend(fid);
CHECK(status, FAIL, "test_datasizes: SDend");
if (num_errs == 0) PASSED();
return num_errs;
}
/*------------------------------------------------------------------------- * Function: test_large * * Purpose: Creates a really large directory. * * Return: Success: 0 * * Failure: number of errors * * Programmer: Robb Matzke * [email protected] * Aug 29 1997 * * Modifications: * Robb Matzke, 2002-03-28 * File is opened by parent instead of here. *------------------------------------------------------------------------- */ static int test_large(hid_t file) { hid_t cwg=-1, dir=-1; int i; char name[1024]; int nsyms = 5000; TESTING("large directories"); /* * Create a directory that has so many entries that the root * of the B-tree ends up splitting. */ if ((cwg=H5Gcreate(file, "/big", (size_t)nsyms*16+2))<0) goto error; for (i=0; i<nsyms; i++) { sprintf(name, "%05d%05d", rand()%100000, i); #if 0 fprintf(stderr, "%s\n", name); #endif if ((dir=H5Gcreate(cwg, name, 0))<0) goto error; if (H5Gclose(dir)<0) goto error; } if (H5Gclose(cwg)<0) goto error; PASSED(); return 0; error: H5E_BEGIN_TRY { H5Gclose(dir); H5Gclose(cwg); } H5E_END_TRY; return 1; }
/*-------------------------------------------------------------------------
* Function: test_1h
*
* Purpose: It should be impossible to create a set of external files
* whose total size overflows a size_t integer.
*
* Return: Success: 0
*
* Failure: number of errors
*
* Programmer: Robb Matzke
* Monday, November 23, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static int
test_1h(void)
{
hid_t dcpl=-1; /*dataset creation properties */
herr_t status; /*return status */
TESTING("address overflow in external files");
if((dcpl=H5Pcreate(H5P_DATASET_CREATE)) < 0) goto error;
if (H5Pset_external(dcpl, "ext1.data", (off_t)0, H5F_UNLIMITED-1) < 0) goto error;
H5E_BEGIN_TRY {
status = H5Pset_external(dcpl, "ext2.data", (off_t)0, (hsize_t)100);
} H5E_END_TRY;
if (status>=0) {
H5_FAILED();
puts(" H5Pset_external() succeeded when it should have failed.");
goto error;
}
if (H5Pclose(dcpl) < 0) goto error;
PASSED();
return 0;
error:
H5E_BEGIN_TRY {
H5Pclose(dcpl);
} H5E_END_TRY;
return 1;
}
/*-------------------------------------------------------------------------
* Function: test_1g
*
* Purpose: It should be impossible to define an unlimited external file
* and then follow it with another external file.
*
* Return: Success: 0
*
* Failure: number of errors
*
* Programmer: Robb Matzke
* Monday, November 23, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static int
test_1g(void)
{
hid_t dcpl=-1; /*dataset creation properties */
herr_t status; /*function return status */
int n; /*number of external files */
TESTING("external file following unlimited file");
if ((dcpl=H5Pcreate (H5P_DATASET_CREATE)) < 0) goto error;
if (H5Pset_external(dcpl, "ext1.data", (off_t)0, H5F_UNLIMITED) < 0) goto error;
H5E_BEGIN_TRY {
status = H5Pset_external(dcpl, "ext2.data", (off_t)0, (hsize_t)100);
} H5E_END_TRY;
if (status>=0) {
H5_FAILED();
puts (" H5Pset_external() succeeded when it should have failed.");
goto error;
}
if ((n = H5Pget_external_count(dcpl)) < 0) goto error;
if (1!=n) {
H5_FAILED();
puts(" Wrong external file count returned.");
goto error;
}
if (H5Pclose(dcpl) < 0) goto error;
PASSED();
return 0;
error:
H5E_BEGIN_TRY {
H5Pclose(dcpl);
} H5E_END_TRY;
return 1;
}
/*-------------------------------------------------------------------------
* Function: test_close_one
*
* Purpose: Tests closing pool with one block allocated
*
* Return: Success: 0
*
* Failure: 1
*
* Programmer: Quincey Koziol
* Friday, May 6, 2005
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static int
test_close_one(void)
{
H5MP_pool_t *mp; /* Memory pool */
/*
* Test memory pool closing
*/
TESTING("closing pool with blocks still allocated in one page");
/* Create a memory pool */
if(NULL == (mp = H5MP_create((size_t)MPOOL_PAGE_SIZE, MPOOL_FLAGS)))
TEST_ERROR
/* Allocate space in pool */
if(NULL == H5MP_malloc(mp, (size_t)MPOOL_NORMAL_BLOCK))
TEST_ERROR
/* Close the memory pool */
if(H5MP_close(mp) < 0)
TEST_ERROR
PASSED();
return 0;
error:
H5E_BEGIN_TRY {
} H5E_END_TRY;
return 1;
} /* test_close_one() */
/*-------------------------------------------------------------------------
* test_open
*
* Tests opening and closing a FL packet table
*
*-------------------------------------------------------------------------
*/
static int test_open(hid_t fid)
{
herr_t err;
hid_t table;
TESTING("H5PTopen");
/* Open the table */
table = H5PTopen(fid, PT_NAME);
if( H5PTis_valid(table) < 0)
goto error;
if( H5PTis_varlen(table) != 0)
goto error;
/* Close the table */
err = H5PTclose(table);
if( err < 0)
goto error;
PASSED();
return SUCCEED;
error:
if (table > 0) H5PTclose(table);
H5_FAILED();
return FAIL;
}
/*-------------------------------------------------------------------------
* Function: test_groups_with_filters
*
* Purpose: Tests opening group with dynamically loaded filters
*
* Return: Success: 0
* Failure: -1
*
* Programmer: Raymond Lu
* 1 April 2013
*
*-------------------------------------------------------------------------
*/
static herr_t
test_groups_with_filters(hid_t file)
{
hid_t gid, group;
int i;
char gname[256];
TESTING("Testing opening groups with DYNLIB3 filter");
/* Open the top group */
if((gid = H5Gopen2(file, "group1", H5P_DEFAULT)) < 0) goto error;
/* Create multiple groups under "group1" */
for (i=0; i < GROUP_ITERATION; i++) {
sprintf(gname, "group_%d", i);
if((group = H5Gopen2(gid, gname, H5P_DEFAULT)) < 0) goto error;
if(H5Gclose(group) < 0) goto error;
}
/* Close the group */
if(H5Gclose(gid) < 0) goto error;
PASSED();
return 0;
error:
return -1;
}
/*-------------------------------------------------------------------------
* Function: test_3
*
* Purpose: Creates a few global heap objects and then removes them all.
* The collection should also be removed.
*
* Return: Success: 0
*
* Failure: number of errors
*
* Programmer: Robb Matzke
* Tuesday, March 31, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static int
test_3 (hid_t fapl)
{
hid_t file = -1;
H5F_t *f = NULL;
H5HG_t obj[1024];
uint8_t out[1024];
int i;
size_t size;
herr_t status;
int nerrors = 0;
char filename[1024];
TESTING("complete object removal");
/* Open a clean file */
h5_fixname(FILENAME[2], fapl, filename, sizeof filename);
if((file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
goto error;
if(NULL == (f = (H5F_t *)H5I_object(file))) {
H5_FAILED();
puts(" Unable to create file");
goto error;
}
/* Create some stuff */
for (i=0; i<1024; i++) {
size = i%30+100;
memset (out, 'A'+i%26, size);
H5Eclear2(H5E_DEFAULT);
status = H5HG_insert (f, H5P_DATASET_XFER_DEFAULT, size, out, obj+i);
if (status<0) {
H5_FAILED();
puts(" Unable to insert object into global heap");
nerrors++;
}
}
/* Remove everything */
for (i=0; i<1024; i++) {
status = H5HG_remove (f, H5P_DATASET_XFER_DEFAULT, obj+i);
if (status<0) {
H5_FAILED();
puts(" Unable to remove object");
nerrors++;
}
}
if (H5Fclose(file)<0) goto error;
if (nerrors) goto error;
PASSED();
return 0;
error:
H5E_BEGIN_TRY {
H5Fclose(file);
} H5E_END_TRY;
return MAX(1, nerrors);
}
/*-------------------------------------------------------------------------
* Function: main
*
* Purpose: Part 1 of a two-part H5Fflush() test.
*
* Return: Success: 0
*
* Failure: 1
*
* Programmer: Robb Matzke
* Friday, October 23, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int
main(void)
{
hid_t fapl, file, dcpl, space, dset, groups, grp;
hsize_t ds_size[2] = {100, 100};
hsize_t ch_size[2] = {5, 5};
size_t i, j;
char name[1024];
h5_reset();
fapl = h5_fileaccess();
TESTING("H5Fflush (part1)");
/* Create the file */
h5_fixname(FILENAME[0], fapl, name, sizeof name);
if ((file=H5Fcreate(name, H5F_ACC_TRUNC, H5P_DEFAULT, fapl))<0) goto error;
/* Create a chunked dataset */
if ((dcpl=H5Pcreate(H5P_DATASET_CREATE))<0) goto error;
if (H5Pset_chunk(dcpl, 2, ch_size)<0) goto error;
if ((space=H5Screate_simple(2, ds_size, NULL))<0) goto error;
if ((dset=H5Dcreate(file, "dset", H5T_NATIVE_FLOAT, space, H5P_DEFAULT))<0)
goto error;
/* Write some data */
for (i=0; i<ds_size[0]; i++) {
/*
* The extra cast in the following statement is a bug workaround
* for the Win32 version 5.0 compiler.
* 1998-11-06 ptl
*/
for (j=0; j<ds_size[1]; j++) {
the_data[i][j] = (double)(hssize_t)i/(hssize_t)(j+1);
}
}
if (H5Dwrite(dset, H5T_NATIVE_DOUBLE, space, space, H5P_DEFAULT,
the_data)<0) goto error;
/* Create some groups */
if ((groups=H5Gcreate(file, "some_groups", 0))<0) goto error;
for (i=0; i<100; i++) {
sprintf(name, "grp%02u", (unsigned)i);
if ((grp=H5Gcreate(groups, name, 0))<0) goto error;
if (H5Gclose(grp)<0) goto error;
}
/* Flush and exit without closing the library */
if (H5Fflush(file, H5F_SCOPE_GLOBAL)<0) goto error;
PASSED();
fflush(stdout);
fflush(stderr);
HD_exit(0);
return 0;
error:
HD_exit(1);
return 1;
}
/*-------------------------------------------------------------------------
* test_append
*
* Tests appending packets to a FL packet table
*
*-------------------------------------------------------------------------
*/
static int test_append(hid_t fid)
{
herr_t err;
hid_t table;
hsize_t count;
TESTING("H5PTappend");
/* Open the table */
table = H5PTopen(fid, PT_NAME);
if( H5PTis_valid(table) < 0)
goto out;
/* Count the number of packets in the table */
err = H5PTget_num_packets(table, &count);
if( err < 0)
goto out;
/* There should be 0 records in the table */
if( count != 0 )
goto out;
/* Append one particle */
err = H5PTappend(table, (size_t)1, &(testPart[0]));
if( err < 0)
goto out;
/* Append several particles */
err = H5PTappend(table, (size_t)6, &(testPart[1]));
if( err < 0)
goto out;
/* Append one more particle */
err = H5PTappend(table, (size_t)1, &(testPart[7]));
if( err < 0)
goto out;
/* Count the number of packets in the table */
err = H5PTget_num_packets(table, &count);
if( err < 0)
goto out;
/* There should be 8 records in the table now */
if( count != 8 )
goto out;
/* Close the table */
err = H5PTclose(table);
if( err < 0)
goto out;
PASSED();
return 0;
out:
H5_FAILED();
if( H5PTis_valid(table) < 0)
H5PTclose(table);
return -1;
}
/*-------------------------------------------------------------------------
* Function: test_value_dsnt_exist
*
* Purpose: Create an enumeration datatype with "gaps in values"
* and then request a name of non-existing value within
* an existing range by calling H5Tenum_nameof function.
* Function should fail instead of succeeding and returning
* a name of one of the existing values.
* Request a value by supplying non-existing name by calling
* H5Tenum_nameof function. Function should fail.
*
*
* Return: Success: 0
*
* Failure: number of errors
*
* Programmer: Elena Pourmal
* Wednesday, June 7, 2002
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static int
test_value_dsnt_exist(void)
{
hid_t datatype_id=(-1); /* identifiers */
int val;
char nam[100];
size_t size = 100;
TESTING("for non-existing name and value");
/* Turn off error reporting since we expect failure in this test */
if (H5Eset_auto(NULL, NULL) < 0) goto error;
if ((datatype_id = H5Tenum_create(H5T_NATIVE_INT))< 0) goto error;
/* These calls should fail, since no memebrs exist yet */
if (H5Tenum_valueof(datatype_id, "SAX", &val) >= 0) goto error;
val = 3;
if (H5Tenum_nameof(datatype_id, &val, nam, size) >= 0) goto error;
val = 2;
if (H5Tenum_insert(datatype_id, "TWO", (int *)&val) < 0) goto error;
val = 6;
if (H5Tenum_insert(datatype_id, "SIX", (int *)&val) < 0) goto error;
val = 10;
if (H5Tenum_insert(datatype_id, "TEN", (int *)&val) < 0) goto error;
/* This call should fail since we did not create a member with value = 3*/
val = 3;
if (H5Tenum_nameof(datatype_id, &val, nam, size) >= 0) goto error;
/* This call should fail since we did not create a member with value = 11*/
val = 11;
if (H5Tenum_nameof(datatype_id, &val, nam, size) >= 0) goto error;
/* This call should fail since we did not create a member with value = 0*/
val = 0;
if (H5Tenum_nameof(datatype_id, &val, nam, size) >= 0) goto error;
/* This call should fail since we do not have SAX name in the type */
if (H5Tenum_valueof(datatype_id, "SAX", &val) >= 0) goto error;
/* This call should fail since we do not have TEEN name in the type */
if (H5Tenum_valueof(datatype_id, "TEEN", &val) >= 0) goto error;
/* This call should fail since we do not have A name in the type */
if (H5Tenum_valueof(datatype_id, "A", &val) >= 0) goto error;
if (H5Tclose(datatype_id) < 0) goto error;
PASSED();
return 0;
error:
H5E_BEGIN_TRY {
H5Tclose(datatype_id);
} H5E_END_TRY;
return 1;
}
/*-------------------------------------------------------------------------
* test_opaque
*
* Tests that the packet table works with an opaque datatype.
*
*-------------------------------------------------------------------------
*/
static int test_opaque(hid_t fid)
{
herr_t err;
hid_t table;
hid_t part_t;
size_t c;
particle_t readBuf[NRECORDS];
TESTING("opaque data");
/* Create an opaque datatype for the particle struct */
if ((part_t = H5Tcreate (H5T_OPAQUE, sizeof(particle_t) )) < 0 )
return -1;
HDassert(part_t != -1);
/* Tag the opaque datatype */
if ( H5Tset_tag(part_t, "Opaque Particle" ) < 0)
return -1;
/* Create a new table */
table = H5PTcreate_fl(fid, "Packet Test Dataset3", part_t, (hsize_t)100, -1);
H5Tclose(part_t);
if( H5PTis_valid(table) < 0)
goto out;
/* Append several particles, starting at particle 1 */
err = H5PTappend(table, (size_t)(NRECORDS - 1), &(testPart[1]));
if( err < 0)
goto out;
/* Read the particles back */
err = H5PTread_packets(table, (hsize_t)0, 7, &(readBuf[0]));
if( err < 0)
goto out;
/* Ensure that particles were read correctly */
for(c=0; c<NRECORDS - 1; c++)
{
if( cmp_par(c+1, c, testPart, readBuf) != 0)
goto out;
}
/* Close the table */
err = H5PTclose(table);
if( err < 0)
goto out;
PASSED();
return 0;
out:
H5_FAILED();
if( H5PTis_valid(table) < 0)
H5PTclose(table);
return -1;
}
/*-------------------------------------------------------------------------
* Function: test_sec2
*
* Purpose: Tests the file handle interface for SEC2 driver
*
* Return: Success: 0
* Failure: -1
*
* Programmer: Raymond Lu
* Tuesday, Sept 24, 2002
*
* Modifications:
*
* Raymond Lu
* Wednesday, June 23, 2004
* Added test for H5Fget_filesize.
*
*-------------------------------------------------------------------------
*/
static herr_t
test_sec2(void)
{
hid_t file=(-1), fapl, access_fapl = -1;
char filename[1024];
int *fhandle=NULL;
hsize_t file_size;
TESTING("SEC2 file driver");
/* Set property list and file name for SEC2 driver. */
fapl = h5_fileaccess();
if(H5Pset_fapl_sec2(fapl) < 0)
TEST_ERROR;
h5_fixname(FILENAME[0], fapl, filename, sizeof filename);
if((file=H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
TEST_ERROR;
/* Retrieve the access property list... */
if ((access_fapl = H5Fget_access_plist(file)) < 0)
TEST_ERROR;
/* ...and close the property list */
if (H5Pclose(access_fapl) < 0)
TEST_ERROR;
/* Check file handle API */
if(H5Fget_vfd_handle(file, H5P_DEFAULT, (void **)&fhandle) < 0)
TEST_ERROR;
if(*fhandle<0)
TEST_ERROR;
/* Check file size API */
if(H5Fget_filesize(file, &file_size) < 0)
TEST_ERROR;
/* There is no garantee the size of metadata in file is constant.
* Just try to check if it's reasonable. It's 2KB right now.
*/
if(file_size<1*KB || file_size>4*KB)
TEST_ERROR;
if(H5Fclose(file) < 0)
TEST_ERROR;
h5_cleanup(FILENAME, fapl);
PASSED();
return 0;
error:
H5E_BEGIN_TRY {
H5Pclose (fapl);
H5Fclose(file);
} H5E_END_TRY;
return -1;
}
/*-------------------------------------------------------------------------
* Function: test_dangle_dataset
*
* Purpose: Check for dangling dataset IDs causing problems on library
* shutdown
*
* Return: Success: zero
* Failure: non-zero
*
* Programmer: Quincey Koziol
* Tuesday, May 13, 2003
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static int
test_dangle_dataset(H5F_close_degree_t degree)
{
char filename[1024];
hid_t fid; /* File ID */
hid_t fapl; /* File access property list */
hid_t dsid; /* Dataset ID */
hid_t sid; /* Dataspace ID */
unsigned u; /* Local index variable */
TESTING(" dangling dataset IDs");
if(H5open() < 0)
TEST_ERROR;
/* Create file access property list */
if((fapl = H5Pcreate(H5P_FILE_ACCESS)) < 0)
TEST_ERROR;
/* Set file close degree */
if(H5Pset_fclose_degree(fapl, degree) < 0)
TEST_ERROR;
h5_fixname(FILENAME[0], H5P_DEFAULT, filename, sizeof filename);
if((fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
TEST_ERROR;
if((sid = H5Screate(H5S_SCALAR)) < 0)
TEST_ERROR;
if((dsid = H5Dcreate2(fid, DSETNAME, H5T_NATIVE_INT, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
TEST_ERROR;
if(H5Dclose(dsid) < 0)
TEST_ERROR;
/* Try creating duplicate dataset */
H5E_BEGIN_TRY {
if((dsid = H5Dcreate2(fid, DSETNAME, H5T_NATIVE_INT, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) >= 0)
TEST_ERROR;
} H5E_END_TRY;
if(H5Sclose(sid) < 0)
TEST_ERROR;
/* Leave open a _lot_ of objects */
for(u = 0; u < MAX_DANGLE; u++)
if((dsid = H5Dopen2(fid, DSETNAME, H5P_DEFAULT)) < 0)
TEST_ERROR;
if(degree == H5F_CLOSE_SEMI) {
H5E_BEGIN_TRY {
if(H5Fclose(fid) >= 0)
TEST_ERROR;
} H5E_END_TRY;
} /* end if */
/*-------------------------------------------------------------------------
* Function: long_links
*
* Purpose: Build a file with long names
*
* Return: Success: 0
*
* Failure: -1
*
* Programmer: Quincey Koziol
* Saturday, April 16, 2005
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static int
long_links(hid_t fapl)
{
hid_t fid = (-1); /* File ID */
hid_t gid = (-1); /* Group ID */
hid_t gid2 = (-1); /* Datatype ID */
char *objname = NULL; /* Name of object [Long] */
size_t u; /* Local index variable */
char filename[NAME_BUF_SIZE];
TESTING("long names for objects & links");
/* Create files */
h5_fixname(FILENAME[1], fapl, filename, sizeof filename);
if((fid=H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl))<0) TEST_ERROR;
/* Create group with short name in file (used as target for hard links) */
if((gid=H5Gcreate (fid, "grp1", (size_t)0))<0) TEST_ERROR;
/* Construct very long file name */
if((objname = HDmalloc((size_t)(MAX_NAME_LEN + 1))) == NULL) TEST_ERROR;
for(u = 0; u < MAX_NAME_LEN; u++)
objname[u] = 'a';
objname[MAX_NAME_LEN] = '\0';
/* Create hard link to existing object */
if(H5Glink2(fid, "grp1", H5G_LINK_HARD, fid, objname) < 0) TEST_ERROR;
/* Create soft link to existing object */
objname[0] = 'b';
if(H5Glink2(fid, "grp1", H5G_LINK_SOFT, fid, objname) < 0) TEST_ERROR;
/* Create group with long name in existing group */
if((gid2=H5Gcreate(gid, objname, (size_t)0))<0) TEST_ERROR;
/* Close objects */
if(H5Gclose(gid2)<0) TEST_ERROR;
if(H5Gclose(gid)<0) TEST_ERROR;
if(H5Fclose(fid)<0) TEST_ERROR;
/* Release memory */
HDfree(objname);
PASSED();
return 0;
error:
H5E_BEGIN_TRY {
H5Gclose (gid2);
H5Gclose (gid);
H5Fclose (fid);
} H5E_END_TRY;
HDfree(objname);
return -1;
}
/*-------------------------------------------------------------------------
* Function: test_misc
*
* Purpose: Test miscellaneous group stuff.
*
* Return: Success: 0
*
* Failure: number of errors
*
* Programmer: Robb Matzke
* Tuesday, November 24, 1998
*
* Modifications:
* Robb Matzke, 2002-03-28
* File is opened by parent instead of here.
*-------------------------------------------------------------------------
*/
static int
test_misc(hid_t file)
{
hid_t g1=-1, g2=-1, g3=-1;
char comment[64];
/* Test current working groups */
TESTING("miscellaneous group tests");
/* Create initial groups for testing, then close */
if ((g1=H5Gcreate(file, "test_1a", 0))<0) goto error;
if ((g2=H5Gcreate(g1, "sub_1", 0))<0) goto error;
if ((g3=H5Gcreate(file, "test_1b", 0))<0) goto error;
if (H5Gset_comment(g3, ".", "hello world")<0) goto error;
if (H5Gclose(g1)<0) goto error;
if (H5Gclose(g2)<0) goto error;
if (H5Gclose(g3)<0) goto error;
/* Open all groups with absolute names to check for exsistence */
if ((g1=H5Gopen(file, "/test_1a"))<0) goto error;
if ((g2=H5Gopen(file, "/test_1a/sub_1"))<0) goto error;
if ((g3=H5Gopen(file, "/test_1b"))<0) goto error;
if (H5Gget_comment(g3, "././.", sizeof comment, comment)<0) goto error;
if (strcmp(comment, "hello world")) {
H5_FAILED();
puts(" Read the wrong comment string from the group.");
printf(" got: \"%s\"\n ans: \"hello world\"\n", comment);
goto error;
}
if (H5Gclose(g1)<0) goto error;
if (H5Gclose(g2)<0) goto error;
if (H5Gclose(g3)<0) goto error;
/* Check that creating groups with no-op names isn't allowed */
H5E_BEGIN_TRY {
g1=H5Gcreate(file, "/", 0);
} H5E_END_TRY
if(g1 >= 0) goto error;
H5E_BEGIN_TRY {
g1=H5Gcreate(file, "./././", 0);
} H5E_END_TRY
if(g1 >= 0) goto error;
PASSED();
return 0;
error:
H5E_BEGIN_TRY {
H5Gclose(g1);
H5Gclose(g2);
H5Gclose(g3);
} H5E_END_TRY;
return 1;
}
/*-------------------------------------------------------------------------
* Function: test_named
*
* Purpose: Create an enumeration data type and store it in the file.
*
* Return: Success: 0
*
* Failure: number of errors
*
* Programmer: Robb Matzke
* Wednesday, December 23, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static int
test_named(hid_t file)
{
hid_t type=-1, cwg=-1;
c_e1 val;
signed char val8;
TESTING("named enumeration types");
if ((cwg=H5Gcreate(file, "test_named", 0))<0) goto error;
/* A native integer */
if ((type = H5Tcreate(H5T_ENUM, sizeof(c_e1)))<0) goto error;
if (H5Tenum_insert(type, "RED", CPTR(val, E1_RED ))<0) goto error;
if (H5Tenum_insert(type, "GREEN", CPTR(val, E1_GREEN))<0) goto error;
if (H5Tenum_insert(type, "BLUE", CPTR(val, E1_BLUE ))<0) goto error;
if (H5Tenum_insert(type, "WHITE", CPTR(val, E1_WHITE))<0) goto error;
if (H5Tenum_insert(type, "BLACK", CPTR(val, E1_BLACK))<0) goto error;
if (H5Tcommit(cwg, "e1_a", type)<0) goto error;
if (H5Tclose(type)<0) goto error;
/* A smaller type */
if ((type = H5Tcreate(H5T_ENUM, 1))<0) goto error;
if (H5Tenum_insert(type, "RED", CPTR(val8, E1_RED ))<0) goto error;
if (H5Tenum_insert(type, "GREEN", CPTR(val8, E1_GREEN))<0) goto error;
if (H5Tenum_insert(type, "BLUE", CPTR(val8, E1_BLUE ))<0) goto error;
if (H5Tenum_insert(type, "WHITE", CPTR(val8, E1_WHITE))<0) goto error;
if (H5Tenum_insert(type, "BLACK", CPTR(val8, E1_BLACK))<0) goto error;
if (H5Tcommit(cwg, "e1_b", type)<0) goto error;
if (H5Tclose(type)<0) goto error;
/* A non-native type */
if (H5T_ORDER_BE==H5Tget_order(H5T_NATIVE_INT)) {
if ((type = H5Tenum_create(H5T_STD_U8LE))<0) goto error;
} else {
if ((type = H5Tenum_create(H5T_STD_U8BE))<0) goto error;
}
if (H5Tenum_insert(type, "RED", CPTR(val8, E1_RED ))<0) goto error;
if (H5Tenum_insert(type, "GREEN", CPTR(val8, E1_GREEN))<0) goto error;
if (H5Tenum_insert(type, "BLUE", CPTR(val8, E1_BLUE ))<0) goto error;
if (H5Tenum_insert(type, "WHITE", CPTR(val8, E1_WHITE))<0) goto error;
if (H5Tenum_insert(type, "BLACK", CPTR(val8, E1_BLACK))<0) goto error;
if (H5Tcommit(cwg, "e1_c", type)<0) goto error;
if (H5Tclose(type)<0) goto error;
if (H5Gclose(cwg)<0) goto error;
PASSED();
return 0;
error:
H5E_BEGIN_TRY {
H5Tclose(type);
H5Gclose(cwg);
} H5E_END_TRY;
return 1;
}
/*-------------------------------------------------------------------------
* Function: test_noconv
*
* Purpose: Tests creation of datasets when no conversion is present.
*
* Return: Success: 0
*
* Failure: number of errors
*
* Programmer: Robb Matzke
* Monday, January 4, 1999
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static int
test_noconv(hid_t file)
{
hid_t cwg=-1, type=-1, space=-1, dset=-1;
c_e1 val;
static c_e1 data1[]={E1_RED, E1_GREEN, E1_BLUE, E1_GREEN, E1_WHITE,
E1_WHITE, E1_BLACK, E1_GREEN, E1_BLUE, E1_RED,
E1_RED, E1_BLUE, E1_GREEN, E1_BLACK, E1_WHITE,
E1_RED, E1_WHITE, E1_GREEN, E1_GREEN, E1_BLUE};
c_e1 data2[NELMTS(data1)];
hsize_t ds_size[1]={NELMTS(data1)};
size_t i;
TESTING("no-conversion datasets");
if ((cwg=H5Gcreate(file, "test_noconv", 0))<0) goto error;
if ((type = H5Tcreate(H5T_ENUM, sizeof(c_e1)))<0) goto error;
if (H5Tenum_insert(type, "RED", CPTR(val, E1_RED ))<0) goto error;
if (H5Tenum_insert(type, "GREEN", CPTR(val, E1_GREEN))<0) goto error;
if (H5Tenum_insert(type, "BLUE", CPTR(val, E1_BLUE ))<0) goto error;
if (H5Tenum_insert(type, "WHITE", CPTR(val, E1_WHITE))<0) goto error;
if (H5Tenum_insert(type, "BLACK", CPTR(val, E1_BLACK))<0) goto error;
if ((space=H5Screate_simple(1, ds_size, NULL))<0) goto error;
if ((dset=H5Dcreate(cwg, "color_table", type, space, H5P_DEFAULT))<0)
goto error;
if (H5Dwrite(dset, type, space, space, H5P_DEFAULT, data1)<0) goto error;
if (H5Dread(dset, type, space, space, H5P_DEFAULT, data2)<0) goto error;
for (i=0; i<ds_size[0]; i++) {
if (data1[i]!=data2[i]) {
H5_FAILED();
printf(" data1[%lu]=%d, data2[%lu]=%d (should be same)\n",
(unsigned long)i, (int)(data1[i]),
(unsigned long)i, (int)(data2[i]));
goto error;
}
}
if (H5Dclose(dset)<0) goto error;
if (H5Sclose(space)<0) goto error;
if (H5Tclose(type)<0) goto error;
if (H5Gclose(cwg)<0) goto error;
PASSED();
return 0;
error:
H5E_BEGIN_TRY {
H5Dclose(dset);
H5Sclose(space);
H5Tclose(type);
H5Gclose(cwg);
} H5E_END_TRY;
return 1;
}
/*-------------------------------------------------------------------------
* Function: test_creating_groups_using_plugins
*
* Purpose: Tests creating group with dynamically loaded filters
*
* Return: SUCCEED/FAIL
*
*-------------------------------------------------------------------------
*/
static herr_t
test_creating_groups_using_plugins(hid_t fid)
{
hid_t gcpl_id = -1;
hid_t gid = -1;
hid_t sub_gid = -1;
int i;
char subgroup_name[256];
TESTING("creating groups with filter plugin 4");
if ((gcpl_id = H5Pcreate(H5P_GROUP_CREATE)) < 0)
TEST_ERROR;
/* Use a filter plugin for creating groups */
if (H5Pset_filter(gcpl_id, FILTER4_ID, H5Z_FLAG_MANDATORY, (size_t)0, NULL) < 0)
TEST_ERROR;
/* Create a group using this filter */
if ((gid = H5Gcreate2(fid, TOP_LEVEL_GROUP_NAME, H5P_DEFAULT, gcpl_id, H5P_DEFAULT)) < 0)
TEST_ERROR;
/* Create multiple groups under the top-level group */
for (i = 0; i < N_SUBGROUPS; i++) {
char *sp = subgroup_name;
sp += HDsprintf(subgroup_name, SUBGROUP_PREFIX);
HDsprintf(sp, "%d", i);
if ((sub_gid = H5Gcreate2(gid, subgroup_name, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
TEST_ERROR;
if (H5Gclose(sub_gid) < 0)
TEST_ERROR;
}
/* Close everything */
if (H5Gclose(gid) < 0)
TEST_ERROR;
if (H5Pclose(gcpl_id) < 0)
TEST_ERROR;
PASSED();
return SUCCEED;
error:
/* Clean up objects used for this test */
H5E_BEGIN_TRY {
H5Gclose(sub_gid);
H5Gclose(gid);
H5Pclose(gcpl_id);
} H5E_END_TRY
return FAIL;
} /* end test_creating_groups_using_plugins() */
/*-------------------------------------------------------------------------
* Function: test_decrement
*
* Purpose: Test operation to decrement bit vector by 1.
*
* Return: Success: 0
*
* Failure: -1
*
* Programmer: Raymond Lu
* Monday, April 12, 2004
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static herr_t
test_decrement (void)
{
uint8_t vector[8];
size_t offset, size;
int i, j;
ssize_t n;
TESTING("bit decrement operations");
for (i=0; i<NTESTS; i++) {
offset = HDrand() % (8*sizeof vector);
size = (unsigned)HDrand() % (8*sizeof(vector)-offset);
/* Don't want size to be 0 */
if(size == 0) continue;
/* All-zero sequence will become 111111(size=6) after decrement */
memset (vector, 0x00, sizeof vector);
/* decrement the sequence by one */
H5T_bit_dec (vector, offset, size);
/* Look for the ones */
n = H5T_bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_LSB, 1);
if ((size_t)n!=offset) {
H5_FAILED();
printf (" Unable to find first bit in destination "
"(n=%d)\n", (int)n);
goto failed;
}
/*
* Look for zeros and ones in reverse order. This is only to test
* that reverse searches work as expected.
*/
n = H5T_bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_MSB, 1);
if (n!=(ssize_t)(offset+size-1)) {
H5_FAILED();
printf (" Unable to find last bit in destination "
"(reverse, n=%d)\n", (int)n);
goto failed;
}
}
PASSED();
return 0;
failed:
printf (" i=%d, offset=%lu, size=%lu\n",
i, (unsigned long)offset, (unsigned long)size);
for (j=sizeof(vector)-1; j>=0; --j) printf ("%02x", vector[j]);
printf ("\n");
return -1;
}
