summaryrefslogtreecommitdiffstats
path: root/test
diff options
context:
space:
mode:
Diffstat (limited to 'test')
-rw-r--r--test/bittests.c104
-rw-r--r--test/cmpd_dset.c2
-rw-r--r--test/dt_arith.c114
-rw-r--r--test/external.c6
-rw-r--r--test/testfiles/error_test_16
-rw-r--r--test/tmisc.c84
6 files changed, 160 insertions, 156 deletions
diff --git a/test/bittests.c b/test/bittests.c
index f063cee..c527bb8 100644
--- a/test/bittests.c
+++ b/test/bittests.c
@@ -56,13 +56,13 @@ test_find (void)
/* The zero length buffer */
HDmemset(v1, 0xaa, sizeof v1);
- n = H5T_bit_find(v1, (size_t)0, (size_t)0, H5T_BIT_LSB, TRUE);
+ 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, (size_t)0, (size_t)0, H5T_BIT_MSB, TRUE);
+ 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)!");
@@ -72,13 +72,13 @@ test_find (void)
/* The zero buffer */
HDmemset(v1, 0, sizeof v1);
- n = H5T_bit_find(v1, (size_t)0, 8 * sizeof(v1), H5T_BIT_LSB, TRUE);
+ 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, (size_t)0, 8 * sizeof(v1), H5T_BIT_MSB, TRUE);
+ 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)!");
@@ -89,13 +89,13 @@ test_find (void)
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);
+ 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, (size_t)0, 8 * sizeof(v1), H5T_BIT_MSB, TRUE);
+ 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);
@@ -105,13 +105,13 @@ test_find (void)
/* The one buffer */
HDmemset(v1, 0xff, sizeof v1);
- n = H5T_bit_find(v1, (size_t)0, 8 * sizeof(v1), H5T_BIT_LSB, FALSE);
+ 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, (size_t)0, 8 * sizeof(v1), H5T_BIT_MSB, FALSE);
+ 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)!");
@@ -122,13 +122,13 @@ test_find (void)
for (i=0; i<8*(int)sizeof(v1); i++) {
memset (v1, 0xff, sizeof v1);
v1[i/8] &= ~(1<<(i%8));
- n = H5T_bit_find (v1, (size_t)0, 8*sizeof(v1), H5T_BIT_LSB, FALSE);
+ n = H5T__bit_find (v1, (size_t)0, 8*sizeof(v1), H5T_BIT_LSB, FALSE);
if ((ssize_t)i!=n) {
H5_FAILED();
printf (" Test for clear bit %d failed (lsb)!\n", i);
goto failed;
}
- n = H5T_bit_find (v1, (size_t)0, 8*sizeof(v1), H5T_BIT_MSB, FALSE);
+ n = H5T__bit_find (v1, (size_t)0, 8*sizeof(v1), H5T_BIT_MSB, FALSE);
if ((ssize_t)i!=n) {
H5_FAILED();
printf (" Test for clear bit %d failed (lsb)!\n", i);
@@ -183,7 +183,7 @@ test_copy (void)
memset (v2, 0x00, sizeof v2);
/* Copy some bits to v2 and make sure something was copied */
- H5T_bit_copy (v2, d_offset, v1, s_offset, size);
+ H5T__bit_copy (v2, d_offset, v1, s_offset, size);
for (j=0; j<(int)sizeof(v2); j++) if (v2[j]) break;
if (size>0 && j>=(int)sizeof(v2)) {
H5_FAILED();
@@ -198,7 +198,7 @@ test_copy (void)
/* Look for the zeros and ones */
- n = H5T_bit_find (v2, (size_t)0, 8*sizeof(v2), H5T_BIT_LSB, 1);
+ n = H5T__bit_find (v2, (size_t)0, 8*sizeof(v2), H5T_BIT_LSB, 1);
if (size>0 && n!=(ssize_t)d_offset) {
H5_FAILED();
printf (" Unable to find first copied bit in destination "
@@ -210,7 +210,7 @@ test_copy (void)
puts (" Found copied bits and shouldn't have!");
goto failed;
}
- n = H5T_bit_find (v2, d_offset, 8*sizeof(v2)-d_offset, H5T_BIT_LSB, 0);
+ n = H5T__bit_find (v2, d_offset, 8*sizeof(v2)-d_offset, H5T_BIT_LSB, 0);
if (d_offset+size<8*sizeof(v2) && n!=(ssize_t)size) {
H5_FAILED();
printf (" Unable to find last copied bit in destination "
@@ -227,7 +227,7 @@ test_copy (void)
* Look for zeros and ones in reverse order. This is only to test
* that reverse searches work as expected.
*/
- n = H5T_bit_find (v2, (size_t)0, 8*sizeof(v2), H5T_BIT_MSB, 1);
+ n = H5T__bit_find (v2, (size_t)0, 8*sizeof(v2), H5T_BIT_MSB, 1);
if (size>0 && (size_t)(n+1)!=d_offset+size) {
H5_FAILED();
printf (" Unable to find last copied bit in destination "
@@ -239,7 +239,7 @@ test_copy (void)
puts (" Found copied bits but shouldn't have (reverse)!");
goto failed;
}
- n = H5T_bit_find (v2, (size_t)0, d_offset+size, H5T_BIT_MSB, 0);
+ n = H5T__bit_find (v2, (size_t)0, d_offset+size, H5T_BIT_MSB, 0);
if (d_offset>0 && n+1!=(ssize_t)d_offset) {
H5_FAILED();
printf (" Unable to find beginning of copied data "
@@ -305,12 +305,12 @@ test_shift (void)
/*-------- LEFT-shift some bits and make sure something was shifted --------*/
memset (vector, 0x00, sizeof vector);
- H5T_bit_set (vector, offset, size, 1);
+ H5T__bit_set (vector, offset, size, 1);
- H5T_bit_shift (vector, shift_dist, offset, size);
+ H5T__bit_shift (vector, shift_dist, offset, size);
/* Look for the ones */
- n = H5T_bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_LSB, 1);
+ n = H5T__bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_LSB, 1);
if ((size_t)n!=offset+shift_dist) {
H5_FAILED();
printf (" Unable to find first bit in destination "
@@ -322,7 +322,7 @@ test_shift (void)
* 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);
+ 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 "
@@ -332,12 +332,12 @@ test_shift (void)
/*-------- RIGHT-shift some bits and make sure something was shifted --------*/
memset (vector, 0x00, sizeof vector);
- H5T_bit_set (vector, offset, size, 1);
+ H5T__bit_set (vector, offset, size, 1);
- H5T_bit_shift (vector, -shift_dist, offset, size);
+ H5T__bit_shift (vector, -shift_dist, offset, size);
/* Look for the ones */
- n = H5T_bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_LSB, 1);
+ 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 "
@@ -349,7 +349,7 @@ test_shift (void)
* 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);
+ n = H5T__bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_MSB, 1);
if (n!=(ssize_t)(offset+size-shift_dist-1)) {
H5_FAILED();
printf (" Unable to find last bit in destination "
@@ -367,12 +367,12 @@ test_shift (void)
shift_dist = -((ssize_t)size);
memset (vector, 0x00, sizeof vector);
- H5T_bit_set (vector, offset, size, 1);
+ H5T__bit_set (vector, offset, size, 1);
- H5T_bit_shift (vector, shift_dist, offset, size);
+ H5T__bit_shift (vector, shift_dist, offset, size);
/* Supposed to fail to find any ones */
- n = H5T_bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_LSB, 1);
+ n = H5T__bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_LSB, 1);
if (n >= 0) {
H5_FAILED();
printf (" Unable to verify all bits are zero in destination(LSB) "
@@ -381,7 +381,7 @@ test_shift (void)
}
/* Look from the other direction */
- n = H5T_bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_MSB, 1);
+ n = H5T__bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_MSB, 1);
if (n >= 0) {
H5_FAILED();
printf (" Unable to verify all bits are zero in destination(MSB) "
@@ -437,15 +437,15 @@ test_increment (void)
memset (vector, 0x00, sizeof vector);
if(size>1) /* if size=6, make a sequence like 011111 */
- H5T_bit_set (vector, offset, size-1, 1);
+ H5T__bit_set (vector, offset, size-1, 1);
else /* if size=1, just set this one bit to 1 */
- H5T_bit_set (vector, offset, size, 1);
+ H5T__bit_set (vector, offset, size, 1);
/* Increment the sequence by one */
- H5T_bit_inc (vector, offset, size);
+ H5T__bit_inc (vector, offset, size);
/* Look for the one */
- n = H5T_bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_LSB, 1);
+ n = H5T__bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_LSB, 1);
if (size!=1 && (size_t)n!=offset+size-1) {
H5_FAILED();
printf (" Unable to find first bit in destination "
@@ -463,7 +463,7 @@ test_increment (void)
* Look for one 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);
+ n = H5T__bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_MSB, 1);
if (size!=1 && n!=(ssize_t)(offset+size-1)) {
H5_FAILED();
printf (" Unable to find last bit in destination "
@@ -526,10 +526,10 @@ test_decrement (void)
memset (vector, 0x00, sizeof vector);
/* decrement the sequence by one */
- H5T_bit_dec (vector, offset, size);
+ 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);
+ 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 "
@@ -541,7 +541,7 @@ test_decrement (void)
* 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);
+ 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 "
@@ -598,10 +598,10 @@ test_negate (void)
memset (vector, 0x00, sizeof vector);
/* negate the sequence */
- H5T_bit_neg (vector, offset, size);
+ H5T__bit_neg (vector, offset, size);
/* Look for the ones */
- n = H5T_bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_LSB, 1);
+ 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 "
@@ -613,7 +613,7 @@ test_negate (void)
* 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);
+ 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 "
@@ -623,13 +623,13 @@ test_negate (void)
/* All-one sequence will become 000000(size=6) after negating */
memset (vector, 0x00, sizeof vector);
- H5T_bit_set (vector, offset, size, 1);
+ H5T__bit_set (vector, offset, size, 1);
/* negate the sequence */
- H5T_bit_neg (vector, offset, size);
+ H5T__bit_neg (vector, offset, size);
/* Look for the ones */
- n = H5T_bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_LSB, 1);
+ n = H5T__bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_LSB, 1);
if (n>=0) {
H5_FAILED();
printf (" Unable to verify all-zero bits in destination "
@@ -641,7 +641,7 @@ test_negate (void)
* Look for 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);
+ n = H5T__bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_MSB, 1);
if (n>=0) {
H5_FAILED();
printf (" Unable to verify all-zero bits in destination "
@@ -695,7 +695,7 @@ test_set (void)
memset (v2, 0x00, sizeof v2);
/* Set some bits in v2 */
- H5T_bit_set (v2, d_offset, size, TRUE);
+ H5T__bit_set (v2, d_offset, size, TRUE);
for (j=0; j<(int)sizeof(v2); j++) if (v2[j]) break;
if (size>0 && j>=(int)sizeof(v2)) {
H5_FAILED();
@@ -710,7 +710,7 @@ test_set (void)
/* Look for the zeros and ones */
- n = H5T_bit_find (v2, (size_t)0, 8*sizeof(v2), H5T_BIT_LSB, 1);
+ n = H5T__bit_find (v2, (size_t)0, 8*sizeof(v2), H5T_BIT_LSB, 1);
if (size>0 && n!=(ssize_t)d_offset) {
H5_FAILED();
printf (" Unable to find first set bit in destination "
@@ -722,7 +722,7 @@ test_set (void)
puts (" Found set bits and shouldn't have!");
goto failed;
}
- n = H5T_bit_find (v2, d_offset, 8*sizeof(v2)-d_offset, H5T_BIT_LSB, 0);
+ n = H5T__bit_find (v2, d_offset, 8*sizeof(v2)-d_offset, H5T_BIT_LSB, 0);
if (d_offset+size<8*sizeof(v2) && n!=(ssize_t)size) {
H5_FAILED();
printf (" Unable to find last set bit in destination "
@@ -739,7 +739,7 @@ test_set (void)
* Look for zeros and ones in reverse order. This is only to test
* that reverse searches work as expected.
*/
- n = H5T_bit_find (v2, (size_t)0, 8*sizeof(v2), H5T_BIT_MSB, 1);
+ n = H5T__bit_find (v2, (size_t)0, 8*sizeof(v2), H5T_BIT_MSB, 1);
if (size>0 && (size_t)(n+1)!=d_offset+size) {
H5_FAILED();
printf (" Unable to find last set bit in destination "
@@ -751,7 +751,7 @@ test_set (void)
puts (" Found set bits but shouldn't have (reverse)!");
goto failed;
}
- n = H5T_bit_find (v2, (size_t)0, d_offset+size, H5T_BIT_MSB, 0);
+ n = H5T__bit_find (v2, (size_t)0, d_offset+size, H5T_BIT_MSB, 0);
if (d_offset>0 && n+1!=(ssize_t)d_offset) {
H5_FAILED();
printf (" Unable to find beginning of set bit region "
@@ -812,7 +812,7 @@ test_clear (void)
memset (v2, 0xff, sizeof v2);
/* Clear some bits in v2 */
- H5T_bit_set (v2, d_offset, size, FALSE);
+ H5T__bit_set (v2, d_offset, size, FALSE);
for (j=0; j<(int)sizeof(v2); j++) if (0xff!=v2[j]) break;
if (size>0 && j>=(int)sizeof(v2)) {
H5_FAILED();
@@ -827,7 +827,7 @@ test_clear (void)
/* Look for the zeros and ones */
- n = H5T_bit_find (v2, (size_t)0, 8*sizeof(v2), H5T_BIT_LSB, 0);
+ n = H5T__bit_find (v2, (size_t)0, 8*sizeof(v2), H5T_BIT_LSB, 0);
if (size>0 && n!=(ssize_t)d_offset) {
H5_FAILED();
printf (" Unable to find first cleared bit in destination "
@@ -839,7 +839,7 @@ test_clear (void)
puts (" Found cleared bits and shouldn't have!");
goto failed;
}
- n = H5T_bit_find (v2, d_offset, 8*sizeof(v2)-d_offset, H5T_BIT_LSB, 1);
+ n = H5T__bit_find (v2, d_offset, 8*sizeof(v2)-d_offset, H5T_BIT_LSB, 1);
if (d_offset+size<8*sizeof(v2) && n!=(ssize_t)size) {
H5_FAILED();
printf (" Unable to find last cleared bit in destination "
@@ -856,7 +856,7 @@ test_clear (void)
* Look for zeros and ones in reverse order. This is only to test
* that reverse searches work as expected.
*/
- n = H5T_bit_find (v2, (size_t)0, 8*sizeof(v2), H5T_BIT_MSB, 0);
+ n = H5T__bit_find (v2, (size_t)0, 8*sizeof(v2), H5T_BIT_MSB, 0);
if (size>0 && (size_t)(n+1)!=d_offset+size) {
H5_FAILED();
printf (" Unable to find last cleared bit in destination "
@@ -868,7 +868,7 @@ test_clear (void)
puts (" Found cleared bits but shouldn't have (reverse)!");
goto failed;
}
- n = H5T_bit_find (v2, (size_t)0, d_offset+size, H5T_BIT_MSB, 1);
+ n = H5T__bit_find (v2, (size_t)0, d_offset+size, H5T_BIT_MSB, 1);
if (d_offset>0 && n+1!=(ssize_t)d_offset) {
H5_FAILED();
printf (" Unable to find beginning of cleared bit region "
diff --git a/test/cmpd_dset.c b/test/cmpd_dset.c
index d7f7842..433c488 100644
--- a/test/cmpd_dset.c
+++ b/test/cmpd_dset.c
@@ -2183,7 +2183,7 @@ main (int argc, char *argv[])
fprintf(stderr, "usage: %s [--noopt]\n", argv[0]);
exit(1);
}
- H5Tunregister(H5T_PERS_DONTCARE, NULL, -1, -1, H5T_conv_struct_opt);
+ H5Tunregister(H5T_PERS_DONTCARE, NULL, -1, -1, H5T__conv_struct_opt);
}
/* Create the file */
diff --git a/test/dt_arith.c b/test/dt_arith.c
index 054f069..0001755 100644
--- a/test/dt_arith.c
+++ b/test/dt_arith.c
@@ -306,9 +306,9 @@ static int without_hardware_g = 0;
*00000111,..., until 11111111.*/ \
memset(tmp1, 0, SRC_SIZE); \
memset(tmp2, 0, SRC_SIZE); \
- H5T_bit_set (tmp2, SRC_PREC-1, (size_t)1, TRUE); /*the negative value*/ \
+ H5T__bit_set (tmp2, SRC_PREC-1, (size_t)1, TRUE); /*the negative value*/ \
for(n=0; n<SRC_MANT_DIG-1; n++) { \
- H5T_bit_set (tmp1, n, (size_t)1, TRUE); /*turn on 1 bit each time*/ \
+ H5T__bit_set (tmp1, n, (size_t)1, TRUE); /*turn on 1 bit each time*/ \
CHANGE_ORDER(tmp1, SRC_ORDR, SRC_SIZE); /*change order for big endian*/ \
memcpy(buf_p, tmp1, SRC_SIZE); \
memcpy(saved_p, tmp1, SRC_SIZE); \
@@ -317,7 +317,7 @@ static int without_hardware_g = 0;
saved_p += SRC_SIZE; \
\
/*negative values*/ \
- H5T_bit_set (tmp2, n, (size_t)1, TRUE); \
+ H5T__bit_set (tmp2, n, (size_t)1, TRUE); \
CHANGE_ORDER(tmp2, SRC_ORDR, SRC_SIZE); \
memcpy(buf_p, tmp2, SRC_SIZE); \
memcpy(saved_p, tmp2, SRC_SIZE); \
@@ -353,7 +353,7 @@ static int without_hardware_g = 0;
buf_p = BUF; \
\
/* +0 */ \
- H5T_bit_set(value, (size_t)0, SRC_PREC, FALSE); \
+ H5T__bit_set(value, (size_t)0, SRC_PREC, FALSE); \
memcpy(buf_p, value, SRC_SIZE*sizeof(unsigned char)); \
buf_p += SRC_SIZE; \
\
@@ -361,7 +361,7 @@ static int without_hardware_g = 0;
if(n==1) { \
memset(value, 0, SRC_SIZE*sizeof(unsigned char)); \
/* -0 */ \
- H5T_bit_set(value, (size_t)(SRC_PREC - 1), (size_t)1, TRUE); \
+ H5T__bit_set(value, (size_t)(SRC_PREC - 1), (size_t)1, TRUE); \
CHANGE_ORDER(value, SRC_ORDR, SRC_SIZE);/*change order for big endian*/ \
HDmemcpy(buf_p, value, SRC_SIZE*sizeof(unsigned char)); \
CHANGE_ORDER(value, SRC_ORDR, SRC_SIZE);/*change back the order for bit operation*/ \
@@ -369,21 +369,21 @@ static int without_hardware_g = 0;
} \
\
/* +/-infinity */ \
- H5T_bit_set(value, (size_t)(SRC_MANT_DIG - 1), SRC_PREC-SRC_MANT_DIG, TRUE); \
+ H5T__bit_set(value, (size_t)(SRC_MANT_DIG - 1), SRC_PREC-SRC_MANT_DIG, TRUE); \
CHANGE_ORDER(value, SRC_ORDR, SRC_SIZE); /*change order for big endian*/ \
HDmemcpy(buf_p, value, SRC_SIZE*sizeof(unsigned char)); \
CHANGE_ORDER(value, SRC_ORDR, SRC_SIZE); /*change back the order for bit operation*/ \
buf_p += SRC_SIZE; \
\
/* +/-SNaN */ \
- H5T_bit_set(value, (size_t)0, (size_t)1, TRUE); \
+ H5T__bit_set(value, (size_t)0, (size_t)1, TRUE); \
CHANGE_ORDER(value, SRC_ORDR, SRC_SIZE); /*change order for big endian*/ \
HDmemcpy(buf_p, value, SRC_SIZE * sizeof(unsigned char)); \
CHANGE_ORDER(value, SRC_ORDR, SRC_SIZE); /*change back the order for bit operation*/ \
buf_p += SRC_SIZE; \
\
/* +/-QNaN */ \
- H5T_bit_set(value, (size_t)(SRC_MANT_DIG - 2), (size_t)1, TRUE); \
+ H5T__bit_set(value, (size_t)(SRC_MANT_DIG - 2), (size_t)1, TRUE); \
CHANGE_ORDER(value, SRC_ORDR, SRC_SIZE); /*change order for big endian*/ \
HDmemcpy(buf_p, value, SRC_SIZE*sizeof(unsigned char)); \
CHANGE_ORDER(value, SRC_ORDR, SRC_SIZE); /*change back the order for bit operation*/ \
@@ -634,7 +634,7 @@ test_hard_query(void)
/* Unregister the hard conversion from int to float. Verify the conversion
* is a soft conversion. */
- H5Tunregister(H5T_PERS_HARD, NULL, H5T_NATIVE_INT, H5T_NATIVE_FLOAT, H5T_conv_int_float);
+ H5Tunregister(H5T_PERS_HARD, NULL, H5T_NATIVE_INT, H5T_NATIVE_FLOAT, H5T__conv_int_float);
if(H5Tcompiler_conv(H5T_NATIVE_INT, H5T_NATIVE_FLOAT) != FALSE) {
H5_FAILED();
printf("Can't query conversion function\n");
@@ -643,7 +643,7 @@ test_hard_query(void)
/* Register the hard conversion from int to float. Verify the conversion
* is a hard conversion. */
- H5Tregister(H5T_PERS_HARD, "int_flt", H5T_NATIVE_INT, H5T_NATIVE_FLOAT, H5T_conv_int_float);
+ H5Tregister(H5T_PERS_HARD, "int_flt", H5T_NATIVE_INT, H5T_NATIVE_FLOAT, H5T__conv_int_float);
if(H5Tcompiler_conv(H5T_NATIVE_INT, H5T_NATIVE_FLOAT) != TRUE) {
H5_FAILED();
printf("Can't query conversion function\n");
@@ -2337,92 +2337,92 @@ test_conv_int_1(const char *name, hid_t src, hid_t dst)
*/
if (H5T_SGN_2==src_sign && H5T_SGN_2==dst_sign) {
if (src_nbits>dst_nbits) {
- if(0==H5T_bit_get_d(src_bits, src_nbits-1, (size_t)1) &&
- H5T_bit_find(src_bits, dst_nbits-1, (src_nbits-dst_nbits),
+ if(0==H5T__bit_get_d(src_bits, src_nbits-1, (size_t)1) &&
+ H5T__bit_find(src_bits, dst_nbits-1, (src_nbits-dst_nbits),
H5T_BIT_MSB, 1)>=0) {
/*
* Source is positive and the magnitude is too large for
* the destination. The destination should be set to the
* maximum possible value: 0x7f...f
*/
- if (0==H5T_bit_get_d(dst_bits, dst_nbits-1, (size_t)1) &&
- H5T_bit_find(dst_bits, (size_t)0, dst_nbits-1, H5T_BIT_LSB, 0) < 0)
+ if (0==H5T__bit_get_d(dst_bits, dst_nbits-1, (size_t)1) &&
+ H5T__bit_find(dst_bits, (size_t)0, dst_nbits-1, H5T_BIT_LSB, 0) < 0)
continue; /*no error*/
- } else if (1==H5T_bit_get_d(src_bits, src_nbits-1, (size_t)1) &&
- H5T_bit_find(src_bits, (size_t)0, src_nbits-1, H5T_BIT_MSB,
+ } else if (1==H5T__bit_get_d(src_bits, src_nbits-1, (size_t)1) &&
+ H5T__bit_find(src_bits, (size_t)0, src_nbits-1, H5T_BIT_MSB,
0)+1>=(ssize_t)dst_nbits) {
/*
* Source is negative but the magnitude is too large for
* the destination. The destination should be set to the
* smallest possible value: 0x80...0
*/
- if (1==H5T_bit_get_d(dst_bits, dst_nbits-1, (size_t)1) &&
- H5T_bit_find(dst_bits, (size_t)0, dst_nbits-1, H5T_BIT_LSB, 1) < 0)
+ if (1==H5T__bit_get_d(dst_bits, dst_nbits-1, (size_t)1) &&
+ H5T__bit_find(dst_bits, (size_t)0, dst_nbits-1, H5T_BIT_LSB, 1) < 0)
continue; /*no error*/
}
} else if(src_nbits<dst_nbits) {
/* Source is smaller than the destination */
- if(0==H5T_bit_get_d(src_bits, src_nbits-1, (size_t)1)) {
+ if(0==H5T__bit_get_d(src_bits, src_nbits-1, (size_t)1)) {
/*
* Source is positive, so the excess bits in the
* destination should be set to 0's.
*/
- if (0==H5T_bit_get_d(dst_bits, src_nbits-1, (size_t)1) &&
- H5T_bit_find(dst_bits, src_nbits, dst_nbits-src_nbits, H5T_BIT_LSB, 1) < 0)
+ if (0==H5T__bit_get_d(dst_bits, src_nbits-1, (size_t)1) &&
+ H5T__bit_find(dst_bits, src_nbits, dst_nbits-src_nbits, H5T_BIT_LSB, 1) < 0)
continue; /*no error*/
} else {
/*
* Source is negative, so the excess bits in the
* destination should be set to 1's.
*/
- if (1==H5T_bit_get_d(dst_bits, src_nbits-1, (size_t)1) &&
- H5T_bit_find(dst_bits, src_nbits, dst_nbits-src_nbits, H5T_BIT_LSB, 0) < 0)
+ if (1==H5T__bit_get_d(dst_bits, src_nbits-1, (size_t)1) &&
+ H5T__bit_find(dst_bits, src_nbits, dst_nbits-src_nbits, H5T_BIT_LSB, 0) < 0)
continue; /*no error*/
}
}
} else if (H5T_SGN_2==src_sign && H5T_SGN_NONE==dst_sign) {
- if (H5T_bit_get_d(src_bits, src_nbits-1, (size_t)1)) {
+ if (H5T__bit_get_d(src_bits, src_nbits-1, (size_t)1)) {
/*
* The source is negative so the result should be zero.
* The source is negative if the most significant bit is
* set. The destination is zero if all bits are zero.
*/
- if (H5T_bit_find(dst_bits, (size_t)0, dst_nbits, H5T_BIT_LSB, 1) < 0)
+ if (H5T__bit_find(dst_bits, (size_t)0, dst_nbits, H5T_BIT_LSB, 1) < 0)
continue; /*no error*/
} else if (src_nbits>dst_nbits &&
- H5T_bit_find(src_bits, dst_nbits-1,
+ H5T__bit_find(src_bits, dst_nbits-1,
src_nbits-dst_nbits, H5T_BIT_LSB, 1)>=0) {
/*
* The source is a value with a magnitude too large for
* the destination. The destination should be the
* largest possible value: 0xff...f
*/
- if (H5T_bit_find(dst_bits, (size_t)0, dst_nbits, H5T_BIT_LSB, 0) < 0)
+ if (H5T__bit_find(dst_bits, (size_t)0, dst_nbits, H5T_BIT_LSB, 0) < 0)
continue; /*no error*/
}
} else if (H5T_SGN_NONE==src_sign && H5T_SGN_2==dst_sign) {
if (src_nbits>=dst_nbits &&
- H5T_bit_find(src_bits, dst_nbits-1, (src_nbits-dst_nbits)+1,
+ H5T__bit_find(src_bits, dst_nbits-1, (src_nbits-dst_nbits)+1,
H5T_BIT_LSB, 1)>=0) {
/*
* The source value has a magnitude that is larger than
* the destination can handle. The destination should be
* set to the largest possible positive value: 0x7f...f
*/
- if (0==H5T_bit_get_d(dst_bits, dst_nbits-1, (size_t)1) &&
- H5T_bit_find(dst_bits, (size_t)0, dst_nbits-1, H5T_BIT_LSB, 0) < 0)
+ if (0==H5T__bit_get_d(dst_bits, dst_nbits-1, (size_t)1) &&
+ H5T__bit_find(dst_bits, (size_t)0, dst_nbits-1, H5T_BIT_LSB, 0) < 0)
continue; /*no error*/
}
} else {
if (src_nbits>dst_nbits &&
- H5T_bit_find(src_bits, dst_nbits, src_nbits-dst_nbits,
+ H5T__bit_find(src_bits, dst_nbits, src_nbits-dst_nbits,
H5T_BIT_LSB, 1)>=0) {
/*
* The unsigned source has a value which is too large for
* the unsigned destination. The destination should be
* set to the largest possible value: 0xff...f
*/
- if (H5T_bit_find(dst_bits, (size_t)0, dst_nbits, H5T_BIT_LSB, 0) < 0)
+ if (H5T__bit_find(dst_bits, (size_t)0, dst_nbits, H5T_BIT_LSB, 0) < 0)
continue; /*no error*/
}
}
@@ -2610,8 +2610,8 @@ error:
/*-------------------------------------------------------------------------
* Function: test_conv_int_2
*
- * Purpose: Tests overlap calculates in H5T_conv_i_i(), which should be
- * the same as for H5T_conv_f_f() and H5T_conv_s_s().
+ * Purpose: Tests overlap calculates in H5T__conv_i_i(), which should be
+ * the same as for H5T__conv_f_f() and H5T__conv_s_s().
*
* Return: Success: 0
*
@@ -2648,7 +2648,7 @@ test_conv_int_2(void)
/*
* Conversion. If overlap calculations aren't right then an
- * assertion will fail in H5T_conv_i_i()
+ * assertion will fail in H5T__conv_i_i()
*/
H5Tconvert(src_type, dst_type, (size_t)100, buf, NULL, H5P_DEFAULT);
H5Tclose(src_type);
@@ -2788,8 +2788,8 @@ my_isinf(int endian, unsigned char *val, size_t size,
bits[size-(i+1)] = *(val + ENDIAN(size, i, endian));
#endif /*H5_VMS*/
- if(H5T_bit_find(bits, mpos, msize, H5T_BIT_LSB, 1) < 0 &&
- H5T_bit_find(bits, epos, esize, H5T_BIT_LSB, 0) < 0)
+ if(H5T__bit_find(bits, mpos, msize, H5T_BIT_LSB, 1) < 0 &&
+ H5T__bit_find(bits, epos, esize, H5T_BIT_LSB, 0) < 0)
retval = 1;
free(bits);
@@ -3321,7 +3321,7 @@ test_conv_flt_1 (const char *name, int run_test, hid_t src, hid_t dst)
}
}
- expo = H5T_bit_get_d(tmp, src_epos, src_esize);
+ expo = H5T__bit_get_d(tmp, src_epos, src_esize);
if(expo==0)
continue; /* Denormalized floating-point value detected */
else {
@@ -3341,7 +3341,7 @@ test_conv_flt_1 (const char *name, int run_test, hid_t src, hid_t dst)
}
}
- expo = H5T_bit_get_d(tmp, dst_epos, dst_esize);
+ expo = H5T__bit_get_d(tmp, dst_epos, dst_esize);
if(expo==0)
continue; /* Denormalized floating-point value detected */
else {
@@ -4348,7 +4348,7 @@ test_conv_int_fp(const char *name, int run_test, hid_t src, hid_t dst)
)
&& (INT_SCHAR==dst_type || INT_SHORT==dst_type || INT_INT==dst_type
|| INT_LONG==dst_type || INT_LLONG==dst_type)) {
- if(0==H5T_bit_get_d(src_bits, src_nbits-1, (size_t)1) &&
+ if(0==H5T__bit_get_d(src_bits, src_nbits-1, (size_t)1) &&
overflows(src_bits, src, dst_nbits-1)) {
/*
* Source is positive and the magnitude is too large for
@@ -4356,15 +4356,15 @@ test_conv_int_fp(const char *name, int run_test, hid_t src, hid_t dst)
* maximum possible value: 0x7f...f
*/
if(!except_set) {
- if (0==H5T_bit_get_d(dst_bits, dst_nbits-1, (size_t)1) &&
- H5T_bit_find(dst_bits, (size_t)0, dst_nbits-1, H5T_BIT_LSB, 0) < 0)
+ if (0==H5T__bit_get_d(dst_bits, dst_nbits-1, (size_t)1) &&
+ H5T__bit_find(dst_bits, (size_t)0, dst_nbits-1, H5T_BIT_LSB, 0) < 0)
continue; /*no error*/
} else {
/* fill_value is small so we know only the 1st byte is set */
if (dst_bits[0] == fill_value)
continue; /*no error*/
}
- } else if (1==H5T_bit_get_d(src_bits, src_nbits-1, (size_t)1) &&
+ } else if (1==H5T__bit_get_d(src_bits, src_nbits-1, (size_t)1) &&
overflows(src_bits, src, dst_nbits-1)) {
/*
* Source is negative but the magnitude is too large for
@@ -4372,8 +4372,8 @@ test_conv_int_fp(const char *name, int run_test, hid_t src, hid_t dst)
* smallest possible value: 0x80...0
*/
if(!except_set) {
- if (1==H5T_bit_get_d(dst_bits, dst_nbits-1, (size_t)1) &&
- H5T_bit_find(dst_bits, (size_t)0, dst_nbits-1, H5T_BIT_LSB, 1) < 0)
+ if (1==H5T__bit_get_d(dst_bits, dst_nbits-1, (size_t)1) &&
+ H5T__bit_find(dst_bits, (size_t)0, dst_nbits-1, H5T_BIT_LSB, 1) < 0)
continue; /*no error*/
} else {
if (dst_bits[0] == fill_value)
@@ -4389,14 +4389,14 @@ test_conv_int_fp(const char *name, int run_test, hid_t src, hid_t dst)
)
&& (INT_UCHAR==dst_type || INT_USHORT==dst_type || INT_UINT==dst_type
|| INT_ULONG==dst_type || INT_ULLONG==dst_type)) {
- if (H5T_bit_get_d(src_bits, src_nbits-1, (size_t)1)) {
+ if (H5T__bit_get_d(src_bits, src_nbits-1, (size_t)1)) {
/*
* The source is negative so the result should be zero.
* The source is negative if the most significant bit is
* set. The destination is zero if all bits are zero.
*/
if(!except_set) {
- if (H5T_bit_find(dst_bits, (size_t)0, dst_nbits, H5T_BIT_LSB, 1) < 0)
+ if (H5T__bit_find(dst_bits, (size_t)0, dst_nbits, H5T_BIT_LSB, 1) < 0)
continue; /*no error*/
} else {
if (dst_bits[0] == fill_value)
@@ -4409,7 +4409,7 @@ test_conv_int_fp(const char *name, int run_test, hid_t src, hid_t dst)
* largest possible value: 0xff...f
*/
if(!except_set) {
- if (H5T_bit_find(dst_bits, (size_t)0, dst_nbits, H5T_BIT_LSB, 0) < 0)
+ if (H5T__bit_find(dst_bits, (size_t)0, dst_nbits, H5T_BIT_LSB, 0) < 0)
continue; /*no error*/
} else {
if (dst_bits[0] == fill_value)
@@ -4757,13 +4757,13 @@ overflows(unsigned char *origin_bits, hid_t src_id, size_t dst_num_bits)
HDmemcpy(bits, origin_bits, src_prec/8+1);
/*Check for special cases: +Inf, -Inf*/
- if (H5T_bit_find (bits, mpos, mant_digits, H5T_BIT_LSB, TRUE) < 0) {
- if (H5T_bit_find (bits, epos, expt_digits, H5T_BIT_LSB, FALSE) < 0) {
+ if (H5T__bit_find (bits, mpos, mant_digits, H5T_BIT_LSB, TRUE) < 0) {
+ if (H5T__bit_find (bits, epos, expt_digits, H5T_BIT_LSB, FALSE) < 0) {
ret_value=TRUE;
goto done;
}
- } else if (H5T_NORM_NONE==norm && H5T_bit_find (bits, mpos, mant_digits-1,
- H5T_BIT_LSB, TRUE) < 0 && H5T_bit_find (bits, epos, expt_digits,
+ } else if (H5T_NORM_NONE==norm && H5T__bit_find (bits, mpos, mant_digits-1,
+ H5T_BIT_LSB, TRUE) < 0 && H5T__bit_find (bits, epos, expt_digits,
H5T_BIT_LSB, FALSE) < 0) {
/*This is a special case for the source of no implied mantissa bit.
*If the exponent bits are all 1s and only the 1st bit of mantissa
@@ -4773,7 +4773,7 @@ overflows(unsigned char *origin_bits, hid_t src_id, size_t dst_num_bits)
}
/* get exponent */
- expt = H5T_bit_get_d(bits, mant_digits, expt_digits) - bias;
+ expt = H5T__bit_get_d(bits, mant_digits, expt_digits) - bias;
if(expt>=(dst_num_bits-1)) {
ret_value=TRUE;
@@ -4781,19 +4781,19 @@ overflows(unsigned char *origin_bits, hid_t src_id, size_t dst_num_bits)
}
/* get significand */
- H5T_bit_copy (mant_bits, (size_t)0, bits, (size_t)0, mant_digits);
+ H5T__bit_copy (mant_bits, (size_t)0, bits, (size_t)0, mant_digits);
/* restore implicit bit if normalization is implied*/
if(norm == H5T_NORM_IMPLIED) {
- H5T_bit_inc(mant_bits, mant_digits, (size_t)1);
+ H5T__bit_inc(mant_bits, mant_digits, (size_t)1);
mant_digits++;
}
/* shift significand */
- H5T_bit_shift (mant_bits, (ssize_t)(expt-expt_digits), (size_t)0, (size_t)(32 * 8));
+ H5T__bit_shift (mant_bits, (ssize_t)(expt-expt_digits), (size_t)0, (size_t)(32 * 8));
- indx = H5T_bit_find(mant_bits, (size_t)0, (size_t)(32 * 8), H5T_BIT_MSB, 1);
+ indx = H5T__bit_find(mant_bits, (size_t)0, (size_t)(32 * 8), H5T_BIT_MSB, 1);
if((size_t)indx>=dst_num_bits)
ret_value=TRUE;
diff --git a/test/external.c b/test/external.c
index 1dedeab..ae1008c 100644
--- a/test/external.c
+++ b/test/external.c
@@ -111,6 +111,7 @@ test_1a(hid_t file)
char name[256]; /*external file name */
off_t file_offset; /*external file offset */
hsize_t file_size; /*sizeof external file segment */
+ haddr_t dset_addr; /*address of dataset */
TESTING("fixed-size data space, exact storage");
@@ -130,7 +131,10 @@ test_1a(hid_t file)
if((dset = H5Dopen2(file, "dset1", H5P_DEFAULT)) < 0) goto error;
/* Test dataset address. Should be undefined. */
- if(H5Dget_offset(dset) != HADDR_UNDEF) goto error;
+ H5E_BEGIN_TRY {
+ dset_addr = H5Dget_offset(dset);
+ } H5E_END_TRY;
+ if(dset_addr != HADDR_UNDEF) goto error;
if((dcpl = H5Dget_create_plist(dset)) < 0) goto error;
if((n = H5Pget_external_count(dcpl)) < 0) goto error;
diff --git a/test/testfiles/error_test_1 b/test/testfiles/error_test_1
index 8d6e208..b322460 100644
--- a/test/testfiles/error_test_1
+++ b/test/testfiles/error_test_1
@@ -44,13 +44,13 @@ HDF5-DIAG: Error detected in HDF5 (version (number)) thread (IDs):
#000: (file name) line (number) in H5Dread(): can't read data
major: Dataset
minor: Read failed
- #001: (file name) line (number) in H5D_read(): can't read data
+ #001: (file name) line (number) in H5D__read(): can't read data
major: Dataset
minor: Read failed
- #002: (file name) line (number) in H5D_chunk_read(): unable to read raw data chunk
+ #002: (file name) line (number) in H5D__chunk_read(): unable to read raw data chunk
major: Low-level I/O
minor: Read failed
- #003: (file name) line (number) in H5D_chunk_lock(): data pipeline read failed
+ #003: (file name) line (number) in H5D__chunk_lock(): data pipeline read failed
major: Data filters
minor: Filter operation failed
#004: (file name) line (number) in H5Z_pipeline(): required filter 'bogus' is not registered
diff --git a/test/tmisc.c b/test/tmisc.c
index 5539cee..6fcf557 100644
--- a/test/tmisc.c
+++ b/test/tmisc.c
@@ -3460,14 +3460,14 @@ test_misc20(void)
CHECK(did, FAIL, "H5Dopen2");
/* Get the layout version */
- ret = H5D_layout_version_test(did,&version);
- CHECK(ret, FAIL, "H5D_layout_version_test");
- VERIFY(version, 3, "H5D_layout_version_test");
+ ret = H5D__layout_version_test(did,&version);
+ CHECK(ret, FAIL, "H5D__layout_version_test");
+ VERIFY(version, 3, "H5D__layout_version_test");
/* Get the layout contiguous storage size */
- ret = H5D_layout_contig_size_test(did,&contig_size);
- CHECK(ret, FAIL, "H5D_layout_contig_size_test");
- VERIFY(contig_size, (MISC20_SPACE_DIM0 * MISC20_SPACE_DIM1 * H5Tget_size(H5T_NATIVE_INT)), "H5D_layout_contig_size_test");
+ ret = H5D__layout_contig_size_test(did,&contig_size);
+ CHECK(ret, FAIL, "H5D__layout_contig_size_test");
+ VERIFY(contig_size, (MISC20_SPACE_DIM0 * MISC20_SPACE_DIM1 * H5Tget_size(H5T_NATIVE_INT)), "H5D__layout_contig_size_test");
/* Close datasset */
ret = H5Dclose(did);
@@ -3478,14 +3478,14 @@ test_misc20(void)
CHECK(did, FAIL, "H5Dopen2");
/* Get the layout version */
- ret = H5D_layout_version_test(did,&version);
- CHECK(ret, FAIL, "H5D_layout_version_test");
- VERIFY(version, 3, "H5D_layout_version_test");
+ ret = H5D__layout_version_test(did,&version);
+ CHECK(ret, FAIL, "H5D__layout_version_test");
+ VERIFY(version, 3, "H5D__layout_version_test");
/* Get the layout contiguous storage size */
- ret = H5D_layout_contig_size_test(did,&contig_size);
- CHECK(ret, FAIL, "H5D_layout_contig_size_test");
- VERIFY(contig_size, (MISC20_SPACE2_DIM0 * MISC20_SPACE2_DIM1 * H5Tget_size(H5T_NATIVE_INT)), "H5D_layout_contig_size_test");
+ ret = H5D__layout_contig_size_test(did,&contig_size);
+ CHECK(ret, FAIL, "H5D__layout_contig_size_test");
+ VERIFY(contig_size, (MISC20_SPACE2_DIM0 * MISC20_SPACE2_DIM1 * H5Tget_size(H5T_NATIVE_INT)), "H5D__layout_contig_size_test");
/* Close datasset */
ret = H5Dclose(did);
@@ -3508,14 +3508,14 @@ test_misc20(void)
CHECK(did, FAIL, "H5Dopen2");
/* Get the layout version */
- ret = H5D_layout_version_test(did,&version);
- CHECK(ret, FAIL, "H5D_layout_version_test");
- VERIFY(version, 2, "H5D_layout_version_test");
+ ret = H5D__layout_version_test(did,&version);
+ CHECK(ret, FAIL, "H5D__layout_version_test");
+ VERIFY(version, 2, "H5D__layout_version_test");
/* Get the layout contiguous storage size */
- ret = H5D_layout_contig_size_test(did,&contig_size);
- CHECK(ret, FAIL, "H5D_layout_contig_size_test");
- VERIFY(contig_size, (MISC20_SPACE_DIM0 * MISC20_SPACE_DIM1 * H5Tget_size(H5T_STD_I32LE)), "H5D_layout_contig_size_test");
+ ret = H5D__layout_contig_size_test(did,&contig_size);
+ CHECK(ret, FAIL, "H5D__layout_contig_size_test");
+ VERIFY(contig_size, (MISC20_SPACE_DIM0 * MISC20_SPACE_DIM1 * H5Tget_size(H5T_STD_I32LE)), "H5D__layout_contig_size_test");
/* Close datasset */
ret = H5Dclose(did);
@@ -4963,10 +4963,10 @@ test_misc28(void)
CHECK(did, FAIL, "H5Dcreate2");
/* Verify that the chunk cache is empty */
- ret = H5D_current_cache_size_test(did, &nbytes_used, &nused);
- CHECK(ret, FAIL, "H5D_current_cache_size_test");
- VERIFY(nbytes_used, (size_t) 0, "H5D_current_cache_size_test");
- VERIFY(nused, 0, "H5D_current_cache_size_test");
+ ret = H5D__current_cache_size_test(did, &nbytes_used, &nused);
+ CHECK(ret, FAIL, "H5D__current_cache_size_test");
+ VERIFY(nbytes_used, (size_t) 0, "H5D__current_cache_size_test");
+ VERIFY(nused, 0, "H5D__current_cache_size_test");
/* Initialize write buffer */
for(i=0; i<MISC28_SIZE; i++)
@@ -4984,10 +4984,10 @@ test_misc28(void)
CHECK(ret, FAIL, "H5Dwrite");
/* Verify that all 10 chunks written have been cached */
- ret = H5D_current_cache_size_test(did, &nbytes_used, &nused);
- CHECK(ret, FAIL, "H5D_current_cache_size_test");
- VERIFY(nbytes_used, (size_t) MISC28_SIZE, "H5D_current_cache_size_test");
- VERIFY(nused, MISC28_SIZE, "H5D_current_cache_size_test");
+ ret = H5D__current_cache_size_test(did, &nbytes_used, &nused);
+ CHECK(ret, FAIL, "H5D__current_cache_size_test");
+ VERIFY(nbytes_used, (size_t) MISC28_SIZE, "H5D__current_cache_size_test");
+ VERIFY(nused, MISC28_SIZE, "H5D__current_cache_size_test");
/* Initialize write buffer */
for(i=0; i<MISC28_SIZE; i++)
@@ -5003,10 +5003,10 @@ test_misc28(void)
CHECK(ret, FAIL, "H5Dwrite");
/* Verify that the size of the cache remains at 10 */
- ret = H5D_current_cache_size_test(did, &nbytes_used, &nused);
- CHECK(ret, FAIL, "H5D_current_cache_size_test");
- VERIFY(nbytes_used, (size_t) MISC28_SIZE, "H5D_current_cache_size_test");
- VERIFY(nused, MISC28_SIZE, "H5D_current_cache_size_test");
+ ret = H5D__current_cache_size_test(did, &nbytes_used, &nused);
+ CHECK(ret, FAIL, "H5D__current_cache_size_test");
+ VERIFY(nbytes_used, (size_t) MISC28_SIZE, "H5D__current_cache_size_test");
+ VERIFY(nused, MISC28_SIZE, "H5D__current_cache_size_test");
/* Close dataset */
ret = H5Dclose(did);
@@ -5018,10 +5018,10 @@ test_misc28(void)
CHECK(did, FAIL, "H5Dopen2");
/* Verify that the chunk cache is empty */
- ret = H5D_current_cache_size_test(did, &nbytes_used, &nused);
- CHECK(ret, FAIL, "H5D_current_cache_size_test");
- VERIFY(nbytes_used, (size_t) 0, "H5D_current_cache_size_test");
- VERIFY(nused, 0, "H5D_current_cache_size_test");
+ ret = H5D__current_cache_size_test(did, &nbytes_used, &nused);
+ CHECK(ret, FAIL, "H5D__current_cache_size_test");
+ VERIFY(nbytes_used, (size_t) 0, "H5D__current_cache_size_test");
+ VERIFY(nused, 0, "H5D__current_cache_size_test");
/* Select hyperslabe for reading */
start[1] = 0;
@@ -5037,10 +5037,10 @@ test_misc28(void)
VERIFY(buf[i], i, "H5Dread");
/* Verify that all 10 chunks read have been cached */
- ret = H5D_current_cache_size_test(did, &nbytes_used, &nused);
- CHECK(ret, FAIL, "H5D_current_cache_size_test");
- VERIFY(nbytes_used, (size_t) MISC28_SIZE, "H5D_current_cache_size_test");
- VERIFY(nused, MISC28_SIZE, "H5D_current_cache_size_test");
+ ret = H5D__current_cache_size_test(did, &nbytes_used, &nused);
+ CHECK(ret, FAIL, "H5D__current_cache_size_test");
+ VERIFY(nbytes_used, (size_t) MISC28_SIZE, "H5D__current_cache_size_test");
+ VERIFY(nused, MISC28_SIZE, "H5D__current_cache_size_test");
/* Select new hyperslab */
start[1] = 1;
@@ -5056,10 +5056,10 @@ test_misc28(void)
VERIFY(buf[i], MISC28_SIZE - 1 - i, "H5Dread");
/* Verify that the size of the cache remains at 10 */
- ret = H5D_current_cache_size_test(did, &nbytes_used, &nused);
- CHECK(ret, FAIL, "H5D_current_cache_size_test");
- VERIFY(nbytes_used, (size_t) MISC28_SIZE, "H5D_current_cache_size_test");
- VERIFY(nused, MISC28_SIZE, "H5D_current_cache_size_test");
+ ret = H5D__current_cache_size_test(did, &nbytes_used, &nused);
+ CHECK(ret, FAIL, "H5D__current_cache_size_test");
+ VERIFY(nbytes_used, (size_t) MISC28_SIZE, "H5D__current_cache_size_test");
+ VERIFY(nused, MISC28_SIZE, "H5D__current_cache_size_test");
/* Close dataset */
ret = H5Dclose(did);