diff options
| -rw-r--r-- | tools/Makefile.in | 8 | ||||
| -rw-r--r-- | tools/h5dumptst.c | 1251 |
2 files changed, 1257 insertions, 2 deletions
diff --git a/tools/Makefile.in b/tools/Makefile.in index 3c22b1b..6dab9e9 100644 --- a/tools/Makefile.in +++ b/tools/Makefile.in @@ -24,7 +24,7 @@ TEST_SCRIPTS=$(srcdir)/testh5dump.sh @TESTH5TOH4@ LT_LINK_LIB=$(LT) --mode=link $(CC) -static -rpath $(libdir) LIB=libh5tools.la LIBHDF5=../src/libhdf5.la -PROGS=h5debug h5import h5ls h5repart h5dump @H5TOH4@ +PROGS=h5debug h5import h5ls h5repart h5dump h5dumptst @H5TOH4@ # Source and object files for the library; do not install LIB_SRC=h5tools.c h5findshd.c @@ -32,7 +32,8 @@ LIB_OBJ=$(LIB_SRC:.c=.lo) PUB_LIB= # Source and object files for programs... -PROG_SRC=h5debug.c h5import.c h5ls.c h5repart.c h5dump.c h5dumputil.c h5toh4.c +PROG_SRC=h5debug.c h5import.c h5ls.c h5repart.c h5dump.c h5dumputil.c \ + h5toh4.c h5dumptst.c PROG_OBJ=$(PROG_SRC:.c=.lo) PRIVATE_HDR=h5tools.h @@ -65,4 +66,7 @@ h5dump: h5dump.lo h5dumputil.lo h5toh4: h5toh4.lo @$(LT_LINK_EXE) $(CFLAGS) -o $@ h5toh4.lo $(LIB) $(LIBHDF5) $(LDFLAGS) $(LIBS) +h5dumptst: h5dumptst.lo + @$(LT_LINK_EXE) $(CFLAGS) -o $@ h5dumptst.lo $(LIB) $(LIBHDF5) $(LDFLAGS) $(LIBS) + @CONCLUDE@ diff --git a/tools/h5dumptst.c b/tools/h5dumptst.c new file mode 100644 index 0000000..2ffcb3e --- /dev/null +++ b/tools/h5dumptst.c @@ -0,0 +1,1251 @@ +/* + * Generate the binary hdf5 files for the h5dump tests. + */ +#include <limits.h> +#include "hdf5.h" +#include <H5private.h> + +#define FILE1 "tgroup.h5" +#define FILE2 "tdset.h5" +#define FILE3 "tattr.h5" +#define FILE4 "tslink.h5" +#define FILE5 "thlink.h5" +#define FILE6 "tcompound.h5" +#define FILE7 "tall.h5" +#define FILE8 "tdset2.h5" +#define FILE9 "tcompound2.h5" +#define FILE10 "tloop.h5" +#define FILE11 "tloop2.h5" +#define FILE12 "tmany.h5" +#define FILE13 "tstr.h5" +#define FILE14 "tstr2.h5" +#define LENSTR 50 +#define LENSTR2 11 +static void test_group(void) { +hid_t fid, group; + + fid = H5Fcreate(FILE1, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); + + /* / */ + group = H5Gcreate (fid, "/g1", 0); + H5Gclose(group); + group = H5Gcreate (fid, "/g2", 0); + H5Gclose(group); + group = H5Gcreate (fid, "/g3", 0); + H5Gclose(group); + + /* /g1 */ + group = H5Gcreate (fid, "/g1/g1.1", 0); + H5Gclose(group); + group = H5Gcreate (fid, "/g1/g1.2", 0); + H5Gclose(group); + + /* /g2 */ + group = H5Gcreate (fid, "/g2/g2.1", 0); + H5Gclose(group); + + /* /g3 */ + group = H5Gcreate (fid, "/g3/g3.1", 0); + H5Gclose(group); + group = H5Gcreate (fid, "/g3/g3.2", 0); + H5Gclose(group); + group = H5Gcreate (fid, "/g3/g3.3", 0); + H5Gclose(group); + group = H5Gcreate (fid, "/g3/g3.4", 0); + H5Gclose(group); + + /* /g2/g2.1 */ + group = H5Gcreate (fid, "/g2/g2.1/g2.1.1", 0); + H5Gclose(group); + group = H5Gcreate (fid, "/g2/g2.1/g2.1.2", 0); + H5Gclose(group); + group = H5Gcreate (fid, "/g2/g2.1/g2.1.3", 0); + H5Gclose(group); + + H5Fclose(fid); +} + +static void test_dataset(void) { +hid_t fid, dataset, space; +hsize_t dims[2]; +int dset1[10][20]; +double dset2[30][20]; +int i, j; + + fid = H5Fcreate(FILE2, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); + + /* dset1 */ + dims[0] = 10; dims[1] = 20; + space = H5Screate_simple(2, dims, NULL); + dataset = H5Dcreate(fid, "/dset1", H5T_STD_I32BE, space, H5P_DEFAULT); + for (i = 0; i < 10; i++) + for (j = 0; j < 20; j++) + dset1[i][j] = j; + H5Dwrite(dataset, H5T_STD_I32BE, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset1); + H5Sclose(space); + H5Dclose(dataset); + + /* dset2 */ + dims[0] = 30; dims[1] = 20; + space = H5Screate_simple(2, dims, NULL); + dataset = H5Dcreate(fid, "/dset2", H5T_IEEE_F64BE, space, H5P_DEFAULT); + for (i = 0; i < 30; i++) + for (j = 0; j < 20; j++) + dset2[i][j] = 0.0001*j; + H5Dwrite(dataset, H5T_IEEE_F64BE, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset2); + H5Sclose(space); + H5Dclose(dataset); + + + H5Fclose(fid); +} + +static void test_dataset2(void) { +hid_t fid, dataset, space, create_plist; +hsize_t dims[2]; +hsize_t maxdims[2]; +int dset1[10][20]; +double dset2[30][10]; +int i, j; + + + fid = H5Fcreate(FILE8, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); + + create_plist = H5Pcreate(H5P_DATASET_CREATE); + + dims[0] = 5; dims[1] = 5; + H5Pset_chunk(create_plist, 2, dims); + + /* dset1 */ + dims[0] = 10; dims[1] = 20; + maxdims[0] = H5S_UNLIMITED; maxdims[1] = 20; + space = H5Screate_simple(2, dims, maxdims); + dataset = H5Dcreate(fid, "/dset1", H5T_STD_I32BE, space, create_plist); + for (i = 0; i < 10; i++) + for (j = 0; j < 20; j++) + dset1[i][j] = j; + H5Dwrite(dataset, H5T_STD_I32BE, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset1); + H5Sclose(space); + H5Dclose(dataset); + + /* dset2 */ + dims[0] = 30; dims[1] = 10; + maxdims[0] = 30; maxdims[1] = H5S_UNLIMITED; + space = H5Screate_simple(2, dims, maxdims); + dataset = H5Dcreate(fid, "/dset2", H5T_IEEE_F64BE, space, create_plist); + for (i = 0; i < 30; i++) + for (j = 0; j < 10; j++) + dset2[i][j] = j; + H5Dwrite(dataset, H5T_IEEE_F64BE, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset2); + H5Sclose(space); + H5Dclose(dataset); + + + H5Fclose(fid); +} + + +static void test_attribute(void) { +hid_t fid, root, space, attr, type; +hsize_t dims[2]; +char buf[60]; +int i, data[20]; +double d[10]; +char string[]= "string attribute"; +int point = 100; + + fid = H5Fcreate(FILE3, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); + + root = H5Gopen (fid, "/"); + + /* attribute 1 */ + dims[0] = 24; + space = H5Screate_simple(1, dims, NULL); + attr = H5Acreate (root, "attr1", H5T_NATIVE_SCHAR, space, H5P_DEFAULT); + sprintf(buf, "attribute of root group"); + H5Awrite(attr, H5T_NATIVE_SCHAR, buf); + H5Sclose(space); + H5Aclose(attr); + + + /* attribute 2 */ + dims[0] = 10; + space = H5Screate_simple(1, dims, NULL); + attr = H5Acreate (root, "attr2", H5T_STD_I32BE, space, H5P_DEFAULT); + for (i = 0; i < 10; i++) data[i] = i+1; + H5Awrite(attr, H5T_STD_I32BE, data); + H5Sclose(space); + H5Aclose(attr); + + /* attribute 3 */ + dims[0] = 10; + space = H5Screate_simple(1, dims, NULL); + attr = H5Acreate (root, "attr3", H5T_IEEE_F64BE, space, H5P_DEFAULT); + for (i = 0; i < 10; i++) d[i] = 0.1 * i; + H5Awrite(attr, H5T_IEEE_F64BE, d); + H5Sclose(space); + H5Aclose(attr); + + /* attribute 4 */ + space = H5Screate(H5S_SCALAR); + attr = H5Acreate (root, "attr4", H5T_STD_I32BE, space, H5P_DEFAULT); + H5Awrite(attr, H5T_STD_I32BE, &point); + H5Sclose(space); + H5Aclose(attr); + + /* attribute 5 */ + space = H5Screate(H5S_SCALAR); + type = H5Tcopy(H5T_C_S1); + H5Tset_size(type, 17); + attr = H5Acreate (root, "attr5", type, space, H5P_DEFAULT); + H5Awrite(attr, type, string); + H5Tclose(type); + H5Sclose(space); + H5Aclose(attr); + + H5Gclose(root); + + H5Fclose(fid); +} + +static void test_softlink(void) { +hid_t fid, root; +herr_t status; + + fid = H5Fcreate(FILE4, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); + + root = H5Gopen (fid, "/"); + + status = H5Glink (root, H5G_LINK_SOFT, "somevalue", "slink1"); + + status = H5Glink (root, H5G_LINK_SOFT, "linkvalue", "slink2"); + + H5Gclose(root); + + H5Fclose(fid); + +} + +/* + / + + / | \ the dataset is hardlinked to three names + /dset1, /g1/dset2, and /g1/g1.1/dset3 + dset1 g1 g2 + /g2 and /g1/g1.1 are hardlinked to the same object. + / \ + dset2 g1.1 + | + dset3 +*/ + + +static void test_hardlink(void) { +hid_t fid, group, dataset, space; +hsize_t dim; +int i, dset[5]; + + fid = H5Fcreate(FILE5, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); + + dim = 5; + space = H5Screate_simple(1, &dim, NULL); + dataset = H5Dcreate(fid, "/dset1", H5T_STD_I32BE, space, H5P_DEFAULT); + for (i = 0; i < 5; i++) dset[i] = i; + H5Dwrite(dataset, H5T_STD_I32BE, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset); + H5Sclose(space); + H5Dclose(dataset); + + group = H5Gcreate (fid, "/g1", 0); + H5Glink (group, H5G_LINK_HARD, "/dset1", "dset2"); + H5Gclose(group); + + group = H5Gcreate (fid, "/g2", 0); + H5Glink (group, H5G_LINK_HARD, "/dset1", "dset3"); + H5Gclose(group); + + group = H5Gopen(fid, "/g1"); + H5Glink (group, H5G_LINK_HARD, "/g2", "g1.1"); + H5Gclose(group); + + H5Fclose(fid); +} + +/* + / + / | \ \ + dset1 group1 type1 type2 + | + dset2 + +*/ +static void test_compound_dt(void) { /* test compound data type */ +hid_t fid, group, dataset, space, space3, type; +typedef struct { + int a; + float b; + double c; +} dset1_t; +dset1_t dset1[5]; + +typedef struct { + int a; + float b; +} dset2_t; +dset2_t dset2[5]; + +typedef struct { + int a[4]; + float b[5][6]; +} dset3_t; +dset3_t dset3[3][6]; + +typedef struct { + int a; + float b; +} dset4_t; +dset4_t dset4[5]; + +typedef struct { + int a; + float b; +} dset5_t; +dset5_t dset5[5]; + +int i, j, k, l, ndims; +size_t dim[2]; + +hsize_t sdim = 5; +hsize_t dset3_dim[2]; + + + for (i = 0; i < (int)sdim; i++) { + dset1[i].a = i; + dset1[i].b = i*i; + dset1[i].c = 1./(i+1); + + dset2[i].a = i; + dset2[i].b = i+ i*0.1; + + dset4[i].a = i; + dset4[i].b = i*1.0; + + dset5[i].a = i; + dset5[i].b = i*0.1; + } + + + fid = H5Fcreate(FILE6, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); + + space = H5Screate_simple(1, &sdim, NULL); + + type = H5Tcreate (H5T_COMPOUND, sizeof(dset1[0])); + + H5Tinsert(type, "a_name", HOFFSET(dset1_t, a), H5T_STD_I32BE); + H5Tinsert(type, "b_name", HOFFSET(dset1_t, b), H5T_IEEE_F32BE); + H5Tinsert(type, "c_name", HOFFSET(dset1_t, c), H5T_IEEE_F64BE); + + dataset = H5Dcreate(fid, "/dset1", type, space, H5P_DEFAULT); + H5Dwrite(dataset, type, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset1); + + H5Tclose(type); + H5Dclose(dataset); + + /* shared data type 1 */ + type = H5Tcreate (H5T_COMPOUND, sizeof(dset2_t)); + H5Tinsert(type, "int_name", HOFFSET(dset2_t, a), H5T_STD_I32BE); + H5Tinsert(type, "float_name", HOFFSET(dset2_t, b), H5T_IEEE_F32BE); + H5Tcommit(fid, "type1", type); + + group = H5Gcreate (fid, "/group1", 0); + + dataset = H5Dcreate(group, "dset2", type, space, H5P_DEFAULT); + H5Dwrite(dataset, type, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset2); + + H5Tclose(type); + H5Dclose(dataset); + + + /* shared data type 2 */ + type = H5Tcreate (H5T_COMPOUND, sizeof(dset3_t)); + ndims = 1; dim[0] = 4; + H5Tinsert_array(type, "int_array", HOFFSET(dset3_t, a), ndims, dim, NULL, H5T_STD_I32BE); + ndims = 2; dim[0] = 5; dim[1] = 6; + H5Tinsert_array(type, "float_array", HOFFSET(dset3_t, b), ndims, dim, NULL, H5T_IEEE_F32BE); + H5Tcommit(fid, "type2", type); + + dset3_dim[0] = 3; dset3_dim[1] = 6; + space3 = H5Screate_simple(2, dset3_dim, NULL); + dataset = H5Dcreate(group, "dset3", type, space3, H5P_DEFAULT); + for (i = 0; i < (int)dset3_dim[0]; i++) { + for (j = 0; j < (int)dset3_dim[1]; j++) { + for (k = 0; k < 4; k++) + dset3[i][j].a[k] = k; + for (k = 0; k < 5; k++) + for (l = 0; l < 6; l++) + dset3[i][j].b[k][l] = 0.1* (k+1); + } + } + H5Dwrite(dataset, type, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset3); + H5Sclose(space3); + H5Tclose(type); + H5Dclose(dataset); + + /* shared data type 3 */ + type = H5Tcreate (H5T_COMPOUND, sizeof(dset4_t)); + H5Tinsert(type, "int", HOFFSET(dset4_t, a), H5T_STD_I32BE); + H5Tinsert(type, "float", HOFFSET(dset4_t, b), H5T_IEEE_F32BE); + H5Tcommit(group, "type3", type); + + dataset = H5Dcreate(group, "dset4", type, space, H5P_DEFAULT); + H5Dwrite(dataset, type, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset4); + + H5Tclose(type); + H5Dclose(dataset); + H5Gclose(group); + + + /* unamed data type */ + group = H5Gcreate (fid, "/group2", 0); + + type = H5Tcreate (H5T_COMPOUND, sizeof(dset5_t)); + H5Tinsert(type, "int", HOFFSET(dset5_t, a), H5T_STD_I32BE); + H5Tinsert(type, "float", HOFFSET(dset5_t, b), H5T_IEEE_F32BE); + H5Tcommit(group, "type4", type); + dataset = H5Dcreate(group, "dset5", type, space, H5P_DEFAULT); + H5Dwrite(dataset, type, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset5); + + H5Gunlink(group,"type4"); + + H5Tclose(type); + H5Dclose(dataset); + H5Sclose(space); + H5Gclose(group); + + H5Fclose(fid); + +} + +/* + / + / | \ \ + dset1 group1 type1 type2 + | + dset2 + +*/ +static void test_compound_dt2(void) { /* test compound data type */ +hid_t fid, group, dataset, space, type, create_plist; +typedef struct { + int a; + float b; + double c; +} dset1_t; +dset1_t dset1[10]; + +typedef struct { + int a; + float b; +} dset2_t; +dset2_t dset2[10]; + +typedef struct { + int a[4]; + float b[5][6]; +} dset3_t; + +typedef struct { + int a; + float b; +} dset4_t; +dset4_t dset4[10]; + +typedef struct { + int a; + float b; +} dset5_t; +dset5_t dset5[10]; + +int i, ndims; +const int perm[2]={0,1}; +size_t dim[2]; + +hsize_t sdim, maxdim; + + sdim = 10; + for (i = 0; i < (int)sdim; i++) { + dset1[i].a = i; + dset1[i].b = i*i; + dset1[i].c = 1./(i+1); + + dset2[i].a = i; + dset2[i].b = i+ i*0.1; + + dset4[i].a = i; + dset4[i].b = i*1.0; + + dset5[i].a = i; + dset5[i].b = i*1.0; + } + + fid = H5Fcreate(FILE9, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); + + create_plist = H5Pcreate(H5P_DATASET_CREATE); + + sdim = 2; + H5Pset_chunk(create_plist, 1, &sdim); + + sdim = 6; + maxdim = H5S_UNLIMITED; + + space = H5Screate_simple(1, &sdim, &maxdim); + + type = H5Tcreate (H5T_COMPOUND, sizeof(dset1[0])); + + H5Tinsert(type, "a_name", HOFFSET(dset1_t, a), H5T_STD_I32BE); + H5Tinsert(type, "b_name", HOFFSET(dset1_t, b), H5T_IEEE_F32BE); + H5Tinsert(type, "c_name", HOFFSET(dset1_t, c), H5T_IEEE_F64BE); + + dataset = H5Dcreate(fid, "/dset1", type, space, create_plist); + H5Dwrite(dataset, type, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset1); + + H5Tclose(type); + H5Sclose(space); + H5Dclose(dataset); + + sdim = 6; + maxdim = 10; + + space = H5Screate_simple(1, &sdim, &maxdim); + + /* shared data type 1 */ + type = H5Tcreate (H5T_COMPOUND, sizeof(dset2_t)); + H5Tinsert(type, "int_name", HOFFSET(dset2_t, a), H5T_STD_I32BE); + H5Tinsert(type, "float_name", HOFFSET(dset2_t, b), H5T_IEEE_F32BE); + H5Tcommit(fid, "type1", type); + + group = H5Gcreate (fid, "/group1", 0); + + dataset = H5Dcreate(group, "dset2", type, space, create_plist); + H5Dwrite(dataset, type, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset2); + + H5Tclose(type); + H5Dclose(dataset); + + + /* shared data type 2 */ + type = H5Tcreate (H5T_COMPOUND, sizeof(dset3_t)); + ndims = 1; dim[0] = 4; + H5Tinsert_array(type, "int_array", HOFFSET(dset3_t, a), ndims, dim, perm, H5T_STD_I32BE); + ndims = 2; dim[0] = 5; dim[1] = 6; + H5Tinsert_array(type, "float_array", HOFFSET(dset3_t, b), ndims, dim, perm, H5T_STD_I32BE); + H5Tcommit(fid, "type2", type); + H5Tclose(type); + + /* shared data type 3 */ + type = H5Tcreate (H5T_COMPOUND, sizeof(dset4_t)); + H5Tinsert(type, "int", HOFFSET(dset4_t, a), H5T_STD_I32BE); + H5Tinsert(type, "float", HOFFSET(dset4_t, b), H5T_IEEE_F32BE); + H5Tcommit(group, "type3", type); + + dataset = H5Dcreate(group, "dset4", type, space, create_plist); + H5Dwrite(dataset, type, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset4); + + H5Tclose(type); + H5Dclose(dataset); + H5Gclose(group); + + + /* unamed data type */ + group = H5Gcreate (fid, "/group2", 0); + + type = H5Tcreate (H5T_COMPOUND, sizeof(dset5_t)); + H5Tinsert(type, "int", HOFFSET(dset5_t, a), H5T_STD_I32BE); + H5Tinsert(type, "float", HOFFSET(dset5_t, b), H5T_IEEE_F32BE); + H5Tcommit(group, "type4", type); + dataset = H5Dcreate(group, "dset5", type, space, create_plist); + H5Dwrite(dataset, type, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset5); + + H5Gunlink(group,"type4"); + + H5Tclose(type); + H5Dclose(dataset); + H5Sclose(space); + H5Gclose(group); + + H5Fclose(fid); + +} + + +/* + +/ : g1 g2 attr1 attr2 +g1 : g1.1 g1.2 +g1.1 : dset1.1.1(attr1, attr2) dset1.1.2 +g1.2 : g1.2.1 +g1.2.1 : slink +g2 : dset2.1 dset2.2 + +*/ + +static void test_all(void) { +hid_t fid, group, attr, dataset, space; +hsize_t dims[2]; +int data[2][2], dset1[10][10], dset2[20]; +char buf[60]; +int i, j; +float dset2_1[10], dset2_2[3][5]; + + fid = H5Fcreate(FILE7, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); + + /* create groups */ + group = H5Gcreate (fid, "/g1", 0); + H5Gclose(group); + + group = H5Gcreate (fid, "/g2", 0); + H5Gclose(group); + + group = H5Gcreate (fid, "/g1/g1.1", 0); + H5Gclose(group); + + group = H5Gcreate (fid, "/g1/g1.2", 0); + H5Gclose(group); + + group = H5Gcreate (fid, "/g1/g1.2/g1.2.1", 0); + H5Gclose(group); + + /* root attributes */ + group = H5Gopen (fid, "/"); + + dims[0] = 10; + space = H5Screate_simple(1, dims, NULL); + attr = H5Acreate (group, "attr1", H5T_NATIVE_SCHAR, space, H5P_DEFAULT); + sprintf(buf, "abcdefghi"); + H5Awrite(attr, H5T_NATIVE_SCHAR, buf); + H5Sclose(space); + H5Aclose(attr); + + dims[0] = 2; dims[1] = 2; + space = H5Screate_simple(2, dims, NULL); + attr = H5Acreate (group, "attr2", H5T_STD_I32BE, space, H5P_DEFAULT); + data[0][0] = 0; data[0][1] = 1; data[1][0] = 2; data[1][1] = 3; + H5Awrite(attr, H5T_STD_I32BE, data); + H5Sclose(space); + H5Aclose(attr); + + H5Gclose(group); + + group = H5Gopen (fid, "/g1/g1.1"); + + /* dset1.1.1 */ + dims[0] = 10; dims[1] = 10; + space = H5Screate_simple(2, dims, NULL); + dataset = H5Dcreate(group, "dset1.1.1", H5T_STD_I32BE, space, H5P_DEFAULT); + for (i = 0; i < 10; i++) + for (j = 0; j < 10; j++) + dset1[i][j] = j; + H5Dwrite(dataset, H5T_STD_I32BE, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset1); + H5Sclose(space); + + /* attributes of dset1.1.1 */ + dims[0] = 27; + space = H5Screate_simple(1, dims, NULL); + attr = H5Acreate (dataset, "attr1", H5T_NATIVE_SCHAR, space, H5P_DEFAULT); + sprintf(buf, "1st attribute of dset1.1.1"); + H5Awrite(attr, H5T_NATIVE_SCHAR, buf); + H5Sclose(space); + H5Aclose(attr); + + dims[0] = 27; + space = H5Screate_simple(1, dims, NULL); + attr = H5Acreate (dataset, "attr2", H5T_NATIVE_SCHAR, space, H5P_DEFAULT); + sprintf(buf, "2nd attribute of dset1.1.1"); + H5Awrite(attr, H5T_NATIVE_SCHAR, buf); + H5Sclose(space); + H5Aclose(attr); + + H5Dclose(dataset); + + /* dset1.1.2 */ + dims[0] = 20; + space = H5Screate_simple(1, dims, NULL); + dataset = H5Dcreate(group, "dset1.1.2", H5T_STD_I32BE, space, H5P_DEFAULT); + for (i = 0; i < 20; i++) + dset2[i] = i; + H5Dwrite(dataset, H5T_STD_I32BE, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset2); + H5Sclose(space); + H5Dclose(dataset); + + H5Gclose(group); + + /* soft link */ + group = H5Gopen (fid, "/g1/g1.2/g1.2.1"); + H5Glink (group, H5G_LINK_SOFT, "somevalue", "slink"); + H5Gclose(group); + + group = H5Gopen (fid, "/g2"); + + /* dset2.1 */ + dims[0] = 10; + space = H5Screate_simple(1, dims, NULL); + dataset = H5Dcreate(group, "dset2.1", H5T_IEEE_F32BE, space, H5P_DEFAULT); + for (i = 0; i < 10; i++) + dset2_1[i] = i*0.1+1; + H5Dwrite(dataset, H5T_IEEE_F32BE, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset2_1); + H5Sclose(space); + H5Dclose(dataset); + + /* dset2.2 */ + dims[0] = 3; dims[1] = 5; + space = H5Screate_simple(2, dims, NULL); + dataset = H5Dcreate(group, "dset2.2", H5T_IEEE_F32BE, space, H5P_DEFAULT); + for (i = 0; i < 3; i++) + for (j = 0; j < 5; j++) + dset2_2[i][j] = i*0.1; + H5Dwrite(dataset, H5T_IEEE_F32BE, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset2_2); + H5Sclose(space); + H5Dclose(dataset); + + H5Gclose(group); + + H5Fclose(fid); + +} + +/* + o + /___\ + g1 o/ \o g2 + \___/ + + +o - group objects + +*/ + +static void test_loop(void) { +hid_t fid, group; + + fid = H5Fcreate(FILE10, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); + + group = H5Gcreate (fid, "/g1", 0); + H5Gclose(group); + group = H5Gcreate (fid, "/g2", 0); + H5Gclose(group); + + H5Glink(fid, H5G_LINK_HARD, "/g2", "/g1/g1.1"); + H5Glink(fid, H5G_LINK_HARD, "/g1", "/g2/g2.1"); + + H5Fclose(fid); +} + +static void test_loop2(void) { +hid_t fid, group; + + fid = H5Fcreate(FILE11, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); + + /* create group object g1 and implcit path from root object */ + group = H5Gcreate (fid, "/g1", 0); + H5Gclose(group); + + /* create group object g2 and implcit path from root object */ + group = H5Gcreate (fid, "/g2", 0); + H5Gclose(group); + + /* create path from object at /g1 to object at /g2 and name it g1.1 */ + H5Glink (fid, H5G_LINK_HARD, "/g2", "/g1/g1.1"); + + /* create path from object at /g2 to object at /g1 and name it g2.1 */ + H5Glink (fid, H5G_LINK_SOFT, "/g1", "/g2/g2.1"); + + H5Fclose(fid); + +} + +/* + / + | | | \ \ \ + g1 g2 g3 g4 g5 g6 + / \ | | \ \ \ + g1.1 g1.2 slink2 link3 dset2 slink4 dset3 + | | (g1) (dset2) (dset3) + dset1 link1 + (dset1) +*/ + +static void test_many(void) { +hid_t fid, group, attr, dataset, space, space2, type, create_plist; +hsize_t dims[2]; +int data[2][2], dset2[10][10], dset3[10][10]; +double d[10]; + +char buf[60]; +int i, j; +int i0, i1, i2, i3; +hsize_t sdim, maxdim; + +typedef struct { /* compound type has members with rank > 1 */ + int a[2][2][2][2]; /* arrays are 2x2x2x2 */ + double b[2][2][2][2]; + double c[2][2][2][2]; +} dset1_t; +dset1_t dset1[6]; + +size_t dim[4]; +int index[4] = {0,1,2,3}; /* normal indicies */ +const int perm[4] = {0,1,2,3}; /* the 0'th and the 3'rd indices are permuted */ + + fid = H5Fcreate(FILE12, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); + + group = H5Gcreate (fid, "/g1", 0); + H5Gclose(group); + + create_plist = H5Pcreate(H5P_DATASET_CREATE); + + sdim = 2; + H5Pset_chunk(create_plist, 1, &sdim); + + group = H5Gcreate (fid, "/g1/g1.1", 0); + + type = H5Tcreate (H5T_COMPOUND, sizeof(dset1[0])); + + dim[0] = dim[1] = dim[2] = dim[3] = 2; + H5Tinsert_array(type, "a_array", HOFFSET(dset1_t, a), 4, dim, perm, H5T_STD_I32BE); + H5Tinsert_array(type, "b_array", HOFFSET(dset1_t, b), 4, dim, perm, H5T_IEEE_F64BE); + H5Tinsert_array(type, "c_array", HOFFSET(dset1_t, c), 4, dim, perm, H5T_IEEE_F64BE); + + H5Tcommit(group, "type1", type); + + /* dset1 */ + sdim = 6; + maxdim = H5S_UNLIMITED; + space = H5Screate_simple(1, &sdim, &maxdim); + dataset = H5Dcreate(group, "dset1", type, space, create_plist); + + /* add attributes to dset1 */ + dims[0] = 10; + space2 = H5Screate_simple(1, dims, NULL); + attr = H5Acreate (dataset, "attr1", H5T_NATIVE_CHAR, space2, H5P_DEFAULT); + sprintf(buf, "abcdefghi"); + H5Awrite(attr, H5T_NATIVE_CHAR, buf); + H5Sclose(space2); + H5Aclose(attr); + + dims[0] = 2; dims[1] = 2; + space2 = H5Screate_simple(2, dims, NULL); + attr = H5Acreate (dataset, "attr2", H5T_STD_I32BE, space2, H5P_DEFAULT); + data[0][0] = 0; data[0][1] = 1; data[1][0] = 2; data[1][1] = 3; + H5Awrite(attr, H5T_STD_I32BE, data); + H5Sclose(space2); + H5Aclose(attr); + + dims[0] = 10; + space2 = H5Screate_simple(1, dims, NULL); + attr = H5Acreate (dataset, "attr3", H5T_IEEE_F64BE, space2, H5P_DEFAULT); + for (i = 0; i < 10; i++) d[i] = 0.1 * i; + H5Awrite(attr, H5T_IEEE_F64BE, d); + H5Sclose(space2); + H5Aclose(attr); + + for (j=0; j<(int)sdim; j++) { + for (i3 = 0; i3 < 2; i3++) { + index[perm[3]] = i3; + for (i2 = 0; i2 < 2; i2++) { + index[perm[2]] = i2; + for (i1 = 0; i1 < 2; i1++) { + index[perm[1]] = i1; + for (i0 = 0; i0 < 2; i0++) { + index[perm[0]] = i0; + + dset1[j].a[index[3]][index[2]][index[1]][index[0]] = i0+j; + dset1[j].b[index[3]][index[2]][index[1]][index[0]] = (double)(i0+j); +#if WIN32 + dset1[j].c[index[3]][index[2]][index[1]][index[0]] = (double)(i0+j+(signed __int64)sdim); +#else + dset1[j].c[index[3]][index[2]][index[1]][index[0]] = (double)(i0+j+sdim); +#endif + } + } + } + } + } + + H5Dwrite(dataset, type, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset1); + + H5Dclose(dataset); + H5Sclose(space); + + H5Tclose(type); + H5Gclose(group); + + group = H5Gcreate (fid, "/g1/g1.2", 0); + H5Glink (group, H5G_LINK_HARD, "/g1/g1.1/dset1", "link1"); + H5Gclose(group); + + group = H5Gcreate (fid, "/g2", 0); + H5Glink (group, H5G_LINK_SOFT, "/g1", "slink2"); + H5Gclose(group); + + group = H5Gcreate (fid, "/g3", 0); + H5Gclose(group); + + group = H5Gcreate (fid, "/g4", 0); + + /* dset2 */ + dims[0] = 10; dims[1] = 10; + space = H5Screate_simple(2, dims, NULL); + + dataset = H5Dcreate(group, "dset2", H5T_STD_I32BE, space, H5P_DEFAULT); + for (i = 0; i < 10; i++) + for (j = 0; j < 10; j++) + dset2[i][j] = j; + H5Dwrite(dataset, H5T_STD_I32BE, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset2); + + H5Dclose(dataset); + + H5Sclose(space); + H5Gclose(group); + + group = H5Gopen(fid, "/g3"); + H5Glink (group, H5G_LINK_HARD, "/g4/dset2", "link3"); + H5Gclose(group); + + group = H5Gcreate (fid, "/g5", 0); + H5Gclose(group); + + group = H5Gcreate (fid, "/g6", 0); + /* dset3 */ + dims[0] = 10; dims[1] = 10; + space = H5Screate_simple(2, dims, NULL); + + dataset = H5Dcreate(group, "dset3", H5T_STD_I32BE, space, H5P_DEFAULT); + for (i = 0; i < 10; i++) + for (j = 0; j < 10; j++) + dset3[i][j] = i; + H5Dwrite(dataset, H5T_STD_I32BE, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset3); + + H5Dclose(dataset); + + H5Sclose(space); + H5Gclose(group); + + group = H5Gopen(fid, "/g5"); + H5Glink (group, H5G_LINK_SOFT, "/g6/dset3", "slink4"); + H5Gclose(group); + + H5Fclose(fid); + +} +static hid_t mkstr(int size, int pad) { +hid_t type; + + if ((type=H5Tcopy(H5T_C_S1))<0) return -1; + if (H5Tset_size(type, size)<0) return -1; + if (H5Tset_strpad(type, pad)<0) return -1; + + return type; +} + +static void test_str(void) { +hid_t fid, dataset, space, f_type, m_type, str_type; + +hsize_t dims1[] = { 3, 4}; +char string1[12][2] = {"s1","s2","s3","s4","s5","s6","s7","s8","s9", + "s0","s1","s2"}; + +hsize_t dims2[]={20}; +char string2[20][9] = {"ab cd ef1", "ab cd ef2", "ab cd ef3", "ab cd ef4", + "ab cd ef5", "ab cd ef6", "ab cd ef7", "ab cd ef8", + "ab cd ef9", "ab cd ef0", "ab cd ef1", "ab cd ef2", + "ab cd ef3", "ab cd ef4", "ab cd ef5", "ab cd ef6", + "ab cd ef7", "ab cd ef8", "ab cd ef9", "ab cd ef0"}; + +hsize_t dims3[] = { 27}; +char string3[27][5] = {"abcd0", "abcd1", "abcd2", "abcd3", + "abcd4", "abcd5", "abcd6", "abcd7", + "abcd8", "abcd9", "abcd0", "abcd1", + "abcd2", "abcd3", "abcd4", "abcd5", + "abcd6", "abcd7", "abcd8", "abcd9", + "abcd0", "abcd1", "abcd2", "abcd3", + "abcd4", "abcd5", "abcd6"}; + +int i, j, k, l; + +hsize_t dims4[] = { 3 }; +char string4[3][20] = { "s1234567890123456789", "s1234567890123456789", + "s1234567890123456789"}; + +hsize_t dims5[] = { 3, 6}; +typedef struct { + char s[12][32]; + int a[8][10]; +} compound_t; +compound_t comp1[3][6]; +size_t mdims[2]; + + fid = H5Fcreate(FILE13, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); + + /* string 1 : nullterm string */ + space = H5Screate_simple(2, dims1, NULL); + f_type = mkstr(5, H5T_STR_NULLTERM); + m_type = mkstr(2, H5T_STR_NULLTERM); + dataset = H5Dcreate(fid, "/string1", f_type, space, H5P_DEFAULT); + H5Dwrite(dataset, m_type, H5S_ALL, H5S_ALL, H5P_DEFAULT, string1); + H5Tclose(m_type); + H5Tclose(f_type); + H5Sclose(space); + H5Dclose(dataset); + + /* string 2 : space pad string */ + space = H5Screate_simple(1, dims2, NULL); + f_type = mkstr(11, H5T_STR_SPACEPAD); + m_type = mkstr(9, H5T_STR_NULLTERM); + dataset = H5Dcreate(fid, "/string2", f_type, space, H5P_DEFAULT); + H5Dwrite(dataset, m_type, H5S_ALL, H5S_ALL, H5P_DEFAULT, string2); + H5Tclose(m_type); + H5Tclose(f_type); + H5Sclose(space); + H5Dclose(dataset); + + /* string 3 : null pad string */ + space = H5Screate_simple(1, dims3, NULL); + f_type = mkstr(8, H5T_STR_NULLPAD); + m_type = mkstr(5, H5T_STR_NULLTERM); + dataset = H5Dcreate(fid, "/string3", f_type, space, H5P_DEFAULT); + H5Dwrite(dataset, m_type, H5S_ALL, H5S_ALL, H5P_DEFAULT, string3); + H5Tclose(m_type); + H5Tclose(f_type); + H5Sclose(space); + H5Dclose(dataset); + + /* string 4 : space pad long string */ + space = H5Screate_simple(1, dims4, NULL); + f_type = mkstr(168, H5T_STR_SPACEPAD); + m_type = mkstr(20, H5T_STR_NULLTERM); + dataset = H5Dcreate(fid, "/string4", f_type, space, H5P_DEFAULT); + H5Dwrite(dataset, m_type, H5S_ALL, H5S_ALL, H5P_DEFAULT, string4); + H5Tclose(m_type); + H5Tclose(f_type); + H5Sclose(space); + H5Dclose(dataset); + + /* compound data */ + space = H5Screate_simple(2, dims5, NULL); + f_type = H5Tcreate (H5T_COMPOUND, sizeof(compound_t)); + mdims[0] = 8; mdims[1] = 10; + H5Tinsert_array(f_type, "int_array", HOFFSET(compound_t, a), 2, mdims, + NULL, H5T_STD_I32BE); + str_type = mkstr(32, H5T_STR_SPACEPAD); + mdims[0] = 3; mdims[1] = 4; + H5Tinsert_array(f_type, "string", HOFFSET(compound_t, s), 2, mdims, + NULL, str_type); + + for (i = 0; i < 3; i++) + for (j = 0; j < 6; j++) { + for (k = 0 ; k < 8; k++) + for (l = 0; l < 10; l++) + comp1[i][j].a[k][l] = l; + for (k = 0 ; k < 12; k++) + sprintf(comp1[i][j].s[k], "abcdefgh12345678abcdefgh12345678"); + } + + dataset = H5Dcreate(fid, "/comp1", f_type, space, H5P_DEFAULT); + H5Dwrite(dataset, f_type, H5S_ALL, H5S_ALL, H5P_DEFAULT, comp1); + + H5Tclose(str_type); + H5Tclose(f_type); + H5Sclose(space); + H5Dclose(dataset); + + H5Fclose(fid); +} + +/* + / + / / | \ \ \ + g1 g2 g3 g4 g5 g6 + | | | | \ \ + string1 string3 string5 + string2 string4 string6 +*/ + +static void test_str2(void) { +hid_t fid, group, attr, dataset, space, space2, mem_space, hyper_space, type; +hid_t fxdlenstr, fxdlenstr2, memtype; +hsize_t dims[1], size[1], start[1], stride[1], count[1], block[1]; + + +int i, j; +int i0, i1, i2, i3; +char buf[LENSTR+10]; +char buf2[3*LENSTR2]; +hsize_t sdim, maxdim; + + fid = H5Fcreate(FILE14, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); + + fxdlenstr = H5Tcopy(H5T_C_S1); + H5Tset_size(fxdlenstr, LENSTR); + H5Tset_cset(fxdlenstr, H5T_CSET_ASCII); + H5Tset_strpad(fxdlenstr, H5T_STR_NULLTERM); + + memtype = H5Tcopy(H5T_C_S1); + H5Tset_size(memtype, LENSTR); + H5Tset_cset(memtype, H5T_CSET_ASCII); + H5Tset_strpad(memtype, H5T_STR_NULLTERM); + + sdim = 10; + size[0] = sdim; + space = H5Screate_simple(1, size, NULL); + size[0] = 1; + mem_space = H5Screate_simple(1,size,NULL); + hyper_space = H5Scopy(space); + + /* dset1 */ + + group = H5Gcreate (fid, "/g1", 0); + dataset = H5Dcreate(group, "dset1", fxdlenstr, space, H5P_DEFAULT); + + /* add attributes to dset1 */ + + fxdlenstr2 = H5Tcopy(H5T_C_S1); + H5Tset_size(fxdlenstr2, LENSTR2); + H5Tset_cset(fxdlenstr2, H5T_CSET_ASCII); + H5Tset_strpad(fxdlenstr2, H5T_STR_NULLTERM); + + dims[0] = 3; + space2 = H5Screate_simple(1, dims, NULL); + attr = H5Acreate (dataset, "attr1", fxdlenstr2, space2, H5P_DEFAULT); + sprintf(&(buf2[0*LENSTR2]), "0123456789"); + sprintf(&(buf2[1*LENSTR2]), "abcdefghij"); + sprintf(&(buf2[2*LENSTR2]), "ABCDEFGHIJ"); + H5Awrite(attr, fxdlenstr2, buf2); + H5Sclose(space2); + H5Tclose(fxdlenstr2); + H5Aclose(attr); + + stride[0]=1; + count[0]=1; + block[0]=1; + + for (i = 0; i < sdim; i++) { + start[0] = i; + sprintf(buf,"This is row %1d of type H5T_STR_NULLTERM of",i); + H5Tset_size(memtype, HDstrlen(buf)+1); + H5Sselect_hyperslab(hyper_space, H5S_SELECT_SET, start, stride, count, block); + H5Dwrite(dataset, memtype, mem_space, hyper_space, H5P_DEFAULT, buf); + } + H5Dclose(dataset); + H5Gclose(group); + + group = H5Gcreate (fid, "/g2", 0); + dataset = H5Dcreate(group, "dset2", fxdlenstr, space, H5P_DEFAULT); + + for (i = 0; i < sdim; i++) { + start[0] = i; + sprintf(buf,"This is row %1d of type H5T_STR_NULLTERM of string array",i); + H5Tset_size(memtype, HDstrlen(buf)+1); + H5Sselect_hyperslab(hyper_space, H5S_SELECT_SET, start, stride, count, block); + H5Dwrite(dataset, memtype, mem_space, hyper_space, H5P_DEFAULT, buf); + } + H5Dclose(dataset); + H5Gclose(group); + + + H5Tclose(fxdlenstr); + fxdlenstr = H5Tcopy(H5T_C_S1); + H5Tset_size(fxdlenstr, LENSTR); + H5Tset_cset(fxdlenstr, H5T_CSET_ASCII); + H5Tset_strpad(fxdlenstr, H5T_STR_NULLPAD); + + group = H5Gcreate (fid, "/g3", 0); + dataset = H5Dcreate(group, "dset3", fxdlenstr, space, H5P_DEFAULT); + + for (i = 0; i < sdim; i++) { + start[0] = i; + sprintf(buf,"This is row %1d of type H5T_STR_NULLPAD of",i); + H5Tset_size(memtype, HDstrlen(buf)+1); + H5Sselect_hyperslab(hyper_space, H5S_SELECT_SET, start, stride, count, block); + H5Dwrite(dataset, memtype, mem_space, hyper_space, H5P_DEFAULT, buf); + } + H5Dclose(dataset); + H5Gclose(group); + + + group = H5Gcreate (fid, "/g4", 0); + dataset = H5Dcreate(group, "dset4", fxdlenstr, space, H5P_DEFAULT); + + for (i = 0; i < sdim; i++) { + start[0] = i; + sprintf(buf,"This is row %1d of type H5T_STR_NULLPAD of string array",i); + H5Tset_size(memtype, HDstrlen(buf)+1); + H5Sselect_hyperslab(hyper_space, H5S_SELECT_SET, start, stride, count, block); + H5Dwrite(dataset, memtype, mem_space, hyper_space, H5P_DEFAULT, buf); + } + H5Dclose(dataset); + H5Gclose(group); + + H5Tclose(fxdlenstr); + fxdlenstr = H5Tcopy(H5T_C_S1); + H5Tset_size(fxdlenstr, LENSTR); + H5Tset_cset(fxdlenstr, H5T_CSET_ASCII); + H5Tset_strpad(fxdlenstr, H5T_STR_SPACEPAD); + + group = H5Gcreate (fid, "/g5", 0); + dataset = H5Dcreate(group, "dset5", fxdlenstr, space, H5P_DEFAULT); + + for (i = 0; i < sdim; i++) { + start[0] = i; + sprintf(buf,"This is row %1d of type H5T_STR_SPACEPAD of",i); + H5Tset_size(memtype, HDstrlen(buf)+1); + H5Sselect_hyperslab(hyper_space, H5S_SELECT_SET, start, stride, count, block); + H5Dwrite(dataset, memtype, mem_space, hyper_space, H5P_DEFAULT, buf); + } + H5Dclose(dataset); + H5Gclose(group); + + + group = H5Gcreate (fid, "/g6", 0); + dataset = H5Dcreate(group, "dset6", fxdlenstr, space, H5P_DEFAULT); + + for (i = 0; i < sdim; i++) { + start[0] = i; + sprintf(buf,"This is row %1d of type H5T_STR_SPACEPAD of string array",i); + H5Tset_size(memtype, HDstrlen(buf)+1); + H5Sselect_hyperslab(hyper_space, H5S_SELECT_SET, start, stride, count, block); + H5Dwrite(dataset, memtype, mem_space, hyper_space, H5P_DEFAULT, buf); + } + H5Dclose(dataset); + H5Gclose(group); + + H5Tclose(fxdlenstr); + H5Tclose(memtype); + H5Sclose(mem_space); + H5Sclose(hyper_space); + H5Sclose(space); + + H5Fclose(fid); + +} + +int main(void){ + +test_group(); +test_attribute(); +test_softlink(); +test_dataset(); +test_hardlink(); +test_compound_dt(); +test_all(); +test_loop(); + +test_dataset2(); +test_compound_dt2(); +test_loop2(); +test_many(); + +test_str(); +test_str2(); + +return 0; + +} |