mirror of
https://github.com/HDFGroup/hdf5.git
synced 2024-11-27 02:10:55 +08:00
ab28d2c820
Bug fix
Description:
An earlier checkin changed some of the assumptions about single block
hyperslabs, causing them to fail in odd ways.
Solution:
Fix errors with single block hyperslabs by keying off of count==1 instead
of stride==1.
Platforms tested:
FreeBSD 4.8 (sleipnir) w/parallel
h5committested
1952 lines
57 KiB
C
1952 lines
57 KiB
C
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
||
* Copyright by the Board of Trustees of the University of Illinois. *
|
||
* All rights reserved. *
|
||
* *
|
||
* This file is part of HDF5. The full HDF5 copyright notice, including *
|
||
* terms governing use, modification, and redistribution, is contained in *
|
||
* the files COPYING and Copyright.html. COPYING can be found at the root *
|
||
* of the source code distribution tree; Copyright.html can be found at the *
|
||
* root level of an installed copy of the electronic HDF5 document set and *
|
||
* is linked from the top-level documents page. It can also be found at *
|
||
* http://hdf.ncsa.uiuc.edu/HDF5/doc/Copyright.html. If you do not have *
|
||
* access to either file, you may request a copy from hdfhelp@ncsa.uiuc.edu. *
|
||
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
|
||
|
||
/*
|
||
* Programmer: Raymond Lu
|
||
* October 14, 2001
|
||
*
|
||
* Purpose: Tests the H5Tget_native_type function.
|
||
*/
|
||
|
||
#include "h5test.h"
|
||
|
||
const char *FILENAME[] = {
|
||
"ntypes",
|
||
NULL
|
||
};
|
||
|
||
int ipoints2[100][200], icheck2[100][200];
|
||
short spoints2[100][200], scheck2[100][200];
|
||
int ipoints3[100][200][5], icheck3[100][200][5];
|
||
|
||
#define DSET_ATOMIC_NAME_1 "atomic_type_1"
|
||
#define DSET_ATOMIC_NAME_2 "atomic_type_2"
|
||
#define DSET_ATOMIC_NAME_3 "atomic_type_3"
|
||
#define DSET_ATOMIC_NAME_4 "atomic_type_4"
|
||
#define DSET_ATOMIC_NAME_5 "atomic_type_5"
|
||
#define DSET_COMPOUND_NAME "compound_type"
|
||
#define DSET_COMPOUND_NAME_2 "compound_type_2"
|
||
#define DSET_COMPOUND_NAME_3 "compound_type_3"
|
||
#define DSET_ENUM_NAME "enum_type"
|
||
#define DSET_ARRAY_NAME "array_type"
|
||
#define DSET_ARRAY2_NAME "array_type_2"
|
||
#define DSET_VL_NAME "vl_type"
|
||
#define DSET_VLSTR_NAME "vlstr_type"
|
||
#define DSET_OPAQUE_NAME "opaque_type"
|
||
#define DSET_BITFIELD_NAME "bitfield_type"
|
||
|
||
#define SPACE1_DIM1 4
|
||
#define SPACE1_RANK 1
|
||
#define SPACE2_RANK 2
|
||
#define SPACE2_DIM1 10
|
||
#define SPACE2_DIM2 10
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: test_atomic_dtype
|
||
*
|
||
* Purpose: Test H5Tget_native_type for atomic datatype
|
||
*
|
||
* Return: Success: 0
|
||
*
|
||
* Failure: -1
|
||
*
|
||
* Programmer: Raymond Lu
|
||
* October 15, 2002
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static herr_t
|
||
test_atomic_dtype(hid_t file)
|
||
{
|
||
hid_t dataset, space;
|
||
hid_t dtype, native_type;
|
||
int i, j, n;
|
||
hsize_t dims[2];
|
||
void *tmp;
|
||
|
||
TESTING("atomic datatype");
|
||
|
||
/* Initialize the dataset */
|
||
for (i = n = 0; i < 100; i++) {
|
||
for (j = 0; j < 200; j++) {
|
||
ipoints2[i][j] = n++;
|
||
}
|
||
}
|
||
|
||
/* Create the data space */
|
||
dims[0] = 100;
|
||
dims[1] = 200;
|
||
if ((space = H5Screate_simple(2, dims, NULL))<0) TEST_ERROR;
|
||
|
||
/*------------------- Test data values ------------------------*/
|
||
/* Create the dataset */
|
||
if ((dataset = H5Dcreate(file, DSET_ATOMIC_NAME_1, H5T_STD_I32BE, space,
|
||
H5P_DEFAULT))<0) TEST_ERROR;
|
||
|
||
/* Write the data to the dataset */
|
||
if (H5Dwrite(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, ipoints2)<0)
|
||
TEST_ERROR;
|
||
|
||
/* Close dataset */
|
||
if(H5Dclose(dataset)<0) TEST_ERROR;
|
||
|
||
/* Open dataset again to check H5Tget_native_type */
|
||
if((dataset=H5Dopen(file, DSET_ATOMIC_NAME_1))<0) TEST_ERROR;
|
||
|
||
if((dtype=H5Dget_type(dataset))<0) TEST_ERROR;
|
||
|
||
if((native_type=H5Tget_native_type(dtype, H5T_DIR_DEFAULT))<0)
|
||
TEST_ERROR;
|
||
|
||
/* Verify the datatype retrieved and converted */
|
||
if(H5Tget_order(native_type) != H5Tget_order(H5T_NATIVE_INT))
|
||
TEST_ERROR;
|
||
if(H5Tget_size(native_type) < H5Tget_size(H5T_STD_I32BE))
|
||
TEST_ERROR;
|
||
if(H5T_INTEGER!=H5Tget_class(native_type))
|
||
TEST_ERROR;
|
||
|
||
/* Read the dataset back. The temporary buffer is for special platforms
|
||
* like Cray. */
|
||
tmp = malloc(dims[0]*dims[1]*H5Tget_size(native_type));
|
||
|
||
if (H5Dread(dataset, native_type, H5S_ALL, H5S_ALL, H5P_DEFAULT, tmp)<0)
|
||
TEST_ERROR;
|
||
|
||
/* Copy data from temporary buffer to destination buffer */
|
||
memcpy(icheck2, tmp, dims[0]*dims[1]*H5Tget_size(native_type));
|
||
free(tmp);
|
||
|
||
/* Convert to the integer type */
|
||
if(H5Tconvert(native_type, H5T_NATIVE_INT, dims[0]*dims[1], icheck2, NULL, H5P_DEFAULT)<0)
|
||
TEST_ERROR;
|
||
|
||
/* Check that the values read are the same as the values written */
|
||
for (i = 0; i < dims[0]; i++) {
|
||
for (j = 0; j < dims[1]; j++) {
|
||
if (ipoints2[i][j] != icheck2[i][j]) {
|
||
H5_FAILED();
|
||
printf(" Read different values than written.\n");
|
||
printf(" At index %d,%d\n", i, j);
|
||
goto error;
|
||
}
|
||
}
|
||
}
|
||
|
||
H5Dclose(dataset);
|
||
H5Tclose(dtype);
|
||
|
||
/*------------------ Test different data types ----------------*/
|
||
|
||
/* Create the dataset of H5T_STD_I64LE */
|
||
if ((dataset = H5Dcreate(file, DSET_ATOMIC_NAME_2, H5T_STD_I64LE, space,
|
||
H5P_DEFAULT))<0) TEST_ERROR;
|
||
|
||
if((dtype=H5Dget_type(dataset))<0) TEST_ERROR;
|
||
|
||
if((native_type=H5Tget_native_type(dtype, H5T_DIR_DEFAULT))<0)
|
||
TEST_ERROR;
|
||
|
||
/* Verify the datatype retrieved and converted */
|
||
if(H5Tget_order(native_type) != H5Tget_order(H5T_NATIVE_LLONG))
|
||
TEST_ERROR;
|
||
if(H5Tget_size(native_type) < H5Tget_size(H5T_STD_I64LE))
|
||
TEST_ERROR;
|
||
if(H5T_INTEGER!=H5Tget_class(native_type))
|
||
TEST_ERROR;
|
||
|
||
if(H5Dclose(dataset)<0) TEST_ERROR;
|
||
if(H5Tclose(dtype)<0) TEST_ERROR;
|
||
|
||
|
||
/* Create the dataset of H5T_STD_I8LE */
|
||
if ((dataset = H5Dcreate(file, DSET_ATOMIC_NAME_3, H5T_STD_I8LE, space,
|
||
H5P_DEFAULT))<0) TEST_ERROR;
|
||
|
||
if((dtype=H5Dget_type(dataset))<0) TEST_ERROR;
|
||
|
||
if((native_type=H5Tget_native_type(dtype, H5T_DIR_ASCEND))<0)
|
||
TEST_ERROR;
|
||
|
||
/* Verify the datatype retrieved and converted */
|
||
if(H5Tget_order(native_type) != H5Tget_order(H5T_NATIVE_CHAR))
|
||
TEST_ERROR;
|
||
if(H5Tget_size(native_type) < H5Tget_size(H5T_STD_I8LE))
|
||
TEST_ERROR;
|
||
if(H5T_INTEGER!=H5Tget_class(native_type))
|
||
TEST_ERROR;
|
||
|
||
if(H5Dclose(dataset)<0) TEST_ERROR;
|
||
if(H5Tclose(dtype)<0) TEST_ERROR;
|
||
|
||
|
||
/* Create the dataset of H5T_IEEE_F32BE */
|
||
if ((dataset = H5Dcreate(file, DSET_ATOMIC_NAME_4, H5T_IEEE_F32BE, space,
|
||
H5P_DEFAULT))<0) TEST_ERROR;
|
||
|
||
if((dtype=H5Dget_type(dataset))<0) TEST_ERROR;
|
||
|
||
if((native_type=H5Tget_native_type(dtype, H5T_DIR_DESCEND))<0)
|
||
TEST_ERROR;
|
||
|
||
/* Verify the datatype retrieved and converted */
|
||
if(H5Tget_order(native_type) != H5Tget_order(H5T_NATIVE_FLOAT))
|
||
TEST_ERROR;
|
||
if(H5Tget_size(native_type) < H5Tget_size(H5T_IEEE_F32BE))
|
||
TEST_ERROR;
|
||
if(H5T_FLOAT!=H5Tget_class(native_type))
|
||
TEST_ERROR;
|
||
|
||
if(H5Dclose(dataset)<0) TEST_ERROR;
|
||
if(H5Tclose(dtype)<0) TEST_ERROR;
|
||
|
||
|
||
/* Create the dataset of H5T_IEEE_F64BE */
|
||
if ((dataset = H5Dcreate(file, DSET_ATOMIC_NAME_5, H5T_IEEE_F64BE, space,
|
||
H5P_DEFAULT))<0) TEST_ERROR;
|
||
|
||
if((dtype=H5Dget_type(dataset))<0) TEST_ERROR;
|
||
|
||
if((native_type=H5Tget_native_type(dtype, H5T_DIR_DESCEND))<0)
|
||
TEST_ERROR;
|
||
|
||
/* Verify the datatype retrieved and converted */
|
||
if(H5Tget_order(native_type) != H5Tget_order(H5T_NATIVE_DOUBLE))
|
||
TEST_ERROR;
|
||
if(H5Tget_size(native_type) < H5Tget_size(H5T_IEEE_F64BE))
|
||
TEST_ERROR;
|
||
if(H5T_FLOAT!=H5Tget_class(native_type))
|
||
TEST_ERROR;
|
||
|
||
if(H5Dclose(dataset)<0) TEST_ERROR;
|
||
if(H5Tclose(dtype)<0) TEST_ERROR;
|
||
|
||
|
||
/* Close dataspace */
|
||
if(H5Sclose(space)<0) TEST_ERROR;
|
||
|
||
PASSED();
|
||
return 0;
|
||
|
||
error:
|
||
return -1;
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: test_compound_dtype2
|
||
*
|
||
* Purpose: Test H5Tget_native_type for compound datatype
|
||
*
|
||
* Return: Success: 0
|
||
*
|
||
* Failure: -1
|
||
*
|
||
* Programmer: Raymond Lu
|
||
* October 15, 2002
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static herr_t
|
||
test_compound_dtype2(hid_t file)
|
||
{
|
||
typedef struct s2 {
|
||
short c2;
|
||
long l2;
|
||
} s2;
|
||
typedef struct s1 {
|
||
char c;
|
||
int i;
|
||
s2 st;
|
||
unsigned long_long l;
|
||
} s1;
|
||
hid_t dataset, space;
|
||
hid_t dtype, native_type, tid, tid2, tid_m, tid_m2;
|
||
int i, j, n;
|
||
hsize_t dims[2];
|
||
s1 *temp_point, *temp_check;
|
||
s1 *points=NULL, *check=NULL;
|
||
void *tmp;
|
||
|
||
TESTING("nested compound datatype");
|
||
|
||
/* Allocate space for the points & check arrays */
|
||
if((points=malloc(sizeof(s1)*100*200))==NULL)
|
||
TEST_ERROR;
|
||
if((check=calloc(sizeof(s1),100*200))==NULL)
|
||
TEST_ERROR;
|
||
|
||
/* Initialize the dataset */
|
||
for (i = n = 0, temp_point=points; i < 100; i++) {
|
||
for (j = 0; j < 200; j++,temp_point++) {
|
||
temp_point->c = 't';
|
||
temp_point->i = n++;
|
||
temp_point->st.c2 = i+j;
|
||
temp_point->st.l2 = (i*5+j*50)*n;
|
||
temp_point->l = (i*10+j*100)*n;
|
||
}
|
||
}
|
||
|
||
/* Create the data space */
|
||
dims[0] = 100;
|
||
dims[1] = 200;
|
||
if ((space = H5Screate_simple(2, dims, NULL))<0) TEST_ERROR;
|
||
|
||
/* Create compound datatype for disk storage */
|
||
#if H5_SIZEOF_LONG==4
|
||
if((tid2=H5Tcreate(H5T_COMPOUND, 6))<0) TEST_ERROR;
|
||
if((tid=H5Tcreate(H5T_COMPOUND, 19))<0) TEST_ERROR;
|
||
#elif H5_SIZEOF_LONG==8
|
||
if((tid2=H5Tcreate(H5T_COMPOUND, 10))<0) TEST_ERROR;
|
||
if((tid=H5Tcreate(H5T_COMPOUND, 23))<0) TEST_ERROR;
|
||
#else
|
||
#error "Unknown 'long' size"
|
||
#endif
|
||
|
||
/* Insert and pack members */
|
||
if(H5Tinsert(tid2, "c2", 0, H5T_STD_I16BE)<0) TEST_ERROR;
|
||
#if H5_SIZEOF_LONG==4
|
||
if(H5Tinsert(tid2, "l2", 2, H5T_STD_I32LE)<0) TEST_ERROR;
|
||
#elif H5_SIZEOF_LONG==8
|
||
if(H5Tinsert(tid2, "l2", 2, H5T_STD_I64LE)<0) TEST_ERROR;
|
||
#else
|
||
#error "Unknown 'long' size"
|
||
#endif
|
||
|
||
if(H5Tinsert(tid, "c", 0, H5T_STD_U8LE)<0) TEST_ERROR;
|
||
if(H5Tinsert(tid, "i", 1, H5T_STD_I32LE)<0) TEST_ERROR;
|
||
if(H5Tinsert(tid, "st", 5, tid2)<0) TEST_ERROR;
|
||
#if H5_SIZEOF_LONG==4
|
||
if(H5Tinsert(tid, "l", 11, H5T_STD_U64BE)<0) TEST_ERROR;
|
||
#elif H5_SIZEOF_LONG==8
|
||
if(H5Tinsert(tid, "l", 15, H5T_STD_U64BE)<0) TEST_ERROR;
|
||
#else
|
||
#error "Unknown 'long' size"
|
||
#endif
|
||
|
||
/* Create the dataset */
|
||
if ((dataset = H5Dcreate(file, DSET_COMPOUND_NAME_2, tid, space,
|
||
H5P_DEFAULT))<0) TEST_ERROR;
|
||
|
||
/* Create compound datatype for memory */
|
||
if((tid_m2=H5Tcreate(H5T_COMPOUND, sizeof(s2)))<0) TEST_ERROR;
|
||
if((tid_m=H5Tcreate(H5T_COMPOUND, sizeof(s1)))<0) TEST_ERROR;
|
||
|
||
/* Insert members */
|
||
if(H5Tinsert(tid_m2, "c2", HOFFSET(s2, c2), H5T_NATIVE_SHORT)<0) TEST_ERROR;
|
||
if(H5Tinsert(tid_m2, "l2", HOFFSET(s2, l2), H5T_NATIVE_LONG)<0) TEST_ERROR;
|
||
if(H5Tinsert(tid_m, "c", HOFFSET(s1, c), H5T_NATIVE_UCHAR)<0) TEST_ERROR;
|
||
if(H5Tinsert(tid_m, "i", HOFFSET(s1, i), H5T_NATIVE_INT)<0) TEST_ERROR;
|
||
if(H5Tinsert(tid_m, "st", HOFFSET(s1, st), tid_m2)<0) TEST_ERROR;
|
||
if(H5Tinsert(tid_m, "l", HOFFSET(s1, l), H5T_NATIVE_ULLONG)<0) TEST_ERROR;
|
||
|
||
/* Write the data to the dataset */
|
||
if (H5Dwrite(dataset, tid_m, H5S_ALL, H5S_ALL, H5P_DEFAULT, points)<0)
|
||
TEST_ERROR;
|
||
|
||
/* Close dataset */
|
||
if(H5Dclose(dataset)<0) TEST_ERROR;
|
||
|
||
/* Close dataspace */
|
||
if(H5Sclose(space)<0) TEST_ERROR;
|
||
|
||
|
||
/* Open dataset again to check H5Tget_native_type */
|
||
if((dataset=H5Dopen(file, DSET_COMPOUND_NAME_2))<0) TEST_ERROR;
|
||
|
||
if((dtype=H5Dget_type(dataset))<0) TEST_ERROR;
|
||
|
||
if((native_type=H5Tget_native_type(dtype, H5T_DIR_DEFAULT))<0)
|
||
TEST_ERROR;
|
||
|
||
if(H5Tget_size(native_type) != H5Tget_size(tid_m))
|
||
TEST_ERROR;
|
||
if(!H5Tequal(native_type, tid_m))
|
||
TEST_ERROR;
|
||
|
||
/* Read the dataset back. Temporary buffer is for special platforms like
|
||
* Cray */
|
||
tmp = malloc(dims[0]*dims[1]*H5Tget_size(native_type));
|
||
|
||
if (H5Dread(dataset, native_type, H5S_ALL, H5S_ALL, H5P_DEFAULT, tmp)<0)
|
||
TEST_ERROR;
|
||
|
||
memcpy(check, tmp, dims[0]*dims[1]*H5Tget_size(native_type));
|
||
free(tmp);
|
||
|
||
if (H5Tconvert(native_type, tid_m, dims[0]*dims[1], check, NULL, H5P_DEFAULT))
|
||
TEST_ERROR;
|
||
|
||
/* Check that the values read are the same as the values written */
|
||
for (i = 0, temp_point=points, temp_check=check; i < 100; i++) {
|
||
for (j = 0; j < 200; j++, temp_point++,temp_check++) {
|
||
if (temp_point->c != temp_check->c ||
|
||
temp_point->i != temp_check->i ||
|
||
temp_point->st.c2 != temp_check->st.c2 ||
|
||
temp_point->st.l2 != temp_check->st.l2 ||
|
||
temp_point->l != temp_check->l ) {
|
||
H5_FAILED();
|
||
printf(" Read different values than written.\n");
|
||
printf(" At index %d,%d\n", i, j);
|
||
goto error;
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Close temporary datatypes */
|
||
if(H5Tclose(tid2)<0) TEST_ERROR;
|
||
if(H5Tclose(tid)<0) TEST_ERROR;
|
||
if(H5Tclose(tid_m2)<0) TEST_ERROR;
|
||
|
||
/* Close HDF5 objects */
|
||
H5Dclose(dataset);
|
||
H5Tclose(dtype);
|
||
H5Tclose(native_type);
|
||
H5Tclose(tid_m);
|
||
|
||
/* Free memory for test data */
|
||
free(points);
|
||
free(check);
|
||
|
||
PASSED();
|
||
return 0;
|
||
|
||
error:
|
||
if(points!=NULL)
|
||
free(points);
|
||
if(check!=NULL)
|
||
free(check);
|
||
return -1;
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: test_compound_dtype
|
||
*
|
||
* Purpose: Test H5Tget_native_type for compound datatype
|
||
*
|
||
* Return: Success: 0
|
||
*
|
||
* Failure: -1
|
||
*
|
||
* Programmer: Raymond Lu
|
||
* October 15, 2002
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static herr_t
|
||
test_compound_dtype(hid_t file)
|
||
{
|
||
typedef struct {
|
||
char c;
|
||
unsigned int i;
|
||
long_long l;
|
||
} s1;
|
||
hid_t dataset, space;
|
||
hid_t dtype, native_type, tid, tid2;
|
||
int i, j, n;
|
||
hsize_t dims[2];
|
||
s1 *temp_point, *temp_check;
|
||
s1 *points, *check;
|
||
void *tmp;
|
||
|
||
TESTING("compound datatype");
|
||
|
||
|
||
/* Allocate space for the points & check arrays */
|
||
if((points=malloc(sizeof(s1)*100*200))==NULL)
|
||
TEST_ERROR;
|
||
if((check=calloc(sizeof(s1),100*200))==NULL)
|
||
TEST_ERROR;
|
||
|
||
/* Initialize the dataset */
|
||
for (i = n = 0, temp_point=points; i < 100; i++) {
|
||
for (j = 0; j < 200; j++,temp_point++) {
|
||
temp_point->c = 't';
|
||
temp_point->i = n++;
|
||
temp_point->l = (i*10+j*100)*n;
|
||
}
|
||
}
|
||
|
||
/* Create the data space */
|
||
dims[0] = 100;
|
||
dims[1] = 200;
|
||
if ((space = H5Screate_simple(2, dims, NULL))<0) TEST_ERROR;
|
||
|
||
/* Create compound datatype for disk storage */
|
||
if((tid=H5Tcreate(H5T_COMPOUND, sizeof(s1)))<0) TEST_ERROR;
|
||
|
||
/* Insert members */
|
||
if(H5Tinsert(tid, "c", 0, H5T_STD_U8LE)<0) TEST_ERROR;
|
||
if(H5Tinsert(tid, "i", 1, H5T_STD_U32LE)<0) TEST_ERROR;
|
||
if(H5Tinsert(tid, "l", 5, H5T_STD_I64BE)<0) TEST_ERROR;
|
||
|
||
/* Create the dataset */
|
||
if ((dataset = H5Dcreate(file, DSET_COMPOUND_NAME, tid, space,
|
||
H5P_DEFAULT))<0) TEST_ERROR;
|
||
|
||
/* Create compound datatype for datatype in memory */
|
||
if((tid2=H5Tcreate(H5T_COMPOUND, sizeof(s1)))<0) TEST_ERROR;
|
||
if(H5Tinsert(tid2, "c", HOFFSET(s1, c), H5T_NATIVE_UCHAR)<0) TEST_ERROR;
|
||
if(H5Tinsert(tid2, "i", HOFFSET(s1, i), H5T_NATIVE_UINT)<0) TEST_ERROR;
|
||
if(H5Tinsert(tid2, "l", HOFFSET(s1, l), H5T_NATIVE_LLONG)<0) TEST_ERROR;
|
||
|
||
/* Write the data to the dataset */
|
||
if (H5Dwrite(dataset, tid2, H5S_ALL, H5S_ALL, H5P_DEFAULT, points)<0)
|
||
TEST_ERROR;
|
||
|
||
/* Close dataset */
|
||
if(H5Dclose(dataset)<0) TEST_ERROR;
|
||
|
||
/* Close dataspace */
|
||
if(H5Sclose(space)<0) TEST_ERROR;
|
||
|
||
|
||
/* Open dataset again to check H5Tget_native_type */
|
||
if((dataset=H5Dopen(file, DSET_COMPOUND_NAME))<0) TEST_ERROR;
|
||
|
||
if((dtype=H5Dget_type(dataset))<0) TEST_ERROR;
|
||
|
||
if((native_type=H5Tget_native_type(dtype, H5T_DIR_DEFAULT))<0)
|
||
TEST_ERROR;
|
||
|
||
if(H5Tget_size(native_type) < H5Tget_size(tid2))
|
||
TEST_ERROR;
|
||
if(!H5Tequal(native_type, tid2))
|
||
TEST_ERROR;
|
||
|
||
/* Read the dataset back. Temporary buffer is for special platforms like
|
||
* Cray */
|
||
tmp = malloc(dims[0]*dims[1]*H5Tget_size(native_type));
|
||
|
||
if (H5Dread(dataset, native_type, H5S_ALL, H5S_ALL, H5P_DEFAULT, tmp)<0)
|
||
TEST_ERROR;
|
||
|
||
memcpy(check, tmp, dims[0]*dims[1]*H5Tget_size(native_type));
|
||
free(tmp);
|
||
|
||
if (H5Tconvert(native_type, tid2, dims[0]*dims[1], check, NULL, H5P_DEFAULT)<0)
|
||
TEST_ERROR;
|
||
|
||
/* Check that the values read are the same as the values written */
|
||
for (i = 0, temp_point=points, temp_check=check; i < 100; i++) {
|
||
for (j = 0; j < 200; j++, temp_point++,temp_check++) {
|
||
if (temp_point->c != temp_check->c ||
|
||
temp_point->i != temp_check->i ||
|
||
temp_point->l != temp_check->l ) {
|
||
H5_FAILED();
|
||
printf(" Read different values than written.\n");
|
||
printf(" At index %d,%d\n", i, j);
|
||
goto error;
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Close datatype */
|
||
if(H5Tclose(tid)<0) TEST_ERROR;
|
||
|
||
H5Dclose(dataset);
|
||
H5Tclose(dtype);
|
||
H5Tclose(native_type);
|
||
H5Tclose(tid2);
|
||
|
||
/* Free memory for test data */
|
||
free(points);
|
||
free(check);
|
||
|
||
PASSED();
|
||
return 0;
|
||
|
||
error:
|
||
return -1;
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: test_compound_dtype3
|
||
*
|
||
* Purpose: Test H5Tget_native_type for compound datatype
|
||
*
|
||
* Return: Success: 0
|
||
*
|
||
* Failure: -1
|
||
*
|
||
* Programmer: Raymond Lu
|
||
* October 15, 2002
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static herr_t
|
||
test_compound_dtype3(hid_t file)
|
||
{
|
||
typedef struct {
|
||
char c;
|
||
int a[5];
|
||
long_long l;
|
||
} s1;
|
||
hid_t dataset, space;
|
||
hid_t dtype, native_type, tid, tid2, tid_m, tid_m2;
|
||
hsize_t array_dims[1]={5};
|
||
int i, j, k, n;
|
||
hsize_t dims[2];
|
||
s1 *temp_point, *temp_check;
|
||
s1 *points=NULL, *check=NULL;
|
||
void *tmp;
|
||
|
||
TESTING("compound datatype");
|
||
|
||
/* Allocate space for the points & check arrays */
|
||
if((points=malloc(sizeof(s1)*100*200))==NULL)
|
||
TEST_ERROR;
|
||
if((check=calloc(sizeof(s1),100*200))==NULL)
|
||
TEST_ERROR;
|
||
|
||
/* Initialize the dataset */
|
||
for (i = n = 0, temp_point=points; i < 100; i++) {
|
||
for (j = 0; j < 200; j++,temp_point++) {
|
||
temp_point->c = 't';
|
||
temp_point->l = (i*10+j*100)*n;
|
||
for (k = 0; k < 5; k++)
|
||
(temp_point->a)[k] = n++;
|
||
}
|
||
}
|
||
|
||
/* Create the data space */
|
||
dims[0] = 100;
|
||
dims[1] = 200;
|
||
if ((space = H5Screate_simple(2, dims, NULL))<0) TEST_ERROR;
|
||
|
||
/* Create array datatype */
|
||
if((tid2=H5Tarray_create(H5T_STD_I32LE, 1, array_dims, NULL))<0) TEST_ERROR;
|
||
|
||
/* Create compound datatype for disk storage */
|
||
if((tid=H5Tcreate(H5T_COMPOUND, 29))<0) TEST_ERROR;
|
||
|
||
/* Insert members */
|
||
if(H5Tinsert(tid, "c", 0, H5T_STD_U8LE)<0) TEST_ERROR;
|
||
if(H5Tinsert(tid, "a", 1, tid2)<0) TEST_ERROR;
|
||
if(H5Tinsert(tid, "l", 21, H5T_STD_I64BE)<0) TEST_ERROR;
|
||
|
||
/* Create the dataset */
|
||
if ((dataset = H5Dcreate(file, DSET_COMPOUND_NAME_3, tid, space,
|
||
H5P_DEFAULT))<0) TEST_ERROR;
|
||
|
||
/* Create array datatype */
|
||
if((tid_m2=H5Tarray_create(H5T_NATIVE_INT, 1, array_dims, NULL))<0) TEST_ERROR;
|
||
|
||
/* Create compound datatype for datatype in memory */
|
||
if((tid_m=H5Tcreate(H5T_COMPOUND, sizeof(s1)))<0) TEST_ERROR;
|
||
if(H5Tinsert(tid_m, "c", HOFFSET(s1, c), H5T_NATIVE_UCHAR)<0) TEST_ERROR;
|
||
if(H5Tinsert(tid_m, "a", HOFFSET(s1, a), tid_m2)<0) TEST_ERROR;
|
||
if(H5Tinsert(tid_m, "l", HOFFSET(s1, l), H5T_NATIVE_LLONG)<0) TEST_ERROR;
|
||
|
||
/* Write the data to the dataset */
|
||
if (H5Dwrite(dataset, tid_m, H5S_ALL, H5S_ALL, H5P_DEFAULT, points)<0)
|
||
TEST_ERROR;
|
||
|
||
/* Close dataset */
|
||
if(H5Dclose(dataset)<0) TEST_ERROR;
|
||
|
||
/* Close datatype */
|
||
if(H5Tclose(tid)<0) TEST_ERROR;
|
||
if(H5Tclose(tid2)<0) TEST_ERROR;
|
||
|
||
/* Close dataspace */
|
||
if(H5Sclose(space)<0) TEST_ERROR;
|
||
|
||
|
||
/* Open dataset again to check H5Tget_native_type */
|
||
if((dataset=H5Dopen(file, DSET_COMPOUND_NAME_3))<0) TEST_ERROR;
|
||
|
||
if((dtype=H5Dget_type(dataset))<0) TEST_ERROR;
|
||
|
||
if((native_type=H5Tget_native_type(dtype, H5T_DIR_DEFAULT))<0)
|
||
TEST_ERROR;
|
||
|
||
if(H5Tget_size(native_type) != H5Tget_size(tid_m))
|
||
TEST_ERROR;
|
||
if(!H5Tequal(native_type, tid_m))
|
||
TEST_ERROR;
|
||
|
||
/* Read the dataset back. Temporary buffer is for special platforms like
|
||
* Cray */
|
||
tmp = malloc(dims[0]*dims[1]*H5Tget_size(native_type));
|
||
|
||
if (H5Dread(dataset, native_type, H5S_ALL, H5S_ALL, H5P_DEFAULT, tmp)<0)
|
||
TEST_ERROR;
|
||
|
||
memcpy(check, tmp, dims[0]*dims[1]*H5Tget_size(native_type));
|
||
free(tmp);
|
||
|
||
if (H5Tconvert(native_type, tid_m, dims[0]*dims[1], check, NULL, H5P_DEFAULT))
|
||
TEST_ERROR;
|
||
|
||
/* Check that the values read are the same as the values written */
|
||
for (i = 0, temp_point=points, temp_check=check; i < 100; i++) {
|
||
for (j = 0; j < 200; j++, temp_point++,temp_check++) {
|
||
if (temp_point->c != temp_check->c ||
|
||
temp_point->l != temp_check->l ) {
|
||
H5_FAILED();
|
||
printf(" Read different values than written.\n");
|
||
printf(" At index %d,%d\n", i, j);
|
||
goto error;
|
||
}
|
||
|
||
for (k = 0; k < 5; k++) {
|
||
if(temp_point->a[k] != temp_check->a[k]) {
|
||
H5_FAILED();
|
||
printf(" Read different values than written.\n");
|
||
printf(" At index %d,%d\n", i, j);
|
||
goto error;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
H5Dclose(dataset);
|
||
H5Tclose(dtype);
|
||
H5Tclose(native_type);
|
||
H5Tclose(tid_m);
|
||
H5Tclose(tid_m2);
|
||
|
||
/* Free memory for test data */
|
||
free(points);
|
||
free(check);
|
||
|
||
PASSED();
|
||
return 0;
|
||
|
||
error:
|
||
return -1;
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: test_enum_dtype
|
||
*
|
||
* Purpose: Test H5Tget_native_type for enumerate datatype
|
||
*
|
||
* Return: Success: 0
|
||
*
|
||
* Failure: -1
|
||
*
|
||
* Programmer: Raymond Lu
|
||
* October 15, 2002
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static herr_t
|
||
test_enum_dtype(hid_t file)
|
||
{
|
||
hid_t dataset, space;
|
||
hid_t tid, tid_m, dtype, native_type;
|
||
int i, j, n;
|
||
hsize_t dims[2];
|
||
void *tmp;
|
||
short colors[8];
|
||
const char *mname[] = { "RED",
|
||
"GREEN",
|
||
"BLUE",
|
||
"YELLOW",
|
||
"PINK",
|
||
"PURPLE",
|
||
"ORANGE",
|
||
"WHITE" };
|
||
|
||
TESTING("enum datatype");
|
||
|
||
/* Initialize the dataset */
|
||
for (i = 0; i < 100; i++) {
|
||
for (j=0, n=0; j < 200; j++, n++)
|
||
spoints2[i][j] = (i*10+j*100+n)%8;
|
||
}
|
||
|
||
/* Create the data space */
|
||
dims[0] = 100;
|
||
dims[1] = 200;
|
||
if ((space = H5Screate_simple(2, dims, NULL))<0) TEST_ERROR;
|
||
|
||
/* Construct enum type based on native type */
|
||
if((tid=H5Tenum_create(H5T_STD_I16LE))<0) TEST_ERROR;
|
||
|
||
for (i = 0; i < 8; i++) {
|
||
colors[i] = i;
|
||
|
||
if(H5Tenum_insert(tid, mname[i], &(colors[i]))<0) TEST_ERROR;
|
||
}
|
||
|
||
/* Create the dataset */
|
||
if ((dataset = H5Dcreate(file, DSET_ENUM_NAME, tid, space,
|
||
H5P_DEFAULT))<0) TEST_ERROR;
|
||
|
||
/* Construct enum type based on native type in memory */
|
||
if((tid_m=H5Tenum_create(H5T_NATIVE_SHORT))<0) TEST_ERROR;
|
||
|
||
for (i = 0; i < 8; i++) {
|
||
colors[i] = i;
|
||
if(H5Tenum_insert(tid_m, mname[i], &(colors[i]))<0) TEST_ERROR;
|
||
}
|
||
|
||
/* Write the data to the dataset */
|
||
if (H5Dwrite(dataset, tid_m, H5S_ALL, H5S_ALL, H5P_DEFAULT, spoints2)<0)
|
||
TEST_ERROR;
|
||
|
||
/* Close dataset */
|
||
if(H5Dclose(dataset)<0) TEST_ERROR;
|
||
|
||
/* Close datatype */
|
||
if(H5Tclose(tid)<0) TEST_ERROR;
|
||
|
||
/* Close dataspace */
|
||
if(H5Sclose(space)<0) TEST_ERROR;
|
||
|
||
/* Open dataset again to check H5Tget_native_type */
|
||
if((dataset=H5Dopen(file, DSET_ENUM_NAME))<0) TEST_ERROR;
|
||
|
||
if((dtype=H5Dget_type(dataset))<0) TEST_ERROR;
|
||
|
||
if((native_type=H5Tget_native_type(dtype, H5T_DIR_DEFAULT))<0)
|
||
TEST_ERROR;
|
||
|
||
if(!H5Tequal(native_type, tid_m))
|
||
TEST_ERROR;
|
||
|
||
/* Read the dataset back. Temporary buffer is for special platforms like
|
||
* Cray */
|
||
tmp = malloc(dims[0]*dims[1]*H5Tget_size(native_type));
|
||
|
||
if (H5Dread(dataset, native_type, H5S_ALL, H5S_ALL, H5P_DEFAULT, tmp)<0)
|
||
TEST_ERROR;
|
||
|
||
memcpy(scheck2, tmp, dims[0]*dims[1]*H5Tget_size(native_type));
|
||
free(tmp);
|
||
|
||
if (H5Tconvert(native_type, tid_m, dims[0]*dims[1], scheck2, NULL, H5P_DEFAULT)<0)
|
||
TEST_ERROR;
|
||
|
||
/* Check that the values read are the same as the values written */
|
||
for (i = 0; i < 100; i++) {
|
||
for (j = 0; j < 200; j++) {
|
||
if (spoints2[i][j] != scheck2[i][j]) {
|
||
H5_FAILED();
|
||
printf(" Read different values than written.\n");
|
||
printf(" At index %d,%d\n", i, j);
|
||
goto error;
|
||
}
|
||
}
|
||
}
|
||
|
||
H5Dclose(dataset);
|
||
H5Tclose(dtype);
|
||
H5Tclose(native_type);
|
||
H5Tclose(tid_m);
|
||
PASSED();
|
||
return 0;
|
||
|
||
error:
|
||
return -1;
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: test_array_dtype
|
||
*
|
||
* Purpose: Test H5Tget_native_type for array datatype
|
||
*
|
||
* Return: Success: 0
|
||
*
|
||
* Failure: -1
|
||
*
|
||
* Programmer: Raymond Lu
|
||
* October 15, 2002
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static herr_t
|
||
test_array_dtype(hid_t file)
|
||
{
|
||
typedef struct {
|
||
char c;
|
||
int i;
|
||
long_long l;
|
||
} s1;
|
||
hid_t dataset, space;
|
||
hid_t dtype, native_type, tid, tid2, tid3, tid_m;
|
||
int i, j, k, n;
|
||
hsize_t space_dims[2], array_dims[1]={5};
|
||
s1 *temp_point, *temp_check;
|
||
s1 *points=NULL, *check=NULL;
|
||
void *tmp;
|
||
|
||
TESTING("array of compound datatype");
|
||
|
||
/* Allocate space for the points & check arrays */
|
||
if((points=malloc(sizeof(s1)*100*200*5))==NULL)
|
||
TEST_ERROR;
|
||
if((check=calloc(sizeof(s1),100*200*5))==NULL)
|
||
TEST_ERROR;
|
||
|
||
/* Initialize the dataset */
|
||
for(i = n = 0, temp_point=points; i < 100; i++)
|
||
for(j = 0; j < 200; j++)
|
||
for(k = 0; k < 5; k++,temp_point++) {
|
||
temp_point->c= 't';
|
||
temp_point->i= n++;
|
||
temp_point->l= (i*10+j*100)*n;
|
||
}
|
||
|
||
/* Create the data space */
|
||
space_dims[0] = 100;
|
||
space_dims[1] = 200;
|
||
if ((space = H5Screate_simple(2, space_dims, NULL))<0) TEST_ERROR;
|
||
|
||
/* Create compound datatype for disk storage */
|
||
if((tid2=H5Tcreate(H5T_COMPOUND, 13))<0) TEST_ERROR;
|
||
|
||
/* Insert members */
|
||
if(H5Tinsert(tid2, "c", 0, H5T_STD_U8BE)<0) TEST_ERROR;
|
||
if(H5Tinsert(tid2, "i", 1, H5T_STD_U32LE)<0) TEST_ERROR;
|
||
if(H5Tinsert(tid2, "l", 5, H5T_STD_I64BE)<0) TEST_ERROR;
|
||
|
||
/* Create array datatype for disk storage */
|
||
if((tid=H5Tarray_create(tid2, 1, array_dims, NULL))<0) TEST_ERROR;
|
||
|
||
/* Create the dataset */
|
||
if ((dataset = H5Dcreate(file, DSET_ARRAY_NAME, tid, space,
|
||
H5P_DEFAULT))<0) TEST_ERROR;
|
||
|
||
/* Create compound datatype for datatype in memory */
|
||
if((tid3=H5Tcreate(H5T_COMPOUND, sizeof(s1)))<0) TEST_ERROR;
|
||
if(H5Tinsert(tid3, "c", HOFFSET(s1, c), H5T_NATIVE_UCHAR)<0) TEST_ERROR;
|
||
if(H5Tinsert(tid3, "i", HOFFSET(s1, i), H5T_NATIVE_UINT)<0) TEST_ERROR;
|
||
if(H5Tinsert(tid3, "l", HOFFSET(s1, l), H5T_NATIVE_LLONG)<0) TEST_ERROR;
|
||
|
||
/* Create array datatype for memory */
|
||
if((tid_m=H5Tarray_create(tid3, 1, array_dims, NULL))<0) TEST_ERROR;
|
||
|
||
/* Write the data to the dataset */
|
||
if (H5Dwrite(dataset, tid_m, H5S_ALL, H5S_ALL, H5P_DEFAULT, points)<0)
|
||
TEST_ERROR;
|
||
|
||
/* Close dataset */
|
||
if(H5Dclose(dataset)<0) TEST_ERROR;
|
||
|
||
/* Close datatype */
|
||
if(H5Tclose(tid)<0) TEST_ERROR;
|
||
if(H5Tclose(tid2)<0) TEST_ERROR;
|
||
|
||
/* Close dataspace */
|
||
if(H5Sclose(space)<0) TEST_ERROR;
|
||
|
||
/* Open dataset again to check H5Tget_native_type */
|
||
if((dataset=H5Dopen(file, DSET_ARRAY_NAME))<0) TEST_ERROR;
|
||
|
||
if((dtype=H5Dget_type(dataset))<0) TEST_ERROR;
|
||
|
||
if((native_type=H5Tget_native_type(dtype, H5T_DIR_DEFAULT))<0)
|
||
TEST_ERROR;
|
||
|
||
if(!H5Tequal(tid_m, native_type)) TEST_ERROR;
|
||
|
||
/* Read the dataset back. Temporary buffer is for special platforms like
|
||
* Cray */
|
||
tmp = malloc(space_dims[0]*space_dims[1]*H5Tget_size(native_type));
|
||
|
||
if (H5Dread(dataset, native_type, H5S_ALL, H5S_ALL, H5P_DEFAULT, tmp)<0)
|
||
TEST_ERROR;
|
||
|
||
memcpy(check, tmp, space_dims[0]*space_dims[1]*H5Tget_size(native_type));
|
||
free(tmp);
|
||
|
||
if (H5Tconvert(native_type, tid_m, space_dims[0]*space_dims[1], check,
|
||
NULL, H5P_DEFAULT)<0)
|
||
TEST_ERROR;
|
||
|
||
/* Check that the values read are the same as the values written */
|
||
for (i = 0, temp_point=points, temp_check=check; i < 100; i++) {
|
||
for (j = 0; j < 200; j++) {
|
||
for (k = 0; k < 5; k++, temp_point++,temp_check++) {
|
||
if (temp_point->c != temp_check->c ||
|
||
temp_point->i != temp_check->i ||
|
||
temp_point->l != temp_check->l ) {
|
||
H5_FAILED();
|
||
printf(" Read different values than written.\n");
|
||
printf(" At index %d,%d\n", i, j);
|
||
goto error;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Close HDF5 objects */
|
||
if(H5Dclose(dataset)) TEST_ERROR;
|
||
if(H5Tclose(native_type)) TEST_ERROR;
|
||
if(H5Tclose(dtype)) TEST_ERROR;
|
||
if(H5Tclose(tid_m)<0) TEST_ERROR;
|
||
if(H5Tclose(tid3)<0) TEST_ERROR;
|
||
|
||
/* Free memory for test data */
|
||
free(points);
|
||
free(check);
|
||
|
||
PASSED();
|
||
return 0;
|
||
|
||
error:
|
||
if(points!=NULL)
|
||
free(points);
|
||
if(check!=NULL)
|
||
free(check);
|
||
return -1;
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: test_array_dtype2
|
||
*
|
||
* Purpose: Test H5Tget_native_type for array datatype
|
||
*
|
||
* Return: Success: 0
|
||
*
|
||
* Failure: -1
|
||
*
|
||
* Programmer: Raymond Lu
|
||
* October 15, 2002
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static herr_t
|
||
test_array_dtype2(hid_t file)
|
||
{
|
||
hid_t dataset, space;
|
||
hid_t dtype, native_type, tid, tid_m;
|
||
int i, j, k, n;
|
||
hsize_t space_dims[2], array_dims[1]={5};
|
||
void *tmp;
|
||
|
||
TESTING("array of atomic datatype");
|
||
|
||
/* Initialize the dataset */
|
||
for(i = n = 0;i < 100; i++)
|
||
for(j = 0; j < 200; j++)
|
||
for(k = 0; k < 5; k++)
|
||
ipoints3[i][j][k] = n++;
|
||
|
||
/* Create the data space */
|
||
space_dims[0] = 100;
|
||
space_dims[1] = 200;
|
||
if ((space = H5Screate_simple(2, space_dims, NULL))<0) TEST_ERROR;
|
||
|
||
/* Create array datatype for disk storage */
|
||
if((tid=H5Tarray_create(H5T_STD_I32LE, 1, array_dims, NULL))<0) TEST_ERROR;
|
||
|
||
/* Create the dataset */
|
||
if ((dataset = H5Dcreate(file, DSET_ARRAY2_NAME, tid, space,
|
||
H5P_DEFAULT))<0) TEST_ERROR;
|
||
|
||
/* Create array datatype for memory */
|
||
if((tid_m=H5Tarray_create(H5T_NATIVE_INT, 1, array_dims, NULL))<0) TEST_ERROR;
|
||
|
||
/* Write the data to the dataset */
|
||
if (H5Dwrite(dataset, tid_m, H5S_ALL, H5S_ALL, H5P_DEFAULT, ipoints3)<0)
|
||
TEST_ERROR;
|
||
|
||
/* Close dataset */
|
||
if(H5Dclose(dataset)<0) TEST_ERROR;
|
||
|
||
/* Close datatype */
|
||
if(H5Tclose(tid)<0) TEST_ERROR;
|
||
|
||
/* Close dataspace */
|
||
if(H5Sclose(space)<0) TEST_ERROR;
|
||
|
||
|
||
/* Open dataset again to check H5Tget_native_type */
|
||
if((dataset=H5Dopen(file, DSET_ARRAY2_NAME))<0) TEST_ERROR;
|
||
|
||
if((dtype=H5Dget_type(dataset))<0) TEST_ERROR;
|
||
|
||
if((native_type=H5Tget_native_type(dtype, H5T_DIR_DEFAULT))<0)
|
||
TEST_ERROR;
|
||
|
||
if(!H5Tequal(tid_m, native_type)) TEST_ERROR;
|
||
|
||
/* Read the dataset back. Temporary buffer is for special platforms like
|
||
* Cray */
|
||
tmp = malloc(space_dims[0]*space_dims[1]*H5Tget_size(native_type));
|
||
|
||
if (H5Dread(dataset, native_type, H5S_ALL, H5S_ALL, H5P_DEFAULT, tmp)<0)
|
||
TEST_ERROR;
|
||
|
||
memcpy(icheck3, tmp, space_dims[0]*space_dims[1]*H5Tget_size(native_type));
|
||
free(tmp);
|
||
|
||
if (H5Tconvert(native_type, tid_m, space_dims[0]*space_dims[1], icheck3, NULL,
|
||
H5P_DEFAULT)<0)
|
||
TEST_ERROR;
|
||
|
||
/* Check that the values read are the same as the values written */
|
||
for (i = 0; i < 100; i++) {
|
||
for (j = 0; j < 200; j++) {
|
||
for (k = 0; k < 5; k++) {
|
||
if(icheck3[i][j][k] != ipoints3[i][j][k]) {
|
||
H5_FAILED();
|
||
printf(" Read different values than written.\n");
|
||
printf(" At index %d,%d\n", i, j);
|
||
goto error;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Close HDF5 objects */
|
||
if(H5Dclose(dataset)) TEST_ERROR;
|
||
if(H5Tclose(native_type)) TEST_ERROR;
|
||
if(H5Tclose(dtype)) TEST_ERROR;
|
||
if(H5Tclose(tid_m)<0) TEST_ERROR;
|
||
|
||
PASSED();
|
||
return 0;
|
||
|
||
error:
|
||
return -1;
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: test_vl_dtype
|
||
*
|
||
* Purpose: Test H5Tget_native_type for variable length datatype
|
||
*
|
||
* Return: Success: 0
|
||
*
|
||
* Failure: -1
|
||
*
|
||
* Programmer: Raymond Lu
|
||
* October 15, 2002
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static herr_t
|
||
test_vl_dtype(hid_t file)
|
||
{
|
||
hvl_t wdata[SPACE1_DIM1]; /* Information to write */
|
||
hvl_t rdata[SPACE1_DIM1]; /* Information read in */
|
||
hvl_t *t1, *t2; /* Temporary pointer to VL information */
|
||
hsize_t dims1[] = {SPACE1_DIM1};
|
||
hid_t dataset, space;
|
||
hid_t dtype, native_type, tid, tid2, tid_m, tid_m2;
|
||
size_t i, j, k;
|
||
|
||
TESTING("variable length datatype");
|
||
|
||
/* Allocate and initialize VL data to write */
|
||
for(i=0; i<SPACE1_DIM1; i++) {
|
||
wdata[i].p=malloc((i+1)*sizeof(hvl_t));
|
||
if(wdata[i].p==NULL) {
|
||
H5_FAILED();
|
||
printf(" Cannot allocate memory for VL data! i=%u\n",(unsigned)i);
|
||
goto error;
|
||
} /* end if */
|
||
wdata[i].len=i+1;
|
||
for(t1=wdata[i].p,j=0; j<(i+1); j++, t1++) {
|
||
t1->p=malloc((j+1)*sizeof(unsigned int));
|
||
if(t1->p==NULL) {
|
||
H5_FAILED();
|
||
printf(" Cannot allocate memory for VL data! i=%u, j=%u\n",(unsigned)i,(unsigned)j);
|
||
goto error;
|
||
} /* end if */
|
||
t1->len=j+1;
|
||
for(k=0; k<(j+1); k++)
|
||
((unsigned int *)t1->p)[k]=(unsigned int)(i*100+j*10+k);
|
||
} /* end for */
|
||
} /* end for */
|
||
|
||
/* Create dataspace for datasets */
|
||
if((space = H5Screate_simple(SPACE1_RANK, dims1, NULL))<0) TEST_ERROR;
|
||
|
||
/* Create the base VL type */
|
||
if((tid2 = H5Tvlen_create (H5T_STD_U32LE))<0) TEST_ERROR;
|
||
|
||
/* Create a VL datatype for disk storage */
|
||
tid = H5Tvlen_create (tid2);
|
||
|
||
/* Create a dataset */
|
||
if((dataset=H5Dcreate(file, DSET_VL_NAME, tid, space, H5P_DEFAULT))<0)
|
||
TEST_ERROR;
|
||
|
||
/* Create a base VL datatype for memory */
|
||
if((tid_m2 = H5Tvlen_create (H5T_NATIVE_UINT))<0) TEST_ERROR;
|
||
|
||
/* Create a VL datatype for memory */
|
||
if((tid_m = H5Tvlen_create (tid_m2))<0) TEST_ERROR;
|
||
|
||
/* Write dataset to disk */
|
||
if(H5Dwrite(dataset,tid_m,H5S_ALL,H5S_ALL,H5P_DEFAULT,wdata)<0) TEST_ERROR;
|
||
|
||
/* Close Dataset */
|
||
if(H5Dclose(dataset)<0) TEST_ERROR;
|
||
|
||
/* Close datatype */
|
||
if(H5Tclose(tid2)<0) TEST_ERROR;
|
||
if(H5Tclose(tid)<0) TEST_ERROR;
|
||
|
||
/* Open a dataset */
|
||
if((dataset=H5Dopen(file, DSET_VL_NAME))<0) TEST_ERROR;
|
||
|
||
/* Get datatype for dataset */
|
||
if((dtype = H5Dget_type(dataset))<0) TEST_ERROR;
|
||
|
||
if((native_type=H5Tget_native_type(dtype, H5T_DIR_DEFAULT))<0)
|
||
TEST_ERROR;
|
||
|
||
if(!H5Tequal(native_type, tid_m))
|
||
TEST_ERROR;
|
||
|
||
/* Read dataset from disk */
|
||
if(H5Dread(dataset,native_type,H5S_ALL,H5S_ALL,H5P_DEFAULT,rdata)<0) TEST_ERROR;
|
||
|
||
/* Compare data read in */
|
||
for(i=0; i<SPACE1_DIM1; i++) {
|
||
if(wdata[i].len!=rdata[i].len) {
|
||
H5_FAILED();
|
||
printf(" VL data length don't match!, wdata[%d].len=%d, rdata[%d].len=%d\n",(int)i,(int)wdata[i].len,(int)i,(int)rdata[i].len);
|
||
goto error;
|
||
} /* end if */
|
||
for(t1=wdata[i].p, t2=rdata[i].p, j=0; j<rdata[i].len; j++, t1++, t2++) {
|
||
if(t1->len!=t2->len) {
|
||
H5_FAILED();
|
||
printf(" VL data length don't match!, wdata[%d].len=%d, rdata[%d].len=%d\n",(int)i,(int)wdata[i].len,(int)i,(int)rdata[i].len);
|
||
goto error;
|
||
} /* end if */
|
||
for(k=0; k<t2->len; k++) {
|
||
if( ((unsigned int *)t1->p)[k] != ((unsigned int *)t2->p)[k] ) {
|
||
H5_FAILED();
|
||
printf(" VL data length don't match!, wdata[%d].len=%d, rdata[%d].len=%d\n",(int)i,(int)wdata[i].len,(int)i,(int)rdata[i].len);
|
||
goto error;
|
||
}
|
||
} /* end for */
|
||
} /* end for */
|
||
} /* end for */
|
||
|
||
/* Reclaim the read VL data */
|
||
if(H5Dvlen_reclaim(native_type,space,H5P_DEFAULT,rdata)<0) TEST_ERROR;
|
||
|
||
/* Reclaim the write VL data */
|
||
if(H5Dvlen_reclaim(native_type,space,H5P_DEFAULT,wdata)<0) TEST_ERROR;
|
||
|
||
/* Close Dataset */
|
||
if(H5Dclose(dataset)<0) TEST_ERROR;
|
||
|
||
/* Close datatype */
|
||
if(H5Tclose(native_type)<0) TEST_ERROR;
|
||
if(H5Tclose(dtype)<0) TEST_ERROR;
|
||
if(H5Tclose(tid_m)<0) TEST_ERROR;
|
||
if(H5Tclose(tid_m2)<0) TEST_ERROR;
|
||
|
||
|
||
/* Close disk dataspace */
|
||
if(H5Sclose(space)<0) TEST_ERROR;
|
||
|
||
PASSED();
|
||
return 0;
|
||
|
||
error:
|
||
return -1;
|
||
} /* end test_vl_type() */
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: test_vlstr_dtype
|
||
*
|
||
* Purpose: Test H5Tget_native_type for variable length string datatype
|
||
*
|
||
* Return: Success: 0
|
||
*
|
||
* Failure: -1
|
||
*
|
||
* Programmer: Raymond Lu
|
||
* October 15, 2002
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static herr_t
|
||
test_vlstr_dtype(hid_t file)
|
||
{
|
||
const char *wdata[SPACE1_DIM1]= {
|
||
"Four score and seven years ago our forefathers brought forth on this continent a new nation,",
|
||
"conceived in liberty and dedicated to the proposition that all men are created equal.",
|
||
"Now we are engaged in a great civil war,",
|
||
"testing whether that nation or any nation so conceived and so dedicated can long endure."
|
||
}; /* Information to write */
|
||
char *rdata[SPACE1_DIM1]; /* Information read in */
|
||
hid_t dataset; /* Dataset ID */
|
||
hid_t sid1; /* Dataspace ID */
|
||
hid_t tid1,dtype,native_type; /* Datatype ID */
|
||
hsize_t dims1[] = {SPACE1_DIM1};
|
||
unsigned i; /* counting variable */
|
||
|
||
/* Output message about test being performed */
|
||
TESTING("variable length string datatype");
|
||
|
||
/* Create dataspace for datasets */
|
||
if((sid1 = H5Screate_simple(SPACE1_RANK, dims1, NULL))<0) TEST_ERROR;
|
||
|
||
/* Create a datatype to refer to */
|
||
if((tid1 = H5Tcopy (H5T_C_S1))<0) TEST_ERROR;
|
||
|
||
if(H5Tset_size (tid1,H5T_VARIABLE)<0) TEST_ERROR;
|
||
if(H5T_STRING!=H5Tget_class(tid1) || !H5Tis_variable_str(tid1))
|
||
TEST_ERROR;
|
||
|
||
/* Create a dataset */
|
||
if((dataset=H5Dcreate(file,DSET_VLSTR_NAME,tid1,sid1,H5P_DEFAULT))<0) TEST_ERROR;
|
||
|
||
/* Write dataset to disk */
|
||
if(H5Dwrite(dataset,tid1,H5S_ALL,H5S_ALL,H5P_DEFAULT,wdata)<0) TEST_ERROR;
|
||
|
||
/* Close Dataset */
|
||
if(H5Dclose(dataset)<0) TEST_ERROR;
|
||
|
||
/* Open a dataset */
|
||
if((dataset=H5Dopen(file, DSET_VLSTR_NAME))<0) TEST_ERROR;
|
||
|
||
/* Get datatype for dataset */
|
||
if((dtype = H5Dget_type(dataset))<0) TEST_ERROR;
|
||
|
||
/* Construct native type */
|
||
if((native_type=H5Tget_native_type(dtype, H5T_DIR_DEFAULT))<0)
|
||
TEST_ERROR;
|
||
|
||
/* Check if the data type is equal */
|
||
if(!H5Tequal(native_type, tid1))
|
||
TEST_ERROR;
|
||
|
||
/* Read dataset from disk */
|
||
if(H5Dread(dataset,native_type,H5S_ALL,H5S_ALL,H5P_DEFAULT,rdata)<0) TEST_ERROR;
|
||
|
||
/* Compare data read in */
|
||
for(i=0; i<SPACE1_DIM1; i++) {
|
||
if(strlen(wdata[i])!=strlen(rdata[i])) {
|
||
H5_FAILED();
|
||
printf(" VL data length don't match!, strlen(wdata[%d])=%d, strlen(rdata[%d])=%d\n",
|
||
(int)i,(int)strlen(wdata[i]),(int)i,(int)strlen(rdata[i]));
|
||
goto error;
|
||
} /* end if */
|
||
if( strcmp(wdata[i],rdata[i]) != 0 ) {
|
||
H5_FAILED();
|
||
printf(" VL data values don't match!, wdata[%d]=%s, rdata[%d]=%s\n",
|
||
(int)i,wdata[i],(int)i,rdata[i]);
|
||
goto error;
|
||
} /* end if */
|
||
} /* end for */
|
||
|
||
/* Close Dataset */
|
||
if(H5Dclose(dataset)<0) TEST_ERROR;
|
||
|
||
/* Close datatype */
|
||
if(H5Tclose(tid1)<0) TEST_ERROR;
|
||
if(H5Tclose(native_type)<0) TEST_ERROR;
|
||
|
||
/* Close disk dataspace */
|
||
if(H5Sclose(sid1)<0) TEST_ERROR;
|
||
|
||
/* Free memory for rdata */
|
||
for(i=0; i<SPACE1_DIM1; i++) {
|
||
HDfree(rdata[i]);
|
||
}
|
||
|
||
PASSED();
|
||
return 0;
|
||
|
||
error:
|
||
return -1;
|
||
} /* end test_vlstr_dtype() */
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: test_refer_dtype
|
||
*
|
||
* Purpose: Test H5Tget_native_type for reference datatype
|
||
*
|
||
* Return: Success: 0
|
||
*
|
||
* Failure: -1
|
||
*
|
||
* Programmer: Raymond Lu
|
||
* October 15, 2002
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static herr_t
|
||
test_refer_dtype(hid_t file)
|
||
{
|
||
|
||
/* Compound datatype */
|
||
typedef struct s1_t {
|
||
unsigned int a;
|
||
unsigned int b;
|
||
float c;
|
||
} s1_t;
|
||
|
||
hid_t dataset; /* Dataset ID */
|
||
hid_t group; /* Group ID */
|
||
hid_t sid1; /* Dataspace ID */
|
||
hid_t tid1, dtype, native_type; /* Datatype ID */
|
||
hsize_t dims1[] = {1};
|
||
hobj_ref_t *wbuf, /* buffer to write to disk */
|
||
*rbuf; /* buffer read from disk */
|
||
|
||
/* Output message about test being performed */
|
||
TESTING("reference datatype");
|
||
|
||
/* Allocate write & read buffers */
|
||
wbuf=HDmalloc(MAX(sizeof(unsigned),sizeof(hobj_ref_t)));
|
||
rbuf=HDmalloc(MAX(sizeof(unsigned),sizeof(hobj_ref_t)));
|
||
|
||
/* Create dataspace for datasets */
|
||
if((sid1 = H5Screate_simple(SPACE1_RANK, dims1, NULL))<0)
|
||
TEST_ERROR;
|
||
|
||
/* Create a group */
|
||
if((group=H5Gcreate(file,"Group1",(size_t)-1))<0)
|
||
TEST_ERROR;
|
||
|
||
/* Create a datatype to refer to */
|
||
if((tid1 = H5Tcreate (H5T_COMPOUND, sizeof(s1_t)))<0)
|
||
TEST_ERROR;
|
||
|
||
/* Insert fields */
|
||
if(H5Tinsert (tid1, "a", HOFFSET(s1_t,a), H5T_NATIVE_INT)<0)
|
||
TEST_ERROR;
|
||
|
||
if(H5Tinsert (tid1, "b", HOFFSET(s1_t,b), H5T_NATIVE_INT)<0)
|
||
TEST_ERROR;
|
||
|
||
if(H5Tinsert (tid1, "c", HOFFSET(s1_t,c), H5T_NATIVE_FLOAT)<0)
|
||
TEST_ERROR;
|
||
|
||
/* Save datatype for later */
|
||
if(H5Tcommit (group, "Datatype1", tid1)<0)
|
||
TEST_ERROR;
|
||
|
||
/* Close datatype */
|
||
if(H5Tclose(tid1)<0)
|
||
TEST_ERROR;
|
||
|
||
/* Close group */
|
||
if(H5Gclose(group)<0)
|
||
TEST_ERROR;
|
||
|
||
/* Create a dataset */
|
||
if((dataset=H5Dcreate(file,"Dataset3",H5T_STD_REF_OBJ,sid1,H5P_DEFAULT))<0)
|
||
TEST_ERROR;
|
||
|
||
/* Create reference to named datatype */
|
||
if(H5Rcreate(wbuf,file,"/Group1/Datatype1",H5R_OBJECT,-1)<0)
|
||
TEST_ERROR;
|
||
#ifdef H5_WANT_H5_V1_4_COMPAT
|
||
if(H5Rget_object_type(dataset,wbuf)!=H5G_TYPE)
|
||
TEST_ERROR;
|
||
#else /* H5_WANT_H5_V1_4_COMPAT */
|
||
if(H5Rget_obj_type(dataset,H5R_OBJECT,wbuf)!=H5G_TYPE)
|
||
TEST_ERROR;
|
||
#endif /* H5_WANT_H5_V1_4_COMPAT */
|
||
|
||
/* Write selection to disk */
|
||
if(H5Dwrite(dataset,H5T_STD_REF_OBJ,H5S_ALL,H5S_ALL,H5P_DEFAULT,wbuf)<0)
|
||
TEST_ERROR;
|
||
|
||
/* Close disk dataspace */
|
||
if(H5Sclose(sid1)<0)
|
||
TEST_ERROR;
|
||
|
||
/* Close Dataset */
|
||
if(H5Dclose(dataset)<0)
|
||
TEST_ERROR;
|
||
|
||
|
||
/* Open the dataset */
|
||
if((dataset=H5Dopen(file,"/Dataset3"))<0)
|
||
TEST_ERROR;
|
||
|
||
/* Get datatype for dataset */
|
||
if((dtype = H5Dget_type(dataset))<0)
|
||
TEST_ERROR;
|
||
|
||
/* Construct native type */
|
||
if((native_type=H5Tget_native_type(dtype, H5T_DIR_DEFAULT))<0)
|
||
TEST_ERROR;
|
||
|
||
/* Check if the data type is equal */
|
||
if(!H5Tequal(native_type, H5T_STD_REF_OBJ))
|
||
TEST_ERROR;
|
||
|
||
/* Read selection from disk */
|
||
if(H5Dread(dataset,native_type,H5S_ALL,H5S_ALL,H5P_DEFAULT,rbuf)<0)
|
||
TEST_ERROR;
|
||
|
||
/* Open datatype object */
|
||
if((tid1 = H5Rdereference(dataset,H5R_OBJECT,rbuf))<0)
|
||
TEST_ERROR;
|
||
|
||
/* Verify correct datatype */
|
||
if(H5Tget_class(tid1)!=H5T_COMPOUND)
|
||
TEST_ERROR;
|
||
|
||
if(H5Tget_nmembers(tid1)!=3)
|
||
TEST_ERROR;
|
||
|
||
/* Close datatype */
|
||
if(H5Tclose(tid1)<0)
|
||
TEST_ERROR;
|
||
|
||
/* Close Dataset */
|
||
if(H5Dclose(dataset)<0)
|
||
TEST_ERROR;
|
||
|
||
/* Free memory buffers */
|
||
free(wbuf);
|
||
free(rbuf);
|
||
|
||
PASSED();
|
||
return 0;
|
||
|
||
error:
|
||
return -1;
|
||
} /* test_refer_dtype() */
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: test_refer_dtype2
|
||
*
|
||
* Purpose: Test H5Tget_native_type for reference
|
||
*
|
||
* Return: Success: 0
|
||
*
|
||
* Failure: -1
|
||
*
|
||
* Programmer: Raymond Lu
|
||
* October 15, 2002
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static herr_t
|
||
test_refer_dtype2(hid_t file)
|
||
{
|
||
hid_t dset1, /* Dataset ID */
|
||
dset2; /* Dereferenced dataset ID */
|
||
hid_t sid1, /* Dataspace ID #1 */
|
||
sid2; /* Dataspace ID #2 */
|
||
hid_t dtype, native_type;
|
||
hsize_t dims1[] = {1},
|
||
dims2[] = {SPACE2_DIM1, SPACE2_DIM2};
|
||
hssize_t start[SPACE2_RANK]; /* Starting location of hyperslab */
|
||
hsize_t stride[SPACE2_RANK]; /* Stride of hyperslab */
|
||
hsize_t count[SPACE2_RANK]; /* Element count of hyperslab */
|
||
hsize_t block[SPACE2_RANK]; /* Block size of hyperslab */
|
||
hdset_reg_ref_t wbuf, /* buffer to write to disk */
|
||
rbuf; /* buffer read from disk */
|
||
uint8_t *dwbuf, /* Buffer for writing numeric data to disk */
|
||
*drbuf; /* Buffer for reading numeric data from disk */
|
||
uint8_t *tu8; /* Temporary pointer to uint8 data */
|
||
int i; /* counting variables */
|
||
|
||
/* Output message about test being performed */
|
||
TESTING("dataset region reference");
|
||
|
||
/* Allocate write & read buffers */
|
||
dwbuf=malloc(sizeof(uint8_t)*SPACE2_DIM1*SPACE2_DIM2);
|
||
drbuf=calloc(sizeof(uint8_t),SPACE2_DIM1*SPACE2_DIM2);
|
||
|
||
/* Create dataspace for datasets */
|
||
if((sid2 = H5Screate_simple(SPACE2_RANK, dims2, NULL))<0)
|
||
TEST_ERROR;
|
||
|
||
/* Create a dataset */
|
||
if((dset2=H5Dcreate(file,"Dataset2",H5T_STD_U8LE,sid2,H5P_DEFAULT))<0)
|
||
TEST_ERROR;
|
||
|
||
for(tu8=dwbuf,i=0; i<SPACE2_DIM1*SPACE2_DIM2; i++)
|
||
*tu8++=i*3;
|
||
|
||
/* Write selection to disk */
|
||
if(H5Dwrite(dset2,H5T_STD_U8LE,H5S_ALL,H5S_ALL,H5P_DEFAULT,dwbuf)<0)
|
||
TEST_ERROR;
|
||
|
||
/* Close Dataset */
|
||
if(H5Dclose(dset2)<0)
|
||
TEST_ERROR;
|
||
|
||
|
||
/* Create dataspace for the reference dataset */
|
||
if((sid1=H5Screate_simple(SPACE1_RANK, dims1, NULL))<0)
|
||
TEST_ERROR;
|
||
|
||
/* Create a reference dataset */
|
||
if((dset1=H5Dcreate(file,"Dataset1",H5T_STD_REF_DSETREG,sid1,H5P_DEFAULT))<0)
|
||
TEST_ERROR;
|
||
|
||
/* Create references */
|
||
/* Select 6x6 hyperslab for first reference */
|
||
start[0]=2; start[1]=2;
|
||
stride[0]=1; stride[1]=1;
|
||
count[0]=1; count[1]=1;
|
||
block[0]=6; block[1]=6;
|
||
|
||
if(H5Sselect_hyperslab(sid2,H5S_SELECT_SET,start,stride,count,block)<0)
|
||
TEST_ERROR;
|
||
|
||
if((int)H5Sget_select_npoints(sid2) != 36)
|
||
TEST_ERROR;
|
||
|
||
/* Store first dataset region */
|
||
if(H5Rcreate(&wbuf,file,"/Dataset2",H5R_DATASET_REGION,sid2)<0)
|
||
TEST_ERROR;
|
||
if(H5Rget_obj_type(dset1,H5R_DATASET_REGION,&wbuf) != H5G_DATASET)
|
||
TEST_ERROR;
|
||
|
||
/* Write selection to disk */
|
||
if(H5Dwrite(dset1,H5T_STD_REF_DSETREG,H5S_ALL,H5S_ALL,H5P_DEFAULT,&wbuf)<0)
|
||
TEST_ERROR;
|
||
|
||
/* Close disk dataspace */
|
||
if(H5Sclose(sid1)<0)
|
||
TEST_ERROR;
|
||
|
||
/* Close Dataset */
|
||
if(H5Dclose(dset1)<0)
|
||
TEST_ERROR;
|
||
|
||
/* Close uint8 dataset dataspace */
|
||
if(H5Sclose(sid2)<0)
|
||
TEST_ERROR;
|
||
|
||
|
||
|
||
|
||
/* Open the dataset */
|
||
if((dset1=H5Dopen(file,"/Dataset1"))<0)
|
||
TEST_ERROR;
|
||
|
||
/* Get datatype for dataset */
|
||
if((dtype = H5Dget_type(dset1))<0)
|
||
TEST_ERROR;
|
||
|
||
/* Construct native type */
|
||
if((native_type=H5Tget_native_type(dtype, H5T_DIR_DEFAULT))<0)
|
||
TEST_ERROR;
|
||
|
||
/* Check if the data type is equal */
|
||
if(!H5Tequal(native_type, H5T_STD_REF_DSETREG))
|
||
TEST_ERROR;
|
||
|
||
/* Read selection from disk */
|
||
if(H5Dread(dset1,H5T_STD_REF_DSETREG,H5S_ALL,H5S_ALL,H5P_DEFAULT,&rbuf)<0)
|
||
TEST_ERROR;
|
||
|
||
/* Try to open objects */
|
||
if((dset2=H5Rdereference(dset1,H5R_DATASET_REGION,&rbuf))<0)
|
||
TEST_ERROR;
|
||
|
||
/* Check what H5Rget_obj_type function returns */
|
||
if(H5Rget_obj_type(dset1, H5R_DATASET_REGION,&rbuf) != H5G_DATASET)
|
||
TEST_ERROR;
|
||
|
||
/* Check information in referenced dataset */
|
||
if((sid1 = H5Dget_space(dset2))<0)
|
||
TEST_ERROR;
|
||
|
||
if((int)H5Sget_simple_extent_npoints(sid1)!=100)
|
||
TEST_ERROR;
|
||
|
||
/* Read from disk */
|
||
if(H5Dread(dset2,H5T_STD_U8LE,H5S_ALL,H5S_ALL,H5P_DEFAULT,drbuf)<0)
|
||
TEST_ERROR;
|
||
|
||
for(tu8=(uint8_t *)drbuf,i=0; i<SPACE2_DIM1*SPACE2_DIM2; i++,tu8++)
|
||
if(*tu8 != (uint8_t)(i*3))
|
||
TEST_ERROR;
|
||
|
||
/* Get the hyperslab selection */
|
||
if((sid2=H5Rget_region(dset1,H5R_DATASET_REGION,&rbuf))<0)
|
||
TEST_ERROR;
|
||
|
||
/* Verify correct hyperslab selected */
|
||
if((int)H5Sget_select_npoints(sid2) != 36)
|
||
TEST_ERROR;
|
||
if((int)H5Sget_select_hyper_nblocks(sid2) != 1)
|
||
TEST_ERROR;
|
||
|
||
/* Close region space */
|
||
if(H5Sclose(sid2)<0)
|
||
TEST_ERROR;
|
||
|
||
/* Close first space */
|
||
if(H5Sclose(sid1)<0)
|
||
TEST_ERROR;
|
||
|
||
/* Close dereferenced Dataset */
|
||
if(H5Dclose(dset2)<0)
|
||
TEST_ERROR;
|
||
|
||
/* Close Dataset */
|
||
if(H5Dclose(dset1)<0)
|
||
TEST_ERROR;
|
||
|
||
/* Free memory buffers */
|
||
free(dwbuf);
|
||
free(drbuf);
|
||
|
||
PASSED();
|
||
return 0;
|
||
|
||
error:
|
||
return -1;
|
||
} /* test_refer_dtype2() */
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: test_opaque_dtype
|
||
*
|
||
* Purpose: Test H5Tget_native_type for opaque datatype
|
||
*
|
||
* Return: Success: 0
|
||
*
|
||
* Failure: -1
|
||
*
|
||
* Programmer: Raymond Lu
|
||
* October 15, 2002
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static herr_t
|
||
test_opaque_dtype(hid_t file)
|
||
{
|
||
hid_t type=-1, space=-1, dset=-1;
|
||
hid_t dataset, dtype, native_type;
|
||
size_t i;
|
||
unsigned char wbuf[32], rbuf[32];
|
||
hsize_t nelmts;
|
||
|
||
TESTING("opaque datatype");
|
||
|
||
/* opaque_1 */
|
||
nelmts = sizeof(wbuf);
|
||
if ((type=H5Tcreate(H5T_OPAQUE, 1))<0 ||
|
||
H5Tset_tag(type, "testing 1-byte opaque type")<0 ||
|
||
(space=H5Screate_simple(1, &nelmts, NULL))<0 ||
|
||
(dset=H5Dcreate(file, DSET_OPAQUE_NAME, type, space, H5P_DEFAULT))<0)
|
||
TEST_ERROR;
|
||
|
||
for (i=0; i<sizeof(wbuf); i++)
|
||
wbuf[i] = (unsigned char)0xff ^ (unsigned char)i;
|
||
|
||
if (H5Dwrite(dset, type, H5S_ALL, H5S_ALL, H5P_DEFAULT, wbuf)<0)
|
||
TEST_ERROR;
|
||
if (H5Sclose(space)<0) TEST_ERROR;
|
||
if (H5Dclose(dset)<0) TEST_ERROR;
|
||
|
||
|
||
/* Open dataset again to check H5Tget_native_type */
|
||
if((dataset=H5Dopen(file, DSET_OPAQUE_NAME))<0) TEST_ERROR;
|
||
|
||
if((dtype=H5Dget_type(dataset))<0) TEST_ERROR;
|
||
|
||
if((native_type=H5Tget_native_type(dtype, H5T_DIR_DEFAULT))<0)
|
||
TEST_ERROR;
|
||
|
||
if(!H5Tequal(native_type, type)) TEST_ERROR;
|
||
|
||
if (H5Dread(dataset, native_type, H5S_ALL, H5S_ALL, H5P_DEFAULT, rbuf)<0)
|
||
TEST_ERROR;
|
||
|
||
for(i=0; i<sizeof(rbuf); i++) {
|
||
if (rbuf[i] != wbuf[i]) {
|
||
H5_FAILED();
|
||
printf(" Read different values than written.\n");
|
||
printf(" At index %u\n", (unsigned)i);
|
||
goto error;
|
||
}
|
||
}
|
||
|
||
if (H5Tclose(type)<0) TEST_ERROR;
|
||
if (H5Tclose(dtype)<0) TEST_ERROR;
|
||
if (H5Tclose(native_type)<0) TEST_ERROR;
|
||
if (H5Dclose(dataset)<0) TEST_ERROR;
|
||
|
||
PASSED();
|
||
return 0;
|
||
|
||
error:
|
||
return -1;
|
||
} /* test_opaque_dtype */
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: test_bitfield_dtype
|
||
*
|
||
* Purpose: Test H5Tget_native_type for bitfield datatype
|
||
*
|
||
* Return: Success: 0
|
||
*
|
||
* Failure: -1
|
||
*
|
||
* Programmer: Raymond Lu
|
||
* October 15, 2002
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static herr_t
|
||
test_bitfield_dtype(hid_t file)
|
||
{
|
||
hid_t type=-1, space=-1, dset=-1;
|
||
hid_t dataset, dtype, native_type;
|
||
size_t i;
|
||
unsigned char wbuf[32], rbuf[32];
|
||
hsize_t nelmts;
|
||
|
||
TESTING("bitfield datatype");
|
||
|
||
/* opaque_1 */
|
||
nelmts = sizeof(wbuf);
|
||
if ((type=H5Tcopy(H5T_STD_B8LE))<0 ||
|
||
(space=H5Screate_simple(1, &nelmts, NULL))<0 ||
|
||
(dset=H5Dcreate(file, DSET_BITFIELD_NAME, type, space, H5P_DEFAULT))<0)
|
||
TEST_ERROR;
|
||
|
||
for (i=0; i<sizeof(wbuf); i++)
|
||
wbuf[i] = (unsigned char)0xff ^ (unsigned char)i;
|
||
|
||
if (H5Dwrite(dset, type, H5S_ALL, H5S_ALL, H5P_DEFAULT, wbuf)<0)
|
||
TEST_ERROR;
|
||
if (H5Sclose(space)<0) TEST_ERROR;
|
||
if (H5Dclose(dset)<0) TEST_ERROR;
|
||
|
||
|
||
/* Open dataset again to check H5Tget_native_type */
|
||
if((dataset=H5Dopen(file, DSET_BITFIELD_NAME))<0) TEST_ERROR;
|
||
|
||
if((dtype=H5Dget_type(dataset))<0) TEST_ERROR;
|
||
|
||
if((native_type=H5Tget_native_type(dtype, H5T_DIR_DEFAULT))<0)
|
||
TEST_ERROR;
|
||
|
||
if(!H5Tequal(native_type, type)) TEST_ERROR;
|
||
|
||
if (H5Dread(dataset, native_type, H5S_ALL, H5S_ALL, H5P_DEFAULT, rbuf)<0)
|
||
TEST_ERROR;
|
||
|
||
for(i=0; i<sizeof(rbuf); i++) {
|
||
if (rbuf[i] != wbuf[i]) {
|
||
H5_FAILED();
|
||
printf(" Read different values than written.\n");
|
||
printf(" At index %u\n", (unsigned)i);
|
||
goto error;
|
||
}
|
||
}
|
||
|
||
if (H5Tclose(type)<0) TEST_ERROR;
|
||
if (H5Tclose(dtype)<0) TEST_ERROR;
|
||
if (H5Tclose(native_type)<0) TEST_ERROR;
|
||
if (H5Dclose(dataset)<0) TEST_ERROR;
|
||
|
||
PASSED();
|
||
return 0;
|
||
|
||
error:
|
||
return -1;
|
||
} /* test_opaque_dtype */
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: main
|
||
*
|
||
* Purpose: Test H5Tget_native_type for different datatype
|
||
*
|
||
* Programmer: Raymond Lu
|
||
* October 15, 2002
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
int
|
||
main(void)
|
||
{
|
||
hid_t file, fapl;
|
||
int nerrors=0;
|
||
char filename[1024];
|
||
|
||
h5_reset();
|
||
fapl = h5_fileaccess();
|
||
|
||
h5_fixname(FILENAME[0], fapl, filename, sizeof filename);
|
||
if ((file=H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl))<0)
|
||
goto error;
|
||
|
||
nerrors += test_atomic_dtype(file)<0 ?1:0;
|
||
nerrors += test_compound_dtype(file)<0 ?1:0;
|
||
nerrors += test_compound_dtype2(file)<0 ?1:0;
|
||
nerrors += test_compound_dtype3(file)<0 ?1:0;
|
||
nerrors += test_enum_dtype(file)<0 ?1:0;
|
||
nerrors += test_array_dtype(file)<0 ?1:0;
|
||
nerrors += test_array_dtype2(file)<0 ?1:0;
|
||
nerrors += test_vl_dtype(file)<0 ?1:0;
|
||
nerrors += test_vlstr_dtype(file)<0 ?1:0;
|
||
nerrors += test_refer_dtype(file)<0 ?1:0;
|
||
nerrors += test_refer_dtype2(file)<0 ?1:0;
|
||
nerrors += test_opaque_dtype(file)<0 ?1:0;
|
||
nerrors += test_bitfield_dtype(file)<0 ?1:0;
|
||
|
||
if (H5Fclose(file)<0) goto error;
|
||
if (nerrors) goto error;
|
||
printf("All native datatype tests passed.\n");
|
||
h5_cleanup(FILENAME, fapl);
|
||
return 0;
|
||
|
||
error:
|
||
nerrors = MAX(1, nerrors);
|
||
printf("***** %d DATASET TEST%s FAILED! *****\n",
|
||
nerrors, 1 == nerrors ? "" : "S");
|
||
return 1;
|
||
}
|