[svn-r2] Oops...

6 files changed, 962 insertions, 0 deletions

diff --git a/test/Makefile b/test/Makefile
new file mode 100644
index 0000000..ec8bcf5
--- /dev/null
+++ b/test/Makefile
@@ -0,0 +1,50 @@
+### Name of target
+TARGET = testhdf5
+
+#
+# PART 2: various choices
+#
+
+### -DDEBUG		Debugging options on
+DEFS = -I../src
+
+################################################
+##   no changes required below this line      ##
+################################################
+
+INCL = ../src/hdf5.h testhdf5.h
+
+OBJ =	testhdf5.o tmeta.o tfile.o theap.o
+
+LIBS =	../src/libhdf5.a
+
+$(TARGET): $(OBJ) $(LIBS)
+	$(CC) -o $(TARGET) $(OBJ) $(LIBS)
+
+all: $(TARGET)
+
+test: $(TARGET)
+	./$(TARGET)
+
+debug: $(OBJ) 
+	purify $(CC) -o $(TARGET) $(OBJ) $(LIBS)
+
+clean:
+	-rm -f *.o core *.core $(TARGET) 
+	-rm -f *.bak *.h5
+
+###########################################################################
+
+testhdf5.o:	testhdf5.c  $(INCL)
+	$(CC) $(CFLAGS) $(DEFS) testhdf5.c
+
+tmeta.o:	tmeta.c  $(INCL)
+	$(CC) $(CFLAGS) $(DEFS) tmeta.c
+
+tfile.o:	tfile.c  $(INCL)
+	$(CC) $(CFLAGS) $(DEFS) tfile.c
+
+theap.o:	theap.c $(INCL)
+	$(CC) $(CFLAGS) $(DEFS) theap.c
+
+
diff --git a/test/testhdf5.c b/test/testhdf5.c
new file mode 100644
index 0000000..60959fa
--- /dev/null
+++ b/test/testhdf5.c
@@ -0,0 +1,302 @@
+/****************************************************************************
+ * NCSA HDF                                                                 *
+ * Software Development Group                                               *
+ * National Center for Supercomputing Applications                          *
+ * University of Illinois at Urbana-Champaign                               *
+ * 605 E. Springfield, Champaign IL 61820                                   *
+ *                                                                          *
+ * For conditions of distribution and use, see the accompanying             *
+ * hdf/COPYING file.                                                        *
+ *                                                                          *
+ ****************************************************************************/
+
+#ifdef RCSID
+static char RcsId[] = "@(#)$Revision$";
+#endif
+
+/* $Id$ */
+
+/*
+   FILE
+       testhdf5.c - HDF5 testing framework main file.
+
+   REMARKS
+       General test wrapper for HDF5 base library test programs
+
+   DESIGN
+       Each test function should be implemented as function having no
+    parameters and returning void (i.e. no return value).  They should be put
+    into the list of InitTest() calls in main() below.  Functions which depend
+    on other functionality should be placed below the InitTest() call for the
+    base functionality testing.
+       Each test module should include testhdf5.h and define a unique set of
+    names for test files they create.
+
+   BUGS/LIMITATIONS
+
+   EXPORTED ROUTINES/VARIABLES:
+       Two variables are exported: num_errs, and Verbosity.
+
+ */
+
+#if defined __MWERKS__
+#include <console.h>
+#endif
+
+#define MAXNUMOFTESTS 30
+#define HDF5_TEST_MASTER
+
+/* Internal Variables */
+static int  Index = 0;
+
+/* ANY new test needs to have a prototype in tproto.h */
+#include "testhdf5.h"
+
+struct TestStruct
+  {
+      int         NumErrors;
+      char        Description[64];
+      int         SkipFlag;
+      char        Name[16];
+      VOID        (*Call) (void);
+  }
+         Test[MAXNUMOFTESTS];
+
+static void InitTest(const char *TheName, VOID(*TheCall) (void), const char *TheDescr);
+static void usage(void);
+
+static void InitTest(const char *TheName, VOID(*TheCall) (void), const char *TheDescr)
+{
+    if (Index >= MAXNUMOFTESTS)
+      {
+          print_func("Uh-oh, too many tests added, increase MAXNUMOFTEST!\n");
+          exit(0);
+      }     /* end if */
+    HDstrcpy(Test[Index].Description, TheDescr);
+    HDstrcpy(Test[Index].Name, TheName);
+    Test[Index].Call = TheCall;
+    Test[Index].NumErrors = -1;
+    Test[Index].SkipFlag = 0;
+    Index++;
+}
+
+static void usage(void)
+{
+    intn        i;
+
+    print_func("Usage: testhdf5 [-v[erbose] (l[ow]|m[edium]|h[igh]|0-10)] \n");
+    print_func("               [-[e]x[clude] name+] \n");
+    print_func("               [-o[nly] name+] \n");
+    print_func("               [-b[egin] name] \n");
+    print_func("               [-s[ummary]]  \n");
+    print_func("               [-c[leanoff]]  \n");
+    print_func("               [-n[ocaching]]  \n");
+    print_func("               [-h[elp]]  \n");
+    print_func("\n\n");
+    print_func("verbose   controls the amount of information displayed\n");
+    print_func("exclude   to exclude tests by name\n");
+    print_func("only      to name tests which should be run\n");
+    print_func("begin     start at the name of the test givin\n");
+    print_func("summary   prints a summary of test results at the end\n");
+    print_func("cleanoff  does not delete *.hdf files after execution of tests\n");
+    print_func("nocaching do not turn on low-level DD caching\n");
+    print_func("help      print out this information\n");
+    print_func("\n\n");
+    print_func("This program currently tests the following: \n\n");
+    print_func("%16s %s\n", "Name", "Description");
+    print_func("%16s %s\n", "----", "-----------");
+    for (i = 0; i < Index; i++)
+        print_func("%16s %s\n", Test[i].Name, Test[i].Description);
+    print_func("\n\n");
+}   /* end usage() */
+
+/*
+ * This routine is designed to provide equivalent functionality to 'printf'
+ * and allow easy replacement for environments which don't have stdin/stdout
+ * available.  (i.e. Windows & the Mac)
+ */
+int print_func(const char *format, ...)
+{
+    va_list arglist;
+    int ret_value;
+
+    va_start(arglist, format);
+    ret_value=vprintf(format, arglist);
+    va_end(arglist);
+    return(ret_value);
+}
+
+int main(int argc, char *argv[])
+{
+    int         CLLoop;         /* Command Line Loop */
+    int         Loop, Loop1;
+    int         Summary = 0;
+    int         CleanUp = 1;
+    int         Cache = 1;
+    uintn       major, minor, release, patch;
+
+#if defined __MWERKS__
+    argc = ccommand(&argv);
+#endif
+
+#if !(defined MAC || defined __MWERKS__ || defined SYMANTEC_C)
+    /* Un-buffer the stdout and stderr */
+    setbuf(stderr, NULL);
+    setbuf(stdout, NULL);
+#endif
+
+    /* Tests are generally arranged from least to most complexity... */
+    InitTest("metadata", test_metadata, "Encode/decode metadata code");
+    InitTest("file", test_file, "Low-Level File I/O");
+    InitTest("heap", test_heap, "Object and Name Heaps");
+
+    Verbosity = 4;  /* Default Verbosity is Low */
+    H5version(&major, &minor, &release, &patch);
+
+    print_func("\nFor help use: testhdf5 -help\n");
+    print_func("Built with HDF5 Library Version: %u.%ur%u, patch %u\n\n", (unsigned) major,
+           (unsigned) minor, (unsigned) release, (unsigned)patch);
+    for (CLLoop = 1; CLLoop < argc; CLLoop++)
+      {
+          if ((argc > CLLoop + 1) && ((HDstrcmp(argv[CLLoop], "-verbose") == 0) ||
+                                      (HDstrcmp(argv[CLLoop], "-v") == 0)))
+            {
+                if (argv[CLLoop + 1][0] == 'l')
+                    Verbosity = 4;
+                else if (argv[CLLoop + 1][0] == 'm')
+                    Verbosity = 6;
+                else if (argv[CLLoop + 1][0] == 'h')
+                    Verbosity = 10;
+                else
+                    Verbosity = atoi(argv[CLLoop + 1]);
+            }   /* end if */
+          if ((argc > CLLoop) && ((HDstrcmp(argv[CLLoop], "-summary") == 0) ||
+                                  (HDstrcmp(argv[CLLoop], "-s") == 0)))
+              Summary = 1;
+
+          if ((argc > CLLoop) && ((HDstrcmp(argv[CLLoop], "-help") == 0) ||
+                                  (HDstrcmp(argv[CLLoop], "-h") == 0)))
+            {
+                usage();
+                exit(0);
+            }
+
+          if ((argc > CLLoop) && ((HDstrcmp(argv[CLLoop], "-cleanoff") == 0) ||
+                                  (HDstrcmp(argv[CLLoop], "-c") == 0)))
+              CleanUp = 0;
+
+          if ((argc > CLLoop) && ((HDstrcmp(argv[CLLoop], "-nocache") == 0) ||
+                                  (HDstrcmp(argv[CLLoop], "-n") == 0)))
+              Cache = 0;
+
+          if ((argc > CLLoop + 1) && ((HDstrcmp(argv[CLLoop], "-exclude") == 0) ||
+                                      (HDstrcmp(argv[CLLoop], "-x") == 0)))
+            {
+                Loop = CLLoop + 1;
+                while ((Loop < argc) && (argv[Loop][0] != '-'))
+                  {
+                      for (Loop1 = 0; Loop1 < Index; Loop1++)
+                          if (HDstrcmp(argv[Loop], Test[Loop1].Name) == 0)
+                              Test[Loop1].SkipFlag = 1;
+                      Loop++;
+                  }     /* end while */
+            }   /* end if */
+          if ((argc > CLLoop + 1) && ((HDstrcmp(argv[CLLoop], "-begin") == 0) ||
+                                      (HDstrcmp(argv[CLLoop], "-b") == 0)))
+            {
+                Loop = CLLoop + 1;
+                while ((Loop < argc) && (argv[Loop][0] != '-'))
+                  {
+                      for (Loop1 = 0; Loop1 < Index; Loop1++)
+                        {
+                            if (HDstrcmp(argv[Loop], Test[Loop1].Name) != 0)
+                                Test[Loop1].SkipFlag = 1;
+                            if (HDstrcmp(argv[Loop], Test[Loop1].Name) == 0)
+                                Loop1 = Index;
+                        }   /* end for */
+                      Loop++;
+                  }     /* end while */
+            }   /* end if */
+          if ((argc > CLLoop + 1) && ((HDstrcmp(argv[CLLoop], "-only") == 0) ||
+                                      (HDstrcmp(argv[CLLoop], "-o") == 0)))
+            {
+                for (Loop = 0; Loop < Index; Loop++)
+                    Test[Loop].SkipFlag = 1;
+                Loop = CLLoop + 1;
+                while ((Loop < argc) && (argv[Loop][0] != '-'))
+                  {
+                      for (Loop1 = 0; Loop1 < Index; Loop1++)
+                          if (HDstrcmp(argv[Loop], Test[Loop1].Name) == 0)
+                              Test[Loop1].SkipFlag = 0;
+                      Loop++;
+                  }     /* end while */
+            }   /* end if */
+      }     /* end for */
+
+#ifdef NOT_YET
+    if(Cache) /* turn on caching, unless we were instucted not to */
+        Hcache(CACHE_ALL_FILES,TRUE);
+#endif /* NOT_YET */
+
+    for (Loop = 0; Loop < Index; Loop++)
+      {
+          if (Test[Loop].SkipFlag)
+            {
+                MESSAGE(2, print_func("Skipping -- %s \n", Test[Loop].Description);
+                    );
+            }
+          else
+            {
+                MESSAGE(2, print_func("Testing  -- %s (%s) \n", Test[Loop].Description,
+                                  Test[Loop].Name);
+                    );
+                MESSAGE(5, print_func("===============================================\n");
+                    );
+                Test[Loop].NumErrors = num_errs;
+                (*Test[Loop].Call) ();
+                Test[Loop].NumErrors = num_errs - Test[Loop].NumErrors;
+                MESSAGE(5, print_func("===============================================\n");
+                    );
+                MESSAGE(5, print_func("There were %d errors detected.\n\n", (int) Test[Loop].NumErrors);
+                    );
+            }   /* end else */
+      }     /* end for */
+
+    MESSAGE(2, print_func("\n\n");
+        )
+        if (num_errs)
+        print_func("!!! %d Error(s) were detected !!!\n\n", (int) num_errs);
+    else
+        print_func("All tests were successful. \n\n");
+
+    if (Summary)
+      {
+          print_func("Summary of Test Results:\n");
+          print_func("Name of Test     Errors Description of Test\n");
+          print_func("---------------- ------ --------------------------------------\n");
+
+          for (Loop = 0; Loop < Index; Loop++)
+            {
+                if (Test[Loop].NumErrors == -1)
+                    print_func("%16s %6s %s\n", Test[Loop].Name, "N/A", Test[Loop].Description);
+                else
+                    print_func("%16s %6d %s\n", Test[Loop].Name, (int) Test[Loop].NumErrors,
+                           Test[Loop].Description);
+            }   /* end for */
+          print_func("\n\n");
+      }     /* end if */
+
+    if (CleanUp)
+      {
+          MESSAGE(2, print_func("\nCleaning Up...\n\n");
+              );
+#if !(defined DOS386 | defined WIN386)
+          system("rm -f *.hdf *.tmp");
+#else   /* OLD_WAY */
+          remove("*.hdf");
+          remove("*.tmp");
+#endif  /* OLD_WAY */
+      }     /* end if */
+    exit(0);
+    return (0);
+}   /* end main() */
diff --git a/test/testhdf5.h b/test/testhdf5.h
new file mode 100644
index 0000000..1b482d2
--- /dev/null
+++ b/test/testhdf5.h
@@ -0,0 +1,115 @@
+/****************************************************************************
+ * NCSA HDF                                                                 *
+ * Software Development Group                                               *
+ * National Center for Supercomputing Applications                          *
+ * University of Illinois at Urbana-Champaign                               *
+ * 605 E. Springfield, Champaign IL 61820                                   *
+ *                                                                          *
+ * For conditions of distribution and use, see the accompanying             *
+ * hdf/COPYING file.                                                        *
+ *                                                                          *
+ ****************************************************************************/
+
+/* $Id$ */
+
+/*
+ * This header file contains information required for testing the HDF5 library.
+ */
+
+#ifndef HDF5TEST_H
+#define HDF5TEST_H
+
+/* Include required headers */
+#include "hdf5.h"
+#include <stdarg.h>
+
+/* Define these for use in all the tests */
+#ifndef HDF5_TEST_MASTER
+extern
+#endif
+int         num_errs
+#ifdef HDF5_TEST_MASTER
+= 0
+#endif
+,           Verbosity
+#ifdef HDF5_TEST_MASTER
+= 0
+#endif
+           ;
+
+/* Use %ld to print the value because long should cover most cases. */
+/* Used to make certain a return value _is_not_ a value */
+#define CHECK(ret, val, where) \
+do {if (Verbosity>9) print_func("   Call to routine: %15s at line %4d in %s returned %ld \n",where,(int)__LINE__,__FILE__,(long)ret);\
+if(ret == val) {print_func("*** UNEXPECTED RETURN from %s is %ld at line %4d in %s\n", where, (long)ret, (int)__LINE__,__FILE__); num_errs++;} \
+} while(0)
+
+#define CHECK_I(ret,where) {						      \
+   if (Verbosity>9) {							      \
+      print_func("   Call to routine: %15s at line %4d in %s returned %ld\n", \
+		 (where), (int)__LINE__, __FILE__, (long)(ret));	      \
+      if ((ret)<0) {							      \
+	 print_func ("*** UNEXPECTED RETURN from %s is %ld line %4d in %s\n", \
+		     (where), (long)(ret), (int)__LINE__, __FILE__);	      \
+	 num_errs++;							      \
+      }									      \
+   }									      \
+}
+		     
+#define CHECK_PTR(ret,where) {						      \
+   if (Verbosity>9) {							      \
+      print_func("   Call to routine: %15s at line %4d in %s returned %p\n",  \
+		 (where), (int)__LINE__, __FILE__, (ret));	 	      \
+      if (!(ret)) {							      \
+	 print_func ("*** UNEXPECTED RETURN from %s is NULL line %4d in %s\n",\
+		     (where), (int)__LINE__, __FILE__);			      \
+	 num_errs++;							      \
+      }									      \
+   }									      \
+}
+
+/* Used to make certain a return value _is_ a value */
+#define VERIFY(x, val, where) \
+do {if (Verbosity>9) print_func("   Call to routine: %15s at line %4d in %s had value %ld \n",where,(int)__LINE__,__FILE__,(long)x);\
+if(x != val) {print_func("*** UNEXPECTED VALUE from %s is %ld at line %4d in %s\n", where, (long)x,(int)__LINE__,__FILE__); num_errs++;} \
+} while(0)
+
+/* Used to document process through a test and to check for errors */
+#define RESULT(ret,func) \
+do { \
+if (Verbosity>8) print_func("   Call to routine: %15s at line %4d in %s returned %ld \n",func,(int)__LINE__,__FILE__,(long)ret); \
+if (Verbosity>9) HEprint(stdout,0); \
+if(ret == FAIL) {print_func("*** UNEXPECTED RETURN from %s is %ld at line %4d in %s\n", func, (long)ret,(int)__LINE__,__FILE__); num_errs++;} \
+} while(0)
+
+/* Used to document process through a test */
+#define MESSAGE(v,a) {if (Verbosity>v) {a}}
+
+/* definitions for command strings */
+#define VERBOSITY_STR	"Verbosity"
+#define SKIP_STR	"Skip"
+#define TEST_STR	"Test"
+#define CLEAN_STR	"Cleanup"
+
+/* System command to use for Cleanup */
+#ifdef VMS
+#define CLEAN_CMD	"delete *.hdf;*"
+#else
+#   ifdef WIN32
+#   define CLEAN_CMD  "del *.hdf"   
+#   else
+/* default is Unix */
+#   define CLEAN_CMD	"rm -f *.hdf"
+#   endif  /* WIN32  */
+#endif /*VMS */
+
+/* Prototypes for the support routines */
+int print_func(const char *, ...);
+
+/* Prototypes for the test routines */
+void test_metadata(void);
+void test_file(void);
+void test_heap (void);
+
+#endif /* HDF5TEST_H */
+
diff --git a/test/tfile.c b/test/tfile.c
new file mode 100644
index 0000000..81c8cd2
--- /dev/null
+++ b/test/tfile.c
@@ -0,0 +1,288 @@
+/****************************************************************************
+ * NCSA HDF                                                                 *
+ * Software Development Group                                               *
+ * National Center for Supercomputing Applications                          *
+ * University of Illinois at Urbana-Champaign                               *
+ * 605 E. Springfield, Champaign IL 61820                                   *
+ *                                                                          *
+ * For conditions of distribution and use, see the accompanying             *
+ * hdf/COPYING file.                                                        *
+ *                                                                          *
+ ****************************************************************************/
+
+#ifdef RCSID
+static char RcsId[] = "$Revision$";
+#endif
+
+/* $Id$ */
+
+/***********************************************************
+*
+* Test program:  tfile
+*
+* Test the low-level file I/O features.
+*
+*************************************************************/
+
+#include "testhdf5.h"
+
+#define F1_USERBLOCK_SIZE  HDF5_USERBLOCK_DEFAULT
+#define F1_OFFSET_SIZE     HDF5_OFFSETSIZE_DEFAULT
+#define F1_LENGTH_SIZE     HDF5_LENGTHSIZE_DEFAULT
+#define F1_BTREEPAGE_SIZE  HDF5_BTREEPAGE_DEFAULT
+#define FILE1   "tfile1.h5"
+
+#define F2_USERBLOCK_SIZE  512
+#define F2_OFFSET_SIZE  8
+#define F2_LENGTH_SIZE  8
+#define F2_BTREEPAGE_SIZE  2048
+#define FILE2   "tfile2.h5"
+
+#define F3_USERBLOCK_SIZE  HDF5_USERBLOCK_DEFAULT
+#define F3_OFFSET_SIZE     F2_OFFSET_SIZE
+#define F3_LENGTH_SIZE     F2_LENGTH_SIZE
+#define F3_BTREEPAGE_SIZE  F2_BTREEPAGE_SIZE
+#define FILE3   "tfile3.h5"
+
+/****************************************************************
+**
+**  test_file_create(): Low-level file creation I/O test routine.
+** 
+****************************************************************/
+static void test_file_create(void)
+{
+    hatom_t fid1,fid2,fid3;    /* HDF5 File IDs */
+    hatom_t tmpl1,tmpl2;       /* File creation templates */
+    uintn parm;           /* File-creation parameters */
+    herr_t ret;         /* Generic return value */
+
+    /* Output message about test being performed */
+    MESSAGE(5, print_func("Testing Low-Level File Creation I/O\n"););
+
+    /* Create first file */
+    fid1=H5Fcreate(FILE1,H5ACC_OVERWRITE,0,0);
+    CHECK(fid1,FAIL,"H5Fcreate");
+
+    /* Try to create first file again (should fail) */
+    fid2=H5Fcreate(FILE1,H5ACC_OVERWRITE,0,0);
+    VERIFY(fid2,FAIL,"H5Fcreate");
+
+    /* Get the file-creation template */
+    tmpl1=H5Fget_create_template(fid1);
+    CHECK(tmpl1,FAIL,"H5Fget_create_template");
+
+    /* Get the file-creation parameters */
+    ret=H5Cgetparm(tmpl1,H5_USERBLOCK_SIZE,&parm);
+printf("USERBLOCK_SIZE=%u\n",parm);
+    CHECK(ret,FAIL,"H5Cgetparm");
+    VERIFY(parm,F1_USERBLOCK_SIZE,"H5Cgetparm");
+
+    ret=H5Cgetparm(tmpl1,H5_OFFSET_SIZE,&parm);
+printf("OFFSET_SIZE=%u\n",parm);
+    CHECK(ret,FAIL,"H5Cgetparm");
+    VERIFY(parm,F1_OFFSET_SIZE,"H5Cgetparm");
+
+    ret=H5Cgetparm(tmpl1,H5_LENGTH_SIZE,&parm);
+printf("LENGTH_SIZE=%u\n",parm);
+    CHECK(ret,FAIL,"H5Cgetparm");
+    VERIFY(parm,F1_LENGTH_SIZE,"H5Cgetparm");
+
+    ret=H5Cgetparm(tmpl1,H5_BTREE_SIZE,&parm);
+printf("BTREE_SIZE=%u\n",parm);
+    CHECK(ret,FAIL,"H5Cgetparm");
+    VERIFY(parm,F1_BTREEPAGE_SIZE,"H5Cgetparm");
+
+    /* Release file-creation template */
+    ret=H5Mrelease(tmpl1);
+    CHECK(ret,FAIL,"H5Mrelease");
+    
+    /* Double-check that the atom has been vaporized */
+    ret=H5Mrelease(tmpl1);
+    VERIFY(ret,FAIL,"H5Mrelease");
+
+    /* Create a new file with a non-standard file-creation template */
+    tmpl1=H5Mcreate(fid1,H5_TEMPLATE,NULL);
+    CHECK(tmpl1,FAIL,"H5Mcreate");
+
+    /* Set the new file-creation parameters */
+    parm=F2_USERBLOCK_SIZE;
+    ret=H5Csetparm(tmpl1,H5_USERBLOCK_SIZE,&parm);
+    CHECK(ret,FAIL,"H5Csetparm");
+
+    parm=F2_OFFSET_SIZE;
+    ret=H5Csetparm(tmpl1,H5_OFFSET_SIZE,&parm);
+    CHECK(ret,FAIL,"H5Csetparm");
+
+    parm=F2_LENGTH_SIZE;
+    ret=H5Csetparm(tmpl1,H5_LENGTH_SIZE,&parm);
+    CHECK(ret,FAIL,"H5Csetparm");
+
+    parm=F2_BTREEPAGE_SIZE;
+    ret=H5Csetparm(tmpl1,H5_BTREE_SIZE,&parm);
+    CHECK(ret,FAIL,"H5Csetparm");
+
+    /* Try to create second file, with non-standard file-creation template params */
+    fid2=H5Fcreate(FILE2,H5ACC_OVERWRITE,tmpl1,0);
+    CHECK(fid2,FAIL,"H5Fcreate");
+
+    /* Release file-creation template */
+    ret=H5Mrelease(tmpl1);
+    CHECK(ret,FAIL,"H5Mrelease");
+    
+    /* Get the file-creation template */
+    tmpl1=H5Fget_create_template(fid2);
+    CHECK(tmpl1,FAIL,"H5Fget_create_template");
+
+    /* Get the file-creation parameters */
+    ret=H5Cgetparm(tmpl1,H5_USERBLOCK_SIZE,&parm);
+printf("USERBLOCK_SIZE=%u\n",parm);
+    CHECK(ret,FAIL,"H5Cgetparm");
+    VERIFY(parm,F2_USERBLOCK_SIZE,"H5Cgetparm");
+
+    ret=H5Cgetparm(tmpl1,H5_OFFSET_SIZE,&parm);
+printf("OFFSET_SIZE=%u\n",parm);
+    CHECK(ret,FAIL,"H5Cgetparm");
+    VERIFY(parm,F2_LENGTH_SIZE,"H5Cgetparm");
+
+    ret=H5Cgetparm(tmpl1,H5_LENGTH_SIZE,&parm);
+printf("LENGTH_SIZE=%u\n",parm);
+    CHECK(ret,FAIL,"H5Cgetparm");
+    VERIFY(parm,F2_OFFSET_SIZE,"H5Cgetparm");
+
+    ret=H5Cgetparm(tmpl1,H5_BTREE_SIZE,&parm);
+printf("BTREE_SIZE=%u\n",parm);
+    CHECK(ret,FAIL,"H5Cgetparm");
+    VERIFY(parm,F2_BTREEPAGE_SIZE,"H5Cgetparm");
+
+    /* Clone the file-creation template */
+    tmpl2=H5Mcopy(tmpl1);
+    CHECK(tmpl2,FAIL,"H5Mcopy");
+
+    /* Release file-creation template */
+    ret=H5Mrelease(tmpl1);
+    CHECK(ret,FAIL,"H5Mrelease");
+
+    /* Set the new file-creation parameter */
+    parm=F3_USERBLOCK_SIZE;
+    ret=H5Csetparm(tmpl2,H5_USERBLOCK_SIZE,&parm);
+    CHECK(ret,FAIL,"H5Csetparm");
+
+    /* Try to create second file, with non-standard file-creation template params */
+    fid3=H5Fcreate(FILE3,H5ACC_OVERWRITE,tmpl2,0);
+    CHECK(fid3,FAIL,"H5Fcreate");
+
+    /* Release file-creation template */
+    ret=H5Mrelease(tmpl2);
+    CHECK(ret,FAIL,"H5Mrelease");
+
+    /* Get the file-creation template */
+    tmpl1=H5Fget_create_template(fid3);
+    CHECK(tmpl1,FAIL,"H5Fget_create_template");
+
+    /* Get the file-creation parameters */
+    ret=H5Cgetparm(tmpl1,H5_USERBLOCK_SIZE,&parm);
+printf("USERBLOCK_SIZE=%u\n",parm);
+    CHECK(ret,FAIL,"H5Cgetparm");
+    VERIFY(parm,F3_USERBLOCK_SIZE,"H5Cgetparm");
+
+    ret=H5Cgetparm(tmpl1,H5_OFFSET_SIZE,&parm);
+printf("OFFSET_SIZE=%u\n",parm);
+    CHECK(ret,FAIL,"H5Cgetparm");
+    VERIFY(parm,F3_LENGTH_SIZE,"H5Cgetparm");
+
+    ret=H5Cgetparm(tmpl1,H5_LENGTH_SIZE,&parm);
+printf("LENGTH_SIZE=%u\n",parm);
+    CHECK(ret,FAIL,"H5Cgetparm");
+    VERIFY(parm,F3_OFFSET_SIZE,"H5Cgetparm");
+
+    ret=H5Cgetparm(tmpl1,H5_BTREE_SIZE,&parm);
+printf("BTREE_SIZE=%u\n",parm);
+    CHECK(ret,FAIL,"H5Cgetparm");
+    VERIFY(parm,F3_BTREEPAGE_SIZE,"H5Cgetparm");
+
+    /* Release file-creation template */
+    ret=H5Mrelease(tmpl1);
+    CHECK(ret,FAIL,"H5Mrelease");
+
+    /* Close first file */
+    ret=H5Fclose(fid1);
+    CHECK(ret,FAIL,"H5Fclose");
+
+    /* Close second file */
+    ret=H5Fclose(fid2);
+    CHECK(ret,FAIL,"H5Fclose");
+
+    /* Close third file */
+    ret=H5Fclose(fid3);
+    CHECK(ret,FAIL,"H5Fclose");
+}   /* test_file_create() */
+
+
+/****************************************************************
+**
+**  test_file_open(): Low-level file open I/O test routine.
+** 
+****************************************************************/
+static void test_file_open(void)
+{
+    hatom_t fid1,fid2,fid3;    /* HDF5 File IDs */
+    hatom_t tmpl1,tmpl2;       /* File creation templates */
+    uintn parm;           /* File-creation parameters */
+    herr_t ret;         /* Generic return value */
+
+    /* Output message about test being performed */
+    MESSAGE(5, print_func("Testing Low-Level File Opening I/O\n"););
+
+    /* Open second file */
+    fid1=H5Fopen(FILE2,H5ACC_WRITE,0);
+    CHECK(fid1,FAIL,"H5Fooen");
+
+    /* Get the file-creation template */
+    tmpl1=H5Fget_create_template(fid1);
+    CHECK(tmpl1,FAIL,"H5Fget_create_template");
+
+    /* Get the file-creation parameters */
+    ret=H5Cgetparm(tmpl1,H5_USERBLOCK_SIZE,&parm);
+printf("USERBLOCK_SIZE=%u\n",parm);
+    CHECK(ret,FAIL,"H5Cgetparm");
+    VERIFY(parm,F2_USERBLOCK_SIZE,"H5Cgetparm");
+
+    ret=H5Cgetparm(tmpl1,H5_OFFSET_SIZE,&parm);
+printf("OFFSET_SIZE=%u\n",parm);
+    CHECK(ret,FAIL,"H5Cgetparm");
+    VERIFY(parm,F2_OFFSET_SIZE,"H5Cgetparm");
+
+    ret=H5Cgetparm(tmpl1,H5_LENGTH_SIZE,&parm);
+printf("LENGTH_SIZE=%u\n",parm);
+    CHECK(ret,FAIL,"H5Cgetparm");
+    VERIFY(parm,F2_LENGTH_SIZE,"H5Cgetparm");
+
+    ret=H5Cgetparm(tmpl1,H5_BTREE_SIZE,&parm);
+printf("BTREE_SIZE=%u\n",parm);
+    CHECK(ret,FAIL,"H5Cgetparm");
+    VERIFY(parm,F2_BTREEPAGE_SIZE,"H5Cgetparm");
+
+    /* Release file-creation template */
+    ret=H5Mrelease(tmpl1);
+    CHECK(ret,FAIL,"H5Mrelease");
+    
+    /* Close first file */
+    ret=H5Fclose(fid1);
+    CHECK(ret,FAIL,"H5Fclose");
+}   /* test_file_open() */
+
+
+/****************************************************************
+**
+**  test_file(): Main low-level file I/O test routine.
+** 
+****************************************************************/
+void test_file(void)
+{
+    /* Output message about test being performed */
+    MESSAGE(5, print_func("Testing Low-Level File I/O\n"););
+
+    test_file_create();     /* Test file creation (also creation templates) */
+    test_file_open();       /* Test file opening */
+}   /* test_file() */
+
diff --git a/test/theap.c b/test/theap.c
new file mode 100644
index 0000000..41a9cbc
--- /dev/null
+++ b/test/theap.c
@@ -0,0 +1,87 @@
+/*-------------------------------------------------------------------------
+ * Copyright (C) 1997	National Center for Supercomputing Applications.
+ *                      All rights reserved.
+ *
+ *-------------------------------------------------------------------------
+ *
+ * Created:		theap.c
+ * 			Jul 17 1997
+ * 			Robb Matzke <robb@maya.nuance.com>
+ *
+ * Purpose:		
+ *
+ * Modifications:	
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "testhdf5.h"
+
+#include "H5ACprivate.h"
+#include "H5Fprivate.h"
+#include "H5Hprivate.h"
+
+#define NOBJS	40
+
+
+/*-------------------------------------------------------------------------
+ * Function:	test_heap
+ *
+ * Purpose:	Test name and object heaps.
+ *
+ * Return:	void
+ *
+ * Programmer:	Robb Matzke
+ *		robb@maya.nuance.com
+ *		Jul 17 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+void
+test_heap (void)
+{
+   int		i, j;
+   hatom_t	fid;
+   hdf5_file_t	*f;
+   off_t	heap;
+   char		buf[NOBJS+8];
+   const char	*s;
+   off_t	obj[NOBJS];
+   
+   MESSAGE (5, print_func("Testing Heaps\n"););
+
+   /* Create the file */
+   fid = H5Fcreate ("theap.h5", H5ACC_OVERWRITE, 0, 0);
+   CHECK (fid, FAIL, "H5Fcreate");
+   f = H5Aatom_object (fid);
+   CHECK (f, NULL, "H5Aatom_object");
+
+   /* Create a new heap */
+   heap = H5H_new (f, 0);
+   CHECK_I (heap, "H5H_new");
+
+   /* Add stuff to the heap */
+   for (i=0; i<NOBJS; i++) {
+      fprintf (stderr, "%d\n", i);
+      sprintf (buf, "%03d-", i);
+      for (j=4; j<i; j++) buf[j] = '0' + j%10;
+      if (j>4) buf[j] = '\0';
+
+      obj[i] = H5H_insert (f, heap, strlen(buf)+1, buf);
+      CHECK_I (heap, "H5H_insert");
+   }
+
+   /* Flush the cache and invalidate everything */
+   H5AC_flush (f, NULL, 0, TRUE);
+
+   /* Read the objects back out */
+   for (i=0; i<NOBJS; i++) {
+      s = H5H_peek (f, heap, obj[i]);
+      print_func ("object is `%s'\n", s);
+   }
+
+   /* Close the file */
+   H5Fclose (fid);
+}
+
diff --git a/test/tmeta.c b/test/tmeta.c
new file mode 100644
index 0000000..7ef7d73
--- /dev/null
+++ b/test/tmeta.c
@@ -0,0 +1,120 @@
+/****************************************************************************
+ * NCSA HDF                                                                 *
+ * Software Development Group                                               *
+ * National Center for Supercomputing Applications                          *
+ * University of Illinois at Urbana-Champaign                               *
+ * 605 E. Springfield, Champaign IL 61820                                   *
+ *                                                                          *
+ * For conditions of distribution and use, see the accompanying             *
+ * hdf/COPYING file.                                                        *
+ *                                                                          *
+ ****************************************************************************/
+
+#ifdef RCSID
+static char RcsId[] = "$Revision$";
+#endif
+
+/* $Id$ */
+
+/***********************************************************
+*
+* Test program:  tmeta
+*
+* Test the basic meta-data encode/decode macros calls.
+*
+*************************************************************/
+
+#include "testhdf5.h"
+
+#define TEST_INT16_VALUE    -7641
+#define TEST_UINT16_VALUE   45002
+#define TEST_INT32_VALUE    -981236
+#define TEST_UINT32_VALUE   3476589
+
+uint8 compar_buffer[]={
+    /* Little-endian encoded version of the 16-bit signed integer */
+    (uint8)((TEST_INT16_VALUE)&0xff), (uint8)((TEST_INT16_VALUE>>8)&0xff), 
+    /* Little-endian encoded version of the 16-bit unsigned integer */
+    (uint8)((TEST_UINT16_VALUE)&0xff), (uint8)((TEST_UINT16_VALUE>>8)&0xff), 
+    /* Little-endian encoded version of the 32-bit signed integer */
+    (uint8)((TEST_INT32_VALUE)&0xff), (uint8)((TEST_INT32_VALUE>>8)&0xff), 
+    (uint8)((TEST_INT32_VALUE>>16)&0xff), (uint8)((TEST_INT32_VALUE>>24)&0xff), 
+    /* Little-endian encoded version of the 32-bit unsigned integer */
+    (uint8)((TEST_UINT32_VALUE)&0xff), (uint8)((TEST_UINT32_VALUE>>8)&0xff), 
+    (uint8)((TEST_UINT32_VALUE>>16)&0xff), (uint8)((TEST_UINT32_VALUE>>24)&0xff), 
+ };
+
+uint8 encode_buffer[sizeof(compar_buffer)];
+
+/****************************************************************
+**
+**  test_metadata(): Main meta-data encode/decode testing routine.
+** 
+****************************************************************/
+void test_metadata(void)
+{
+    int16 ei16=TEST_INT16_VALUE;    /* variables to hold the values to encode */
+    uint16 eu16=TEST_UINT16_VALUE;
+    int32 ei32=TEST_INT32_VALUE;
+    uint32 eu32=TEST_UINT32_VALUE;
+    int16 di16;    /* variables to hold the decoded values */
+    uint16 du16;
+    int32 di32;
+    uint32 du32;
+    uint8 *p;       /* pointer into the buffer being en/de-coded */
+
+    /* Output message about test being performed */
+    MESSAGE(5, print_func("Testing Metadata encode/decode code\n"););
+
+    /* Start by encoding the values above */
+    p=encode_buffer;
+    INT16ENCODE(p,ei16);    /* Encode the int16 value */
+    UINT16ENCODE(p,eu16);   /* Encode the uint16 value */
+    INT32ENCODE(p,ei32);    /* Encode the int32 value */
+    UINT32ENCODE(p,eu32);   /* Encode the uint32 value */
+
+    /* Check if we got what we asked for */
+    if(HDmemcmp(encode_buffer,compar_buffer,sizeof(compar_buffer))!=0)
+      {
+        uintn u;     /* local counting variable */
+
+        for(u=0; u<sizeof(compar_buffer); u++)
+          {
+            if(compar_buffer[u]!=encode_buffer[u])
+              {
+                print_func("Error encoding meta-data at offset %u, wanted: %u, got: %u\n",(unsigned)u,(unsigned)compar_buffer[u],(unsigned)encode_buffer[u]);
+                num_errs++;
+              } /* end if */
+          } /* end for */
+      } /* end if */
+
+    /* Test decoding macros */
+    p=encode_buffer;
+    INT16DECODE(p,di16);    /* Decode the int16 value */
+    UINT16DECODE(p,du16);   /* Decode the uint16 value */
+    INT32DECODE(p,di32);    /* Decode the int32 value */
+    UINT32DECODE(p,du32);   /* Decode the uint32 value */
+
+    /* Check the values decoded */
+    if(di16!=TEST_INT16_VALUE)
+      {
+        print_func("Error decoding int16 meta-data wanted: %d, got: %d\n",(int)TEST_INT16_VALUE,(int)di16);
+        num_errs++;
+      } /* end if */
+    if(du16!=TEST_UINT16_VALUE)
+      {
+        print_func("Error decoding uint16 meta-data wanted: %u, got: %u\n",(unsigned)TEST_UINT16_VALUE,(unsigned)du16);
+        num_errs++;
+      } /* end if */
+    if(di32!=TEST_INT32_VALUE)
+      {
+        print_func("Error decoding int32 meta-data wanted: %ld, got: %ld\n",(long)TEST_INT32_VALUE,(long)di32);
+        num_errs++;
+      } /* end if */
+    if(du32!=TEST_UINT32_VALUE)
+      {
+        print_func("Error decoding uint32 meta-data wanted: %lu, got: %lu\n",(unsigned long)TEST_UINT32_VALUE,(unsigned long)du32);
+        num_errs++;
+      } /* end if */
+}   /* test_metadata() */
+