Brings over most of the HD prefix removal (#3293)

1 files changed, 215 insertions, 215 deletions

diff --git a/test/fheap.c b/test/fheap.c
index 8709879..759bce3 100644
--- a/test/fheap.c
+++ b/test/fheap.c
@@ -195,7 +195,7 @@ static int
 init_small_cparam(H5HF_create_t *cparam)
 {
     /* Wipe out background */
-    HDmemset(cparam, 0, sizeof(H5HF_create_t));
+    memset(cparam, 0, sizeof(H5HF_create_t));
 
     /* General parameters */
     cparam->id_len           = SMALL_ID_LEN;
@@ -231,7 +231,7 @@ static int
 init_large_cparam(H5HF_create_t *cparam)
 {
     /* Wipe out background */
-    HDmemset(cparam, 0, sizeof(H5HF_create_t));
+    memset(cparam, 0, sizeof(H5HF_create_t));
 
     /* General parameters */
     cparam->id_len           = LARGE_ID_LEN;
@@ -271,45 +271,45 @@ check_stats(const H5HF_t *fh, const fheap_heap_state_t *state)
     if (H5HF_stat_info(fh, &heap_stats) < 0)
         FAIL_STACK_ERROR;
     if (heap_stats.man_nobjs != state->man_nobjs) {
-        HDfprintf(stdout, "heap_stats.man_nobjs = %" PRIuHSIZE ", state->man_nobjs = %zu\n",
-                  heap_stats.man_nobjs, state->man_nobjs);
+        fprintf(stdout, "heap_stats.man_nobjs = %" PRIuHSIZE ", state->man_nobjs = %zu\n",
+                heap_stats.man_nobjs, state->man_nobjs);
         TEST_ERROR;
     } /* end if */
     if (heap_stats.man_size != state->man_size) {
-        HDfprintf(stdout, "heap_stats.man_size = %" PRIuHSIZE ", state->man_size = %" PRIuHSIZE "\n",
-                  heap_stats.man_size, state->man_size);
+        fprintf(stdout, "heap_stats.man_size = %" PRIuHSIZE ", state->man_size = %" PRIuHSIZE "\n",
+                heap_stats.man_size, state->man_size);
         TEST_ERROR;
     } /* end if */
     if (heap_stats.man_alloc_size != state->man_alloc_size) {
-        HDfprintf(stdout,
-                  "heap_stats.man_alloc_size = %" PRIuHSIZE ", state->man_alloc_size = %" PRIuHSIZE "\n",
-                  heap_stats.man_alloc_size, state->man_alloc_size);
+        fprintf(stdout,
+                "heap_stats.man_alloc_size = %" PRIuHSIZE ", state->man_alloc_size = %" PRIuHSIZE "\n",
+                heap_stats.man_alloc_size, state->man_alloc_size);
         TEST_ERROR;
     } /* end if */
     if (heap_stats.man_free_space != state->man_free_space) {
-        HDfprintf(stdout,
-                  "heap_stats.man_free_space = %" PRIuHSIZE ", state->man_free_space = %" PRIuHSIZE "\n",
-                  heap_stats.man_free_space, state->man_free_space);
+        fprintf(stdout,
+                "heap_stats.man_free_space = %" PRIuHSIZE ", state->man_free_space = %" PRIuHSIZE "\n",
+                heap_stats.man_free_space, state->man_free_space);
         TEST_ERROR;
     } /* end if */
     if (heap_stats.huge_nobjs != state->huge_nobjs) {
-        HDfprintf(stdout, "heap_stats.huge_nobjs = %" PRIuHSIZE ", state->huge_nobjs = %zu\n",
-                  heap_stats.huge_nobjs, state->huge_nobjs);
+        fprintf(stdout, "heap_stats.huge_nobjs = %" PRIuHSIZE ", state->huge_nobjs = %zu\n",
+                heap_stats.huge_nobjs, state->huge_nobjs);
         TEST_ERROR;
     } /* end if */
     if (heap_stats.huge_size != state->huge_size) {
-        HDfprintf(stdout, "heap_stats.huge_size = %" PRIuHSIZE ", state->huge_size = %" PRIuHSIZE "\n",
-                  heap_stats.huge_size, state->huge_size);
+        fprintf(stdout, "heap_stats.huge_size = %" PRIuHSIZE ", state->huge_size = %" PRIuHSIZE "\n",
+                heap_stats.huge_size, state->huge_size);
         TEST_ERROR;
     } /* end if */
     if (heap_stats.tiny_nobjs != state->tiny_nobjs) {
-        HDfprintf(stdout, "heap_stats.tiny_nobjs = %" PRIuHSIZE ", state->tiny_nobjs = %zu\n",
-                  heap_stats.tiny_nobjs, state->tiny_nobjs);
+        fprintf(stdout, "heap_stats.tiny_nobjs = %" PRIuHSIZE ", state->tiny_nobjs = %zu\n",
+                heap_stats.tiny_nobjs, state->tiny_nobjs);
         TEST_ERROR;
     } /* end if */
     if (heap_stats.tiny_size != state->tiny_size) {
-        HDfprintf(stdout, "heap_stats.tiny_size = %" PRIuHSIZE ", state->tiny_size = %" PRIuHSIZE "\n",
-                  heap_stats.tiny_size, state->tiny_size);
+        fprintf(stdout, "heap_stats.tiny_size = %" PRIuHSIZE ", state->tiny_size = %" PRIuHSIZE "\n",
+                heap_stats.tiny_size, state->tiny_size);
         TEST_ERROR;
     } /* end if */
 
@@ -338,7 +338,7 @@ static herr_t
 op_memcpy(const void *obj, size_t obj_len, void *op_data)
 {
     /* Make copy of the object */
-    HDmemcpy(op_data, obj, obj_len);
+    memcpy(op_data, obj, obj_len);
 
     return (SUCCEED);
 } /* op_memcpy() */
@@ -376,7 +376,7 @@ add_obj(H5HF_t *fh, size_t obj_off, size_t obj_size, fheap_heap_state_t *state,
     size_t         robj_size;                /* Object size read in */
 
     /* Sanity check */
-    HDassert(fh);
+    assert(fh);
 
     /* Initialize object buffer */
     obj = &shared_wobj_g[obj_off];
@@ -388,7 +388,7 @@ add_obj(H5HF_t *fh, size_t obj_off, size_t obj_size, fheap_heap_state_t *state,
         TEST_ERROR;
 
     /* Insert object */
-    HDmemset(heap_id, 0, id_len);
+    memset(heap_id, 0, id_len);
     if (H5HF_insert(fh, obj_size, obj, heap_id) < 0)
         FAIL_STACK_ERROR;
 
@@ -423,7 +423,7 @@ add_obj(H5HF_t *fh, size_t obj_off, size_t obj_size, fheap_heap_state_t *state,
         TEST_ERROR;
     if (H5HF_read(fh, heap_id, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(obj, shared_robj_g, obj_size) != 0)
+    if (memcmp(obj, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* If the heap IDs are to be retained, append them to the list */
@@ -450,7 +450,7 @@ add_obj(H5HF_t *fh, size_t obj_off, size_t obj_size, fheap_heap_state_t *state,
         } /* end if */
 
         /* Append the object info onto the array */
-        HDmemcpy(&keep_ids->ids[keep_ids->num_ids * id_len], heap_id, id_len);
+        memcpy(&keep_ids->ids[keep_ids->num_ids * id_len], heap_id, id_len);
         keep_ids->lens[keep_ids->num_ids] = obj_size;
         keep_ids->offs[keep_ids->num_ids] = obj_off;
 
@@ -510,7 +510,7 @@ get_fill_size(const fheap_test_param_t *tparam)
 
         case FHEAP_TEST_FILL_N:
         default:
-            HDassert(0 && "Unknown bulk fill type?!?");
+            assert(0 && "Unknown bulk fill type?!?");
     } /* end switch */
 
     return (0);
@@ -547,7 +547,7 @@ begin_test(fheap_test_param_t *tparam, const char *base_desc, fheap_heap_ids_t *
     H5MM_xfree(test_desc);
 
     /* Initialize the heap ID structure */
-    HDmemset(keep_ids, 0, sizeof(fheap_heap_ids_t));
+    memset(keep_ids, 0, sizeof(fheap_heap_ids_t));
 
     /* Retrieve "bulk" filling object size */
     if (fill_size)
@@ -661,7 +661,7 @@ open_heap(char *filename, hid_t fapl, const H5HF_create_t *cparam, const fheap_t
             FAIL_STACK_ERROR;
         if (!H5F_addr_defined(*fh_addr))
             TEST_ERROR;
-        HDmemset(state, 0, sizeof(fheap_heap_state_t));
+        memset(state, 0, sizeof(fheap_heap_state_t));
         if (check_stats(*fh, state))
             TEST_ERROR;
 
@@ -706,7 +706,7 @@ open_heap(char *filename, hid_t fapl, const H5HF_create_t *cparam, const fheap_t
             FAIL_STACK_ERROR;
         if (!H5F_addr_defined(*fh_addr))
             TEST_ERROR;
-        HDmemset(state, 0, sizeof(fheap_heap_state_t));
+        memset(state, 0, sizeof(fheap_heap_state_t));
         if (check_stats(*fh, state))
             TEST_ERROR;
     } /* end if */
@@ -849,9 +849,9 @@ del_objs_half_refill(H5F_t *f, H5HF_t **fh, fheap_test_param_t *tparam, fheap_he
     size_t         u;                     /* Local index variable */
 
     /* Sanity check */
-    HDassert(fh);
-    HDassert(*fh);
-    HDassert(keep_ids);
+    assert(fh);
+    assert(*fh);
+    assert(keep_ids);
 
     /* Check for closing & re-opening the heap */
     if (tparam->reopen_heap) {
@@ -940,10 +940,10 @@ del_objs(H5F_t *f, H5HF_t **fh, fheap_test_param_t *tparam, fheap_heap_state_t *
     size_t  u;                     /* Local index variable */
 
     /* Sanity check */
-    HDassert(fh);
-    HDassert(*fh);
-    HDassert(state);
-    HDassert(keep_ids);
+    assert(fh);
+    assert(*fh);
+    assert(state);
+    assert(keep_ids);
 
     /* Check for first deleting half of objects & then re-inserting them */
     if (tparam->drain_half == FHEAP_DEL_DRAIN_HALF)
@@ -984,7 +984,7 @@ del_objs(H5F_t *f, H5HF_t **fh, fheap_test_param_t *tparam, fheap_heap_state_t *
     } /* end for */
 
     /* Heap should be completely empty now, reset our state */
-    HDmemset(state, 0, sizeof(fheap_heap_state_t));
+    memset(state, 0, sizeof(fheap_heap_state_t));
 
     /* Check up on heap... */
     if (check_stats(*fh, state))
@@ -1037,9 +1037,9 @@ fill_heap(H5HF_t *fh, unsigned block_row, size_t obj_size, fheap_heap_state_t *s
     unsigned       u;            /* Local index variable */
 
     /* Sanity check */
-    HDassert(fh);
-    HDassert(state);
-    HDassert(obj_size + 256 < shared_obj_size_g);
+    assert(fh);
+    assert(state);
+    assert(obj_size + 256 < shared_obj_size_g);
 
     /* Initialize starting information */
     data_size    = (size_t)DBLOCK_FREE(fh, block_row);
@@ -1166,7 +1166,7 @@ fill_heap(H5HF_t *fh, unsigned block_row, size_t obj_size, fheap_heap_state_t *s
 
         /* Check that object is correct */
         wobj = &shared_wobj_g[*curr_off_ptr];
-        if (HDmemcmp(wobj, shared_robj_g, *curr_len_ptr) != 0)
+        if (memcmp(wobj, shared_robj_g, *curr_len_ptr) != 0)
             TEST_ERROR;
 
         /* Adjust object & ID pointers */
@@ -1192,9 +1192,9 @@ fill_heap(H5HF_t *fh, unsigned block_row, size_t obj_size, fheap_heap_state_t *s
         } /* end if */
 
         /* Append the IDs onto the array */
-        HDmemcpy(&keep_ids->ids[keep_ids->num_ids * id_len], shared_ids_g, (num_ids * id_len));
-        HDmemcpy(&keep_ids->lens[keep_ids->num_ids], shared_lens_g, (num_ids * sizeof(size_t)));
-        HDmemcpy(&keep_ids->offs[keep_ids->num_ids], shared_offs_g, (num_ids * sizeof(size_t)));
+        memcpy(&keep_ids->ids[keep_ids->num_ids * id_len], shared_ids_g, (num_ids * id_len));
+        memcpy(&keep_ids->lens[keep_ids->num_ids], shared_lens_g, (num_ids * sizeof(size_t)));
+        memcpy(&keep_ids->offs[keep_ids->num_ids], shared_offs_g, (num_ids * sizeof(size_t)));
 
         /* Increment the number of IDs kept */
         keep_ids->num_ids += num_ids;
@@ -1236,8 +1236,8 @@ fill_root_row(H5HF_t *fh, unsigned row, size_t obj_size, fheap_heap_state_t *sta
     unsigned u;                /* Local index variable */
 
     /* Sanity check */
-    HDassert(fh);
-    HDassert(state);
+    assert(fh);
+    assert(state);
 
     /* Get some information for the heap */
     block_size = (size_t)DBLOCK_SIZE(fh, row);
@@ -1325,8 +1325,8 @@ fill_partial_row(H5HF_t *fh, unsigned row, unsigned width, size_t obj_size, fhea
     unsigned u;          /* Local index variable */
 
     /* Sanity check */
-    HDassert(fh);
-    HDassert(state);
+    assert(fh);
+    assert(state);
 
     /* Get some information for the heap */
     block_size = (size_t)DBLOCK_SIZE(fh, row);
@@ -1366,8 +1366,8 @@ static int
 fill_row(H5HF_t *fh, unsigned row, size_t obj_size, fheap_heap_state_t *state, fheap_heap_ids_t *keep_ids)
 {
     /* Sanity check */
-    HDassert(fh);
-    HDassert(state);
+    assert(fh);
+    assert(state);
 
     /* Fill the entire row (with the partial row fill routine) */
     if (fill_partial_row(fh, row, DTABLE_WIDTH(fh), obj_size, state, keep_ids))
@@ -1405,7 +1405,7 @@ fill_root_direct(H5HF_t *fh, size_t obj_size, fheap_heap_state_t *state, fheap_h
 
     /* Get heap info */
     max_dblock_rows = DTABLE_MAX_DROWS(fh);
-    HDassert(max_dblock_rows);
+    assert(max_dblock_rows);
 
     /* Loop over rows */
     for (row = 0; row < max_dblock_rows; row++)
@@ -1444,7 +1444,7 @@ fill_2nd_indirect(H5HF_t *fh, unsigned pos, size_t obj_size, fheap_heap_state_t
 
     /* Get some information for the heap */
     max_dblock_rows = IBLOCK_MAX_DROWS(fh, pos);
-    HDassert(max_dblock_rows);
+    assert(max_dblock_rows);
 
     /* Loop over rows */
     for (row = 0; row < max_dblock_rows; row++)
@@ -1481,7 +1481,7 @@ fill_all_direct(H5HF_t *fh, size_t obj_size, fheap_heap_state_t *state, fheap_he
 
     /* Get heap info */
     max_dblock_rows = DTABLE_MAX_DROWS(fh);
-    HDassert(max_dblock_rows);
+    assert(max_dblock_rows);
 
     /* Loop over rows */
     for (row = 0; row < max_dblock_rows; row++)
@@ -1859,14 +1859,14 @@ test_create(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tparam)
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         TEST_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
     if (check_stats(fh, &state))
         TEST_ERROR;
     PASSED();
 
     /* Query the type of address mapping */
     TESTING("query heap creation parameters");
-    HDmemset(&test_cparam, 0, sizeof(H5HF_create_t));
+    memset(&test_cparam, 0, sizeof(H5HF_create_t));
     if (H5HF_get_cparam_test(fh, &test_cparam) < 0)
         FAIL_STACK_ERROR;
     if (H5HF_cmp_cparam_test(cparam, &test_cparam))
@@ -1984,7 +1984,7 @@ test_reopen(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tparam)
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         TEST_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
     if (check_stats(fh, &state))
         TEST_ERROR;
 
@@ -2018,7 +2018,7 @@ test_reopen(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tparam)
         FAIL_STACK_ERROR;
 
     /* Query the creation parameters */
-    HDmemset(&test_cparam, 0, sizeof(H5HF_create_t));
+    memset(&test_cparam, 0, sizeof(H5HF_create_t));
     if (H5HF_get_cparam_test(fh, &test_cparam) < 0)
         FAIL_STACK_ERROR;
     if (H5HF_cmp_cparam_test(cparam, &test_cparam))
@@ -2139,7 +2139,7 @@ test_open_twice(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tparam)
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         TEST_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
     if (check_stats(fh, &state))
         TEST_ERROR;
 
@@ -2148,7 +2148,7 @@ test_open_twice(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tparam)
         FAIL_STACK_ERROR;
 
     /* Verify the creation parameters */
-    HDmemset(&test_cparam, 0, sizeof(H5HF_create_t));
+    memset(&test_cparam, 0, sizeof(H5HF_create_t));
     if (H5HF_get_cparam_test(fh2, &test_cparam) < 0)
         FAIL_STACK_ERROR;
     if (H5HF_cmp_cparam_test(cparam, &test_cparam))
@@ -2180,7 +2180,7 @@ test_open_twice(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tparam)
         FAIL_STACK_ERROR;
 
     /* Verify the creation parameters */
-    HDmemset(&test_cparam, 0, sizeof(H5HF_create_t));
+    memset(&test_cparam, 0, sizeof(H5HF_create_t));
     if (H5HF_get_cparam_test(fh2, &test_cparam) < 0)
         FAIL_STACK_ERROR;
     if (H5HF_cmp_cparam_test(cparam, &test_cparam))
@@ -2309,7 +2309,7 @@ test_delete_open(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tparam)
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         TEST_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
     if (check_stats(fh, &state))
         TEST_ERROR;
 
@@ -2322,7 +2322,7 @@ test_delete_open(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tparam)
         FAIL_STACK_ERROR;
 
     /* Verify the creation parameters */
-    HDmemset(&test_cparam, 0, sizeof(H5HF_create_t));
+    memset(&test_cparam, 0, sizeof(H5HF_create_t));
     if (H5HF_get_cparam_test(fh2, &test_cparam) < 0)
         FAIL_STACK_ERROR;
     if (H5HF_cmp_cparam_test(cparam, &test_cparam))
@@ -2464,7 +2464,7 @@ test_id_limits(hid_t fapl, H5HF_create_t *cparam, hid_t fcpl)
     TESTING("limits of heap ID lengths");
 
     /* Copy heap creation properties */
-    HDmemcpy(&tmp_cparam, cparam, sizeof(H5HF_create_t));
+    memcpy(&tmp_cparam, cparam, sizeof(H5HF_create_t));
 
     /* Set the 'default' heap ID length */
     tmp_cparam.id_len = 0;
@@ -2800,7 +2800,7 @@ test_filtered_create(hid_t fapl, H5HF_create_t *cparam, hid_t fcpl)
     TESTING("creating heaps with I/O filters");
 
     /* Copy heap creation properties */
-    HDmemcpy(&tmp_cparam, cparam, sizeof(H5HF_create_t));
+    memcpy(&tmp_cparam, cparam, sizeof(H5HF_create_t));
 
     /* Set an I/O filter for heap data */
     deflate_level = 6;
@@ -2843,7 +2843,7 @@ test_filtered_create(hid_t fapl, H5HF_create_t *cparam, hid_t fcpl)
         FAIL_STACK_ERROR;
 
     /* Query the heap creation parameters */
-    HDmemset(&test_cparam, 0, sizeof(H5HF_create_t));
+    memset(&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))
@@ -3204,7 +3204,7 @@ test_man_insert_weird(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpa
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         TEST_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
     if (check_stats(fh, &state))
         TEST_ERROR;
 
@@ -3317,7 +3317,7 @@ test_man_insert_first(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpa
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         TEST_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
     if (check_stats(fh, &state))
         TEST_ERROR;
 
@@ -3418,7 +3418,7 @@ test_man_insert_second(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tp
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
 
     /*
      * Test inserting first (small) object into absolute heap
@@ -3515,7 +3515,7 @@ test_man_insert_root_mult(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
 
     /*
      * Test inserting mult. (small) object into absolute heap
@@ -3614,7 +3614,7 @@ test_man_insert_force_indirect(hid_t fapl, H5HF_create_t *cparam, fheap_test_par
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
 
     /*
      * Test forcing creation of indirect root block & second direct block
@@ -3720,7 +3720,7 @@ test_man_insert_fill_second(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
 
     /*
      * Test inserting mult. (small) objects to fill second direct block
@@ -3827,7 +3827,7 @@ test_man_insert_third_direct(hid_t fapl, H5HF_create_t *cparam, fheap_test_param
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
 
     /*
      * Test inserting mult. (small) objects to create third direct block
@@ -3938,7 +3938,7 @@ test_man_fill_first_row(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *t
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
 
     /*
      * Test inserting mult. (small) objects to fill first row in root indirect block
@@ -4034,7 +4034,7 @@ test_man_start_second_row(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
 
     /*
      * Test inserting mult. (small) objects to start second row in root indirect block
@@ -4137,7 +4137,7 @@ test_man_fill_second_row(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
 
     /*
      * Test inserting mult. (small) objects to start second row in root indirect block
@@ -4238,7 +4238,7 @@ test_man_start_third_row(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
 
     /*
      * Test inserting mult. (small) objects to start third row in root indirect block
@@ -4349,7 +4349,7 @@ test_man_fill_fourth_row(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
 
     /*
      * Test inserting mult. (small) objects to fill four rows in root indirect block
@@ -4446,7 +4446,7 @@ test_man_fill_all_root_direct(hid_t fapl, H5HF_create_t *cparam, fheap_test_para
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
 
     /*
      * Test inserting mult. (small) objects to fill all direct  rows in root indirect block
@@ -4542,7 +4542,7 @@ test_man_first_recursive_indirect(hid_t fapl, H5HF_create_t *cparam, fheap_test_
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
 
     /*
      * Test inserting mult. (small) objects to force creation of first recursive indirect block
@@ -4644,7 +4644,7 @@ test_man_second_direct_recursive_indirect(hid_t fapl, H5HF_create_t *cparam, fhe
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
 
     /*
      * Test inserting mult. (small) objects to force creation of second direct
@@ -4754,7 +4754,7 @@ test_man_fill_first_recursive_indirect(hid_t fapl, H5HF_create_t *cparam, fheap_
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
 
     /*
      * Test inserting mult. (small) objects to fill all direct
@@ -4857,7 +4857,7 @@ test_man_second_recursive_indirect(hid_t fapl, H5HF_create_t *cparam, fheap_test
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
 
     /*
      * Test inserting mult. (small) objects to fill all direct
@@ -4968,7 +4968,7 @@ test_man_fill_second_recursive_indirect(hid_t fapl, H5HF_create_t *cparam, fheap
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
 
     /*
      * Test inserting mult. (small) objects to fill all direct
@@ -5072,7 +5072,7 @@ test_man_fill_recursive_indirect_row(hid_t fapl, H5HF_create_t *cparam, fheap_te
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
 
     /*
      * Test inserting mult. (small) objects to fill all direct
@@ -5174,7 +5174,7 @@ test_man_start_2nd_recursive_indirect(hid_t fapl, H5HF_create_t *cparam, fheap_t
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
 
     /*
      * Test inserting mult. (small) objects to fill all direct
@@ -5283,7 +5283,7 @@ test_man_recursive_indirect_two_deep(hid_t fapl, H5HF_create_t *cparam, fheap_te
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
 
     /*
      * Test inserting mult. (small) objects to fill all direct
@@ -5386,7 +5386,7 @@ test_man_start_3rd_recursive_indirect(hid_t fapl, H5HF_create_t *cparam, fheap_t
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
 
     /*
      * Test inserting mult. (small) objects to fill all direct
@@ -5496,7 +5496,7 @@ test_man_fill_first_3rd_recursive_indirect(hid_t fapl, H5HF_create_t *cparam, fh
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
 
     /*
      * Test inserting mult. (small) objects to fill all direct
@@ -5607,7 +5607,7 @@ test_man_fill_3rd_recursive_indirect_row(hid_t fapl, H5HF_create_t *cparam, fhea
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
 
     /*
      * Test inserting mult. (small) objects to fill all direct
@@ -5715,7 +5715,7 @@ test_man_fill_all_3rd_recursive_indirect(hid_t fapl, H5HF_create_t *cparam, fhea
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
 
     /*
      * Test inserting mult. (small) objects to fill all direct
@@ -5824,7 +5824,7 @@ test_man_start_4th_recursive_indirect(hid_t fapl, H5HF_create_t *cparam, fheap_t
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
 
     /*
      * Test inserting mult. (small) objects to fill all direct
@@ -5939,7 +5939,7 @@ test_man_fill_first_4th_recursive_indirect(hid_t fapl, H5HF_create_t *cparam, fh
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
 
     /*
      * Test inserting mult. (small) objects to fill all direct
@@ -6060,7 +6060,7 @@ test_man_fill_4th_recursive_indirect_row(hid_t fapl, H5HF_create_t *cparam, fhea
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
 
     /*
      * Test inserting mult. (small) objects to fill all direct
@@ -6172,7 +6172,7 @@ test_man_fill_all_4th_recursive_indirect(hid_t fapl, H5HF_create_t *cparam, fhea
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
 
     /*
      * Test inserting mult. (small) objects to fill all direct
@@ -6286,7 +6286,7 @@ test_man_start_5th_recursive_indirect(hid_t fapl, H5HF_create_t *cparam, fheap_t
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
 
     /*
      * Test inserting mult. (small) objects to fill all direct
@@ -6418,7 +6418,7 @@ test_man_remove_bogus(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpa
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
     if (check_stats(fh, &state))
         FAIL_STACK_ERROR;
 
@@ -6438,7 +6438,7 @@ test_man_remove_bogus(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpa
     seed = (unsigned long)HDtime(NULL);
 #if 0
 /* seed = (unsigned long)1155438845; */
-HDfprintf(stderr, "Random # seed was: %lu\n", seed);
+fprintf(stderr, "Random # seed was: %lu\n", seed);
 #endif
     HDsrandom((unsigned)seed);
 
@@ -6510,7 +6510,7 @@ HDfprintf(stderr, "Random # seed was: %lu\n", seed);
     return (0);
 
 error:
-    HDfprintf(stderr, "Random # seed was: %lu\n", seed);
+    fprintf(stderr, "Random # seed was: %lu\n", seed);
     H5E_BEGIN_TRY
     {
         if (fh)
@@ -6577,7 +6577,7 @@ test_man_remove_one(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpara
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
     if (check_stats(fh, &state))
         FAIL_STACK_ERROR;
 
@@ -6742,7 +6742,7 @@ test_man_remove_two(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpara
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
     if (check_stats(fh, &state))
         FAIL_STACK_ERROR;
 
@@ -6936,7 +6936,7 @@ test_man_remove_one_larger(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
     if (check_stats(fh, &state))
         FAIL_STACK_ERROR;
 
@@ -7106,7 +7106,7 @@ test_man_remove_two_larger(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
     if (check_stats(fh, &state))
         FAIL_STACK_ERROR;
 
@@ -7347,7 +7347,7 @@ test_man_remove_three_larger(hid_t fapl, H5HF_create_t *cparam, fheap_test_param
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
     if (check_stats(fh, &state))
         FAIL_STACK_ERROR;
 
@@ -7622,9 +7622,9 @@ test_man_incr_insert_remove(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_
     h5_fixname(FILENAME[0], fapl, filename, sizeof(filename));
 
     /* Set up data array */
-    if (NULL == (heap_id_data = (unsigned char *)HDcalloc(100 * MAX_HEAP_ID_LEN, sizeof(unsigned char))))
+    if (NULL == (heap_id_data = (unsigned char *)calloc(100 * MAX_HEAP_ID_LEN, sizeof(unsigned char))))
         TEST_ERROR;
-    if (NULL == (heap_id = (unsigned char **)HDcalloc(100, sizeof(heap_id_data))))
+    if (NULL == (heap_id = (unsigned char **)calloc(100, sizeof(heap_id_data))))
         TEST_ERROR;
     for (i = 0; i < 100; i++)
         heap_id[i] = heap_id_data + (i * MAX_HEAP_ID_LEN);
@@ -7652,7 +7652,7 @@ test_man_incr_insert_remove(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_
         FAIL_STACK_ERROR;
     if (!H5F_addr_defined(fh_addr))
         FAIL_STACK_ERROR;
-    HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+    memset(&state, 0, sizeof(fheap_heap_state_t));
     if (check_stats(fh, &state))
         FAIL_STACK_ERROR;
 
@@ -7661,8 +7661,8 @@ test_man_incr_insert_remove(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_
      */
     TESTING("incremental object insertion and removal");
 
-    HDmemset(&obj1, 0, sizeof(obj1));
-    HDmemset(&obj2, 0, sizeof(obj2));
+    memset(&obj1, 0, sizeof(obj1));
+    memset(&obj2, 0, sizeof(obj2));
     for (i = 0; i < 100; i++) {
         for (j = 0; j < i; j++) {
             if (H5HF_remove(fh, heap_id[j]) < 0)
@@ -7678,7 +7678,7 @@ test_man_incr_insert_remove(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_
             TEST_ERROR;
 
         /* Insert object */
-        HDmemset(heap_id[i], 0, id_len);
+        memset(heap_id[i], 0, id_len);
         HDsnprintf(obj1.b, sizeof(obj1.b), "%s%2d", "ABCDEFGHIJKLMNOPQRSTUVWXYZ", i);
         if (H5HF_insert(fh, (sizeof(obj1)), &obj1, heap_id[i]) < 0)
             FAIL_STACK_ERROR;
@@ -7695,8 +7695,8 @@ test_man_incr_insert_remove(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_
     /* All tests passed */
     PASSED();
 
-    HDfree(heap_id);
-    HDfree(heap_id_data);
+    free(heap_id);
+    free(heap_id_data);
 
     return 0;
 
@@ -7709,8 +7709,8 @@ error:
     }
     H5E_END_TRY;
 
-    HDfree(heap_id);
-    HDfree(heap_id_data);
+    free(heap_id);
+    free(heap_id_data);
 
     return 1;
 } /* test_man_incr_insert_remove() */
@@ -12692,10 +12692,10 @@ test_huge_insert_one(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
         FAIL_STACK_ERROR;
     if (obj_size != robj_size)
         TEST_ERROR;
-    HDmemset(shared_robj_g, 0, obj_size);
+    memset(shared_robj_g, 0, obj_size);
     if (H5HF_read(fh, heap_id, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
+    if (memcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* Delete individual objects, if we won't be deleting the entire heap later */
@@ -12845,10 +12845,10 @@ test_huge_insert_two(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
         FAIL_STACK_ERROR;
     if (obj_size != robj_size)
         TEST_ERROR;
-    HDmemset(shared_robj_g, 0, obj_size);
+    memset(shared_robj_g, 0, obj_size);
     if (H5HF_read(fh, heap_id, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
+    if (memcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* Insert second object too large for managed heap blocks */
@@ -12875,10 +12875,10 @@ test_huge_insert_two(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
         FAIL_STACK_ERROR;
     if (obj_size != robj_size)
         TEST_ERROR;
-    HDmemset(shared_robj_g, 0, obj_size);
+    memset(shared_robj_g, 0, obj_size);
     if (H5HF_read(fh, heap_id2, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
+    if (memcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* Delete individual objects, if we won't be deleting the entire heap later */
@@ -13078,10 +13078,10 @@ test_huge_insert_three(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tp
         FAIL_STACK_ERROR;
     if (obj_size != robj_size)
         TEST_ERROR;
-    HDmemset(shared_robj_g, 0, obj_size);
+    memset(shared_robj_g, 0, obj_size);
     if (H5HF_read(fh, heap_id, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
+    if (memcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* Insert second object too large for managed heap blocks */
@@ -13108,10 +13108,10 @@ test_huge_insert_three(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tp
         FAIL_STACK_ERROR;
     if (obj_size != robj_size)
         TEST_ERROR;
-    HDmemset(shared_robj_g, 0, obj_size);
+    memset(shared_robj_g, 0, obj_size);
     if (H5HF_read(fh, heap_id2, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
+    if (memcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* Insert third object too large for managed heap blocks */
@@ -13138,10 +13138,10 @@ test_huge_insert_three(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tp
         FAIL_STACK_ERROR;
     if (obj_size != robj_size)
         TEST_ERROR;
-    HDmemset(shared_robj_g, 0, obj_size);
+    memset(shared_robj_g, 0, obj_size);
     if (H5HF_read(fh, heap_id3, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
+    if (memcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* Delete individual objects, if we won't be deleting the entire heap later */
@@ -13389,10 +13389,10 @@ test_huge_insert_mix(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
         FAIL_STACK_ERROR;
     if (obj_size != robj_size)
         TEST_ERROR;
-    HDmemset(shared_robj_g, 0, obj_size);
+    memset(shared_robj_g, 0, obj_size);
     if (H5HF_read(fh, heap_id, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
+    if (memcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* Insert second object too large for managed heap blocks */
@@ -13419,10 +13419,10 @@ test_huge_insert_mix(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
         FAIL_STACK_ERROR;
     if (obj_size != robj_size)
         TEST_ERROR;
-    HDmemset(shared_robj_g, 0, obj_size);
+    memset(shared_robj_g, 0, obj_size);
     if (H5HF_read(fh, heap_id2, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
+    if (memcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* Insert third object too large for managed heap blocks */
@@ -13449,10 +13449,10 @@ test_huge_insert_mix(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
         FAIL_STACK_ERROR;
     if (obj_size != robj_size)
         TEST_ERROR;
-    HDmemset(shared_robj_g, 0, obj_size);
+    memset(shared_robj_g, 0, obj_size);
     if (H5HF_read(fh, heap_id3, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
+    if (memcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* Insert fourth object small enough to fit into 'normal' heap blocks */
@@ -13486,10 +13486,10 @@ test_huge_insert_mix(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
         FAIL_STACK_ERROR;
     if (obj_size != robj_size)
         TEST_ERROR;
-    HDmemset(shared_robj_g, 0, obj_size);
+    memset(shared_robj_g, 0, obj_size);
     if (H5HF_read(fh, heap_id4, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
+    if (memcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* Insert fifth object small enough to fit into 'normal' heap blocks */
@@ -13524,10 +13524,10 @@ test_huge_insert_mix(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
         FAIL_STACK_ERROR;
     if (obj_size != robj_size)
         TEST_ERROR;
-    HDmemset(shared_robj_g, 0, obj_size);
+    memset(shared_robj_g, 0, obj_size);
     if (H5HF_read(fh, heap_id5, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
+    if (memcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* Delete individual objects, if we won't be deleting the entire heap later */
@@ -13662,7 +13662,7 @@ test_huge_insert_mix(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
         } /* end else */
 
         /* Check up on heap... */
-        HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+        memset(&state, 0, sizeof(fheap_heap_state_t));
         if (check_stats(fh, &state))
             TEST_ERROR;
     } /* end if */
@@ -13764,7 +13764,7 @@ test_filtered_huge(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tparam
     const char *base_desc = "insert 'huge' object into heap with I/O filters, then remove";
 
     /* Copy heap creation properties */
-    HDmemcpy(&tmp_cparam, cparam, sizeof(H5HF_create_t));
+    memcpy(&tmp_cparam, cparam, sizeof(H5HF_create_t));
 
     /* Set an I/O filter for heap data */
     deflate_level = 6;
@@ -13862,10 +13862,10 @@ test_filtered_huge(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tparam
         FAIL_STACK_ERROR;
     if (obj_size != robj_size)
         TEST_ERROR;
-    HDmemset(shared_robj_g, 0, obj_size);
+    memset(shared_robj_g, 0, obj_size);
     if (H5HF_read(fh, heap_id, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
+    if (memcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* Delete individual objects, if we won't be deleting the entire heap later */
@@ -14013,10 +14013,10 @@ test_tiny_insert_one(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
         FAIL_STACK_ERROR;
     if (obj_size != robj_size)
         TEST_ERROR;
-    HDmemset(shared_robj_g, 0, obj_size);
+    memset(shared_robj_g, 0, obj_size);
     if (H5HF_read(fh, heap_id, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
+    if (memcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* Delete individual objects, if we won't be deleting the entire heap later */
@@ -14166,10 +14166,10 @@ test_tiny_insert_two(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
         FAIL_STACK_ERROR;
     if (obj_size != robj_size)
         TEST_ERROR;
-    HDmemset(shared_robj_g, 0, obj_size);
+    memset(shared_robj_g, 0, obj_size);
     if (H5HF_read(fh, heap_id, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
+    if (memcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* Insert second object small enough to encode in heap ID */
@@ -14196,10 +14196,10 @@ test_tiny_insert_two(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
         FAIL_STACK_ERROR;
     if (obj_size != robj_size)
         TEST_ERROR;
-    HDmemset(shared_robj_g, 0, obj_size);
+    memset(shared_robj_g, 0, obj_size);
     if (H5HF_read(fh, heap_id2, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
+    if (memcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* Delete individual objects, if we won't be deleting the entire heap later */
@@ -14412,17 +14412,17 @@ test_tiny_insert_mix(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
         FAIL_STACK_ERROR;
     if (obj_size != robj_size)
         TEST_ERROR;
-    HDmemset(shared_robj_g, 0, obj_size);
+    memset(shared_robj_g, 0, obj_size);
     if (H5HF_read(fh, heap_id, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
+    if (memcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* Check 'op' functionality on first huge object */
-    HDmemset(shared_robj_g, 0, obj_size);
+    memset(shared_robj_g, 0, obj_size);
     if (H5HF_op(fh, heap_id, op_memcpy, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
+    if (memcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* Insert second object too large for managed heap blocks */
@@ -14449,17 +14449,17 @@ test_tiny_insert_mix(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
         FAIL_STACK_ERROR;
     if (obj_size != robj_size)
         TEST_ERROR;
-    HDmemset(shared_robj_g, 0, obj_size);
+    memset(shared_robj_g, 0, obj_size);
     if (H5HF_read(fh, heap_id2, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
+    if (memcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* Check 'op' functionality on second huge object */
-    HDmemset(shared_robj_g, 0, obj_size);
+    memset(shared_robj_g, 0, obj_size);
     if (H5HF_op(fh, heap_id2, op_memcpy, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
+    if (memcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* Insert third object too large for managed heap blocks */
@@ -14486,17 +14486,17 @@ test_tiny_insert_mix(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
         FAIL_STACK_ERROR;
     if (obj_size != robj_size)
         TEST_ERROR;
-    HDmemset(shared_robj_g, 0, obj_size);
+    memset(shared_robj_g, 0, obj_size);
     if (H5HF_read(fh, heap_id3, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
+    if (memcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* Check 'op' functionality on third huge object */
-    HDmemset(shared_robj_g, 0, obj_size);
+    memset(shared_robj_g, 0, obj_size);
     if (H5HF_op(fh, heap_id3, op_memcpy, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
+    if (memcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* Insert fourth object small enough to fit into 'normal' heap blocks */
@@ -14530,17 +14530,17 @@ test_tiny_insert_mix(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
         FAIL_STACK_ERROR;
     if (obj_size != robj_size)
         TEST_ERROR;
-    HDmemset(shared_robj_g, 0, obj_size);
+    memset(shared_robj_g, 0, obj_size);
     if (H5HF_read(fh, heap_id4, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
+    if (memcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* Check 'op' functionality on fourth ('normal') object */
-    HDmemset(shared_robj_g, 0, obj_size);
+    memset(shared_robj_g, 0, obj_size);
     if (H5HF_op(fh, heap_id4, op_memcpy, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
+    if (memcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* Insert fifth object small enough to fit into 'normal' heap blocks */
@@ -14575,17 +14575,17 @@ test_tiny_insert_mix(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
         FAIL_STACK_ERROR;
     if (obj_size != robj_size)
         TEST_ERROR;
-    HDmemset(shared_robj_g, 0, obj_size);
+    memset(shared_robj_g, 0, obj_size);
     if (H5HF_read(fh, heap_id5, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
+    if (memcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* Check 'op' functionality on fifth ('normal') object */
-    HDmemset(shared_robj_g, 0, obj_size);
+    memset(shared_robj_g, 0, obj_size);
     if (H5HF_op(fh, heap_id5, op_memcpy, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
+    if (memcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* Insert sixth object small enough to encode in heap ID */
@@ -14612,17 +14612,17 @@ test_tiny_insert_mix(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
         FAIL_STACK_ERROR;
     if (obj_size != robj_size)
         TEST_ERROR;
-    HDmemset(shared_robj_g, 0, obj_size);
+    memset(shared_robj_g, 0, obj_size);
     if (H5HF_read(fh, heap_id6, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
+    if (memcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* Check 'op' functionality on sixth ('tiny') object */
-    HDmemset(shared_robj_g, 0, obj_size);
+    memset(shared_robj_g, 0, obj_size);
     if (H5HF_op(fh, heap_id6, op_memcpy, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
+    if (memcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* Insert seventh object small enough to encode in heap ID */
@@ -14649,17 +14649,17 @@ test_tiny_insert_mix(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
         FAIL_STACK_ERROR;
     if (obj_size != robj_size)
         TEST_ERROR;
-    HDmemset(shared_robj_g, 0, obj_size);
+    memset(shared_robj_g, 0, obj_size);
     if (H5HF_read(fh, heap_id7, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
+    if (memcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* Check 'op' functionality on seventh ('tiny') object */
-    HDmemset(shared_robj_g, 0, obj_size);
+    memset(shared_robj_g, 0, obj_size);
     if (H5HF_op(fh, heap_id7, op_memcpy, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
+    if (memcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* Delete individual objects, if we won't be deleting the entire heap later */
@@ -14856,7 +14856,7 @@ test_tiny_insert_mix(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpar
         } /* end else */
 
         /* Check up on heap... */
-        HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+        memset(&state, 0, sizeof(fheap_heap_state_t));
         if (check_stats(fh, &state))
             TEST_ERROR;
     } /* end if */
@@ -14960,7 +14960,7 @@ test_filtered_man_root_direct(hid_t fapl, H5HF_create_t *cparam, fheap_test_para
     const char *base_desc = "insert one 'managed' object into heap with I/O filters, then remove";
 
     /* Copy heap creation properties */
-    HDmemcpy(&tmp_cparam, cparam, sizeof(H5HF_create_t));
+    memcpy(&tmp_cparam, cparam, sizeof(H5HF_create_t));
 
     /* Set an I/O filter for heap data */
     deflate_level = 6;
@@ -15026,10 +15026,10 @@ test_filtered_man_root_direct(hid_t fapl, H5HF_create_t *cparam, fheap_test_para
         FAIL_STACK_ERROR;
     if (obj_size != robj_size)
         TEST_ERROR;
-    HDmemset(shared_robj_g, 0, obj_size);
+    memset(shared_robj_g, 0, obj_size);
     if (H5HF_read(fh, heap_id, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
+    if (memcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* Delete individual objects, if we won't be deleting the entire heap later */
@@ -15045,7 +15045,7 @@ test_filtered_man_root_direct(hid_t fapl, H5HF_create_t *cparam, fheap_test_para
             TEST_ERROR;
 
         /* Check up on heap... */
-        HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+        memset(&state, 0, sizeof(fheap_heap_state_t));
         if (check_stats(fh, &state))
             TEST_ERROR;
     } /* end if */
@@ -15134,7 +15134,7 @@ test_filtered_man_root_indirect(hid_t fapl, H5HF_create_t *cparam, fheap_test_pa
     const char *base_desc = "insert two 'managed' objects into heap with I/O filters, then remove";
 
     /* Copy heap creation properties */
-    HDmemcpy(&tmp_cparam, cparam, sizeof(H5HF_create_t));
+    memcpy(&tmp_cparam, cparam, sizeof(H5HF_create_t));
 
     /* Set an I/O filter for heap data */
     deflate_level = 6;
@@ -15209,10 +15209,10 @@ test_filtered_man_root_indirect(hid_t fapl, H5HF_create_t *cparam, fheap_test_pa
         FAIL_STACK_ERROR;
     if (obj_size != robj_size)
         TEST_ERROR;
-    HDmemset(shared_robj_g, 0, obj_size);
+    memset(shared_robj_g, 0, obj_size);
     if (H5HF_read(fh, heap_id1, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
+    if (memcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* Read in ('normal') object #2 */
@@ -15220,10 +15220,10 @@ test_filtered_man_root_indirect(hid_t fapl, H5HF_create_t *cparam, fheap_test_pa
         FAIL_STACK_ERROR;
     if (obj_size != robj_size)
         TEST_ERROR;
-    HDmemset(shared_robj_g, 0, obj_size);
+    memset(shared_robj_g, 0, obj_size);
     if (H5HF_read(fh, heap_id2, shared_robj_g) < 0)
         FAIL_STACK_ERROR;
-    if (HDmemcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
+    if (memcmp(shared_wobj_g, shared_robj_g, obj_size) != 0)
         TEST_ERROR;
 
     /* Delete individual objects, if we won't be deleting the entire heap later */
@@ -15267,7 +15267,7 @@ test_filtered_man_root_indirect(hid_t fapl, H5HF_create_t *cparam, fheap_test_pa
                 FAIL_STACK_ERROR;
 
             /* Check up on heap... */
-            HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+            memset(&state, 0, sizeof(fheap_heap_state_t));
             if (check_stats(fh, &state))
                 TEST_ERROR;
 
@@ -15297,7 +15297,7 @@ test_filtered_man_root_indirect(hid_t fapl, H5HF_create_t *cparam, fheap_test_pa
                 FAIL_STACK_ERROR;
 
             /* Check up on heap... */
-            HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+            memset(&state, 0, sizeof(fheap_heap_state_t));
             if (check_stats(fh, &state))
                 TEST_ERROR;
         } /* end if */
@@ -15340,7 +15340,7 @@ test_filtered_man_root_indirect(hid_t fapl, H5HF_create_t *cparam, fheap_test_pa
                 FAIL_STACK_ERROR;
 
             /* Check up on heap... */
-            HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+            memset(&state, 0, sizeof(fheap_heap_state_t));
             if (check_stats(fh, &state))
                 TEST_ERROR;
 
@@ -15370,7 +15370,7 @@ test_filtered_man_root_indirect(hid_t fapl, H5HF_create_t *cparam, fheap_test_pa
                 FAIL_STACK_ERROR;
 
             /* Check up on heap... */
-            HDmemset(&state, 0, sizeof(fheap_heap_state_t));
+            memset(&state, 0, sizeof(fheap_heap_state_t));
             if (check_stats(fh, &state))
                 TEST_ERROR;
         } /* end else */
@@ -15460,10 +15460,10 @@ test_random(hsize_t size_limit, hid_t fapl, H5HF_create_t *cparam, fheap_test_pa
     size_t             u;                            /* Local index variable */
 
     /* Initialize the heap ID structure */
-    HDmemset(&keep_ids, 0, sizeof(fheap_heap_ids_t));
+    memset(&keep_ids, 0, sizeof(fheap_heap_ids_t));
 
     /* Copy heap creation properties */
-    HDmemcpy(&tmp_cparam, cparam, sizeof(H5HF_create_t));
+    memcpy(&tmp_cparam, cparam, sizeof(H5HF_create_t));
 
     /* Check if we are compressing the blocks */
     if (tparam->comp == FHEAP_TEST_COMPRESS) {
@@ -15508,7 +15508,7 @@ test_random(hsize_t size_limit, hid_t fapl, H5HF_create_t *cparam, fheap_test_pa
     seed = (unsigned long)HDtime(NULL);
 #if 0
 /* seed = (unsigned long)1156158635; */
-HDfprintf(stderr, "Random # seed was: %lu\n", seed);
+fprintf(stderr, "Random # seed was: %lu\n", seed);
 #endif
     HDsrandom((unsigned)seed);
 
@@ -15545,9 +15545,9 @@ HDfprintf(stderr, "Random # seed was: %lu\n", seed);
 
             /* Swap current position with future position */
             /* (just swap the heap ID, the len & offset isn't used */
-            HDmemcpy(temp_id, &keep_ids.ids[u * id_len], id_len);
-            HDmemcpy(&keep_ids.ids[u * id_len], &keep_ids.ids[(u + pos) * id_len], id_len);
-            HDmemcpy(&keep_ids.ids[(u + pos) * id_len], temp_id, id_len);
+            memcpy(temp_id, &keep_ids.ids[u * id_len], id_len);
+            memcpy(&keep_ids.ids[u * id_len], &keep_ids.ids[(u + pos) * id_len], id_len);
+            memcpy(&keep_ids.ids[(u + pos) * id_len], temp_id, id_len);
         } /* end if */
     }     /* end for */
 
@@ -15608,7 +15608,7 @@ HDfprintf(stderr, "Random # seed was: %lu\n", seed);
     return (0);
 
 error:
-    HDfprintf(stderr, "Random # seed was: %lu\n", seed);
+    fprintf(stderr, "Random # seed was: %lu\n", seed);
     H5E_BEGIN_TRY
     {
         H5MM_xfree(keep_ids.ids);
@@ -15664,10 +15664,10 @@ test_random_pow2(hsize_t size_limit, hid_t fapl, H5HF_create_t *cparam, fheap_te
     size_t             u;                            /* Local index variable */
 
     /* Initialize the heap ID structure */
-    HDmemset(&keep_ids, 0, sizeof(fheap_heap_ids_t));
+    memset(&keep_ids, 0, sizeof(fheap_heap_ids_t));
 
     /* Copy heap creation properties */
-    HDmemcpy(&tmp_cparam, cparam, sizeof(H5HF_create_t));
+    memcpy(&tmp_cparam, cparam, sizeof(H5HF_create_t));
 
     /* Check if we are compressing the blocks */
     if (tparam->comp == FHEAP_TEST_COMPRESS) {
@@ -15714,7 +15714,7 @@ test_random_pow2(hsize_t size_limit, hid_t fapl, H5HF_create_t *cparam, fheap_te
     seed = (unsigned long)HDtime(NULL);
 #if 0
 /* seed = (unsigned long)1155181717; */
-HDfprintf(stderr, "Random # seed was: %lu\n", seed);
+fprintf(stderr, "Random # seed was: %lu\n", seed);
 #endif
     HDsrandom((unsigned)seed);
 
@@ -15763,9 +15763,9 @@ HDfprintf(stderr, "Random # seed was: %lu\n", seed);
 
             /* Swap current position with future position */
             /* (just swap the heap ID, the len & offset isn't used */
-            HDmemcpy(temp_id, &keep_ids.ids[u * id_len], id_len);
-            HDmemcpy(&keep_ids.ids[u * id_len], &keep_ids.ids[(u + pos) * id_len], id_len);
-            HDmemcpy(&keep_ids.ids[(u + pos) * id_len], temp_id, id_len);
+            memcpy(temp_id, &keep_ids.ids[u * id_len], id_len);
+            memcpy(&keep_ids.ids[u * id_len], &keep_ids.ids[(u + pos) * id_len], id_len);
+            memcpy(&keep_ids.ids[(u + pos) * id_len], temp_id, id_len);
         } /* end if */
     }     /* end for */
 
@@ -15826,7 +15826,7 @@ HDfprintf(stderr, "Random # seed was: %lu\n", seed);
     return (0);
 
 error:
-    HDfprintf(stderr, "Random # seed was: %lu\n", seed);
+    fprintf(stderr, "Random # seed was: %lu\n", seed);
     H5E_BEGIN_TRY
     {
         H5MM_xfree(keep_ids.ids);
@@ -15899,10 +15899,10 @@ test_write(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tparam)
         TESTING("writing objects in heap");
 
     /* Initialize the heap ID structure */
-    HDmemset(&keep_ids, 0, sizeof(fheap_heap_ids_t));
+    memset(&keep_ids, 0, sizeof(fheap_heap_ids_t));
 
     /* Copy heap creation properties */
-    HDmemcpy(&tmp_cparam, cparam, sizeof(H5HF_create_t));
+    memcpy(&tmp_cparam, cparam, sizeof(H5HF_create_t));
 
     /* Check if we are compressing the blocks */
     if (tparam->comp == FHEAP_TEST_COMPRESS) {
@@ -15956,7 +15956,7 @@ test_write(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tparam)
         ret = H5HF_write(fh, huge_heap_id, &id_changed, shared_wobj_g);
     }
     H5E_END_TRY;
-    HDassert(!id_changed);
+    assert(!id_changed);
     if (tparam->comp == FHEAP_TEST_COMPRESS) {
         if (ret >= 0)
             TEST_ERROR;
@@ -15972,7 +15972,7 @@ test_write(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tparam)
         ret = H5HF_write(fh, tiny_heap_id, &id_changed, shared_wobj_g);
     }
     H5E_END_TRY;
-    HDassert(!id_changed);
+    assert(!id_changed);
     if (ret >= 0)
         TEST_ERROR;
 
@@ -16028,14 +16028,14 @@ test_write(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tparam)
         /* Overwrite data just written */
         if (H5HF_write(fh, &keep_ids.ids[id_len * u], &id_changed, rewrite_obj) < 0)
             FAIL_STACK_ERROR;
-        HDassert(!id_changed);
+        assert(!id_changed);
 
         /* Read data back in */
         if (H5HF_read(fh, &keep_ids.ids[id_len * u], shared_robj_g) < 0)
             FAIL_STACK_ERROR;
 
         /* Compare data read in */
-        if (HDmemcmp(rewrite_obj, shared_robj_g, obj_size) != 0)
+        if (memcmp(rewrite_obj, shared_robj_g, obj_size) != 0)
             TEST_ERROR;
 
         /* Change size of data to write */
@@ -16084,7 +16084,7 @@ test_write(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tparam)
             FAIL_STACK_ERROR;
 
         /* Compare data read in */
-        if (HDmemcmp(rewrite_obj, shared_robj_g, obj_size) != 0)
+        if (memcmp(rewrite_obj, shared_robj_g, obj_size) != 0)
             TEST_ERROR;
 
         /* Change size of data to write */
@@ -16169,7 +16169,7 @@ test_bug1(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tparam)
     TESTING("bug1: inserting several objects & removing one, then re-inserting");
 
     /* Initialize the heap ID structure */
-    HDmemset(&keep_ids, 0, sizeof(fheap_heap_ids_t));
+    memset(&keep_ids, 0, sizeof(fheap_heap_ids_t));
 
     /* Perform common file & heap open operations */
     if (open_heap(filename, fapl, cparam, tparam, &file, &f, &fh, &fh_addr, &state, &empty_size) < 0)
@@ -16362,7 +16362,7 @@ main(void)
      *      in the future for parallel build.
      */
     if (ExpressMode > 1)
-        HDprintf("***Express test mode on.  Some tests may be skipped\n");
+        printf("***Express test mode on.  Some tests may be skipped\n");
     else if (ExpressMode == 0) {
 #ifdef H5_HAVE_PARALLEL
         num_pb_fs = NUM_PB_FS - 2;
@@ -16477,7 +16477,7 @@ main(void)
         /* Iterate over the testing parameters */
         for (curr_test = FHEAP_TEST_NORMAL; curr_test < FHEAP_TEST_NTESTS; curr_test++) {
             /* Clear the testing parameters */
-            HDmemset(&tparam, 0, sizeof(fheap_test_param_t));
+            memset(&tparam, 0, sizeof(fheap_test_param_t));
             tparam.actual_id_len = HEAP_ID_LEN;
 
             /* Set to run with different file space setting */
@@ -16580,7 +16580,7 @@ main(void)
                      * level of complexity gradually. -QAK
                      */
                     if (ExpressMode > 1)
-                        HDprintf(
+                        printf(
                             "***Express test mode on.  test_man_start_5th_recursive_indirect is skipped\n");
                     else
                         nerrors += test_man_start_5th_recursive_indirect(fapl, &small_cparam, &tparam);
@@ -16628,7 +16628,7 @@ main(void)
                                 nerrors += test_man_remove_first_two_rows(fapl, &small_cparam, &tparam);
                                 nerrors += test_man_remove_first_four_rows(fapl, &small_cparam, &tparam);
                                 if (ExpressMode > 1)
-                                    HDprintf("***Express test mode on.  Some tests skipped\n");
+                                    printf("***Express test mode on.  Some tests skipped\n");
                                 else {
                                     nerrors += test_man_remove_all_root_direct(fapl, &small_cparam, &tparam);
                                     nerrors += test_man_remove_2nd_indirect(fapl, &small_cparam, &tparam);
@@ -16678,7 +16678,7 @@ main(void)
                                     test_man_fill_1st_row_3rd_direct_fill_2nd_direct_less_one_wrap_start_block_add_skipped(
                                         fapl, &small_cparam, &tparam);
                                 if (ExpressMode > 1)
-                                    HDprintf("***Express test mode on.  Some tests skipped\n");
+                                    printf("***Express test mode on.  Some tests skipped\n");
                                 else {
                                     nerrors +=
                                         test_man_fill_3rd_direct_fill_direct_skip_start_block_add_skipped(
@@ -16808,7 +16808,7 @@ main(void)
 
             /* Random object insertion & deletion */
             if (ExpressMode > 1)
-                HDprintf("***Express test mode on.  Some tests skipped\n");
+                printf("***Express test mode on.  Some tests skipped\n");
             else {
                 /* Random tests using "small" heap creation parameters */
                 HDputs("Using 'small' heap creation parameters");