[svn-r12592] Description:

    Several changes, all mooshed together:
        - Add support for "tiny" objects - which can be stored in the heap
            ID itself, instead of in the heap data blocks.
        - Flesh out support for compressed direct blocks, but comment it
            out until John's got some metadata cache changes in place to
            support it.
        - Add support for applying I/O pipeline filters to 'huge' objects
        - Refactor 'huge' object code to store information for 'huge' objects
            directly in the heap ID, when there are I/O pipeline filters
            applied to the heap (and the heap ID is large enough to hold the
            information)
        - Update h5debug tool to correctly handle 'huge' & 'tiny' objects.
        - Misc. other code cleanups, etc.

Tested on:
    FreeBSD/32 4.11 (sleipnir)
    Linux/64 2.4 (mir)
    Solaris/64 2.9 (shanti)

1 files changed, 1921 insertions, 19 deletions

diff --git a/test/fheap.c b/test/fheap.c
index 49baf02..ade01a5 100644
--- a/test/fheap.c
+++ b/test/fheap.c
@@ -111,6 +111,8 @@ typedef struct fheap_heap_state_t {
     hsize_t     man_free_space;         /* Managed object free space within heap */
     size_t      huge_nobjs;             /* # of 'huge' objects within heap */
     hsize_t     huge_size;              /* Size of 'huge' object heap */
+    size_t      tiny_nobjs;             /* # of 'tiny' objects within heap */
+    hsize_t     tiny_size;              /* Size of 'tiny' object heap */
 } fheap_heap_state_t;
 
 /* Heap IDs to retain */
@@ -220,6 +222,14 @@ check_stats(const H5HF_t *fh, const fheap_heap_state_t *state)
         HDfprintf(stdout, "heap_stats.huge_size = %Hu, state->huge_size = %Hu\n", heap_stats.huge_size, state->huge_size);
         FAIL_STACK_ERROR
     } /* end if */
+    if(heap_stats.tiny_nobjs != state->tiny_nobjs) {
+        HDfprintf(stdout, "heap_stats.tiny_nobjs = %Hu, state->tiny_nobjs = %Hu\n", heap_stats.tiny_nobjs, state->tiny_nobjs);
+        FAIL_STACK_ERROR
+    } /* end if */
+    if(heap_stats.tiny_size != state->tiny_size) {
+        HDfprintf(stdout, "heap_stats.tiny_size = %Hu, state->tiny_size = %Hu\n", heap_stats.tiny_size, state->tiny_size);
+        FAIL_STACK_ERROR
+    } /* end if */
 
     /* All tests passed */
     return(0);
@@ -1684,7 +1694,7 @@ test_create(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t UNUSED *tparam
     HDmemset(&test_cparam, 0, sizeof(H5HF_create_t));
     if(H5HF_get_cparam_test(fh, &test_cparam) < 0)
         FAIL_STACK_ERROR
-    if(HDmemcmp(cparam, &test_cparam, sizeof(H5HF_create_t)))
+    if(H5HF_cmp_cparam_test(cparam, &test_cparam))
         TEST_ERROR
 
     /* Close the fractal heap */
@@ -1792,7 +1802,7 @@ test_reopen(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t UNUSED *tparam
     HDmemset(&test_cparam, 0, sizeof(H5HF_create_t));
     if(H5HF_get_cparam_test(fh, &test_cparam) < 0)
         FAIL_STACK_ERROR
-    if(HDmemcmp(cparam, &test_cparam, sizeof(H5HF_create_t)))
+    if(H5HF_cmp_cparam_test(cparam, &test_cparam))
         TEST_ERROR
 
     /* Close the fractal heap */
@@ -1817,6 +1827,466 @@ error:
     return(1);
 } /* test_reopen() */
 
+
+/*-------------------------------------------------------------------------
+ * Function:	test_id_limits
+ *
+ * Purpose:	Test limits for heap ID lengths
+ *
+ * Return:	Success:	0
+ *		Failure:	1
+ *
+ * Programmer:	Quincey Koziol
+ *              Monday, August 14, 2006
+ *
+ *-------------------------------------------------------------------------
+ */
+static int
+test_id_limits(hid_t fapl, H5HF_create_t *cparam)
+{
+    hid_t	file = -1;              /* File ID */
+    hid_t       dxpl = H5P_DATASET_XFER_DEFAULT;     /* DXPL to use */
+    char	filename[FHEAP_FILENAME_LEN];         /* Filename to use */
+    H5F_t	*f = NULL;              /* Internal file object pointer */
+    H5HF_t      *fh = NULL;             /* Fractal heap wrapper */
+    H5HF_create_t tmp_cparam;           /* Local heap creation parameters */
+    unsigned    deflate_level;          /* Deflation level */
+    size_t      id_len;                 /* Size of fractal heap IDs */
+    size_t      tiny_max_len;           /* Max. length of tiny objects */
+    hbool_t     tiny_len_extended;      /* Do tiny objects use two bytes for the length? */
+    hbool_t     huge_ids_direct;        /* Are 'huge' objects directly acccessed? */
+
+    /* Set the filename to use for this test (dependent on fapl) */
+    h5_fixname(FILENAME[0], fapl, filename, sizeof(filename));
+
+    /* Create the file to work on */
+    if((file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
+        FAIL_STACK_ERROR
+
+    /* Get a pointer to the internal file object */
+    if(NULL == (f = H5I_object(file)))
+        FAIL_STACK_ERROR
+
+    /* Display testing message */
+    TESTING("limits of heap ID lengths")
+
+    /* Copy heap creation properties */
+    HDmemcpy(&tmp_cparam, cparam, sizeof(H5HF_create_t));
+
+
+    /* Set the 'default' heap ID length */
+    tmp_cparam.id_len = 0;
+
+    /* Create absolute heap */
+    if(NULL == (fh = H5HF_create(f, dxpl, &tmp_cparam)))
+        FAIL_STACK_ERROR
+
+    /* Test ID length information for heap */
+    if(H5HF_get_id_len(fh, &id_len) < 0)
+        FAIL_STACK_ERROR
+    if(id_len != HEAP_ID_LEN)
+        FAIL_STACK_ERROR
+    if(H5HF_get_tiny_info_test(fh, &tiny_max_len, &tiny_len_extended) < 0)
+        FAIL_STACK_ERROR
+    if(tiny_max_len != (HEAP_ID_LEN - 1))
+        TEST_ERROR
+    if(tiny_len_extended != FALSE)
+        TEST_ERROR
+    if(H5HF_get_huge_info_test(fh, NULL, &huge_ids_direct) < 0)
+        FAIL_STACK_ERROR
+    if(huge_ids_direct != FALSE)
+        TEST_ERROR
+
+    /* Close the fractal heap */
+    if(H5HF_close(fh, dxpl) < 0)
+        FAIL_STACK_ERROR
+    fh = NULL;
+
+
+    /* Set the heap ID length to the size needed for directly accessing 'huge' objects */
+    /* (with no I/O pipeline filters) */
+    tmp_cparam.id_len = 1;
+
+    /* Create absolute heap */
+    if(NULL == (fh = H5HF_create(f, dxpl, &tmp_cparam)))
+        FAIL_STACK_ERROR
+
+    /* Test ID length information for heap */
+    if(H5HF_get_id_len(fh, &id_len) < 0)
+        FAIL_STACK_ERROR
+    if(id_len != 17)
+        FAIL_STACK_ERROR
+    if(H5HF_get_tiny_info_test(fh, &tiny_max_len, &tiny_len_extended) < 0)
+        FAIL_STACK_ERROR
+    if(tiny_max_len != 16)
+        TEST_ERROR
+    if(tiny_len_extended != FALSE)
+        TEST_ERROR
+    if(H5HF_get_huge_info_test(fh, NULL, &huge_ids_direct) < 0)
+        FAIL_STACK_ERROR
+    if(huge_ids_direct != TRUE)
+        TEST_ERROR
+
+    /* Close the fractal heap */
+    if(H5HF_close(fh, dxpl) < 0)
+        FAIL_STACK_ERROR
+    fh = NULL;
+
+
+    /* Set the heap ID length to the size needed for directly accessing 'huge' objects */
+    /* (with I/O pipeline filters) */
+    tmp_cparam.id_len = 1;
+
+    /* Set an I/O filter for heap data */
+    deflate_level = 6;
+    if(H5Z_append(&tmp_cparam.pline, H5Z_FILTER_DEFLATE, H5Z_FLAG_OPTIONAL, 1, &deflate_level) < 0)
+        FAIL_STACK_ERROR
+
+    /* Create absolute heap */
+    if(NULL == (fh = H5HF_create(f, dxpl, &tmp_cparam)))
+        FAIL_STACK_ERROR
+
+    /* Test ID length information for heap */
+    if(H5HF_get_id_len(fh, &id_len) < 0)
+        FAIL_STACK_ERROR
+    if(id_len != 29)
+        FAIL_STACK_ERROR
+    if(H5HF_get_tiny_info_test(fh, &tiny_max_len, &tiny_len_extended) < 0)
+        FAIL_STACK_ERROR
+    if(tiny_max_len != 27)
+        TEST_ERROR
+    if(tiny_len_extended != TRUE)
+        TEST_ERROR
+    if(H5HF_get_huge_info_test(fh, NULL, &huge_ids_direct) < 0)
+        FAIL_STACK_ERROR
+    if(huge_ids_direct != TRUE)
+        TEST_ERROR
+
+    /* Close the fractal heap */
+    if(H5HF_close(fh, dxpl) < 0)
+        FAIL_STACK_ERROR
+    fh = NULL;
+
+    /* Release the I/O pipeline filter information */
+    H5O_reset(H5O_PLINE_ID, &tmp_cparam.pline);
+
+
+    /* Set the heap ID length to a size that's too small for 'managed' heap IDs */
+    tmp_cparam.id_len = 3;
+
+    /* Create absolute heap */
+    H5E_BEGIN_TRY {
+        fh = H5HF_create(f, dxpl, &tmp_cparam);
+    } H5E_END_TRY;
+    if(NULL != fh)
+        FAIL_STACK_ERROR
+
+
+    /* Set the heap ID length a size that's large enough for 'tiny' & 'managed'
+     *  objects, but too small for directly accessing 'huge' objects
+     */
+    tmp_cparam.id_len = 8;
+
+    /* Create absolute heap */
+    if(NULL == (fh = H5HF_create(f, dxpl, &tmp_cparam)))
+        FAIL_STACK_ERROR
+
+    /* Test ID length information for heap */
+    if(H5HF_get_id_len(fh, &id_len) < 0)
+        FAIL_STACK_ERROR
+    if(id_len != 8)
+        FAIL_STACK_ERROR
+    if(H5HF_get_tiny_info_test(fh, &tiny_max_len, &tiny_len_extended) < 0)
+        FAIL_STACK_ERROR
+    if(tiny_max_len != 7)
+        TEST_ERROR
+    if(tiny_len_extended != FALSE)
+        TEST_ERROR
+    if(H5HF_get_huge_info_test(fh, NULL, &huge_ids_direct) < 0)
+        FAIL_STACK_ERROR
+    if(huge_ids_direct != FALSE)
+        TEST_ERROR
+
+    /* Close the fractal heap */
+    if(H5HF_close(fh, dxpl) < 0)
+        FAIL_STACK_ERROR
+    fh = NULL;
+
+
+    /* Set the heap ID length a size that's large enough for directly
+     *  directly accessing 'huge' objects
+     */
+    tmp_cparam.id_len = 17;
+
+    /* Create absolute heap */
+    if(NULL == (fh = H5HF_create(f, dxpl, &tmp_cparam)))
+        FAIL_STACK_ERROR
+
+    /* Test ID length information for heap */
+    if(H5HF_get_id_len(fh, &id_len) < 0)
+        FAIL_STACK_ERROR
+    if(id_len != 17)
+        FAIL_STACK_ERROR
+    if(H5HF_get_tiny_info_test(fh, &tiny_max_len, &tiny_len_extended) < 0)
+        FAIL_STACK_ERROR
+    if(tiny_max_len != 16)
+        TEST_ERROR
+    if(tiny_len_extended != FALSE)
+        TEST_ERROR
+    if(H5HF_get_huge_info_test(fh, NULL, &huge_ids_direct) < 0)
+        FAIL_STACK_ERROR
+    if(huge_ids_direct != TRUE)
+        TEST_ERROR
+
+    /* Close the fractal heap */
+    if(H5HF_close(fh, dxpl) < 0)
+        FAIL_STACK_ERROR
+    fh = NULL;
+
+
+    /* Set the heap ID length to the low side of the boundary condition for
+     *  encoding 'tiny' objects in one byte
+     */
+    tmp_cparam.id_len = 18;
+
+    /* Create absolute heap */
+    if(NULL == (fh = H5HF_create(f, dxpl, &tmp_cparam)))
+        FAIL_STACK_ERROR
+
+    /* Test ID length information for heap */
+    if(H5HF_get_id_len(fh, &id_len) < 0)
+        FAIL_STACK_ERROR
+    if(id_len != 18)
+        FAIL_STACK_ERROR
+    if(H5HF_get_tiny_info_test(fh, &tiny_max_len, &tiny_len_extended) < 0)
+        FAIL_STACK_ERROR
+    if(tiny_max_len != 16)
+        TEST_ERROR
+    if(tiny_len_extended != FALSE)
+        TEST_ERROR
+    if(H5HF_get_huge_info_test(fh, NULL, &huge_ids_direct) < 0)
+        FAIL_STACK_ERROR
+    if(huge_ids_direct != TRUE)
+        TEST_ERROR
+
+    /* Close the fractal heap */
+    if(H5HF_close(fh, dxpl) < 0)
+        FAIL_STACK_ERROR
+    fh = NULL;
+
+
+    /* Set the heap ID length to the high side of the boundary condition for
+     *  encoding 'tiny' objects in one byte
+     */
+    tmp_cparam.id_len = 19;
+
+    /* Create absolute heap */
+    if(NULL == (fh = H5HF_create(f, dxpl, &tmp_cparam)))
+        FAIL_STACK_ERROR
+
+    /* Test ID length information for heap */
+    if(H5HF_get_id_len(fh, &id_len) < 0)
+        FAIL_STACK_ERROR
+    if(id_len != 19)
+        FAIL_STACK_ERROR
+    if(H5HF_get_tiny_info_test(fh, &tiny_max_len, &tiny_len_extended) < 0)
+        FAIL_STACK_ERROR
+    if(tiny_max_len != 17)
+        TEST_ERROR
+    if(tiny_len_extended != TRUE)
+        TEST_ERROR
+    if(H5HF_get_huge_info_test(fh, NULL, &huge_ids_direct) < 0)
+        FAIL_STACK_ERROR
+    if(huge_ids_direct != TRUE)
+        TEST_ERROR
+
+    /* Close the fractal heap */
+    if(H5HF_close(fh, dxpl) < 0)
+        FAIL_STACK_ERROR
+    fh = NULL;
+
+
+    /* Set the heap ID length a size that's larger than what is needed for
+     *  directly accessing 'huge' objects
+     */
+    tmp_cparam.id_len = 45;
+
+    /* Create absolute heap */
+    if(NULL == (fh = H5HF_create(f, dxpl, &tmp_cparam)))
+        FAIL_STACK_ERROR
+
+    /* Test ID length information for heap */
+    if(H5HF_get_id_len(fh, &id_len) < 0)
+        FAIL_STACK_ERROR
+    if(id_len != 45)
+        FAIL_STACK_ERROR
+    if(H5HF_get_tiny_info_test(fh, &tiny_max_len, &tiny_len_extended) < 0)
+        FAIL_STACK_ERROR
+    if(tiny_max_len != 43)
+        TEST_ERROR
+    if(tiny_len_extended != TRUE)
+        TEST_ERROR
+    if(H5HF_get_huge_info_test(fh, NULL, &huge_ids_direct) < 0)
+        FAIL_STACK_ERROR
+    if(huge_ids_direct != TRUE)
+        TEST_ERROR
+
+    /* Close the fractal heap */
+    if(H5HF_close(fh, dxpl) < 0)
+        FAIL_STACK_ERROR
+    fh = NULL;
+
+
+    /* Set the heap ID length to a size that's too large to encode the length
+     *  of 'tiny' objects
+     */
+    tmp_cparam.id_len = H5HF_MAX_ID_LEN + 1;
+
+    /* Create absolute heap */
+    H5E_BEGIN_TRY {
+        fh = H5HF_create(f, dxpl, &tmp_cparam);
+    } H5E_END_TRY;
+    if(NULL != fh)
+        FAIL_STACK_ERROR
+
+
+    /* Close the file */
+    if(H5Fclose(file) < 0)
+        FAIL_STACK_ERROR
+
+    /* All tests passed */
+    PASSED()
+
+    return(0);
+
+error:
+    H5E_BEGIN_TRY {
+        if(fh)
+            H5HF_close(fh, dxpl);
+	H5Fclose(file);
+    } H5E_END_TRY;
+    return(1);
+} /* test_id_limits() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	test_filtered_create
+ *
+ * Purpose:	Test creating a heap with I/O filters
+ *
+ * Return:	Success:	0
+ *		Failure:	1
+ *
+ * Programmer:	Quincey Koziol
+ *              Monday, August 14, 2006
+ *
+ *-------------------------------------------------------------------------
+ */
+static int
+test_filtered_create(hid_t fapl, H5HF_create_t *cparam)
+{
+    hid_t	file = -1;              /* File ID */
+    hid_t       dxpl = H5P_DATASET_XFER_DEFAULT;     /* DXPL to use */
+    char	filename[FHEAP_FILENAME_LEN];         /* Filename to use */
+    H5F_t	*f = NULL;              /* Internal file object pointer */
+    H5HF_t      *fh = NULL;             /* Fractal heap wrapper */
+    haddr_t     fh_addr;                /* Address of fractal heap */
+    H5HF_create_t tmp_cparam;           /* Local heap creation parameters */
+    H5HF_create_t test_cparam;          /* Temporary local heap creation parameters */
+    unsigned    deflate_level;          /* Deflation level */
+
+    /* Set the filename to use for this test (dependent on fapl) */
+    h5_fixname(FILENAME[0], fapl, filename, sizeof(filename));
+
+    /* Create the file to work on */
+    if((file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
+        FAIL_STACK_ERROR
+
+    /* Get a pointer to the internal file object */
+    if(NULL == (f = H5I_object(file)))
+        FAIL_STACK_ERROR
+
+    /* Display testing message */
+    TESTING("creating heaps with I/O filters")
+
+    /* Copy heap creation properties */
+    HDmemcpy(&tmp_cparam, cparam, sizeof(H5HF_create_t));
+
+
+    /* Set an I/O filter for heap data */
+    deflate_level = 6;
+    if(H5Z_append(&tmp_cparam.pline, H5Z_FILTER_DEFLATE, H5Z_FLAG_OPTIONAL, 1, &deflate_level) < 0)
+        FAIL_STACK_ERROR
+
+    /* Create absolute heap */
+    if(NULL == (fh = H5HF_create(f, dxpl, &tmp_cparam)))
+        FAIL_STACK_ERROR
+
+    /* Get heap's address */
+    if(H5HF_get_heap_addr(fh, &fh_addr) < 0)
+        FAIL_STACK_ERROR
+    if(!H5F_addr_defined(fh_addr))
+        TEST_ERROR
+
+/* XXX: Check heap's I/O filter settings? */
+
+    /* Close the fractal heap */
+    if(H5HF_close(fh, dxpl) < 0)
+        FAIL_STACK_ERROR
+    fh = NULL;
+
+    /* Close the file */
+    if(H5Fclose(file) < 0)
+        FAIL_STACK_ERROR
+
+    /* Re-open the file */
+    if((file = H5Fopen(filename, H5F_ACC_RDONLY, fapl)) < 0)
+        FAIL_STACK_ERROR
+
+    /* Get a pointer to the internal file object */
+    if(NULL == (f = H5I_object(file)))
+        FAIL_STACK_ERROR
+
+    /* Re-open the heap */
+    if(NULL == (fh = H5HF_open(f, H5P_DATASET_XFER_DEFAULT, fh_addr)))
+        FAIL_STACK_ERROR
+
+    /* Query the heap creation parameters */
+    HDmemset(&test_cparam, 0, sizeof(H5HF_create_t));
+    if(H5HF_get_cparam_test(fh, &test_cparam) < 0)
+        FAIL_STACK_ERROR
+    if(H5HF_cmp_cparam_test(&tmp_cparam, &test_cparam))
+        FAIL_STACK_ERROR
+
+/* XXX: Check heap's I/O filter settings? */
+
+    /* Close the fractal heap */
+    if(H5HF_close(fh, H5P_DATASET_XFER_DEFAULT) < 0)
+        FAIL_STACK_ERROR
+
+
+    /* Close the file */
+    if(H5Fclose(file) < 0)
+        FAIL_STACK_ERROR
+
+    /* Release the I/O pipeline filter information */
+    H5O_reset(H5O_PLINE_ID, &tmp_cparam.pline);
+    H5O_reset(H5O_PLINE_ID, &test_cparam.pline);
+
+    /* All tests passed */
+    PASSED()
+
+    return(0);
+
+error:
+    H5E_BEGIN_TRY {
+        if(fh)
+            H5HF_close(fh, dxpl);
+	H5Fclose(file);
+    } H5E_END_TRY;
+    return(1);
+} /* test_filtered_create() */
+
 #ifdef ALL_INSERT_TESTS
 
 /*-------------------------------------------------------------------------
@@ -10894,6 +11364,7 @@ test_huge_insert_one(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
     unsigned char *heap_id = NULL;      /* Heap ID for object */
     size_t      obj_size;               /* Size of object */
     size_t      robj_size;              /* Size of object read */
+    unsigned char obj_type;             /* Type of storage for object */
     fheap_heap_state_t state;           /* State of fractal heap */
     const char *base_desc = "insert one huge object, then remove %s";       /* Test description */
 
@@ -10919,6 +11390,10 @@ test_huge_insert_one(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
     obj_size = SMALL_STAND_SIZE + 1;
     if(H5HF_insert(fh, dxpl, obj_size, shared_wobj_g, heap_id) < 0)
         FAIL_STACK_ERROR
+    if(H5HF_get_id_type_test(fh, heap_id, &obj_type) < 0)
+        FAIL_STACK_ERROR
+    if(obj_type != H5HF_ID_TYPE_HUGE)
+        TEST_ERROR
 
     /* Check for closing & re-opening the heap */
     if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
@@ -11043,6 +11518,7 @@ test_huge_insert_two(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
     unsigned char *heap_id2 = NULL;     /* Heap ID for second object */
     size_t      obj_size;               /* Size of object */
     size_t      robj_size;              /* Size of object read */
+    unsigned char obj_type;             /* Type of storage for object */
     fheap_heap_state_t state;           /* State of fractal heap */
     const char *base_desc = "insert two huge objects, then remove %s";       /* Test description */
 
@@ -11070,6 +11546,10 @@ test_huge_insert_two(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
     obj_size = SMALL_STAND_SIZE + 1;
     if(H5HF_insert(fh, dxpl, obj_size, shared_wobj_g, heap_id) < 0)
         FAIL_STACK_ERROR
+    if(H5HF_get_id_type_test(fh, heap_id, &obj_type) < 0)
+        FAIL_STACK_ERROR
+    if(obj_type != H5HF_ID_TYPE_HUGE)
+        TEST_ERROR
 
     /* Check for closing & re-opening the heap */
     if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
@@ -11096,6 +11576,10 @@ test_huge_insert_two(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
     obj_size = SMALL_STAND_SIZE + 1;
     if(H5HF_insert(fh, dxpl, obj_size, shared_wobj_g, heap_id2) < 0)
         FAIL_STACK_ERROR
+    if(H5HF_get_id_type_test(fh, heap_id2, &obj_type) < 0)
+        FAIL_STACK_ERROR
+    if(obj_type != H5HF_ID_TYPE_HUGE)
+        TEST_ERROR
 
     /* Check for closing & re-opening the heap */
     if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
@@ -11268,6 +11752,7 @@ test_huge_insert_three(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tp
     unsigned char *heap_id3 = NULL;     /* Heap ID for third object */
     size_t      obj_size;               /* Size of object */
     size_t      robj_size;              /* Size of object read */
+    unsigned char obj_type;             /* Type of storage for object */
     fheap_heap_state_t state;           /* State of fractal heap */
     const char *base_desc = "insert three huge objects, then remove %s";       /* Test description */
 
@@ -11297,6 +11782,10 @@ test_huge_insert_three(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tp
     obj_size = SMALL_STAND_SIZE + 1;
     if(H5HF_insert(fh, dxpl, obj_size, shared_wobj_g, heap_id) < 0)
         FAIL_STACK_ERROR
+    if(H5HF_get_id_type_test(fh, heap_id, &obj_type) < 0)
+        FAIL_STACK_ERROR
+    if(obj_type != H5HF_ID_TYPE_HUGE)
+        TEST_ERROR
 
     /* Check for closing & re-opening the heap */
     if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
@@ -11323,6 +11812,10 @@ test_huge_insert_three(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tp
     obj_size = SMALL_STAND_SIZE + 2;
     if(H5HF_insert(fh, dxpl, obj_size, shared_wobj_g, heap_id2) < 0)
         FAIL_STACK_ERROR
+    if(H5HF_get_id_type_test(fh, heap_id2, &obj_type) < 0)
+        FAIL_STACK_ERROR
+    if(obj_type != H5HF_ID_TYPE_HUGE)
+        TEST_ERROR
 
     /* Check for closing & re-opening the heap */
     if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
@@ -11349,6 +11842,10 @@ test_huge_insert_three(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tp
     obj_size = SMALL_STAND_SIZE + 3;
     if(H5HF_insert(fh, dxpl, obj_size, shared_wobj_g, heap_id3) < 0)
         FAIL_STACK_ERROR
+    if(H5HF_get_id_type_test(fh, heap_id3, &obj_type) < 0)
+        FAIL_STACK_ERROR
+    if(obj_type != H5HF_ID_TYPE_HUGE)
+        TEST_ERROR
 
     /* Check for closing & re-opening the heap */
     if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
@@ -11565,6 +12062,7 @@ test_huge_insert_mix(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
     unsigned char *heap_id5 = NULL;     /* Heap ID for fifth object */
     size_t      obj_size;               /* Size of object */
     size_t      robj_size;              /* Size of object read */
+    unsigned char obj_type;             /* Type of storage for object */
     fheap_heap_state_t state;           /* State of fractal heap */
     const char *base_desc = "insert mix of normal & huge objects, then remove %s";       /* Test description */
 
@@ -11598,6 +12096,10 @@ test_huge_insert_mix(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
     obj_size = SMALL_STAND_SIZE + 1;
     if(H5HF_insert(fh, dxpl, obj_size, shared_wobj_g, heap_id) < 0)
         FAIL_STACK_ERROR
+    if(H5HF_get_id_type_test(fh, heap_id, &obj_type) < 0)
+        FAIL_STACK_ERROR
+    if(obj_type != H5HF_ID_TYPE_HUGE)
+        TEST_ERROR
 
     /* Check for closing & re-opening the heap */
     if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
@@ -11624,6 +12126,10 @@ test_huge_insert_mix(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
     obj_size = SMALL_STAND_SIZE + 2;
     if(H5HF_insert(fh, dxpl, obj_size, shared_wobj_g, heap_id2) < 0)
         FAIL_STACK_ERROR
+    if(H5HF_get_id_type_test(fh, heap_id2, &obj_type) < 0)
+        FAIL_STACK_ERROR
+    if(obj_type != H5HF_ID_TYPE_HUGE)
+        TEST_ERROR
 
     /* Check for closing & re-opening the heap */
     if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
@@ -11650,6 +12156,10 @@ test_huge_insert_mix(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
     obj_size = SMALL_STAND_SIZE + 3;
     if(H5HF_insert(fh, dxpl, obj_size, shared_wobj_g, heap_id3) < 0)
         FAIL_STACK_ERROR
+    if(H5HF_get_id_type_test(fh, heap_id3, &obj_type) < 0)
+        FAIL_STACK_ERROR
+    if(obj_type != H5HF_ID_TYPE_HUGE)
+        TEST_ERROR
 
     /* Check for closing & re-opening the heap */
     if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
@@ -11676,6 +12186,10 @@ test_huge_insert_mix(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
     obj_size = DBLOCK_SIZE(fh, 0) + 1;
     if(H5HF_insert(fh, dxpl, obj_size, shared_wobj_g, heap_id4) < 0)
         FAIL_STACK_ERROR
+    if(H5HF_get_id_type_test(fh, heap_id4, &obj_type) < 0)
+        FAIL_STACK_ERROR
+    if(obj_type != H5HF_ID_TYPE_MAN)
+        TEST_ERROR
 
     /* Check for closing & re-opening the heap */
     if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
@@ -11709,6 +12223,10 @@ test_huge_insert_mix(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
     obj_size = DBLOCK_SIZE(fh, 3) + 1;
     if(H5HF_insert(fh, dxpl, obj_size, shared_wobj_g, heap_id5) < 0)
         FAIL_STACK_ERROR
+    if(H5HF_get_id_type_test(fh, heap_id5, &obj_type) < 0)
+        FAIL_STACK_ERROR
+    if(obj_type != H5HF_ID_TYPE_MAN)
+        TEST_ERROR
 
     /* Check for closing & re-opening the heap */
     if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
@@ -11823,7 +12341,15 @@ test_huge_insert_mix(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
             if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
                 TEST_ERROR
 
+            /* Reset 'managed' object statistics after they are all removed  */
+            state.man_nobjs = 0;
+            state.man_size = 0;
+            state.man_alloc_size = 0;
+            state.man_free_space = 0;
+
             /* Remove third object from heap */
+            if(H5HF_get_obj_len(fh, dxpl, heap_id3, &robj_size) < 0)
+                FAIL_STACK_ERROR
             if(H5HF_remove(fh, dxpl, heap_id3) < 0)
                 FAIL_STACK_ERROR
 
@@ -11831,7 +12357,15 @@ test_huge_insert_mix(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
             if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
                 TEST_ERROR
 
+            /* Check up on heap... */
+            state.huge_size -= robj_size;
+            state.huge_nobjs--;
+            if(check_stats(fh, &state))
+                TEST_ERROR
+
             /* Remove second object from heap */
+            if(H5HF_get_obj_len(fh, dxpl, heap_id2, &robj_size) < 0)
+                FAIL_STACK_ERROR
             if(H5HF_remove(fh, dxpl, heap_id2) < 0)
                 FAIL_STACK_ERROR
 
@@ -11839,6 +12373,613 @@ test_huge_insert_mix(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
             if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
                 TEST_ERROR
 
+            /* Check up on heap... */
+            state.huge_size -= robj_size;
+            state.huge_nobjs--;
+            if(check_stats(fh, &state))
+                TEST_ERROR
+
+            /* Remove first object from heap */
+            if(H5HF_remove(fh, dxpl, heap_id) < 0)
+                FAIL_STACK_ERROR
+
+            /* Check for closing & re-opening the heap */
+            if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+                TEST_ERROR
+        } /* end else */
+
+        /* Check up on heap... */
+        HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+        if(check_stats(fh, &state))
+            TEST_ERROR
+    } /* end if */
+
+
+    /* Close the fractal heap */
+    if(H5HF_close(fh, dxpl) < 0)
+        FAIL_STACK_ERROR
+    fh = NULL;
+
+    /* Check for deleting the entire heap */
+    if(tparam->del_dir == FHEAP_DEL_HEAP) {
+        /* Delete heap */
+        if(H5HF_delete(f, dxpl, fh_addr) < 0)
+            FAIL_STACK_ERROR
+    } /* end if */
+
+    /* Close the file */
+    if(H5Fclose(file) < 0)
+        FAIL_STACK_ERROR
+
+    /* Get the size of the file */
+    if((file_size = h5_get_file_size(filename)) == 0)
+        TEST_ERROR
+#ifdef QAK
+HDfprintf(stderr, "file_size = %lu\n", (unsigned long)file_size);
+#endif /* QAK */
+
+    /* Verify the file is correct size */
+    if(file_size != empty_size)
+        TEST_ERROR
+
+    /* Free resources */
+    H5MM_xfree(heap_id);
+    H5MM_xfree(heap_id2);
+    H5MM_xfree(heap_id3);
+    H5MM_xfree(heap_id4);
+    H5MM_xfree(heap_id5);
+    H5MM_xfree(keep_ids.ids);
+    H5MM_xfree(keep_ids.lens);
+    H5MM_xfree(keep_ids.offs);
+
+    /* All tests passed */
+    PASSED()
+
+    return(0);
+
+error:
+    H5E_BEGIN_TRY {
+        H5MM_xfree(heap_id);
+        H5MM_xfree(heap_id2);
+        H5MM_xfree(heap_id3);
+        H5MM_xfree(heap_id4);
+        H5MM_xfree(heap_id5);
+        H5MM_xfree(keep_ids.ids);
+        H5MM_xfree(keep_ids.lens);
+        H5MM_xfree(keep_ids.offs);
+        if(fh)
+            H5HF_close(fh, dxpl);
+	H5Fclose(file);
+    } H5E_END_TRY;
+    return(1);
+} /* test_huge_insert_mix() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	test_filtered_huge
+ *
+ * Purpose:	Test storing 'huge' object in a heap with I/O filters
+ *
+ * Return:	Success:	0
+ *		Failure:	1
+ *
+ * Programmer:	Quincey Koziol
+ *              Tuesday, August 15, 2006
+ *
+ *-------------------------------------------------------------------------
+ */
+static int
+test_filtered_huge(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tparam)
+{
+    hid_t	file = -1;              /* File ID */
+    hid_t       dxpl = H5P_DATASET_XFER_DEFAULT;     /* DXPL to use */
+    char	filename[FHEAP_FILENAME_LEN];         /* Filename to use */
+    H5F_t	*f = NULL;              /* Internal file object pointer */
+    H5HF_t      *fh = NULL;             /* Fractal heap wrapper */
+    haddr_t     fh_addr;                /* Address of fractal heap */
+    H5HF_create_t tmp_cparam;           /* Local heap creation parameters */
+    fheap_heap_ids_t keep_ids;          /* Structure to retain heap IDs */
+    size_t      id_len;                 /* Size of fractal heap IDs */
+    off_t       empty_size;             /* Size of a file with an empty heap */
+    off_t       file_size;              /* Size of file currently */
+    unsigned char *heap_id = NULL;      /* Heap ID for object */
+    size_t      obj_size;               /* Size of object */
+    size_t      robj_size;              /* Size of object read */
+    unsigned char obj_type;             /* Type of storage for object */
+    fheap_heap_state_t state;           /* State of fractal heap */
+    unsigned    deflate_level;          /* Deflation level */
+    unsigned    old_actual_id_len;      /* Old actual ID length */
+    hbool_t     huge_ids_direct;        /* Are 'huge' objects directly acccessed? */
+    const char *base_desc = "insert 'huge' object into heap with I/O filters, then remove %s";       /* Test description */
+
+    /* Copy heap creation properties */
+    HDmemcpy(&tmp_cparam, cparam, sizeof(H5HF_create_t));
+
+    /* Set an I/O filter for heap data */
+    deflate_level = 6;
+    if(H5Z_append(&tmp_cparam.pline, H5Z_FILTER_DEFLATE, H5Z_FLAG_OPTIONAL, 1, &deflate_level) < 0)
+        FAIL_STACK_ERROR
+
+    /* Adjust actual ID length, if asking for IDs that can directly access 'huge' objects */
+    if(cparam->id_len == 1) {
+        old_actual_id_len = tparam->actual_id_len;
+        tparam->actual_id_len = 29;   /* 1 + 8 (file address size) + 8 (file length size) + 4 (filter mask length) + 8 (object length size) */
+    } /* end if */
+
+    /* Perform common file & heap open operations */
+    if(open_heap(filename, fapl, dxpl, &tmp_cparam, tparam, &file, &f, &fh, &fh_addr, &state, &empty_size) < 0)
+        TEST_ERROR
+
+    /* Perform common test initialization operations */
+    if(begin_test(tparam, base_desc, &keep_ids, NULL) < 0)
+        TEST_ERROR
+
+
+    /* Allocate heap ID(s) */
+    if(NULL == (heap_id = H5MM_malloc(tparam->actual_id_len)))
+        TEST_ERROR
+
+    /* Make certain that 'huge' object's heap IDs are correct form */
+    if(H5HF_get_id_len(fh, &id_len) < 0)
+        FAIL_STACK_ERROR
+    if(id_len != tparam->actual_id_len)
+        TEST_ERROR
+    if(H5HF_get_huge_info_test(fh, NULL, &huge_ids_direct) < 0)
+        FAIL_STACK_ERROR
+    if(cparam->id_len == 1) {
+        if(huge_ids_direct != TRUE)
+            TEST_ERROR
+    } /* end if */
+    else
+        if(tparam->actual_id_len >= 29) {
+            if(huge_ids_direct != TRUE)
+                TEST_ERROR
+        } /* end if */
+        else {
+            if(huge_ids_direct != FALSE)
+                TEST_ERROR
+        } /* end else */
+
+    /* Insert object too large for managed heap blocks */
+    obj_size = SMALL_STAND_SIZE + 1;
+    if(H5HF_insert(fh, dxpl, obj_size, shared_wobj_g, heap_id) < 0)
+        FAIL_STACK_ERROR
+    if(H5HF_get_id_type_test(fh, heap_id, &obj_type) < 0)
+        FAIL_STACK_ERROR
+    if(obj_type != H5HF_ID_TYPE_HUGE)
+        TEST_ERROR
+
+    /* Check for closing & re-opening the heap */
+    if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+        TEST_ERROR
+
+/* QAK */
+#ifdef QAK
+    /* Close the fractal heap */
+    if(H5HF_close(fh, dxpl) < 0)
+        FAIL_STACK_ERROR
+    fh = NULL;
+
+    /* Close the file */
+    if(H5Fclose(file) < 0)
+        FAIL_STACK_ERROR
+
+    /* Re-open the file */
+    if((file = H5Fopen(filename, H5F_ACC_RDONLY, fapl)) < 0)
+        FAIL_STACK_ERROR
+
+    /* Get a pointer to the internal file object */
+    if(NULL == (f = H5I_object(file)))
+        FAIL_STACK_ERROR
+
+    /* Re-open the heap */
+    if(NULL == (fh = H5HF_open(f, H5P_DATASET_XFER_DEFAULT, fh_addr)))
+        FAIL_STACK_ERROR
+#endif /* QAK */
+/* QAK */
+
+    /* Check up on heap... */
+    state.huge_size = obj_size;
+    state.huge_nobjs = 1;
+    if(check_stats(fh, &state))
+        TEST_ERROR
+
+    /* Read in huge object */
+    if(H5HF_get_obj_len(fh, dxpl, heap_id, &robj_size) < 0)
+        FAIL_STACK_ERROR
+    if(obj_size != robj_size)
+        TEST_ERROR
+    HDmemset(shared_robj_g, 0, obj_size);
+    if(H5HF_read(fh, dxpl, heap_id, shared_robj_g) < 0)
+        FAIL_STACK_ERROR
+    if(HDmemcmp(shared_wobj_g, shared_robj_g, obj_size))
+        TEST_ERROR
+
+    /* Delete individual objects, if we won't be deleting the entire heap later */
+    if(tparam->del_dir != FHEAP_DEL_HEAP) {
+        /* Remove object from heap */
+        if(H5HF_remove(fh, dxpl, heap_id) < 0)
+            FAIL_STACK_ERROR
+
+        /* Check for closing & re-opening the heap */
+        if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+            TEST_ERROR
+
+        /* Check up on heap... */
+        state.huge_size = 0;
+        state.huge_nobjs = 0;
+        if(check_stats(fh, &state))
+            TEST_ERROR
+    } /* end if */
+
+    /* Close the fractal heap */
+    if(H5HF_close(fh, dxpl) < 0)
+        FAIL_STACK_ERROR
+    fh = NULL;
+
+    /* Check for deleting the entire heap */
+    if(tparam->del_dir == FHEAP_DEL_HEAP) {
+        /* Delete heap */
+        if(H5HF_delete(f, dxpl, fh_addr) < 0)
+            FAIL_STACK_ERROR
+    } /* end if */
+
+    /* Close the file */
+    if(H5Fclose(file) < 0)
+        FAIL_STACK_ERROR
+
+    /* Get the size of the file */
+    if((file_size = h5_get_file_size(filename)) == 0)
+        TEST_ERROR
+#ifdef QAK
+HDfprintf(stderr, "empty_size = %lu, file_size = %lu\n", (unsigned long)empty_size, (unsigned long)file_size);
+#endif /* QAK */
+
+    /* Verify the file is correct size */
+    if(file_size != empty_size)
+        TEST_ERROR
+
+    /* Reset actual ID length, if asking for IDs that can directly access 'huge' objects */
+    if(cparam->id_len == 1)
+        tparam->actual_id_len = old_actual_id_len;
+
+    /* Free resources */
+    H5O_reset(H5O_PLINE_ID, &tmp_cparam.pline); /* Release the I/O pipeline filter information */
+    H5MM_xfree(heap_id);
+
+    /* All tests passed */
+    PASSED()
+
+    return(0);
+
+error:
+    H5E_BEGIN_TRY {
+        H5MM_xfree(heap_id);
+        if(fh)
+            H5HF_close(fh, dxpl);
+	H5Fclose(file);
+    } H5E_END_TRY;
+    return(1);
+} /* test_filtered_huge() */
+#endif /* QAK */
+
+#ifndef QAK
+
+/*-------------------------------------------------------------------------
+ * Function:	test_tiny_insert_one
+ *
+ * Purpose:	Test inserting one tiny object in the heap
+ *
+ *              Then, remove all the objects, in various ways
+ *
+ * Return:	Success:	0
+ *		Failure:	1
+ *
+ * Programmer:	Quincey Koziol
+ *              Monday, August 14, 2006
+ *
+ *-------------------------------------------------------------------------
+ */
+static int
+test_tiny_insert_one(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tparam)
+{
+    hid_t	file = -1;              /* File ID */
+    hid_t       dxpl = H5P_DATASET_XFER_DEFAULT;     /* DXPL to use */
+    char	filename[FHEAP_FILENAME_LEN];         /* Filename to use */
+    H5F_t	*f = NULL;              /* Internal file object pointer */
+    H5HF_t      *fh = NULL;             /* Fractal heap wrapper */
+    haddr_t     fh_addr;                /* Address of fractal heap */
+    fheap_heap_ids_t keep_ids;          /* Structure to retain heap IDs */
+    size_t      id_len;                 /* Size of fractal heap IDs */
+    off_t       empty_size;             /* Size of a file with an empty heap */
+    off_t       file_size;              /* Size of file currently */
+    unsigned char *heap_id = NULL;      /* Heap ID for object */
+    size_t      obj_size;               /* Size of object */
+    size_t      robj_size;              /* Size of object read */
+    unsigned char obj_type;             /* Type of storage for object */
+    fheap_heap_state_t state;           /* State of fractal heap */
+    const char *base_desc = "insert one tiny object, then remove %s";       /* Test description */
+
+    /* Perform common file & heap open operations */
+    if(open_heap(filename, fapl, dxpl, cparam, tparam, &file, &f, &fh, &fh_addr, &state, &empty_size) < 0)
+        TEST_ERROR
+
+    /* Perform common test initialization operations */
+    if(begin_test(tparam, base_desc, &keep_ids, NULL) < 0)
+        TEST_ERROR
+
+    /* Allocate heap ID(s) */
+    if(NULL == (heap_id = H5MM_malloc(tparam->actual_id_len)))
+        TEST_ERROR
+
+    /* Make certain that 'tiny' object's heap IDs are correct size */
+    if(H5HF_get_id_len(fh, &id_len) < 0)
+        FAIL_STACK_ERROR
+    if(id_len != tparam->actual_id_len)
+        TEST_ERROR
+
+    /* Insert object small enough to encode in heap ID */
+    obj_size = tparam->actual_id_len - 2;
+    if(H5HF_insert(fh, dxpl, obj_size, shared_wobj_g, heap_id) < 0)
+        FAIL_STACK_ERROR
+    if(H5HF_get_id_type_test(fh, heap_id, &obj_type) < 0)
+        FAIL_STACK_ERROR
+    if(obj_type != H5HF_ID_TYPE_TINY)
+        TEST_ERROR
+
+    /* Check for closing & re-opening the heap */
+    if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+        TEST_ERROR
+
+    /* Check up on heap... */
+    state.tiny_size = obj_size;
+    state.tiny_nobjs = 1;
+    if(check_stats(fh, &state))
+        TEST_ERROR
+
+    /* Read in tiny object */
+    if(H5HF_get_obj_len(fh, dxpl, heap_id, &robj_size) < 0)
+        FAIL_STACK_ERROR
+    if(obj_size != robj_size)
+        TEST_ERROR
+    HDmemset(shared_robj_g, 0, obj_size);
+    if(H5HF_read(fh, dxpl, heap_id, shared_robj_g) < 0)
+        FAIL_STACK_ERROR
+    if(HDmemcmp(shared_wobj_g, shared_robj_g, obj_size))
+        TEST_ERROR
+
+    /* Delete individual objects, if we won't be deleting the entire heap later */
+    if(tparam->del_dir != FHEAP_DEL_HEAP) {
+        /* Remove object from heap */
+        if(H5HF_remove(fh, dxpl, heap_id) < 0)
+            FAIL_STACK_ERROR
+
+        /* Check for closing & re-opening the heap */
+        if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+            TEST_ERROR
+
+        /* Check up on heap... */
+        state.tiny_size = 0;
+        state.tiny_nobjs = 0;
+        if(check_stats(fh, &state))
+            TEST_ERROR
+    } /* end if */
+
+
+    /* Close the fractal heap */
+    if(H5HF_close(fh, dxpl) < 0)
+        FAIL_STACK_ERROR
+    fh = NULL;
+
+    /* Check for deleting the entire heap */
+    if(tparam->del_dir == FHEAP_DEL_HEAP) {
+        /* Delete heap */
+        if(H5HF_delete(f, dxpl, fh_addr) < 0)
+            FAIL_STACK_ERROR
+    } /* end if */
+
+    /* Close the file */
+    if(H5Fclose(file) < 0)
+        FAIL_STACK_ERROR
+
+    /* Get the size of the file */
+    if((file_size = h5_get_file_size(filename)) == 0)
+        TEST_ERROR
+#ifdef QAK
+HDfprintf(stderr, "file_size = %lu\n", (unsigned long)file_size);
+#endif /* QAK */
+
+    /* Verify the file is correct size */
+    if(file_size != empty_size)
+        TEST_ERROR
+
+    /* Free resources */
+    H5MM_xfree(heap_id);
+    H5MM_xfree(keep_ids.ids);
+    H5MM_xfree(keep_ids.lens);
+    H5MM_xfree(keep_ids.offs);
+
+    /* All tests passed */
+    PASSED()
+
+    return(0);
+
+error:
+    H5E_BEGIN_TRY {
+        H5MM_xfree(heap_id);
+        H5MM_xfree(keep_ids.ids);
+        H5MM_xfree(keep_ids.lens);
+        H5MM_xfree(keep_ids.offs);
+        if(fh)
+            H5HF_close(fh, dxpl);
+	H5Fclose(file);
+    } H5E_END_TRY;
+    return(1);
+} /* test_tiny_insert_one() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	test_tiny_insert_two
+ *
+ * Purpose:	Test inserting two tiny objects in the heap
+ *
+ *              Then, remove all the objects, in various ways
+ *
+ * Return:	Success:	0
+ *		Failure:	1
+ *
+ * Programmer:	Quincey Koziol
+ *              Monday, August 14, 2006
+ *
+ *-------------------------------------------------------------------------
+ */
+static int
+test_tiny_insert_two(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tparam)
+{
+    hid_t	file = -1;              /* File ID */
+    hid_t       dxpl = H5P_DATASET_XFER_DEFAULT;     /* DXPL to use */
+    char	filename[FHEAP_FILENAME_LEN];         /* Filename to use */
+    H5F_t	*f = NULL;              /* Internal file object pointer */
+    H5HF_t      *fh = NULL;             /* Fractal heap wrapper */
+    haddr_t     fh_addr;                /* Address of fractal heap */
+    fheap_heap_ids_t keep_ids;          /* Structure to retain heap IDs */
+    size_t      id_len;                 /* Size of fractal heap IDs */
+    off_t       empty_size;             /* Size of a file with an empty heap */
+    off_t       file_size;              /* Size of file currently */
+    unsigned char *heap_id = NULL;      /* Heap ID for first object */
+    unsigned char *heap_id2 = NULL;     /* Heap ID for second object */
+    size_t      obj_size;               /* Size of object */
+    size_t      robj_size;              /* Size of object read */
+    unsigned char obj_type;             /* Type of storage for object */
+    fheap_heap_state_t state;           /* State of fractal heap */
+    const char *base_desc = "insert two tiny objects, then remove %s";       /* Test description */
+
+    /* Perform common file & heap open operations */
+    if(open_heap(filename, fapl, dxpl, cparam, tparam, &file, &f, &fh, &fh_addr, &state, &empty_size) < 0)
+        TEST_ERROR
+
+    /* Perform common test initialization operations */
+    if(begin_test(tparam, base_desc, &keep_ids, NULL) < 0)
+        TEST_ERROR
+
+    /* Allocate heap ID(s) */
+    if(NULL == (heap_id = H5MM_malloc(tparam->actual_id_len)))
+        TEST_ERROR
+    if(NULL == (heap_id2 = H5MM_malloc(tparam->actual_id_len)))
+        TEST_ERROR
+
+    /* Make certain that 'tiny' object's heap IDs are correct size */
+    if(H5HF_get_id_len(fh, &id_len) < 0)
+        FAIL_STACK_ERROR
+    if(id_len != tparam->actual_id_len)
+        TEST_ERROR
+
+    /* Insert object small enough to encode in heap ID */
+    obj_size = tparam->actual_id_len - 2;
+    if(H5HF_insert(fh, dxpl, obj_size, shared_wobj_g, heap_id) < 0)
+        FAIL_STACK_ERROR
+    if(H5HF_get_id_type_test(fh, heap_id, &obj_type) < 0)
+        FAIL_STACK_ERROR
+    if(obj_type != H5HF_ID_TYPE_TINY)
+        TEST_ERROR
+
+    /* Check for closing & re-opening the heap */
+    if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+        TEST_ERROR
+
+    /* Check up on heap... */
+    state.tiny_size = obj_size;
+    state.tiny_nobjs = 1;
+    if(check_stats(fh, &state))
+        TEST_ERROR
+
+    /* Read in tiny object */
+    if(H5HF_get_obj_len(fh, dxpl, heap_id, &robj_size) < 0)
+        FAIL_STACK_ERROR
+    if(obj_size != robj_size)
+        TEST_ERROR
+    HDmemset(shared_robj_g, 0, obj_size);
+    if(H5HF_read(fh, dxpl, heap_id, shared_robj_g) < 0)
+        FAIL_STACK_ERROR
+    if(HDmemcmp(shared_wobj_g, shared_robj_g, obj_size))
+        TEST_ERROR
+
+    /* Insert second object small enough to encode in heap ID */
+    obj_size = tparam->actual_id_len - 2;
+    if(H5HF_insert(fh, dxpl, obj_size, shared_wobj_g, heap_id2) < 0)
+        FAIL_STACK_ERROR
+    if(H5HF_get_id_type_test(fh, heap_id2, &obj_type) < 0)
+        FAIL_STACK_ERROR
+    if(obj_type != H5HF_ID_TYPE_TINY)
+        TEST_ERROR
+
+    /* Check for closing & re-opening the heap */
+    if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+        TEST_ERROR
+
+    /* Check up on heap... */
+    state.tiny_size += obj_size ;
+    state.tiny_nobjs = 2;
+    if(check_stats(fh, &state))
+        TEST_ERROR
+
+    /* Read in second tiny object */
+    if(H5HF_get_obj_len(fh, dxpl, heap_id2, &robj_size) < 0)
+        FAIL_STACK_ERROR
+    if(obj_size != robj_size)
+        TEST_ERROR
+    HDmemset(shared_robj_g, 0, obj_size);
+    if(H5HF_read(fh, dxpl, heap_id2, shared_robj_g) < 0)
+        FAIL_STACK_ERROR
+    if(HDmemcmp(shared_wobj_g, shared_robj_g, obj_size))
+        TEST_ERROR
+
+    /* Delete individual objects, if we won't be deleting the entire heap later */
+    if(tparam->del_dir != FHEAP_DEL_HEAP) {
+        if(tparam->del_dir == FHEAP_DEL_FORWARD) {
+            /* Remove first object from heap */
+            if(H5HF_remove(fh, dxpl, heap_id) < 0)
+                FAIL_STACK_ERROR
+
+            /* Check for closing & re-opening the heap */
+            if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+                TEST_ERROR
+
+            /* Check up on heap... */
+            state.tiny_size = obj_size;
+            state.tiny_nobjs = 1;
+            if(check_stats(fh, &state))
+                TEST_ERROR
+
+            /* Remove second object from heap */
+            if(H5HF_remove(fh, dxpl, heap_id2) < 0)
+                FAIL_STACK_ERROR
+
+            /* Check for closing & re-opening the heap */
+            if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+                TEST_ERROR
+
+            /* Check up on heap... */
+            state.tiny_size = 0;
+            state.tiny_nobjs = 0;
+            if(check_stats(fh, &state))
+                TEST_ERROR
+        } /* end if */
+        else {
+            /* Remove second object from heap */
+            if(H5HF_remove(fh, dxpl, heap_id2) < 0)
+                FAIL_STACK_ERROR
+
+            /* Check for closing & re-opening the heap */
+            if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+                TEST_ERROR
+
+            /* Check up on heap... */
+            state.tiny_size = obj_size;
+            state.tiny_nobjs = 1;
+            if(check_stats(fh, &state))
+                TEST_ERROR
+
             /* Remove first object from heap */
             if(H5HF_remove(fh, dxpl, heap_id) < 0)
                 FAIL_STACK_ERROR
@@ -11848,7 +12989,8 @@ test_huge_insert_mix(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
                 TEST_ERROR
 
             /* Check up on heap... */
-            HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+            state.tiny_size = 0;
+            state.tiny_nobjs = 0;
             if(check_stats(fh, &state))
                 TEST_ERROR
         } /* end else */
@@ -11885,9 +13027,563 @@ HDfprintf(stderr, "file_size = %lu\n", (unsigned long)file_size);
     /* Free resources */
     H5MM_xfree(heap_id);
     H5MM_xfree(heap_id2);
+    H5MM_xfree(keep_ids.ids);
+    H5MM_xfree(keep_ids.lens);
+    H5MM_xfree(keep_ids.offs);
+
+    /* All tests passed */
+    PASSED()
+
+    return(0);
+
+error:
+    H5E_BEGIN_TRY {
+        H5MM_xfree(heap_id);
+        H5MM_xfree(heap_id2);
+        H5MM_xfree(keep_ids.ids);
+        H5MM_xfree(keep_ids.lens);
+        H5MM_xfree(keep_ids.offs);
+        if(fh)
+            H5HF_close(fh, dxpl);
+	H5Fclose(file);
+    } H5E_END_TRY;
+    return(1);
+} /* test_tiny_insert_two() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	test_tiny_insert_mix
+ *
+ * Purpose:	Test inserting a mix of 'normal', 'huge' & 'tiny' objects in
+ *              the heap
+ *
+ *              Then, remove all the objects, in various ways
+ *
+ * Return:	Success:	0
+ *		Failure:	1
+ *
+ * Programmer:	Quincey Koziol
+ *              Monday, August 14, 2006
+ *
+ *-------------------------------------------------------------------------
+ */
+static int
+test_tiny_insert_mix(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tparam)
+{
+    hid_t	file = -1;              /* File ID */
+    hid_t       dxpl = H5P_DATASET_XFER_DEFAULT;     /* DXPL to use */
+    char	filename[FHEAP_FILENAME_LEN];         /* Filename to use */
+    H5F_t	*f = NULL;              /* Internal file object pointer */
+    H5HF_t      *fh = NULL;             /* Fractal heap wrapper */
+    haddr_t     fh_addr;                /* Address of fractal heap */
+    fheap_heap_ids_t keep_ids;          /* Structure to retain heap IDs */
+    size_t      id_len;                 /* Size of fractal heap IDs */
+    off_t       empty_size;             /* Size of a file with an empty heap */
+    off_t       file_size;              /* Size of file currently */
+    unsigned char *heap_id = NULL;      /* Heap ID for first object */
+    unsigned char *heap_id2 = NULL;     /* Heap ID for second object */
+    unsigned char *heap_id3 = NULL;     /* Heap ID for third object */
+    unsigned char *heap_id4 = NULL;     /* Heap ID for fourth object */
+    unsigned char *heap_id5 = NULL;     /* Heap ID for fifth object */
+    unsigned char *heap_id6 = NULL;     /* Heap ID for sixth object */
+    unsigned char *heap_id7 = NULL;     /* Heap ID for seventh object */
+    size_t      obj_size;               /* Size of object */
+    size_t      robj_size;              /* Size of object read */
+    unsigned char obj_type;             /* Type of storage for object */
+    fheap_heap_state_t state;           /* State of fractal heap */
+    const char *base_desc = "insert mix of normal, huge & tiny objects, then remove %s";       /* Test description */
+
+    /* Perform common file & heap open operations */
+    if(open_heap(filename, fapl, dxpl, cparam, tparam, &file, &f, &fh, &fh_addr, &state, &empty_size) < 0)
+        TEST_ERROR
+
+    /* Perform common test initialization operations */
+    if(begin_test(tparam, base_desc, &keep_ids, NULL) < 0)
+        TEST_ERROR
+
+    /* Allocate heap ID(s) */
+    if(NULL == (heap_id = H5MM_malloc(tparam->actual_id_len)))
+        TEST_ERROR
+    if(NULL == (heap_id2 = H5MM_malloc(tparam->actual_id_len)))
+        TEST_ERROR
+    if(NULL == (heap_id3 = H5MM_malloc(tparam->actual_id_len)))
+        TEST_ERROR
+    if(NULL == (heap_id4 = H5MM_malloc(tparam->actual_id_len)))
+        TEST_ERROR
+    if(NULL == (heap_id5 = H5MM_malloc(tparam->actual_id_len)))
+        TEST_ERROR
+    if(NULL == (heap_id6 = H5MM_malloc(tparam->actual_id_len)))
+        TEST_ERROR
+    if(NULL == (heap_id7 = H5MM_malloc(tparam->actual_id_len)))
+        TEST_ERROR
+
+    /* Make certain that 'tiny' object's heap IDs are correct size */
+    if(H5HF_get_id_len(fh, &id_len) < 0)
+        FAIL_STACK_ERROR
+    if(id_len != tparam->actual_id_len)
+        TEST_ERROR
+
+    /* Insert first object too large for managed heap blocks */
+    obj_size = SMALL_STAND_SIZE + 1;
+    if(H5HF_insert(fh, dxpl, obj_size, shared_wobj_g, heap_id) < 0)
+        FAIL_STACK_ERROR
+    if(H5HF_get_id_type_test(fh, heap_id, &obj_type) < 0)
+        FAIL_STACK_ERROR
+    if(obj_type != H5HF_ID_TYPE_HUGE)
+        TEST_ERROR
+
+    /* Check for closing & re-opening the heap */
+    if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+        TEST_ERROR
+
+    /* Check up on heap... */
+    state.huge_size += obj_size;
+    state.huge_nobjs++;
+    if(check_stats(fh, &state))
+        TEST_ERROR
+
+    /* Read in first huge object */
+    if(H5HF_get_obj_len(fh, dxpl, heap_id, &robj_size) < 0)
+        FAIL_STACK_ERROR
+    if(obj_size != robj_size)
+        TEST_ERROR
+    HDmemset(shared_robj_g, 0, obj_size);
+    if(H5HF_read(fh, dxpl, heap_id, shared_robj_g) < 0)
+        FAIL_STACK_ERROR
+    if(HDmemcmp(shared_wobj_g, shared_robj_g, obj_size))
+        TEST_ERROR
+
+    /* Insert second object too large for managed heap blocks */
+    obj_size = SMALL_STAND_SIZE + 2;
+    if(H5HF_insert(fh, dxpl, obj_size, shared_wobj_g, heap_id2) < 0)
+        FAIL_STACK_ERROR
+    if(H5HF_get_id_type_test(fh, heap_id2, &obj_type) < 0)
+        FAIL_STACK_ERROR
+    if(obj_type != H5HF_ID_TYPE_HUGE)
+        TEST_ERROR
+
+    /* Check for closing & re-opening the heap */
+    if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+        TEST_ERROR
+
+    /* Check up on heap... */
+    state.huge_size += obj_size;
+    state.huge_nobjs++;
+    if(check_stats(fh, &state))
+        TEST_ERROR
+
+    /* Read in second huge object */
+    if(H5HF_get_obj_len(fh, dxpl, heap_id2, &robj_size) < 0)
+        FAIL_STACK_ERROR
+    if(obj_size != robj_size)
+        TEST_ERROR
+    HDmemset(shared_robj_g, 0, obj_size);
+    if(H5HF_read(fh, dxpl, heap_id2, shared_robj_g) < 0)
+        FAIL_STACK_ERROR
+    if(HDmemcmp(shared_wobj_g, shared_robj_g, obj_size))
+        TEST_ERROR
+
+    /* Insert third object too large for managed heap blocks */
+    obj_size = SMALL_STAND_SIZE + 3;
+    if(H5HF_insert(fh, dxpl, obj_size, shared_wobj_g, heap_id3) < 0)
+        FAIL_STACK_ERROR
+    if(H5HF_get_id_type_test(fh, heap_id3, &obj_type) < 0)
+        FAIL_STACK_ERROR
+    if(obj_type != H5HF_ID_TYPE_HUGE)
+        TEST_ERROR
+
+    /* Check for closing & re-opening the heap */
+    if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+        TEST_ERROR
+
+    /* Check up on heap... */
+    state.huge_size += obj_size;
+    state.huge_nobjs++;
+    if(check_stats(fh, &state))
+        TEST_ERROR
+
+    /* Read in third huge object */
+    if(H5HF_get_obj_len(fh, dxpl, heap_id3, &robj_size) < 0)
+        FAIL_STACK_ERROR
+    if(obj_size != robj_size)
+        TEST_ERROR
+    HDmemset(shared_robj_g, 0, obj_size);
+    if(H5HF_read(fh, dxpl, heap_id3, shared_robj_g) < 0)
+        FAIL_STACK_ERROR
+    if(HDmemcmp(shared_wobj_g, shared_robj_g, obj_size))
+        TEST_ERROR
+
+    /* Insert fourth object small enough to fit into 'normal' heap blocks */
+    obj_size = DBLOCK_SIZE(fh, 0) + 1;
+    if(H5HF_insert(fh, dxpl, obj_size, shared_wobj_g, heap_id4) < 0)
+        FAIL_STACK_ERROR
+    if(H5HF_get_id_type_test(fh, heap_id4, &obj_type) < 0)
+        FAIL_STACK_ERROR
+    if(obj_type != H5HF_ID_TYPE_MAN)
+        TEST_ERROR
+
+    /* Check for closing & re-opening the heap */
+    if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+        TEST_ERROR
+
+    /* Check up on heap... */
+    state.man_size = cparam->managed.width * DBLOCK_SIZE(fh, 0);
+    state.man_size += cparam->managed.width * DBLOCK_SIZE(fh, 1);
+    state.man_size += cparam->managed.width * DBLOCK_SIZE(fh, 2);
+    state.man_alloc_size = DBLOCK_SIZE(fh, 2);
+    state.man_free_space = cparam->managed.width * DBLOCK_FREE(fh, 0);
+    state.man_free_space += cparam->managed.width * DBLOCK_FREE(fh, 1);
+    state.man_free_space += DBLOCK_FREE(fh, 2) - obj_size;
+    state.man_free_space += (cparam->managed.width - 1) * DBLOCK_FREE(fh, 2);
+    state.man_nobjs++;
+    if(check_stats(fh, &state))
+        TEST_ERROR
+
+    /* Read in fourth ('normal') object */
+    if(H5HF_get_obj_len(fh, dxpl, heap_id4, &robj_size) < 0)
+        FAIL_STACK_ERROR
+    if(obj_size != robj_size)
+        TEST_ERROR
+    HDmemset(shared_robj_g, 0, obj_size);
+    if(H5HF_read(fh, dxpl, heap_id4, shared_robj_g) < 0)
+        FAIL_STACK_ERROR
+    if(HDmemcmp(shared_wobj_g, shared_robj_g, obj_size))
+        TEST_ERROR
+
+    /* Insert fifth object small enough to fit into 'normal' heap blocks */
+    obj_size = DBLOCK_SIZE(fh, 3) + 1;
+    if(H5HF_insert(fh, dxpl, obj_size, shared_wobj_g, heap_id5) < 0)
+        FAIL_STACK_ERROR
+    if(H5HF_get_id_type_test(fh, heap_id5, &obj_type) < 0)
+        FAIL_STACK_ERROR
+    if(obj_type != H5HF_ID_TYPE_MAN)
+        TEST_ERROR
+
+    /* Check for closing & re-opening the heap */
+    if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+        TEST_ERROR
+
+    /* Check up on heap... */
+    /* (account for doubling of root indirect block) */
+    state.man_size += cparam->managed.width * DBLOCK_SIZE(fh, 3);
+    state.man_size += cparam->managed.width * DBLOCK_SIZE(fh, 4);
+    state.man_size += cparam->managed.width * DBLOCK_SIZE(fh, 5);
+    state.man_alloc_size += DBLOCK_SIZE(fh, 4);
+    state.man_free_space += cparam->managed.width * DBLOCK_FREE(fh, 3);
+    state.man_free_space += DBLOCK_FREE(fh, 4) - obj_size;
+    state.man_free_space += (cparam->managed.width - 1) * DBLOCK_FREE(fh, 4);
+    state.man_free_space += cparam->managed.width * DBLOCK_FREE(fh, 5);
+    state.man_nobjs++;
+    if(check_stats(fh, &state))
+        TEST_ERROR
+
+    /* Read in fifth ('normal') object */
+    if(H5HF_get_obj_len(fh, dxpl, heap_id5, &robj_size) < 0)
+        FAIL_STACK_ERROR
+    if(obj_size != robj_size)
+        TEST_ERROR
+    HDmemset(shared_robj_g, 0, obj_size);
+    if(H5HF_read(fh, dxpl, heap_id5, shared_robj_g) < 0)
+        FAIL_STACK_ERROR
+    if(HDmemcmp(shared_wobj_g, shared_robj_g, obj_size))
+        TEST_ERROR
+
+
+    /* Insert sixth object small enough to encode in heap ID */
+    obj_size = tparam->actual_id_len - 2;
+    if(H5HF_insert(fh, dxpl, obj_size, shared_wobj_g, heap_id6) < 0)
+        FAIL_STACK_ERROR
+    if(H5HF_get_id_type_test(fh, heap_id6, &obj_type) < 0)
+        FAIL_STACK_ERROR
+    if(obj_type != H5HF_ID_TYPE_TINY)
+        TEST_ERROR
+
+    /* Check for closing & re-opening the heap */
+    if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+        TEST_ERROR
+
+    /* Check up on heap... */
+    state.tiny_size = obj_size;
+    state.tiny_nobjs = 1;
+    if(check_stats(fh, &state))
+        TEST_ERROR
+
+    /* Read in tiny object */
+    if(H5HF_get_obj_len(fh, dxpl, heap_id6, &robj_size) < 0)
+        FAIL_STACK_ERROR
+    if(obj_size != robj_size)
+        TEST_ERROR
+    HDmemset(shared_robj_g, 0, obj_size);
+    if(H5HF_read(fh, dxpl, heap_id6, shared_robj_g) < 0)
+        FAIL_STACK_ERROR
+    if(HDmemcmp(shared_wobj_g, shared_robj_g, obj_size))
+        TEST_ERROR
+
+    /* Insert seventh object small enough to encode in heap ID */
+    obj_size = tparam->actual_id_len - 2;
+    if(H5HF_insert(fh, dxpl, obj_size, shared_wobj_g, heap_id7) < 0)
+        FAIL_STACK_ERROR
+    if(H5HF_get_id_type_test(fh, heap_id7, &obj_type) < 0)
+        FAIL_STACK_ERROR
+    if(obj_type != H5HF_ID_TYPE_TINY)
+        TEST_ERROR
+
+    /* Check for closing & re-opening the heap */
+    if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+        TEST_ERROR
+
+    /* Check up on heap... */
+    state.tiny_size += obj_size;
+    state.tiny_nobjs++;
+    if(check_stats(fh, &state))
+        TEST_ERROR
+
+    /* Read in tiny object */
+    if(H5HF_get_obj_len(fh, dxpl, heap_id7, &robj_size) < 0)
+        FAIL_STACK_ERROR
+    if(obj_size != robj_size)
+        TEST_ERROR
+    HDmemset(shared_robj_g, 0, obj_size);
+    if(H5HF_read(fh, dxpl, heap_id7, shared_robj_g) < 0)
+        FAIL_STACK_ERROR
+    if(HDmemcmp(shared_wobj_g, shared_robj_g, obj_size))
+        TEST_ERROR
+
+    /* Delete individual objects, if we won't be deleting the entire heap later */
+    if(tparam->del_dir != FHEAP_DEL_HEAP) {
+        if(tparam->del_dir == FHEAP_DEL_FORWARD) {
+            /* Remove first object from heap */
+            if(H5HF_get_obj_len(fh, dxpl, heap_id, &robj_size) < 0)
+                FAIL_STACK_ERROR
+            if(H5HF_remove(fh, dxpl, heap_id) < 0)
+                FAIL_STACK_ERROR
+
+            /* Check for closing & re-opening the heap */
+            if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+                TEST_ERROR
+
+            /* Check up on heap... */
+            state.huge_size -= robj_size;
+            state.huge_nobjs--;
+            if(check_stats(fh, &state))
+                TEST_ERROR
+
+            /* Remove second object from heap */
+            if(H5HF_get_obj_len(fh, dxpl, heap_id2, &robj_size) < 0)
+                FAIL_STACK_ERROR
+            if(H5HF_remove(fh, dxpl, heap_id2) < 0)
+                FAIL_STACK_ERROR
+
+            /* Check for closing & re-opening the heap */
+            if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+                TEST_ERROR
+
+            /* Check up on heap... */
+            state.huge_size -= robj_size;
+            state.huge_nobjs--;
+            if(check_stats(fh, &state))
+                TEST_ERROR
+
+            /* Remove third object from heap */
+            if(H5HF_get_obj_len(fh, dxpl, heap_id3, &robj_size) < 0)
+                FAIL_STACK_ERROR
+            if(H5HF_remove(fh, dxpl, heap_id3) < 0)
+                FAIL_STACK_ERROR
+
+            /* Check for closing & re-opening the heap */
+            if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+                TEST_ERROR
+
+            /* Check up on heap... */
+            state.huge_size -= robj_size;
+            state.huge_nobjs--;
+            if(check_stats(fh, &state))
+                TEST_ERROR
+
+            /* Remove fourth ('normal') object from heap */
+            if(H5HF_remove(fh, dxpl, heap_id4) < 0)
+                FAIL_STACK_ERROR
+
+            /* Check for closing & re-opening the heap */
+            if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+                TEST_ERROR
+
+            /* Remove fifth ('normal') object from heap */
+            if(H5HF_remove(fh, dxpl, heap_id5) < 0)
+                FAIL_STACK_ERROR
+
+            /* Check for closing & re-opening the heap */
+            if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+                TEST_ERROR
+
+            /* Reset 'managed' object statistics after they are all removed  */
+            state.man_nobjs = 0;
+            state.man_size = 0;
+            state.man_alloc_size = 0;
+            state.man_free_space = 0;
+
+            /* Remove sixth object from heap */
+            if(H5HF_get_obj_len(fh, dxpl, heap_id6, &robj_size) < 0)
+                FAIL_STACK_ERROR
+            if(H5HF_remove(fh, dxpl, heap_id6) < 0)
+                FAIL_STACK_ERROR
+
+            /* Check for closing & re-opening the heap */
+            if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+                TEST_ERROR
+
+            /* Check up on heap... */
+            state.tiny_size -= robj_size;
+            state.tiny_nobjs--;
+            if(check_stats(fh, &state))
+                TEST_ERROR
+
+            /* Remove seventh object from heap */
+            if(H5HF_remove(fh, dxpl, heap_id7) < 0)
+                FAIL_STACK_ERROR
+
+            /* Check for closing & re-opening the heap */
+            if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+                TEST_ERROR
+        } /* end if */
+        else {
+            /* Remove seventh object from heap */
+            if(H5HF_get_obj_len(fh, dxpl, heap_id7, &robj_size) < 0)
+                FAIL_STACK_ERROR
+            if(H5HF_remove(fh, dxpl, heap_id7) < 0)
+                FAIL_STACK_ERROR
+
+            /* Check for closing & re-opening the heap */
+            if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+                TEST_ERROR
+
+            /* Check up on heap... */
+            state.tiny_size -= robj_size;
+            state.tiny_nobjs--;
+            if(check_stats(fh, &state))
+                TEST_ERROR
+
+            /* Remove sixth object from heap */
+            if(H5HF_get_obj_len(fh, dxpl, heap_id6, &robj_size) < 0)
+                FAIL_STACK_ERROR
+            if(H5HF_remove(fh, dxpl, heap_id6) < 0)
+                FAIL_STACK_ERROR
+
+            /* Check for closing & re-opening the heap */
+            if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+                TEST_ERROR
+
+            /* Check up on heap... */
+            state.tiny_size -= robj_size;
+            state.tiny_nobjs--;
+            if(check_stats(fh, &state))
+                TEST_ERROR
+
+            /* Remove fifth ('normal') object from heap */
+            if(H5HF_remove(fh, dxpl, heap_id5) < 0)
+                FAIL_STACK_ERROR
+
+            /* Check for closing & re-opening the heap */
+            if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+                TEST_ERROR
+
+            /* Remove fourth ('normal') object from heap */
+            if(H5HF_remove(fh, dxpl, heap_id4) < 0)
+                FAIL_STACK_ERROR
+
+            /* Check for closing & re-opening the heap */
+            if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+                TEST_ERROR
+
+            /* Reset 'managed' object statistics after they are all removed  */
+            state.man_nobjs = 0;
+            state.man_size = 0;
+            state.man_alloc_size = 0;
+            state.man_free_space = 0;
+
+            /* Remove third object from heap */
+            if(H5HF_get_obj_len(fh, dxpl, heap_id3, &robj_size) < 0)
+                FAIL_STACK_ERROR
+            if(H5HF_remove(fh, dxpl, heap_id3) < 0)
+                FAIL_STACK_ERROR
+
+            /* Check for closing & re-opening the heap */
+            if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+                TEST_ERROR
+
+            /* Check up on heap... */
+            state.huge_size -= robj_size;
+            state.huge_nobjs--;
+            if(check_stats(fh, &state))
+                TEST_ERROR
+
+            /* Remove second object from heap */
+            if(H5HF_get_obj_len(fh, dxpl, heap_id2, &robj_size) < 0)
+                FAIL_STACK_ERROR
+            if(H5HF_remove(fh, dxpl, heap_id2) < 0)
+                FAIL_STACK_ERROR
+
+            /* Check for closing & re-opening the heap */
+            if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+                TEST_ERROR
+
+            /* Check up on heap... */
+            state.huge_size -= robj_size;
+            state.huge_nobjs--;
+            if(check_stats(fh, &state))
+                TEST_ERROR
+
+            /* Remove first object from heap */
+            if(H5HF_remove(fh, dxpl, heap_id) < 0)
+                FAIL_STACK_ERROR
+
+            /* Check for closing & re-opening the heap */
+            if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+                TEST_ERROR
+        } /* end else */
+
+        /* Check up on heap... */
+        HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+        if(check_stats(fh, &state))
+            TEST_ERROR
+    } /* end if */
+
+
+    /* Close the fractal heap */
+    if(H5HF_close(fh, dxpl) < 0)
+        FAIL_STACK_ERROR
+    fh = NULL;
+
+    /* Check for deleting the entire heap */
+    if(tparam->del_dir == FHEAP_DEL_HEAP) {
+        /* Delete heap */
+        if(H5HF_delete(f, dxpl, fh_addr) < 0)
+            FAIL_STACK_ERROR
+    } /* end if */
+
+    /* Close the file */
+    if(H5Fclose(file) < 0)
+        FAIL_STACK_ERROR
+
+    /* Get the size of the file */
+    if((file_size = h5_get_file_size(filename)) == 0)
+        TEST_ERROR
+#ifdef QAK
+HDfprintf(stderr, "file_size = %lu\n", (unsigned long)file_size);
+#endif /* QAK */
+
+    /* Verify the file is correct size */
+    if(file_size != empty_size)
+        TEST_ERROR
+
+    /* Free resources */
+    H5MM_xfree(heap_id);
+    H5MM_xfree(heap_id2);
     H5MM_xfree(heap_id3);
     H5MM_xfree(heap_id4);
     H5MM_xfree(heap_id5);
+    H5MM_xfree(heap_id6);
+    H5MM_xfree(heap_id7);
     H5MM_xfree(keep_ids.ids);
     H5MM_xfree(keep_ids.lens);
     H5MM_xfree(keep_ids.offs);
@@ -11904,6 +13600,8 @@ error:
         H5MM_xfree(heap_id3);
         H5MM_xfree(heap_id4);
         H5MM_xfree(heap_id5);
+        H5MM_xfree(heap_id6);
+        H5MM_xfree(heap_id7);
         H5MM_xfree(keep_ids.ids);
         H5MM_xfree(keep_ids.lens);
         H5MM_xfree(keep_ids.offs);
@@ -11912,14 +13610,192 @@ error:
 	H5Fclose(file);
     } H5E_END_TRY;
     return(1);
-} /* test_huge_insert_mix() */
+} /* test_tiny_insert_mix() */
 #endif /* QAK */
 #endif /* QAK2 */
 
+#ifdef NOT_YET
+
+/*-------------------------------------------------------------------------
+ * Function:	test_filtered_man_one
+ *
+ * Purpose:	Test storing one 'managed' object in a heap with I/O filters
+ *
+ * Return:	Success:	0
+ *		Failure:	1
+ *
+ * Programmer:	Quincey Koziol
+ *              Monday, August 14, 2006
+ *
+ *-------------------------------------------------------------------------
+ */
+static int
+test_filtered_man_one(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tparam)
+{
+    hid_t	file = -1;              /* File ID */
+    hid_t       dxpl = H5P_DATASET_XFER_DEFAULT;     /* DXPL to use */
+    char	filename[FHEAP_FILENAME_LEN];         /* Filename to use */
+    H5F_t	*f = NULL;              /* Internal file object pointer */
+    H5HF_t      *fh = NULL;             /* Fractal heap wrapper */
+    haddr_t     fh_addr;                /* Address of fractal heap */
+    H5HF_create_t tmp_cparam;           /* Local heap creation parameters */
+    fheap_heap_ids_t keep_ids;          /* Structure to retain heap IDs */
+    off_t       empty_size;             /* Size of a file with an empty heap */
+    off_t       file_size;              /* Size of file currently */
+    unsigned char heap_id[HEAP_ID_LEN]; /* Heap ID for object */
+    size_t      obj_size;               /* Size of object */
+    size_t      robj_size;              /* Size of object read */
+    unsigned char obj_type;             /* Type of storage for object */
+    fheap_heap_state_t state;           /* State of fractal heap */
+    unsigned    deflate_level;          /* Deflation level */
+    const char *base_desc = "insert one 'managed' object into heap with I/O filters, then remove %s";       /* Test description */
+
+    /* Copy heap creation properties */
+    HDmemcpy(&tmp_cparam, cparam, sizeof(H5HF_create_t));
+
+    /* Set an I/O filter for heap data */
+    deflate_level = 6;
+    if(H5Z_append(&tmp_cparam.pline, H5Z_FILTER_DEFLATE, H5Z_FLAG_OPTIONAL, 1, &deflate_level) < 0)
+        FAIL_STACK_ERROR
+
+    /* Perform common file & heap open operations */
+    if(open_heap(filename, fapl, dxpl, &tmp_cparam, tparam, &file, &f, &fh, &fh_addr, &state, &empty_size) < 0)
+        TEST_ERROR
+
+    /* Perform common test initialization operations */
+    if(begin_test(tparam, base_desc, &keep_ids, NULL) < 0)
+        TEST_ERROR
+
+
+    /* Insert object small enough to fit into 'normal' heap blocks */
+    obj_size = DBLOCK_SIZE(fh, 0) + 1;
+    if(H5HF_insert(fh, dxpl, obj_size, shared_wobj_g, heap_id) < 0)
+        FAIL_STACK_ERROR
+    if(H5HF_get_id_type_test(fh, heap_id, &obj_type) < 0)
+        FAIL_STACK_ERROR
+    if(obj_type != H5HF_ID_TYPE_MAN)
+        TEST_ERROR
+
+    /* Check for closing & re-opening the heap */
+    if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+        TEST_ERROR
+
+/* QAK */
+#ifdef QAK
+    /* Close the fractal heap */
+    if(H5HF_close(fh, dxpl) < 0)
+        FAIL_STACK_ERROR
+    fh = NULL;
+
+    /* Close the file */
+    if(H5Fclose(file) < 0)
+        FAIL_STACK_ERROR
+
+    /* Re-open the file */
+    if((file = H5Fopen(filename, H5F_ACC_RDONLY, fapl)) < 0)
+        FAIL_STACK_ERROR
+
+    /* Get a pointer to the internal file object */
+    if(NULL == (f = H5I_object(file)))
+        FAIL_STACK_ERROR
+
+    /* Re-open the heap */
+    if(NULL == (fh = H5HF_open(f, H5P_DATASET_XFER_DEFAULT, fh_addr)))
+        FAIL_STACK_ERROR
+#endif /* QAK */
+/* QAK */
+
+    /* Check up on heap... */
+    state.man_size = tmp_cparam.managed.width * DBLOCK_SIZE(fh, 0);
+    state.man_size += tmp_cparam.managed.width * DBLOCK_SIZE(fh, 1);
+    state.man_size += tmp_cparam.managed.width * DBLOCK_SIZE(fh, 2);
+    state.man_alloc_size = DBLOCK_SIZE(fh, 2);
+    state.man_free_space = tmp_cparam.managed.width * DBLOCK_FREE(fh, 0);
+    state.man_free_space += tmp_cparam.managed.width * DBLOCK_FREE(fh, 1);
+    state.man_free_space += DBLOCK_FREE(fh, 2) - obj_size;
+    state.man_free_space += (tmp_cparam.managed.width - 1) * DBLOCK_FREE(fh, 2);
+    state.man_nobjs++;
+    if(check_stats(fh, &state))
+        TEST_ERROR
+
+    /* Read in ('normal') object */
+    if(H5HF_get_obj_len(fh, dxpl, heap_id, &robj_size) < 0)
+        FAIL_STACK_ERROR
+    if(obj_size != robj_size)
+        TEST_ERROR
+    HDmemset(shared_robj_g, 0, obj_size);
+    if(H5HF_read(fh, dxpl, heap_id, shared_robj_g) < 0)
+        FAIL_STACK_ERROR
+    if(HDmemcmp(shared_wobj_g, shared_robj_g, obj_size))
+        TEST_ERROR
+
+    /* Delete individual objects, if we won't be deleting the entire heap later */
+    if(tparam->del_dir != FHEAP_DEL_HEAP) {
+        /* Remove object from heap */
+        if(H5HF_get_obj_len(fh, dxpl, heap_id, &robj_size) < 0)
+            FAIL_STACK_ERROR
+        if(H5HF_remove(fh, dxpl, heap_id) < 0)
+            FAIL_STACK_ERROR
+
+        /* Check for closing & re-opening the heap */
+        if(reopen_heap(f, dxpl, &fh, fh_addr, tparam) < 0)
+            TEST_ERROR
+
+        /* Check up on heap... */
+        HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+        if(check_stats(fh, &state))
+            TEST_ERROR
+    } /* end if */
+
+    /* Close the fractal heap */
+    if(H5HF_close(fh, H5P_DATASET_XFER_DEFAULT) < 0)
+        FAIL_STACK_ERROR
+    fh = NULL;
+
+    /* Check for deleting the entire heap */
+    if(tparam->del_dir == FHEAP_DEL_HEAP) {
+        /* Delete heap */
+        if(H5HF_delete(f, dxpl, fh_addr) < 0)
+            FAIL_STACK_ERROR
+    } /* end if */
+
+    /* Close the file */
+    if(H5Fclose(file) < 0)
+        FAIL_STACK_ERROR
+
+    /* Get the size of the file */
+    if((file_size = h5_get_file_size(filename)) == 0)
+        TEST_ERROR
+#ifdef QAK
+HDfprintf(stderr, "empty_size = %lu, file_size = %lu\n", (unsigned long)empty_size, (unsigned long)file_size);
+#endif /* QAK */
+
+    /* Verify the file is correct size */
+    if(file_size != empty_size)
+        TEST_ERROR
+
+    /* Free resources */
+    H5O_reset(H5O_PLINE_ID, &tmp_cparam.pline); /* Release the I/O pipeline filter information */
+
+    /* All tests passed */
+    PASSED()
+
+    return(0);
+
+error:
+    H5E_BEGIN_TRY {
+        if(fh)
+            H5HF_close(fh, dxpl);
+	H5Fclose(file);
+    } H5E_END_TRY;
+    return(1);
+} /* test_filtered_man_one() */
+#endif /* NOT_YET */
+
 #ifndef QAK
 
 /*-------------------------------------------------------------------------
- * Function:	test_man_random
+ * Function:	test_random
  *
  * Purpose:	Test inserting random sized objects into a heap, and read
  *              them back.
@@ -11936,7 +13812,7 @@ error:
  *-------------------------------------------------------------------------
  */
 static int
-test_man_random(hsize_t size_limit, hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tparam)
+test_random(hsize_t size_limit, hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tparam)
 {
     hid_t	file = -1;              /* File ID */
     hid_t       dxpl = H5P_DATASET_XFER_DEFAULT;     /* DXPL to use */
@@ -12085,11 +13961,11 @@ error:
 	H5Fclose(file);
     } H5E_END_TRY;
     return(1);
-} /* test_man_random() */
+} /* test_random() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	test_man_random_pow2
+ * Function:	test_random_pow2
  *
  * Purpose:	Test inserting random sized objects with a "power of 2
  *              distribution" (which favors small objects) into a heap,
@@ -12107,7 +13983,7 @@ error:
  *-------------------------------------------------------------------------
  */
 static int
-test_man_random_pow2(hsize_t size_limit, hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tparam)
+test_random_pow2(hsize_t size_limit, hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tparam)
 {
     hid_t	file = -1;              /* File ID */
     hid_t       dxpl = H5P_DATASET_XFER_DEFAULT;     /* DXPL to use */
@@ -12268,7 +14144,7 @@ error:
 	H5Fclose(file);
     } H5E_END_TRY;
     return(1);
-} /* test_man_random_pow2() */
+} /* test_random_pow2() */
 #endif /* QAK */
 
 
@@ -12356,6 +14232,8 @@ curr_test = FHEAP_TEST_REOPEN;
         /* Test fractal heap creation */
         nerrors += test_create(fapl, &cparam, &tparam);
         nerrors += test_reopen(fapl, &cparam, &tparam);
+        nerrors += test_id_limits(fapl, &cparam);
+        nerrors += test_filtered_create(fapl, &cparam);
 
 #ifndef QAK2
 #ifndef QAK
@@ -12562,15 +14440,15 @@ HDfprintf(stderr, "Uncomment tests!\n");
 #endif /* QAK */
 
         /*
-         * Test fractal heap huge object insertion & deletion
+         * Test fractal heap 'huge' & 'tiny' object insertion & deletion
          */
 #ifndef QAK
         {
         fheap_test_del_dir_t del_dir;   /* Deletion direction */
         unsigned id_len;                /* Length of heap IDs */
 
-        /* Test "normal" & "direct" storage of 'huge' heap IDs */
-        for(id_len = 0; id_len < 2; id_len++) {
+        /* Test "normal" & "direct" storage of 'huge' & 'tiny' heap IDs */
+        for(id_len = 0; id_len < 3; id_len++) {
             /* Set the ID length for this test */
             cparam.id_len = id_len;
 
@@ -12586,7 +14464,14 @@ HDfprintf(stderr, "Uncomment tests!\n");
                     puts("Using 'direct' heap ID format for 'huge' objects");
 
                     /* Adjust actual length of heap IDs for directly storing 'huge' object's file offset & length in heap ID */
-                    tparam.actual_id_len = 17;   /* 1 + 8 (address size) + 8 (length size) */
+                    tparam.actual_id_len = 17;   /* 1 + 8 (file address size) + 8 (file length size) */
+                    break;
+
+                /* Use "direct" storage for 'huge' objects and larger IDs for 'tiny' objects */
+                case 2:
+                    cparam.id_len = 37;
+                    puts("Using 'direct' heap ID format for 'huge' objects and larger IDs for 'tiny' objects");
+                    tparam.actual_id_len = 37;
                     break;
 
                 /* An unknown test? */
@@ -12594,14 +14479,25 @@ HDfprintf(stderr, "Uncomment tests!\n");
                     goto error;
             } /* end switch */
 
-            /* Try several different methods of deleting 'huge' objects */
+            /* Try several different methods of deleting objects */
             for(del_dir = FHEAP_DEL_FORWARD; del_dir < FHEAP_DEL_NDIRS; del_dir++) {
                 tparam.del_dir = del_dir;
 
+                /* Test 'huge' object insert & delete */
                 nerrors += test_huge_insert_one(fapl, &cparam, &tparam);
                 nerrors += test_huge_insert_two(fapl, &cparam, &tparam);
                 nerrors += test_huge_insert_three(fapl, &cparam, &tparam);
                 nerrors += test_huge_insert_mix(fapl, &cparam, &tparam);
+                nerrors += test_filtered_huge(fapl, &cparam, &tparam);
+
+#ifndef QAK
+                /* Test 'tiny' object insert & delete */
+                nerrors += test_tiny_insert_one(fapl, &cparam, &tparam);
+                nerrors += test_tiny_insert_two(fapl, &cparam, &tparam);
+                nerrors += test_tiny_insert_mix(fapl, &cparam, &tparam);
+#else /* QAK */
+HDfprintf(stderr, "Uncomment tests!\n");
+#endif /* QAK */
             } /* end for */
         } /* end for */
 
@@ -12616,6 +14512,12 @@ HDfprintf(stderr, "Uncomment tests!\n");
 HDfprintf(stderr, "Uncomment tests!\n");
 #endif /* QAK2 */
 
+        /* Test I/O filter support */
+#ifdef NOT_YET
+        /* This test isn't working properly yet */
+        nerrors += test_filtered_man_one(fapl, &cparam, &tparam);
+#endif /* NOT_YET */
+
 #ifndef QAK
         /* Random object insertion & deletion */
         if (ExpressMode > 1)
@@ -12624,12 +14526,12 @@ HDfprintf(stderr, "Uncomment tests!\n");
             /* (reduce size of tests when re-opening each time) */
 /* XXX: Try to speed things up enough that these tests don't have to be reduced */
             tparam.del_dir = FHEAP_DEL_FORWARD;
-            nerrors += test_man_random((curr_test == FHEAP_TEST_NORMAL ? (hsize_t)(100*1000*1000) : (hsize_t)(50*1000*1000)), fapl, &cparam, &tparam);
-            nerrors += test_man_random_pow2((curr_test == FHEAP_TEST_NORMAL ? (hsize_t)(100*1000*1000) : (hsize_t)(4*1000*1000)), fapl, &cparam, &tparam);
+            nerrors += test_random((curr_test == FHEAP_TEST_NORMAL ? (hsize_t)(100*1000*1000) : (hsize_t)(50*1000*1000)), fapl, &cparam, &tparam);
+            nerrors += test_random_pow2((curr_test == FHEAP_TEST_NORMAL ? (hsize_t)(100*1000*1000) : (hsize_t)(4*1000*1000)), fapl, &cparam, &tparam);
 
             tparam.del_dir = FHEAP_DEL_HEAP;
-            nerrors += test_man_random((curr_test == FHEAP_TEST_NORMAL ? (hsize_t)(100*1000*1000) : (hsize_t)(50*1000*1000)), fapl, &cparam, &tparam);
-            nerrors += test_man_random_pow2((curr_test == FHEAP_TEST_NORMAL ? (hsize_t)(100*1000*1000) : (hsize_t)(4*1000*1000)), fapl, &cparam, &tparam);
+            nerrors += test_random((curr_test == FHEAP_TEST_NORMAL ? (hsize_t)(100*1000*1000) : (hsize_t)(50*1000*1000)), fapl, &cparam, &tparam);
+            nerrors += test_random_pow2((curr_test == FHEAP_TEST_NORMAL ? (hsize_t)(100*1000*1000) : (hsize_t)(4*1000*1000)), fapl, &cparam, &tparam);
         } /* end else */
 #else /* QAK */
 HDfprintf(stderr, "Uncomment tests!\n");