mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2025-02-17 16:10:24 +08:00
Code Issues Packages Projects Releases Wiki Activity

[svn-r12833] Description:

Browse Source 
Clean up more warnings...

Tested on:
    Linux/32 2.6 (chicago)
    Linux/64 2.6 (chicago2)
This commit is contained in:
Quincey Koziol 2006-10-30 19:13:27 -05:00
parent 3f69573f57
commit bcda3c2dbf
16 changed files with 215 additions and 225 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/H5FScache.c
View File

@ -548,7 +548,7 @@ HDfprintf(stderr, "%s: Load free space sections, addr = %a\n", FUNC, addr);
HGOTO_ERROR(H5E_FSPACE, H5E_CANTLOAD, NULL, "incorrect address for free space sections")
/* Allocate space for the buffer to serialize the sections into */
old_sect_size = fspace->sect_size;
H5_ASSIGN_OVERFLOW(/* To: */ old_sect_size, /* From: */ fspace->sect_size, /* From: */ hsize_t, /* To: */ size_t);
#ifdef QAK
HDfprintf(stderr, "%s: fspace->sect_size = %Hu\n", FUNC, fspace->sect_size);
#endif /* QAK */
@ -1121,7 +1121,7 @@ H5FS_cache_sinfo_size(const H5F_t UNUSED *f, const H5FS_sinfo_t *sinfo, size_t *
HDassert(size_ptr);
/* Set size value */
*size_ptr = sinfo->fspace->sect_size;
H5_ASSIGN_OVERFLOW(/* To: */ *size_ptr, /* From: */ sinfo->fspace->sect_size, /* From: */ hsize_t, /* To: */ size_t);
FUNC_LEAVE_NOAPI(SUCCEED)
} /* H5FS_cache_sinfo_size() */

44
test/bittests.c
View File

@ -54,15 +54,15 @@ test_find (void)
TESTING("bit search operations");
/* The zero length buffer */
memset (v1, 0xaa, sizeof v1);
n = H5T_bit_find (v1, 0, 0, H5T_BIT_LSB, TRUE);
if (-1!=n) {
HDmemset(v1, 0xaa, sizeof v1);
n = H5T_bit_find(v1, (size_t)0, (size_t)0, H5T_BIT_LSB, TRUE);
if(-1 != n) {
H5_FAILED();
puts (" Zero length test failed (lsb)!");
goto failed;
}
n = H5T_bit_find (v1, 0, 0, H5T_BIT_MSB, TRUE);
if (-1!=n) {
n = H5T_bit_find(v1, (size_t)0, (size_t)0, H5T_BIT_MSB, TRUE);
if(-1 != n) {
H5_FAILED();
puts (" Zero length test failed (msb)!");
goto failed;
@ -70,32 +70,32 @@ test_find (void)
/* The zero buffer */
memset (v1, 0, sizeof v1);
n = H5T_bit_find (v1, 0, 8*sizeof(v1), H5T_BIT_LSB, TRUE);
if (-1!=n) {
HDmemset(v1, 0, sizeof v1);
n = H5T_bit_find(v1, (size_t)0, 8 * sizeof(v1), H5T_BIT_LSB, TRUE);
if(-1 != n) {
H5_FAILED();
puts (" Zero buffer test failed (lsb)!");
goto failed;
}
n = H5T_bit_find (v1, 0, 8*sizeof(v1), H5T_BIT_MSB, TRUE);
if (-1!=n) {
n = H5T_bit_find(v1, (size_t)0, 8 * sizeof(v1), H5T_BIT_MSB, TRUE);
if(-1 != n) {
H5_FAILED();
puts (" Zero buffer test failed (msb)!");
goto failed;
}
/* Try all combinations of one byte */
for (i=0; i<8*(int)sizeof(v1); i++) {
memset (v1, 0, sizeof v1);
v1[i/8] = 1<<(i%8);
n = H5T_bit_find (v1, 0, 8*sizeof(v1), H5T_BIT_LSB, TRUE);
if ((ssize_t)i!=n) {
for(i = 0; i < 8 * (int)sizeof(v1); i++) {
HDmemset(v1, 0, sizeof v1);
v1[i / 8] = 1 << (i % 8);
n = H5T_bit_find(v1, (size_t)0, 8 * sizeof(v1), H5T_BIT_LSB, TRUE);
if((ssize_t)i != n) {
H5_FAILED();
printf (" Test for set bit %d failed (lsb)!\n", i);
goto failed;
}
n = H5T_bit_find (v1, 0, 8*sizeof(v1), H5T_BIT_MSB, TRUE);
if ((ssize_t)i!=n) {
n = H5T_bit_find(v1, (size_t)0, 8 * sizeof(v1), H5T_BIT_MSB, TRUE);
if((ssize_t)i != n) {
H5_FAILED();
printf (" Test for set bit %d failed (msb)!\n", i);
goto failed;
@ -103,15 +103,15 @@ test_find (void)
}
/* The one buffer */
memset (v1, 0xff, sizeof v1);
n = H5T_bit_find (v1, 0, 8*sizeof(v1), H5T_BIT_LSB, FALSE);
if (-1!=n) {
HDmemset(v1, 0xff, sizeof v1);
n = H5T_bit_find(v1, (size_t)0, 8 * sizeof(v1), H5T_BIT_LSB, FALSE);
if(-1 != n) {
H5_FAILED();
puts (" One buffer test failed (lsb)!");
goto failed;
}
n = H5T_bit_find (v1, 0, 8*sizeof(v1), H5T_BIT_MSB, FALSE);
if (-1!=n) {
n = H5T_bit_find(v1, (size_t)0, 8 * sizeof(v1), H5T_BIT_MSB, FALSE);
if(-1 != n) {
H5_FAILED();
puts (" One buffer test failed (msb)!");
goto failed;

68
test/cache.c
View File

@ -9119,11 +9119,11 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 1);
unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 1,
H5C__NO_FLAGS_SET, 0);
H5C__NO_FLAGS_SET, (size_t)0);
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 2);
unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 2,
H5C__NO_FLAGS_SET, 0);
H5C__NO_FLAGS_SET, (size_t)0);
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 3);
unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 3,
@ -9142,11 +9142,11 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 6);
unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 6,
H5C__NO_FLAGS_SET, 0);
H5C__NO_FLAGS_SET, (size_t)0);
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 7);
unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 7,
H5C__NO_FLAGS_SET, 0);
H5C__NO_FLAGS_SET, (size_t)0);
if ( ( cache_ptr->index_len != 8 ) ||
( cache_ptr->index_size != (4 * (VARIABLE_ENTRY_SIZE / 2)) +
@ -9190,25 +9190,25 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
* (VET, 7) dirties (VET, 6)
*/
add_flush_op(VARIABLE_ENTRY_TYPE, 1, FLUSH_OP__DIRTY,
VARIABLE_ENTRY_TYPE, 0, FALSE, 0);
VARIABLE_ENTRY_TYPE, 0, FALSE, (size_t)0);
add_flush_op(VARIABLE_ENTRY_TYPE, 1, FLUSH_OP__RESIZE,
VARIABLE_ENTRY_TYPE, 0, FALSE,
3 * VARIABLE_ENTRY_SIZE / 4);
add_flush_op(VARIABLE_ENTRY_TYPE, 2, FLUSH_OP__DIRTY,
VARIABLE_ENTRY_TYPE, 0, FALSE, 0);
VARIABLE_ENTRY_TYPE, 0, FALSE, (size_t)0);
add_flush_op(VARIABLE_ENTRY_TYPE, 2, FLUSH_OP__RESIZE,
VARIABLE_ENTRY_TYPE, 0, FALSE, VARIABLE_ENTRY_SIZE);
add_flush_op(VARIABLE_ENTRY_TYPE, 2, FLUSH_OP__RENAME,
VARIABLE_ENTRY_TYPE, 0, FALSE, 0);
VARIABLE_ENTRY_TYPE, 0, FALSE, (size_t)0);
add_flush_op(VARIABLE_ENTRY_TYPE, 3, FLUSH_OP__DIRTY,
VARIABLE_ENTRY_TYPE, 0, FALSE, 0);
VARIABLE_ENTRY_TYPE, 0, FALSE, (size_t)0);
add_flush_op(VARIABLE_ENTRY_TYPE, 3, FLUSH_OP__RESIZE,
VARIABLE_ENTRY_TYPE, 3, FALSE, VARIABLE_ENTRY_SIZE);
add_flush_op(VARIABLE_ENTRY_TYPE, 7, FLUSH_OP__DIRTY,
VARIABLE_ENTRY_TYPE, 6, FALSE, 0);
VARIABLE_ENTRY_TYPE, 6, FALSE, (size_t)0);
}
if ( pass ) {
@ -9249,14 +9249,14 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
unprotect_entry_with_size_change(cache_ptr, MONSTER_ENTRY_TYPE, i,
H5C__DIRTIED_FLAG, 0);
H5C__DIRTIED_FLAG, (size_t)0);
}
for ( i = 0; i < 1; i++ )
{
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i,
H5C__DIRTIED_FLAG, 0);
H5C__DIRTIED_FLAG, (size_t)0);
}
/* The cache should now be exactly full */
@ -9324,7 +9324,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 1);
unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, 1,
H5C__DIRTIED_FLAG, 0);
H5C__DIRTIED_FLAG, (size_t)0);
if ( ( cache_ptr->index_len != 40 ) ||
( cache_ptr->index_size != (2 * 1024 * 1024) -
@ -9390,7 +9390,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 2);
unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, 2,
H5C__DIRTIED_FLAG, 0);
H5C__DIRTIED_FLAG, (size_t)0);
if ( ( cache_ptr->index_len != 40 ) ||
( cache_ptr->index_size != (2 * 1024 * 1024) -
@ -9463,11 +9463,11 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 3);
unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, 3,
H5C__DIRTIED_FLAG, 0);
H5C__DIRTIED_FLAG, (size_t)0);
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 4);
unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, 4,
H5C__DIRTIED_FLAG, 0);
H5C__DIRTIED_FLAG, (size_t)0);
/* verify cache size */
if ( ( cache_ptr->index_len != 41 ) ||
@ -9504,14 +9504,14 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
unprotect_entry_with_size_change(cache_ptr, MONSTER_ENTRY_TYPE, i,
H5C__DIRTIED_FLAG, 0);
H5C__DIRTIED_FLAG, (size_t)0);
}
for ( i = 0; i < 5; i++ )
{
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i,
H5C__DIRTIED_FLAG, 0);
H5C__DIRTIED_FLAG, (size_t)0);
}
/* verify cache size */
@ -9571,7 +9571,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
{
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i,
H5C__DIRTIED_FLAG, 0);
H5C__DIRTIED_FLAG, (size_t)0);
}
/* verify cache size */
@ -9633,7 +9633,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
{
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i,
H5C__DIRTIED_FLAG, 0);
H5C__DIRTIED_FLAG, (size_t)0);
}
/* verify cache size */
@ -9699,7 +9699,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
{
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i,
H5C__DIRTIED_FLAG, 0);
H5C__DIRTIED_FLAG, (size_t)0);
}
/* verify cache size */
@ -9735,14 +9735,14 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
unprotect_entry_with_size_change(cache_ptr, MONSTER_ENTRY_TYPE, i,
H5C__DIRTIED_FLAG, 0);
H5C__DIRTIED_FLAG, (size_t)0);
}
for ( i = 0; i < 10; i++ )
{
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i,
H5C__DIRTIED_FLAG, 0);
H5C__DIRTIED_FLAG, (size_t)0);
}
/* verify cache size */
@ -9846,7 +9846,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
{
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i,
H5C__DIRTIED_FLAG, 0);
H5C__DIRTIED_FLAG, (size_t)0);
}
/* verify cache size */
@ -9879,14 +9879,14 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
unprotect_entry_with_size_change(cache_ptr, MONSTER_ENTRY_TYPE, i,
H5C__DIRTIED_FLAG, 0);
H5C__DIRTIED_FLAG, (size_t)0);
}
for ( i = 0; i < num_large_entries; i++ )
{
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i,
H5C__DIRTIED_FLAG, 0);
H5C__DIRTIED_FLAG, (size_t)0);
}
/* update the expected array to mark all these entries dirty again. */
@ -9973,7 +9973,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
{
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i,
H5C__DIRTIED_FLAG, 0);
H5C__DIRTIED_FLAG, (size_t)0);
}
/* verify cache size */
@ -12316,7 +12316,7 @@ check_get_entry_status(void)
}
}
mark_pinned_entry_dirty(cache_ptr, 0, 0, FALSE, 0);
mark_pinned_entry_dirty(cache_ptr, 0, 0, FALSE, (size_t)0);
if ( pass ) {
@ -14400,7 +14400,7 @@ check_double_pin_err(void)
result = H5C_unprotect(NULL, -1, -1, cache_ptr, &(types[0]),
entry_ptr->addr, (void *)entry_ptr,
H5C__PIN_ENTRY_FLAG, 0);
H5C__PIN_ENTRY_FLAG, (size_t)0);
if ( result > 0 ) {
@ -14486,7 +14486,7 @@ check_double_unpin_err(void)
result = H5C_unprotect(NULL, -1, -1, cache_ptr, &(types[0]),
entry_ptr->addr, (void *)entry_ptr,
H5C__UNPIN_ENTRY_FLAG, 0);
H5C__UNPIN_ENTRY_FLAG, (size_t)0);
if ( result > 0 ) {
@ -14781,7 +14781,7 @@ check_double_unprotect_err(void)
result = H5C_unprotect(NULL, -1, -1, cache_ptr, &(types[0]),
entry_ptr->addr, (void *)entry_ptr,
H5C__NO_FLAGS_SET, 0);
H5C__NO_FLAGS_SET, (size_t)0);
if ( result > 0 ) {
@ -14879,7 +14879,7 @@ check_mark_entry_dirty_errs(void)
if ( pass ) {
result = H5C_mark_pinned_entry_dirty(cache_ptr, (void *)entry_ptr,
FALSE, 0);
FALSE, (size_t)0);
if ( result > 0 ) {
@ -14896,7 +14896,7 @@ check_mark_entry_dirty_errs(void)
if ( pass ) {
result = H5C_mark_pinned_entry_dirty(cache_ptr, (void *)entry_ptr,
FALSE, 0);
FALSE, (size_t)0);
if ( result > 0 ) {
@ -15119,7 +15119,7 @@ check_resize_entry_errs(void)
if ( pass ) {
result = H5C_resize_pinned_entry(cache_ptr, (void *)entry_ptr, 1);
result = H5C_resize_pinned_entry(cache_ptr, (void *)entry_ptr, (size_t)1);
if ( result > 0 ) {
@ -15136,7 +15136,7 @@ check_resize_entry_errs(void)
if ( pass ) {
result = H5C_resize_pinned_entry(cache_ptr, (void *)entry_ptr, 0);
result = H5C_resize_pinned_entry(cache_ptr, (void *)entry_ptr, (size_t)0);
if ( result > 0 ) {

12
test/cache_api.c
View File

@ -1070,8 +1070,8 @@ check_and_validate_cache_hit_rate(hid_t file_id,
{
/* const char * fcn_name = "check_and_validate_cache_hit_rate()"; */
herr_t result;
int64_t cache_hits;
int64_t cache_accesses;
int64_t cache_hits = 0;
int64_t cache_accesses = 0;
double expected_hit_rate;
double hit_rate;
H5F_t * file_ptr = NULL;
@ -2113,7 +2113,7 @@ H5AC_cache_config_t invalid_configs[NUM_INVALID_CONFIGS] =
{
/* 1 -- bad rpt_fcn_enabled */
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ -1,
/* hbool_t rpt_fcn_enabled = */ (hbool_t)-1,
/* hbool_t open_trace_file = */ FALSE,
/* hbool_t close_trace_file = */ FALSE,
/* char trace_file_name[] = */ "",
@ -2142,7 +2142,7 @@ H5AC_cache_config_t invalid_configs[NUM_INVALID_CONFIGS] =
/* 2 -- bad open_trace_file */
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t open_trace_file = */ -1,
/* hbool_t open_trace_file = */ (hbool_t)-1,
/* hbool_t close_trace_file = */ FALSE,
/* char trace_file_name[] = */ "",
/* hbool_t set_initial_size = */ TRUE,
@ -2171,7 +2171,7 @@ H5AC_cache_config_t invalid_configs[NUM_INVALID_CONFIGS] =
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t open_trace_file = */ FALSE,
/* hbool_t close_trace_file = */ -1,
/* hbool_t close_trace_file = */ (hbool_t)-1,
/* char trace_file_name[] = */ "",
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (1 * 1024 * 1024),
@ -2630,7 +2630,7 @@ H5AC_cache_config_t invalid_configs[NUM_INVALID_CONFIGS] =
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.9,
/* double increment = */ 2.0,
/* hbool_t apply_max_increment = */ -1,
/* hbool_t apply_max_increment = */ (hbool_t)-1,
/* size_t max_increment = */ (4 * 1024 * 1024),
/* enum H5C_cache_decr_mode decr_mode = */ H5C_decr__age_out_with_threshold,
/* double upper_hr_threshold = */ 0.999,

3
test/dtypes.c
View File

@ -491,7 +491,6 @@ error:
static int
test_compound_1(void)
{
complex_t tmp;
hid_t complex_id;
hid_t super;
size_t size;
@ -507,7 +506,7 @@ test_compound_1(void)
TESTING("compound data types");
/* Create the empty type */
if ((complex_id = H5Tcreate(H5T_COMPOUND, sizeof tmp))<0) goto error;
if ((complex_id = H5Tcreate(H5T_COMPOUND, sizeof(complex_t)))<0) goto error;
/* Attempt to add the new compound datatype as a field within itself */
H5E_BEGIN_TRY {

110
test/hyperslab.c
View File

@ -194,7 +194,7 @@ test_fill(size_t nx, size_t ny, size_t nz,
fflush(stdout);
/* Allocate array */
dst = HDcalloc(1,nx*ny*nz);
dst = HDcalloc((size_t)1, nx * ny * nz);
init_full(dst, nx, ny, nz);
for (i = 0; i < nx; i += di) {
@ -398,8 +398,8 @@ test_copy(int mode,
/*
* Allocate arrays
*/
src = HDcalloc(1,nx*ny*nz);
dst = HDcalloc(1,nx*ny*nz);
src = HDcalloc((size_t)1, nx * ny * nz);
dst = HDcalloc((size_t)1, nx * ny * nz);
init_full(src, nx, ny, nz);
for (i=0; i<nx; i+=di) {
@ -733,8 +733,8 @@ test_endian(size_t nx)
/* Initialize arrays */
src = HDmalloc(nx * 4);
init_full(src, nx, 4, 1);
dst = HDcalloc(nx , 4);
init_full(src, nx, (size_t)4, (size_t)1);
dst = HDcalloc(nx , (size_t)4);
/* Initialize strides */
src_stride[0] = 0;
@ -761,9 +761,9 @@ test_endian(size_t nx)
printf(" i=%lu, j=%lu\n",
(unsigned long)i, (unsigned long)j);
printf(" Source array is:\n");
print_array(src, nx, 4, 1);
print_array(src, nx, (size_t)4, (size_t)1);
printf("\n Result is:\n");
print_array(dst, nx, 4, 1);
print_array(dst, nx, (size_t)4, (size_t)1);
}
goto error;
}
@ -922,9 +922,9 @@ test_sub_super(size_t nx, size_t ny)
/* Initialize */
full = HDmalloc(4 * nx * ny);
init_full(full, 2 * nx, 2 * ny, 1);
half = HDcalloc(1,nx*ny);
twice = HDcalloc(4,nx*ny);
init_full(full, 2 * nx, 2 * ny, (size_t)1);
half = HDcalloc((size_t)1, nx * ny);
twice = HDcalloc((size_t)4, nx * ny);
/* Setup */
size[0] = nx;
@ -951,9 +951,9 @@ test_sub_super(size_t nx, size_t ny)
(unsigned long)i,
(unsigned long)j);
printf(" full is:\n");
print_array(full, 2 * nx, 2 * ny, 1);
print_array(full, 2 * nx, 2 * ny, (size_t)1);
printf("\n half is:\n");
print_array(half, nx, ny, 1);
print_array(half, nx, ny, (size_t)1);
}
goto error;
}
@ -1023,9 +1023,9 @@ test_sub_super(size_t nx, size_t ny)
if (!isatty(1)) {
AT();
printf(" %s\n Half is:\n", s);
print_array(half, nx, ny, 1);
print_array(half, nx, ny, (size_t)1);
printf("\n Twice is:\n");
print_array(twice, 2 * nx, 2 * ny, 1);
print_array(twice, 2 * nx, 2 * ny, (size_t)1);
}
goto error;
}
@ -1245,19 +1245,19 @@ main(int argc, char *argv[])
*------------------------------
*/
if (size_of_test & TEST_SMALL) {
status = test_fill(11, 0, 0, 1, 1, 1, 1, 1, 1);
status = test_fill((size_t)11, (size_t)0, (size_t)0, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1);
nerrors += status < 0 ? 1 : 0;
status = test_fill(11, 10, 0, 1, 1, 1, 1, 1, 1);
status = test_fill((size_t)11, (size_t)10, (size_t)0, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1);
nerrors += status < 0 ? 1 : 0;
status = test_fill(3, 5, 5, 1, 1, 1, 1, 1, 1);
status = test_fill((size_t)3, (size_t)5, (size_t)5, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1);
nerrors += status < 0 ? 1 : 0;
}
if (size_of_test & TEST_MEDIUM) {
status = test_fill(113, 0, 0, 1, 1, 1, 1, 1, 1);
status = test_fill((size_t)113, (size_t)0, (size_t)0, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1);
nerrors += status < 0 ? 1 : 0;
status = test_fill(15, 11, 0, 1, 1, 1, 1, 1, 1);
status = test_fill((size_t)15, (size_t)11, (size_t)0, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1);
nerrors += status < 0 ? 1 : 0;
status = test_fill(5, 7, 7, 1, 1, 1, 1, 1, 1);
status = test_fill((size_t)5, (size_t)7, (size_t)7, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1);
nerrors += status < 0 ? 1 : 0;
}
/*------------------------------
@ -1267,62 +1267,62 @@ main(int argc, char *argv[])
/* exhaustive, one-dimensional test */
if (size_of_test & TEST_SMALL) {
status = test_copy(VARIABLE_SRC, 11, 0, 0, 1, 1, 1, 1, 1, 1);
status = test_copy(VARIABLE_SRC, (size_t)11, (size_t)0, (size_t)0, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1);
nerrors += status < 0 ? 1 : 0;
status = test_copy(VARIABLE_DST, 11, 0, 0, 1, 1, 1, 1, 1, 1);
status = test_copy(VARIABLE_DST, (size_t)11, (size_t)0, (size_t)0, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1);
nerrors += status < 0 ? 1 : 0;
status = test_copy(VARIABLE_BOTH, 11, 0, 0, 1, 1, 1, 1, 1, 1);
status = test_copy(VARIABLE_BOTH, (size_t)11, (size_t)0, (size_t)0, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1);
nerrors += status < 0 ? 1 : 0;
}
if (size_of_test & TEST_MEDIUM) {
status = test_copy(VARIABLE_SRC, 179, 0, 0, 1, 1, 1, 1, 1, 1);
status = test_copy(VARIABLE_SRC, (size_t)179, (size_t)0, (size_t)0, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1);
nerrors += status < 0 ? 1 : 0;
status = test_copy(VARIABLE_DST, 179, 0, 0, 1, 1, 1, 1, 1, 1);
status = test_copy(VARIABLE_DST, (size_t)179, (size_t)0, (size_t)0, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1);
nerrors += status < 0 ? 1 : 0;
status = test_copy(VARIABLE_BOTH, 179, 0, 0, 1, 1, 1, 1, 1, 1);
status = test_copy(VARIABLE_BOTH, (size_t)179, (size_t)0, (size_t)0, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1);
nerrors += status < 0 ? 1 : 0;
}
/* exhaustive, two-dimensional test */
if (size_of_test & TEST_SMALL) {
status = test_copy(VARIABLE_SRC, 11, 10, 0, 1, 1, 1, 1, 1, 1);
status = test_copy(VARIABLE_SRC, (size_t)11, (size_t)10, (size_t)0, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1);
nerrors += status < 0 ? 1 : 0;
status = test_copy(VARIABLE_DST, 11, 10, 0, 1, 1, 1, 1, 1, 1);
status = test_copy(VARIABLE_DST, (size_t)11, (size_t)10, (size_t)0, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1);
nerrors += status < 0 ? 1 : 0;
status = test_copy(VARIABLE_BOTH, 11, 10, 0, 1, 1, 1, 1, 1, 1);
status = test_copy(VARIABLE_BOTH, (size_t)11, (size_t)10, (size_t)0, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1);
nerrors += status < 0 ? 1 : 0;
}
if (size_of_test & TEST_MEDIUM) {
status = test_copy(VARIABLE_SRC, 13, 19, 0, 1, 1, 1, 1, 1, 1);
status = test_copy(VARIABLE_SRC, (size_t)13, (size_t)19, (size_t)0, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1);
nerrors += status < 0 ? 1 : 0;
status = test_copy(VARIABLE_DST, 13, 19, 0, 1, 1, 1, 1, 1, 1);
status = test_copy(VARIABLE_DST, (size_t)13, (size_t)19, (size_t)0, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1);
nerrors += status < 0 ? 1 : 0;
status = test_copy(VARIABLE_BOTH, 13, 19, 0, 1, 1, 1, 1, 1, 1);
status = test_copy(VARIABLE_BOTH, (size_t)13, (size_t)19, (size_t)0, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1);
nerrors += status < 0 ? 1 : 0;
}
/* sparse, two-dimensional test */
if (size_of_test & TEST_MEDIUM) {
status = test_copy(VARIABLE_SRC, 73, 67, 0, 7, 11, 1, 13, 11, 1);
status = test_copy(VARIABLE_SRC, (size_t)73, (size_t)67, (size_t)0, (size_t)7, (size_t)11, (size_t)1, (size_t)13, (size_t)11, (size_t)1);
nerrors += status < 0 ? 1 : 0;
status = test_copy(VARIABLE_DST, 73, 67, 0, 7, 11, 1, 13, 11, 1);
status = test_copy(VARIABLE_DST, (size_t)73, (size_t)67, (size_t)0, (size_t)7, (size_t)11, (size_t)1, (size_t)13, (size_t)11, (size_t)1);
nerrors += status < 0 ? 1 : 0;
status = test_copy(VARIABLE_BOTH, 73, 67, 0, 7, 11, 1, 13, 11, 1);
status = test_copy(VARIABLE_BOTH, (size_t)73, (size_t)67, (size_t)0, (size_t)7, (size_t)11, (size_t)1, (size_t)13, (size_t)11, (size_t)1);
nerrors += status < 0 ? 1 : 0;
}
/* exhaustive, three-dimensional test */
if (size_of_test & TEST_SMALL) {
status = test_copy(VARIABLE_SRC, 3, 5, 5, 1, 1, 1, 1, 1, 1);
status = test_copy(VARIABLE_SRC, (size_t)3, (size_t)5, (size_t)5, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1);
nerrors += status < 0 ? 1 : 0;
status = test_copy(VARIABLE_DST, 3, 5, 5, 1, 1, 1, 1, 1, 1);
status = test_copy(VARIABLE_DST, (size_t)3, (size_t)5, (size_t)5, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1);
nerrors += status < 0 ? 1 : 0;
status = test_copy(VARIABLE_BOTH, 3, 5, 5, 1, 1, 1, 1, 1, 1);
status = test_copy(VARIABLE_BOTH, (size_t)3, (size_t)5, (size_t)5, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1);
nerrors += status < 0 ? 1 : 0;
}
if (size_of_test & TEST_MEDIUM) {
status = test_copy(VARIABLE_SRC, 7, 9, 5, 1, 1, 1, 1, 1, 1);
status = test_copy(VARIABLE_SRC, (size_t)7, (size_t)9, (size_t)5, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1);
nerrors += status < 0 ? 1 : 0;
status = test_copy(VARIABLE_DST, 7, 9, 5, 1, 1, 1, 1, 1, 1);
status = test_copy(VARIABLE_DST, (size_t)7, (size_t)9, (size_t)5, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1);
nerrors += status < 0 ? 1 : 0;
status = test_copy(VARIABLE_BOTH, 7, 9, 5, 1, 1, 1, 1, 1, 1);
status = test_copy(VARIABLE_BOTH, (size_t)7, (size_t)9, (size_t)5, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1, (size_t)1);
nerrors += status < 0 ? 1 : 0;
}
/*---------------------
@ -1331,11 +1331,11 @@ main(int argc, char *argv[])
*/
if (size_of_test & TEST_SMALL) {
status = test_multifill(10);
status = test_multifill((size_t)10);
nerrors += status < 0 ? 1 : 0;
}
if (size_of_test & TEST_MEDIUM) {
status = test_multifill(500000);
status = test_multifill((size_t)500000);
nerrors += status < 0 ? 1 : 0;
}
/*---------------------------
@ -1344,19 +1344,19 @@ main(int argc, char *argv[])
*/
if (size_of_test & TEST_SMALL) {
status = test_endian(10);
status = test_endian((size_t)10);
nerrors += status < 0 ? 1 : 0;
status = test_transpose(9, 9);
status = test_transpose((size_t)9, (size_t)9);
nerrors += status < 0 ? 1 : 0;
status = test_transpose(3, 11);
status = test_transpose((size_t)3, (size_t)11);
nerrors += status < 0 ? 1 : 0;
}
if (size_of_test & TEST_MEDIUM) {
status = test_endian(800000);
status = test_endian((size_t)800000);
nerrors += status < 0 ? 1 : 0;
status = test_transpose(1200, 1200);
status = test_transpose((size_t)1200, (size_t)1200);
nerrors += status < 0 ? 1 : 0;
status = test_transpose(800, 1800);
status = test_transpose((size_t)800, (size_t)1800);
nerrors += status < 0 ? 1 : 0;
}
/*-------------------------
@ -1365,11 +1365,11 @@ main(int argc, char *argv[])
*/
if (size_of_test & TEST_SMALL) {
status = test_sub_super(5, 10);
status = test_sub_super((size_t)5, (size_t)10);
nerrors += status < 0 ? 1 : 0;
}
if (size_of_test & TEST_MEDIUM) {
status = test_sub_super(480, 640);
status = test_sub_super((size_t)480, (size_t)640);
nerrors += status < 0 ? 1 : 0;
}
/*-------------------------
@ -1378,11 +1378,11 @@ main(int argc, char *argv[])
*/
if (size_of_test & TEST_SMALL) {
status = test_array_fill(1,9);
status = test_array_fill((size_t)1, (size_t)9);
nerrors += status < 0 ? 1 : 0;
}
if (size_of_test & TEST_MEDIUM) {
status = test_array_fill(9,257);
status = test_array_fill((size_t)9, (size_t)257);
nerrors += status < 0 ? 1 : 0;
}
/*-------------------------
@ -1391,11 +1391,11 @@ main(int argc, char *argv[])
*/
if (size_of_test & TEST_SMALL) {
status = test_array_offset_n_calc(20,7,11,13);
status = test_array_offset_n_calc((size_t)20, (size_t)7, (size_t)11, (size_t)13);
nerrors += status < 0 ? 1 : 0;
}
if (size_of_test & TEST_MEDIUM) {
status = test_array_offset_n_calc(500,71,193,347);
status = test_array_offset_n_calc((size_t)500, (size_t)71, (size_t)193, (size_t)347);
nerrors += status < 0 ? 1 : 0;
}

30
test/istore.c
View File

@ -254,7 +254,7 @@ test_extend(hid_t f, const char *prefix,
TESTING(s);
buf = HDmalloc(nx * ny * nz);
check = HDmalloc(nx * ny * nz);
whole = HDcalloc(1,nx*ny*nz);
whole = HDcalloc((size_t)1, nx * ny * nz);
whole_size[0] = nx;
whole_size[1] = ny;
@ -612,7 +612,7 @@ main(int argc, char *argv[])
/* Use larger file addresses... */
fcpl = H5Pcreate(H5P_FILE_CREATE);
H5Pset_sizes(fcpl, 8, 0);
H5Pset_sizes(fcpl, (size_t)8, (size_t)0);
/* Create the test file */
h5_fixname(FILENAME[0], fapl, filename, sizeof filename);
@ -649,39 +649,39 @@ main(int argc, char *argv[])
nerrors += status < 0 ? 1 : 0;
if (size_of_test & TEST_SMALL) {
status = test_extend(file, "extend", 10, 0, 0);
status = test_extend(file, "extend", (size_t)10, (size_t)0, (size_t)0);
nerrors += status < 0 ? 1 : 0;
status = test_extend(file, "extend", 10, 10, 0);
status = test_extend(file, "extend", (size_t)10, (size_t)10, (size_t)0);
nerrors += status < 0 ? 1 : 0;
status = test_extend(file, "extend", 10, 10, 10);
status = test_extend(file, "extend", (size_t)10, (size_t)10, (size_t)10);
nerrors += status < 0 ? 1 : 0;
}
if (size_of_test & TEST_MEDIUM) {
status = test_extend(file, "extend", 10000, 0, 0);
status = test_extend(file, "extend", (size_t)10000, (size_t)0, (size_t)0);
nerrors += status < 0 ? 1 : 0;
status = test_extend(file, "extend", 2500, 10, 0);
status = test_extend(file, "extend", (size_t)2500, (size_t)10, (size_t)0);
nerrors += status < 0 ? 1 : 0;
status = test_extend(file, "extend", 10, 400, 10);
status = test_extend(file, "extend", (size_t)10, (size_t)400, (size_t)10);
nerrors += status < 0 ? 1 : 0;
}
if (size_of_test & TEST_SMALL) {
status = test_sparse(file, "sparse", 100, 5, 0, 0);
status = test_sparse(file, "sparse", (size_t)100, (size_t)5, (size_t)0, (size_t)0);
nerrors += status < 0 ? 1 : 0;
status = test_sparse(file, "sparse", 100, 3, 4, 0);
status = test_sparse(file, "sparse", (size_t)100, (size_t)3, (size_t)4, (size_t)0);
nerrors += status < 0 ? 1 : 0;
status = test_sparse(file, "sparse", 100, 2, 3, 4);
status = test_sparse(file, "sparse", (size_t)100, (size_t)2, (size_t)3, (size_t)4);
nerrors += status < 0 ? 1 : 0;
}
if (size_of_test & TEST_MEDIUM) {
status = test_sparse(file, "sparse", 1000, 30, 0, 0);
status = test_sparse(file, "sparse", (size_t)1000, (size_t)30, (size_t)0, (size_t)0);
nerrors += status < 0 ? 1 : 0;
status = test_sparse(file, "sparse", 2000, 7, 3, 0);
status = test_sparse(file, "sparse", (size_t)2000, (size_t)7, (size_t)3, (size_t)0);
nerrors += status < 0 ? 1 : 0;
status = test_sparse(file, "sparse", 2000, 4, 2, 3);
status = test_sparse(file, "sparse", (size_t)2000, (size_t)4, (size_t)2, (size_t)3);
nerrors += status < 0 ? 1 : 0;
}
if (size_of_test & TEST_LARGE) {
status = test_sparse(file, "sparse", 800, 50, 50, 50);
status = test_sparse(file, "sparse", (size_t)800, (size_t)50, (size_t)50, (size_t)50);
nerrors += status < 0 ? 1 : 0;
}

6
test/lheap.c
View File

@ -75,17 +75,17 @@ main(void)
h5_fixname(FILENAME[0], fapl, filename, sizeof filename);
if ((file=H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl))<0)
goto error;
if (NULL==(f=H5I_object(file))) {
if(NULL == (f = H5I_object(file))) {
H5_FAILED();
H5Eprint_stack(H5E_DEFAULT, stdout);
goto error;
}
if (H5HL_create(f, H5P_DATASET_XFER_DEFAULT, 0, &heap_addr/*out*/)<0) {
if(H5HL_create(f, H5P_DATASET_XFER_DEFAULT, (size_t)0, &heap_addr/*out*/) < 0) {
H5_FAILED();
H5Eprint_stack(H5E_DEFAULT, stdout);
goto error;
}
for (i = 0; i < NOBJS; i++) {
for(i = 0; i < NOBJS; i++) {
sprintf(buf, "%03d-", i);
for (j=4; j<i; j++) buf[j] = '0' + j%10;
if (j>4) buf[j] = '\0';

13
test/links.c
View File

@ -76,7 +76,7 @@ const char *FILENAME[] = {
#define CORDER_GROUP_NAME "corder_group"
#define CORDER_EST_ENTRY_LEN 9
#ifndef QAK
#ifdef QAK
/*-------------------------------------------------------------------------
* Function: mklinks
@ -5937,7 +5937,7 @@ main(void)
/* Set the "use the latest version of the format" flag for creating objects in the file */
if(H5Pset_latest_format(fapl2, TRUE) < 0) TEST_ERROR
#ifndef QAK
#ifdef QAK
/* Loop over using new group format */
for(new_format = FALSE; new_format <= TRUE; new_format++) {
/* General tests... (on both old & new format groups */
@ -5995,15 +5995,6 @@ main(void)
/* Creation order tests */
if(new_format == TRUE) {
nerrors += corder_create_empty(fapl2) < 0 ? 1 : 0;
/* XXX: when creation order indexing is fully working, go back and add checks
* to these tests to make certain that the creation order values are
* correct.
*/
nerrors += corder_create_compact(fapl2) < 0 ? 1 : 0;
nerrors += corder_create_dense(fapl2) < 0 ? 1 : 0;
nerrors += corder_transition(fapl2) < 0 ? 1 : 0;
nerrors += corder_delete(fapl2) < 0 ? 1 : 0;
} /* end if */
} /* end for */
#else /* QAK */

2
test/ohdr.c
View File

@ -84,7 +84,7 @@ main(void)
*/
TESTING("object header creation");
HDmemset(&oh_loc, 0, sizeof(oh_loc));
if (H5O_create(f, H5P_DATASET_XFER_DEFAULT, 64, &oh_loc/*out*/)<0) {
if(H5O_create(f, H5P_DATASET_XFER_DEFAULT, (size_t)64, &oh_loc/*out*/)<0) {
H5_FAILED();
H5Eprint_stack(H5E_DEFAULT, stdout);
goto error;

62
test/pool.c
View File

@ -68,11 +68,11 @@ test_create(void)
TESTING("memory pool creation");
/* Create a memory pool */
if (NULL == (mp = H5MP_create(MPOOL_PAGE_SIZE, MPOOL_FLAGS)))
if(NULL == (mp = H5MP_create((size_t)MPOOL_PAGE_SIZE, MPOOL_FLAGS)))
TEST_ERROR
/* Check free space */
if (H5MP_get_pool_free_size(mp, &free_size) < 0)
if(H5MP_get_pool_free_size(mp, &free_size) < 0)
TEST_ERROR;
if(free_size != 0)
TEST_ERROR
@ -126,15 +126,15 @@ test_close_one(void)
TESTING("closing pool with blocks still allocated in one page");
/* Create a memory pool */
if (NULL == (mp = H5MP_create(MPOOL_PAGE_SIZE, MPOOL_FLAGS)))
if(NULL == (mp = H5MP_create((size_t)MPOOL_PAGE_SIZE, MPOOL_FLAGS)))
TEST_ERROR
/* Allocate space in pool */
if (NULL == (spc1 = H5MP_malloc(mp, MPOOL_NORMAL_BLOCK)))
if(NULL == (spc1 = H5MP_malloc(mp, (size_t)MPOOL_NORMAL_BLOCK)))
TEST_ERROR
/* Close the memory pool */
if (H5MP_close(mp) < 0)
if(H5MP_close(mp) < 0)
TEST_ERROR
PASSED();
@ -178,15 +178,15 @@ test_allocate_first(void)
TESTING("allocating first block in pool");
/* Create a memory pool */
if (NULL == (mp = H5MP_create(MPOOL_PAGE_SIZE, MPOOL_FLAGS)))
if(NULL == (mp = H5MP_create((size_t)MPOOL_PAGE_SIZE, MPOOL_FLAGS)))
TEST_ERROR
/* Allocate space in pool */
if (NULL == (spc = H5MP_malloc(mp, MPOOL_NORMAL_BLOCK)))
if(NULL == (spc = H5MP_malloc(mp, (size_t)MPOOL_NORMAL_BLOCK)))
TEST_ERROR
/* Check pool's free space */
if (H5MP_get_pool_free_size(mp, &free_size) < 0)
if(H5MP_get_pool_free_size(mp, &free_size) < 0)
TEST_ERROR;
if(free_size != MPOOL_PAGE_SIZE - (H5MP_BLOCK_ALIGN(MPOOL_NORMAL_BLOCK) + H5MP_BLOCK_ALIGN(sizeof(H5MP_page_blk_t)) + H5MP_BLOCK_ALIGN(sizeof(H5MP_page_t))))
TEST_ERROR
@ -235,15 +235,15 @@ test_allocate_first(void)
TESTING("allocating large first block in pool");
/* Create a memory pool */
if (NULL == (mp = H5MP_create(MPOOL_PAGE_SIZE, MPOOL_FLAGS)))
if(NULL == (mp = H5MP_create((size_t)MPOOL_PAGE_SIZE, MPOOL_FLAGS)))
TEST_ERROR
/* Allocate space in pool */
if (NULL == (spc = H5MP_malloc(mp, MPOOL_LARGE_BLOCK)))
if(NULL == (spc = H5MP_malloc(mp, (size_t)MPOOL_LARGE_BLOCK)))
TEST_ERROR
/* Check pool's free space */
if (H5MP_get_pool_free_size(mp, &free_size) < 0)
if(H5MP_get_pool_free_size(mp, &free_size) < 0)
TEST_ERROR;
if(free_size != 0)
TEST_ERROR
@ -329,15 +329,15 @@ test_allocate_split(void)
TESTING("splitting block in pool");
/* Create a memory pool */
if (NULL == (mp = H5MP_create(MPOOL_PAGE_SIZE, MPOOL_FLAGS)))
if(NULL == (mp = H5MP_create((size_t)MPOOL_PAGE_SIZE, MPOOL_FLAGS)))
TEST_ERROR
/* Allocate space in pool */
if (NULL == (spc1 = H5MP_malloc(mp, MPOOL_NORMAL_BLOCK)))
if(NULL == (spc1 = H5MP_malloc(mp, (size_t)MPOOL_NORMAL_BLOCK)))
TEST_ERROR
/* Check pool's free space */
if (H5MP_get_pool_free_size(mp, &free_size) < 0)
if(H5MP_get_pool_free_size(mp, &free_size) < 0)
TEST_ERROR;
if(free_size != MPOOL_PAGE_SIZE - (H5MP_BLOCK_ALIGN(MPOOL_NORMAL_BLOCK) + H5MP_BLOCK_ALIGN(sizeof(H5MP_page_blk_t)) + H5MP_BLOCK_ALIGN(sizeof(H5MP_page_t))))
TEST_ERROR
@ -347,11 +347,11 @@ test_allocate_split(void)
TEST_ERROR;
/* Allocate more space in pool */
if (NULL == (spc2 = H5MP_malloc(mp, MPOOL_NORMAL_BLOCK)))
if(NULL == (spc2 = H5MP_malloc(mp, (size_t)MPOOL_NORMAL_BLOCK)))
TEST_ERROR
/* Check pool's free space */
if (H5MP_get_pool_free_size(mp, &free_size) < 0)
if(H5MP_get_pool_free_size(mp, &free_size) < 0)
TEST_ERROR;
if(free_size != MPOOL_PAGE_SIZE - (((H5MP_BLOCK_ALIGN(MPOOL_NORMAL_BLOCK) + H5MP_BLOCK_ALIGN(sizeof(H5MP_page_blk_t))) * 2) + H5MP_BLOCK_ALIGN(sizeof(H5MP_page_t))))
TEST_ERROR
@ -431,16 +431,16 @@ test_allocate_many_small(void)
TESTING("allocating many small blocks");
/* Create a memory pool */
if (NULL == (mp = H5MP_create(MPOOL_PAGE_SIZE, MPOOL_FLAGS)))
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, MPOOL_SMALL_BLOCK)))
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)
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
@ -512,16 +512,16 @@ test_allocate_new_page(void)
TESTING("allocate normal-sized block in new page");
/* Create a memory pool */
if (NULL == (mp = H5MP_create(MPOOL_PAGE_SIZE, MPOOL_FLAGS)))
if(NULL == (mp = H5MP_create((size_t)MPOOL_PAGE_SIZE, MPOOL_FLAGS)))
TEST_ERROR
/* Allocate space in pool */
for(u = 0; u < MPOOL_NUM_NORMAL_BLOCKS; u++)
if (NULL == (spc[u] = H5MP_malloc(mp, MPOOL_NORMAL_BLOCK)))
if(NULL == (spc[u] = H5MP_malloc(mp, (size_t)MPOOL_NORMAL_BLOCK)))
TEST_ERROR
/* Check pool's free space */
if (H5MP_get_pool_free_size(mp, &free_size) < 0)
if(H5MP_get_pool_free_size(mp, &free_size) < 0)
TEST_ERROR;
if(free_size != (MPOOL_PAGE_SIZE * 3) - (((H5MP_BLOCK_ALIGN(MPOOL_NORMAL_BLOCK) + H5MP_BLOCK_ALIGN(sizeof(H5MP_page_blk_t))) * MPOOL_NUM_NORMAL_BLOCKS) + (H5MP_BLOCK_ALIGN(sizeof(H5MP_page_t)) * 3)))
TEST_ERROR
@ -556,15 +556,15 @@ test_allocate_new_page(void)
TESTING("allocate large-sized block in new page");
/* Create a memory pool */
if (NULL == (mp = H5MP_create(MPOOL_PAGE_SIZE, MPOOL_FLAGS)))
if(NULL == (mp = H5MP_create((size_t)MPOOL_PAGE_SIZE, MPOOL_FLAGS)))
TEST_ERROR
/* Allocate space in pool */
/* (Normal sized block) */
if (NULL == (spc1 = H5MP_malloc(mp, MPOOL_NORMAL_BLOCK)))
if(NULL == (spc1 = H5MP_malloc(mp, (size_t)MPOOL_NORMAL_BLOCK)))
TEST_ERROR
/* (Larger sized block) */
if (NULL == (spc2 = H5MP_malloc(mp, MPOOL_LARGE_BLOCK)))
if(NULL == (spc2 = H5MP_malloc(mp, (size_t)MPOOL_LARGE_BLOCK)))
TEST_ERROR
/* Check pool's free space */
@ -648,7 +648,7 @@ HDfprintf(stderr,"curr_time=%lu\n",(unsigned long)curr_time);
HDsrandom((unsigned long)curr_time);
/* Create a memory pool */
if (NULL == (mp = H5MP_create(MPOOL_PAGE_SIZE, MPOOL_FLAGS)))
if(NULL == (mp = H5MP_create((size_t)MPOOL_PAGE_SIZE, MPOOL_FLAGS)))
TEST_ERROR
/* Allocate space for the block sizes */
@ -665,11 +665,11 @@ HDfprintf(stderr,"curr_time=%lu\n",(unsigned long)curr_time);
/* Allocate space in pool */
for(u = 0; u < MPOOL_NUM_RANDOM; u++)
if (NULL == (spc[u] = H5MP_malloc(mp, blk_size[u])))
if(NULL == (spc[u] = H5MP_malloc(mp, blk_size[u])))
TEST_ERROR
/* Check that free space totals match */
if (H5MP_pool_is_free_size_correct(mp) <= 0)
if(H5MP_pool_is_free_size_correct(mp) <= 0)
TEST_ERROR;
/* Shuffle pointers to free */
@ -695,11 +695,11 @@ HDfprintf(stderr,"curr_time=%lu\n",(unsigned long)curr_time);
/* Allocate space in pool (again) */
/* (Leave allocated to test closing pool with many blocks still allocated) */
for(u = 0; u < MPOOL_NUM_RANDOM; u++)
if (NULL == (spc[u] = H5MP_malloc(mp, blk_size[u])))
if(NULL == (spc[u] = H5MP_malloc(mp, blk_size[u])))
TEST_ERROR
/* Check that free space totals match */
if (H5MP_pool_is_free_size_correct(mp) <= 0)
if(H5MP_pool_is_free_size_correct(mp) <= 0)
TEST_ERROR;
/* Close the memory pool */

8
test/stab.c
View File

@ -187,11 +187,11 @@ test_long(hid_t fapl, hbool_t new_format)
if((fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0) TEST_ERROR
/* Group names */
name1 = HDmalloc(LONG_NAME_LEN);
name1 = HDmalloc((size_t)LONG_NAME_LEN);
for(i = 0; i < LONG_NAME_LEN; i++)
name1[i] = (char)('A' + i%26);
name1[LONG_NAME_LEN - 1] = '\0';
name2 = HDmalloc((2 * LONG_NAME_LEN) + 2);
name2 = HDmalloc((size_t)((2 * LONG_NAME_LEN) + 2));
sprintf(name2, "%s/%s", name1, name1);
/* Create groups */
@ -221,8 +221,8 @@ error:
H5Gclose(g1);
H5Gclose(g2);
H5Fclose(fid);
H5MM_xfree(name2);
H5MM_xfree(name1);
HDfree(name2);
HDfree(name1);
} H5E_END_TRY;
return 1;
} /* end test_long() */

2
test/titerate.c
View File

@ -789,7 +789,7 @@ static void test_grp_memb_funcs(hid_t fapl)
VERIFY(obj_type, H5G_GROUP, "H5Gget_objname_by_idx");
if(!HDstrcmp(dataset_name, "dtype"))
VERIFY(obj_type, H5G_TYPE, "H5Gget_objname_by_idx");
if(!HDstrncmp(dataset_name, "Dataset", 7))
if(!HDstrncmp(dataset_name, "Dataset", (size_t)7))
VERIFY(obj_type, H5G_DATASET, "H5Gget_objname_by_idx");
} /* end for */

48
test/tunicode.c
View File

@ -77,7 +77,7 @@ void test_fl_string(hid_t fid, const char *string)
*/
dtype_id = H5Tcopy(H5T_C_S1);
CHECK(dtype_id, FAIL, "H5Tcopy");
ret=H5Tset_size(dtype_id, MAX_STRING_LENGTH);
ret = H5Tset_size(dtype_id, (size_t)MAX_STRING_LENGTH);
CHECK(ret, FAIL, "H5Tset_size");
cset=H5Tget_cset(dtype_id);
VERIFY(cset, H5T_CSET_ASCII, "H5Tget_cset");
@ -172,7 +172,7 @@ void test_strpad(hid_t UNUSED fid, const char *string)
strncpy(buf, new_string, big_len);
strncpy(&buf[big_len], new_string, big_len);
ret = H5Tconvert(src_type, dst_type, 2, buf, NULL, H5P_DEFAULT);
ret = H5Tconvert(src_type, dst_type, (size_t)2, buf, NULL, H5P_DEFAULT);
CHECK(ret, FAIL, "H5Tconvert");
/* After conversion, the buffer should look like
@ -190,11 +190,11 @@ void test_strpad(hid_t UNUSED fid, const char *string)
/* Now convert from smaller datatype to bigger datatype. This should
* leave our buffer looking like: "abc\0\0\0\0\0abc\0\0\0\0\0" */
ret = H5Tconvert(dst_type, src_type, 2, buf, NULL, H5P_DEFAULT);
ret = H5Tconvert(dst_type, src_type, (size_t)2, buf, NULL, H5P_DEFAULT);
CHECK(ret, FAIL, "H5Tconvert");
/* First fill the buffer with NULLs */
HDmemset(cmpbuf, '\0', LONG_BUF_SIZE);
HDmemset(cmpbuf, '\0', (size_t)LONG_BUF_SIZE);
/* Copy in the characters */
HDstrncpy(cmpbuf, new_string, small_len -1);
HDstrncpy(&cmpbuf[big_len], new_string, small_len -1);
@ -234,7 +234,7 @@ void test_strpad(hid_t UNUSED fid, const char *string)
strncpy(buf, new_string, big_len);
strncpy(&buf[big_len], new_string, big_len);
ret = H5Tconvert(src_type, dst_type, 2, buf, NULL, H5P_DEFAULT);
ret = H5Tconvert(src_type, dst_type, (size_t)2, buf, NULL, H5P_DEFAULT);
CHECK(ret, FAIL, "H5Tconvert");
/* After conversion, the buffer should look like
@ -250,11 +250,11 @@ void test_strpad(hid_t UNUSED fid, const char *string)
/* Now convert from smaller datatype to bigger datatype. This should
* leave our buffer looking like: "abcd\0\0\0\0abcd\0\0\0\0" */
ret = H5Tconvert(dst_type, src_type, 2, buf, NULL, H5P_DEFAULT);
ret = H5Tconvert(dst_type, src_type, (size_t)2, buf, NULL, H5P_DEFAULT);
CHECK(ret, FAIL, "H5Tconvert");
/* First fill the buffer with NULLs */
HDmemset(cmpbuf, '\0', LONG_BUF_SIZE);
HDmemset(cmpbuf, '\0', (size_t)LONG_BUF_SIZE);
/* Copy in the characters */
HDstrncpy(cmpbuf, new_string, small_len);
HDstrncpy(&cmpbuf[big_len], new_string, small_len);
@ -280,7 +280,7 @@ void test_strpad(hid_t UNUSED fid, const char *string)
HDstrcpy(buf, new_string);
HDstrcpy(&buf[big_len], new_string);
ret = H5Tconvert(src_type, dst_type, 2, buf, NULL, H5P_DEFAULT);
ret = H5Tconvert(src_type, dst_type, (size_t)2, buf, NULL, H5P_DEFAULT);
CHECK(ret, FAIL, "H5Tconvert");
/* After conversion, the buffer should look like
@ -296,11 +296,11 @@ void test_strpad(hid_t UNUSED fid, const char *string)
/* Now convert from smaller datatype to bigger datatype. This should
* leave our buffer looking like: "abcd abcd " */
ret = H5Tconvert(dst_type, src_type, 2, buf, NULL, H5P_DEFAULT);
ret = H5Tconvert(dst_type, src_type, (size_t)2, buf, NULL, H5P_DEFAULT);
CHECK(ret, FAIL, "H5Tconvert");
/* First fill the buffer with spaces */
HDmemset(cmpbuf, ' ', LONG_BUF_SIZE);
HDmemset(cmpbuf, ' ', (size_t)LONG_BUF_SIZE);
/* Copy in the characters */
HDstrncpy(cmpbuf, new_string, small_len);
HDstrncpy(&cmpbuf[big_len], new_string, small_len);
@ -390,7 +390,7 @@ void test_objnames(hid_t fid, const char* string)
herr_t ret;
/* Create a group with a UTF-8 name */
grp_id = H5Gcreate(fid, string, 0);
grp_id = H5Gcreate(fid, string, (size_t)0);
CHECK(grp_id, FAIL, "H5Gcreate");
/* Set a comment on the group to test that we can access the group
@ -398,7 +398,7 @@ void test_objnames(hid_t fid, const char* string)
*/
ret = H5Gset_comment(fid, string, string);
CHECK(ret, FAIL, "H5Gset_comment");
ret = H5Gget_comment(fid, string, MAX_STRING_LENGTH, read_buf);
ret = H5Gget_comment(fid, string, (size_t)MAX_STRING_LENGTH, read_buf);
CHECK(ret, FAIL, "H5Gget_comment");
ret = H5Gclose(grp_id);
@ -407,7 +407,7 @@ void test_objnames(hid_t fid, const char* string)
VERIFY(strcmp(string, read_buf), 0, "strcmp");
/* Create a new dataset with a UTF-8 name */
grp1_id = H5Gcreate(fid, GROUP1_NAME, 0);
grp1_id = H5Gcreate(fid, GROUP1_NAME, (size_t)0);
CHECK(grp1_id, FAIL, "H5Gcreate");
space_id = H5Screate_simple(RANK, &dims, NULL);
@ -429,10 +429,10 @@ void test_objnames(hid_t fid, const char* string)
CHECK(ret, FAIL, "H5Gclose");
/* Do the same for a named datatype */
grp2_id = H5Gcreate(fid, GROUP2_NAME, 0);
grp2_id = H5Gcreate(fid, GROUP2_NAME, (size_t)0);
CHECK(grp2_id, FAIL, "H5Gcreate");
type_id = H5Tcreate(H5T_OPAQUE, 1);
type_id = H5Tcreate(H5T_OPAQUE, (size_t)1);
CHECK(type_id, FAIL, "H5Tcreate");
ret = H5Tcommit(grp2_id, string, type_id);
CHECK(type_id, FAIL, "H5Tcommit");
@ -482,7 +482,7 @@ void test_objnames(hid_t fid, const char* string)
* pointing through the hard link to the datatype. Give the soft
* link a name in UTF-8. Ensure that the soft link works. */
grp3_id = H5Gcreate(fid, GROUP3_NAME, 0);
grp3_id = H5Gcreate(fid, GROUP3_NAME, (size_t)0);
CHECK(grp3_id, FAIL, "H5Gcreate");
ret = H5Glink2(fid, GROUP2_NAME, H5G_LINK_HARD, grp3_id, GROUP2_NAME);
@ -518,20 +518,20 @@ void test_attrname(hid_t fid, const char * string)
/* Create a new group and give it an attribute whose
* name and value are UTF-8 strings.
*/
group_id = H5Gcreate(fid, GROUP4_NAME, 0);
group_id = H5Gcreate(fid, GROUP4_NAME, (size_t)0);
CHECK(group_id, FAIL, "H5Gcreate");
space_id = H5Screate_simple(RANK, &dims, NULL);
CHECK(space_id, FAIL, "H5Screate_simple");
dtype_id = H5Tcopy(H5T_C_S1);
CHECK(dtype_id, FAIL, "H5Tcopy");
ret=H5Tset_size(dtype_id, MAX_STRING_LENGTH);
ret = H5Tset_size(dtype_id, (size_t)MAX_STRING_LENGTH);
CHECK(ret, FAIL, "H5Tset_size");
/* Create the attribute and check that its name is correct */
attr_id = H5Acreate(group_id, string, dtype_id, space_id, H5P_DEFAULT);
CHECK(attr_id, FAIL, "H5Acreate");
ret = H5Aget_name(attr_id, MAX_STRING_LENGTH, read_buf);
ret = H5Aget_name(attr_id, (size_t)MAX_STRING_LENGTH, read_buf);
CHECK(ret, FAIL, "H5Aget_name");
ret = strcmp(read_buf, string);
VERIFY(ret, 0, "strcmp");
@ -684,7 +684,7 @@ void test_enum(hid_t UNUSED fid, const char * string)
ret = H5Tenum_valueof(type_id, string, &val);
CHECK(ret, FAIL, "H5Tenum_valueof");
VERIFY(val, E1_WHITE, "H5Tenum_valueof");
ret = H5Tenum_nameof(type_id, &val, readbuf, MAX_STRING_LENGTH);
ret = H5Tenum_nameof(type_id, &val, readbuf, (size_t)MAX_STRING_LENGTH);
CHECK(ret, FAIL, "H5Tenum_nameof");
ret = strcmp(readbuf, string);
VERIFY(ret, 0, "strcmp");
@ -705,7 +705,7 @@ void test_opaque(hid_t UNUSED fid, const char * string)
herr_t ret;
/* Create an opaque type and give it a UTF-8 tag */
type_id = H5Tcreate(H5T_OPAQUE, 4);
type_id = H5Tcreate(H5T_OPAQUE, (size_t)4);
CHECK(type_id, FAIL, "H5Tcreate");
ret = H5Tset_tag(type_id, string);
CHECK(ret, FAIL, "H5Tset_tag");
@ -730,9 +730,9 @@ void test_opaque(hid_t UNUSED fid, const char * string)
static hid_t mkstr(size_t len, H5T_str_t strpad)
{
hid_t t;
if ((t=H5Tcopy(H5T_C_S1))<0) return -1;
if (H5Tset_size(t, len)<0) return -1;
if (H5Tset_strpad(t, strpad)<0) return -1;
if((t = H5Tcopy(H5T_C_S1)) < 0) return -1;
if(H5Tset_size(t, len) < 0) return -1;
if(H5Tset_strpad(t, strpad) < 0) return -1;
return t;
}

8
test/tvlstr.c
View File

@ -170,8 +170,8 @@ test_vlstrings_basic(void)
dataset2=H5Dcreate(fid1,"Dataset2",tid1,dataspace,H5P_DEFAULT);
CHECK(dataset, FAIL, "H5Dcreate");
wdata2 = (char*)HDcalloc(65534, sizeof(char));
HDmemset(wdata2, 'A', 65533);
wdata2 = (char*)HDcalloc((size_t)65534, sizeof(char));
HDmemset(wdata2, 'A', (size_t)65533);
ret=H5Dwrite(dataset2,tid1,H5S_ALL,H5S_ALL,H5P_DEFAULT,&wdata2);
CHECK(ret, FAIL, "H5Dwrite");
@ -613,8 +613,8 @@ static void test_write_vl_string_attribute(void)
att = H5Acreate(root, "test_scalar_large", type, dataspace, H5P_DEFAULT);
CHECK(att, FAIL, "H5Acreate");
string_att_write = (char*)HDcalloc(8192, sizeof(char));
HDmemset(string_att_write, 'A', 8191);
string_att_write = (char*)HDcalloc((size_t)8192, sizeof(char));
HDmemset(string_att_write, 'A', (size_t)8191);
ret = H5Awrite(att, type, &string_att_write);
CHECK(ret, FAIL, "H5Awrite");

20
test/tvltypes.c
View File

@ -198,17 +198,17 @@ test_vltypes_funcs(void)
ret=H5Tset_pad(type, H5T_PAD_ZERO, H5T_PAD_ONE);
CHECK(ret, FAIL, "H5Tset_pad");
inpad=H5Tget_inpad(type);
inpad = H5Tget_inpad(type);
CHECK(inpad, FAIL, "H5Tget_inpad");
norm=H5Tget_norm(type);
norm = H5Tget_norm(type);
CHECK(norm, FAIL, "H5Tget_norm");
ret=H5Tset_offset(type, 16);
ret = H5Tset_offset(type, (size_t)16);
CHECK(ret, FAIL, "H5Tset_offset");
H5E_BEGIN_TRY {
cset=H5Tget_cset(type);
cset = H5Tget_cset(type);
} H5E_END_TRY;
VERIFY(cset, FAIL, "H5Tget_cset");
@ -797,11 +797,11 @@ test_vltypes_vlen_compound(void)
continue;
} /* end if */
for(j=0; j<rdata[i].len; j++) {
if( ((s1 *)wdata[i].p)[j].i != ((s1 *)rdata[i].p)[j].i ) {
if(((s1 *)wdata[i].p)[j].i != ((s1 *)rdata[i].p)[j].i ) {
TestErrPrintf("VL data values don't match!, wdata[%d].p[%d].i=%d, rdata[%d].p[%d].i=%d\n",(int)i,(int)j, (int)((s1 *)wdata[i].p)[j].i, (int)i,(int)j, (int)((s1 *)rdata[i].p)[j].i);
continue;
} /* end if */
if( ((s1 *)wdata[i].p)[j].f != ((s1 *)rdata[i].p)[j].f ) {
if(((s1 *)wdata[i].p)[j].f != ((s1 *)rdata[i].p)[j].f ) {
TestErrPrintf("VL data values don't match!, wdata[%d].p[%d].f=%f, rdata[%d].p[%d].f=%f\n",(int)i,(int)j, (double)((s1 *)wdata[i].p)[j].f, (int)i,(int)j, (double)((s1 *)rdata[i].p)[j].f);
continue;
} /* end if */
@ -1668,7 +1668,7 @@ test_vltypes_vlen_vlen_atomic(void)
/* 10 hvl_t elements allocated = 1 + 2 + 3 + 4 elements for each array position */
/* 20 unsigned int elements allocated = 1 + 3 + 6 + 10 elements */
VERIFY(size,((SPACE1_DIM1*(SPACE1_DIM1+1))/2)*sizeof(hvl_t)+vlen_size_func(SPACE1_DIM1)*sizeof(unsigned int),"H5Dvlen_get_buf_size");
VERIFY(size,((SPACE1_DIM1*(SPACE1_DIM1+1))/2)*sizeof(hvl_t)+vlen_size_func((unsigned long)SPACE1_DIM1)*sizeof(unsigned int),"H5Dvlen_get_buf_size");
/* Read dataset from disk */
ret=H5Dread(dataset,tid2,H5S_ALL,H5S_ALL,xfer_pid,rdata);
@ -1677,7 +1677,7 @@ test_vltypes_vlen_vlen_atomic(void)
/* Make certain the correct amount of memory has been used */
/* 10 hvl_t elements allocated = 1 + 2 + 3 + 4 elements for each array position */
/* 20 unsigned int elements allocated = 1 + 3 + 6 + 10 elements */
VERIFY(mem_used,((SPACE1_DIM1*(SPACE1_DIM1+1))/2)*sizeof(hvl_t)+vlen_size_func(SPACE1_DIM1)*sizeof(unsigned int),"H5Dread");
VERIFY(mem_used,((SPACE1_DIM1*(SPACE1_DIM1+1))/2)*sizeof(hvl_t)+vlen_size_func((unsigned long)SPACE1_DIM1)*sizeof(unsigned int),"H5Dread");
/* Compare data read in */
for(i=0; i<SPACE1_DIM1; i++) {
@ -2024,7 +2024,7 @@ rewrite_shorter_vltypes_vlen_vlen_atomic(void)
/* 10 hvl_t elements allocated = 1 + 2 + 3 + 4 elements for each array position */
/* 20 unsigned int elements allocated = 1 + 3 + 6 + 10 elements */
VERIFY(size,((SPACE1_DIM1*(SPACE1_DIM1+1))/2)*sizeof(hvl_t)+vlen_size_func(SPACE1_DIM1)*sizeof(unsigned int),"H5Dvlen_get_buf_size");
VERIFY(size,((SPACE1_DIM1*(SPACE1_DIM1+1))/2)*sizeof(hvl_t)+vlen_size_func((unsigned long)SPACE1_DIM1)*sizeof(unsigned int),"H5Dvlen_get_buf_size");
/* Read dataset from disk */
ret=H5Dread(dataset,tid2,H5S_ALL,H5S_ALL,xfer_pid,rdata);
@ -2033,7 +2033,7 @@ rewrite_shorter_vltypes_vlen_vlen_atomic(void)
/* Make certain the correct amount of memory has been used */
/* 10 hvl_t elements allocated = 1 + 2 + 3 + 4 elements for each array position */
/* 20 unsigned int elements allocated = 1 + 3 + 6 + 10 elements */
VERIFY(mem_used,((SPACE1_DIM1*(SPACE1_DIM1+1))/2)*sizeof(hvl_t)+vlen_size_func(SPACE1_DIM1)*sizeof(unsigned int),"H5Dread");
VERIFY(mem_used,((SPACE1_DIM1*(SPACE1_DIM1+1))/2)*sizeof(hvl_t)+vlen_size_func((unsigned long)SPACE1_DIM1)*sizeof(unsigned int),"H5Dread");
/* Compare data read in */
for(i=0; i<SPACE1_DIM1; i++) {