[svn-r1393] Added entry for h5dumptst.c which creates test files for h5dump tool

tests.  h5dumptst should be run from inside testfiles directory.

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;
+
+}