Switch list lengths to unsigned integers (to align better w/cache image merge)

13 files changed, 273 insertions, 570 deletions

diff --git a/src/H5AC.c b/src/H5AC.c
index 117e662..c93ec70 100644
--- a/src/H5AC.c
+++ b/src/H5AC.c
@@ -2094,7 +2094,7 @@ done:
  */
 herr_t
 H5AC_get_cache_size(H5AC_t *cache_ptr, size_t *max_size_ptr, size_t *min_clean_size_ptr,
-    size_t *cur_size_ptr, int32_t *cur_num_entries_ptr)
+    size_t *cur_size_ptr, uint32_t *cur_num_entries_ptr)
 {
     herr_t ret_value = SUCCEED;      /* Return value */
 
diff --git a/src/H5ACprivate.h b/src/H5ACprivate.h
index 3dd6079..d8d73c5 100644
--- a/src/H5ACprivate.h
+++ b/src/H5ACprivate.h
@@ -344,7 +344,6 @@ H5_DLLVAR hid_t H5AC_rawdata_dxpl_id;
 #define H5AC__TAKE_OWNERSHIP_FLAG         H5C__TAKE_OWNERSHIP_FLAG
 #define H5AC__FLUSH_LAST_FLAG		  H5C__FLUSH_LAST_FLAG
 #define H5AC__FLUSH_COLLECTIVELY_FLAG	  H5C__FLUSH_COLLECTIVELY_FLAG
-#define H5AC__EVICT_ALLOW_LAST_PINS_FLAG  H5C__EVICT_ALLOW_LAST_PINS_FLAG
 
 
 /* #defines of flags used to report entry status in the
@@ -394,7 +393,7 @@ H5_DLL herr_t H5AC_remove_entry(void *entry);
 H5_DLL herr_t H5AC_get_cache_auto_resize_config(const H5AC_t * cache_ptr,
     H5AC_cache_config_t *config_ptr);
 H5_DLL herr_t H5AC_get_cache_size(H5AC_t *cache_ptr, size_t *max_size_ptr,
-    size_t *min_clean_size_ptr, size_t *cur_size_ptr, int32_t *cur_num_entries_ptr);
+    size_t *min_clean_size_ptr, size_t *cur_size_ptr, uint32_t *cur_num_entries_ptr);
 H5_DLL herr_t H5AC_get_cache_hit_rate(H5AC_t *cache_ptr, double *hit_rate_ptr);
 H5_DLL herr_t H5AC_reset_cache_hit_rate_stats(H5AC_t *cache_ptr);
 H5_DLL herr_t H5AC_set_cache_auto_resize_config(H5AC_t *cache_ptr,
diff --git a/src/H5C.c b/src/H5C.c
index 22cb0df..862bee4 100644
--- a/src/H5C.c
+++ b/src/H5C.c
@@ -868,7 +868,7 @@ H5C_expunge_entry(H5F_t *f, hid_t dxpl_id, const H5C_class_t *type,
 
 #if H5C_DO_EXTREME_SANITY_CHECKS
     if(H5C_validate_lru_list(cache_ptr) < 0)
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "LRU extreme sanity check failed on entry.\n")
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "LRU extreme sanity check failed on entry")
 #endif /* H5C_DO_EXTREME_SANITY_CHECKS */
 
     /* Look for entry in cache */
@@ -909,7 +909,7 @@ H5C_expunge_entry(H5F_t *f, hid_t dxpl_id, const H5C_class_t *type,
 done:
 #if H5C_DO_EXTREME_SANITY_CHECKS
     if(H5C_validate_lru_list(cache_ptr) < 0)
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "LRU extreme sanity check failed on exit.\n")
+        HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "LRU extreme sanity check failed on exit")
 #endif /* H5C_DO_EXTREME_SANITY_CHECKS */
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -968,12 +968,12 @@ H5C_flush_cache(H5F_t *f, hid_t dxpl_id, unsigned flags)
 {
 #if H5C_DO_SANITY_CHECKS
     int			i;
-    int32_t		index_len = 0;
+    uint32_t		index_len = 0;
     size_t		index_size = (size_t)0;
     size_t		clean_index_size = (size_t)0;
     size_t		dirty_index_size = (size_t)0;
     size_t		slist_size = (size_t)0;
-    int32_t		slist_len = 0;
+    uint32_t		slist_len = 0;
 #endif /* H5C_DO_SANITY_CHECKS */
     H5C_ring_t		ring;
     H5C_t             * cache_ptr;
@@ -1020,7 +1020,7 @@ H5C_flush_cache(H5F_t *f, hid_t dxpl_id, unsigned flags)
     if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
             (H5C_validate_pinned_entry_list(cache_ptr) < 0) ||
             (H5C_validate_lru_list(cache_ptr) < 0))
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on entry.\n")
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on entry")
 #endif /* H5C_DO_EXTREME_SANITY_CHECKS */
 
     ignore_protected = ( (flags & H5C__FLUSH_IGNORE_PROTECTED_FLAG) != 0 );
@@ -1173,16 +1173,8 @@ H5C_flush_to_min_clean(H5F_t * f,
                     "cache write is not permitted!?!\n");
     }
 #if 1 /* original code */
-    result = H5C_make_space_in_cache(f,
-                                     dxpl_id,
-                                     (size_t)0,
-                                     write_permitted);
-
-    if ( result < 0 ) {
-
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                    "H5C_make_space_in_cache failed.")
-    }
+    if(H5C_make_space_in_cache(f, dxpl_id, (size_t)0, write_permitted) < 0)
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "H5C__make_space_in_cache failed")
 #else /* modified code -- commented out for now */
     if ( cache_ptr->max_cache_size > cache_ptr->index_size ) {
 
@@ -1336,8 +1328,9 @@ H5C_insert_entry(H5F_t *             f,
     hbool_t             set_flush_marker;
     hbool_t		write_permitted = TRUE;
     size_t		empty_space;
-    H5C_cache_entry_t  *entry_ptr;
+    H5C_cache_entry_t  *entry_ptr = NULL;
     H5C_cache_entry_t  *test_entry_ptr;
+    hbool_t		entry_tagged = FALSE;
     herr_t		ret_value = SUCCEED;    /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
@@ -1357,14 +1350,10 @@ H5C_insert_entry(H5F_t *             f,
 #if H5C_DO_EXTREME_SANITY_CHECKS
     /* no need to verify that entry is not already in the index as */
     /* we already make that check below.                           */
-
-    if ( ( H5C_validate_protected_entry_list(cache_ptr) < 0 ) ||
-         ( H5C_validate_pinned_entry_list(cache_ptr) < 0 ) ||
-         ( H5C_validate_lru_list(cache_ptr) < 0 ) ) {
-
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                    "an extreme sanity check failed on entry.\n");
-    }
+    if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
+            (H5C_validate_pinned_entry_list(cache_ptr) < 0) ||
+            (H5C_validate_lru_list(cache_ptr) < 0))
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on entry")
 #endif /* H5C_DO_EXTREME_SANITY_CHECKS */
 
     set_flush_marker   = ( (flags & H5C__SET_FLUSH_MARKER_FLAG) != 0 );
@@ -1461,6 +1450,7 @@ H5C_insert_entry(H5F_t *             f,
     /* Apply tag to newly inserted entry */
     if(H5C__tag_entry(cache_ptr, entry_ptr, dxpl_id) < 0)
         HGOTO_ERROR(H5E_CACHE, H5E_CANTTAG, FAIL, "Cannot tag metadata entry")
+    entry_tagged = TRUE;
 
     H5C__RESET_CACHE_ENTRY_STATS(entry_ptr)
 
@@ -1533,10 +1523,10 @@ H5C_insert_entry(H5F_t *             f,
     H5C__UPDATE_RP_FOR_INSERTION(cache_ptr, entry_ptr, FAIL)
 
 #if H5C_DO_EXTREME_SANITY_CHECKS
-    if ( ( H5C_validate_protected_entry_list(cache_ptr) < 0 ) ||
-         ( H5C_validate_pinned_entry_list(cache_ptr) < 0 ) ||
-         ( H5C_validate_lru_list(cache_ptr) < 0 ) )
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed just before done.\n")
+    if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
+            (H5C_validate_pinned_entry_list(cache_ptr) < 0) ||
+            (H5C_validate_lru_list(cache_ptr) < 0))
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed just before done")
 #endif /* H5C_DO_EXTREME_SANITY_CHECKS */
 
     /* If the entry's type has a 'notify' callback send a 'after insertion'
@@ -1588,16 +1578,15 @@ H5C_insert_entry(H5F_t *             f,
 
 done:
 #if H5C_DO_EXTREME_SANITY_CHECKS
-    if ( ( H5C_validate_protected_entry_list(cache_ptr) < 0 ) ||
-         ( H5C_validate_pinned_entry_list(cache_ptr) < 0 ) ||
-         ( H5C_validate_lru_list(cache_ptr) < 0 ) )
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on exit.\n")
+    if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
+            (H5C_validate_pinned_entry_list(cache_ptr) < 0) ||
+            (H5C_validate_lru_list(cache_ptr) < 0))
+        HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on exit")
 #endif /* H5C_DO_EXTREME_SANITY_CHECKS */
 
-    if(ret_value < 0 && entry_ptr->tag_info) {
+    if(ret_value < 0 && entry_tagged)
         if(H5C__untag_entry(cache_ptr, entry_ptr) < 0)
             HDONE_ERROR(H5E_CACHE, H5E_CANTREMOVE, FAIL, "can't remove entry from tag list")
-    }
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5C_insert_entry() */
@@ -1920,7 +1909,7 @@ H5C_move_entry(H5C_t *	     cache_ptr,
     if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
              (H5C_validate_pinned_entry_list(cache_ptr) < 0) ||
              (H5C_validate_lru_list(cache_ptr) < 0))
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on entry.\n")
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on entry")
 #endif /* H5C_DO_EXTREME_SANITY_CHECKS */
 
     H5C__SEARCH_INDEX(cache_ptr, old_addr, entry_ptr, FAIL)
@@ -2024,7 +2013,7 @@ done:
     if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
              (H5C_validate_pinned_entry_list(cache_ptr) < 0) ||
              (H5C_validate_lru_list(cache_ptr) < 0))
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on exit.\n")
+        HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on exit")
 #endif /* H5C_DO_EXTREME_SANITY_CHECKS */
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -2070,12 +2059,9 @@ H5C_resize_entry(void *thing, size_t new_size)
         HGOTO_ERROR(H5E_CACHE, H5E_BADTYPE, FAIL, "Entry isn't pinned or protected??")
 
 #if H5C_DO_EXTREME_SANITY_CHECKS
-    if ( ( H5C_validate_protected_entry_list(cache_ptr) < 0 ) ||
-         ( H5C_validate_pinned_entry_list(cache_ptr) < 0 ) ) {
-
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                    "an extreme sanity check failed on entry.\n");
-    }
+    if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
+            (H5C_validate_pinned_entry_list(cache_ptr) < 0))
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on entry")
 #endif /* H5C_DO_EXTREME_SANITY_CHECKS */
 
     /* update for change in entry size if necessary */
@@ -2172,14 +2158,10 @@ H5C_resize_entry(void *thing, size_t new_size)
     } /* end if */
 
 done:
-
 #if H5C_DO_EXTREME_SANITY_CHECKS
-    if ( ( H5C_validate_protected_entry_list(cache_ptr) < 0 ) ||
-         ( H5C_validate_pinned_entry_list(cache_ptr) < 0 ) ) {
-
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                    "an extreme sanity check failed on exit.\n");
-    }
+    if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
+            (H5C_validate_pinned_entry_list(cache_ptr) < 0))
+        HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on exit")
 #endif /* H5C_DO_EXTREME_SANITY_CHECKS */
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -2275,13 +2257,10 @@ H5C_pin_protected_entry(void *thing)
     HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC);
 
 #if H5C_DO_EXTREME_SANITY_CHECKS
-    if ( ( H5C_validate_protected_entry_list(cache_ptr) < 0 ) ||
-         ( H5C_validate_pinned_entry_list(cache_ptr) < 0 ) ||
-         ( H5C_validate_lru_list(cache_ptr) < 0 ) ) {
-
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                    "an extreme sanity check failed on entry.\n");
-    }
+    if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
+            (H5C_validate_pinned_entry_list(cache_ptr) < 0) ||
+            (H5C_validate_lru_list(cache_ptr) < 0))
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on entry")
 #endif /* H5C_DO_EXTREME_SANITY_CHECKS */
 
 
@@ -2294,15 +2273,11 @@ H5C_pin_protected_entry(void *thing)
         HGOTO_ERROR(H5E_CACHE, H5E_CANTPIN, FAIL, "Can't pin entry by client")
 
 done:
-
 #if H5C_DO_EXTREME_SANITY_CHECKS
-    if ( ( H5C_validate_protected_entry_list(cache_ptr) < 0 ) ||
-         ( H5C_validate_pinned_entry_list(cache_ptr) < 0 ) ||
-         ( H5C_validate_lru_list(cache_ptr) < 0 ) ) {
-
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                    "an extreme sanity check failed on exit.\n");
-    }
+    if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
+            (H5C_validate_pinned_entry_list(cache_ptr) < 0) ||
+            (H5C_validate_lru_list(cache_ptr) < 0))
+        HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on exit")
 #endif /* H5C_DO_EXTREME_SANITY_CHECKS */
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -2396,12 +2371,10 @@ H5C_protect(H5F_t *		f,
     HDassert( H5F_addr_defined(addr) );
 
 #if H5C_DO_EXTREME_SANITY_CHECKS
-    if ( ( H5C_validate_protected_entry_list(cache_ptr) < 0 ) ||
-         ( H5C_validate_pinned_entry_list(cache_ptr) < 0 ) ||
-         ( H5C_validate_lru_list(cache_ptr) < 0 ) ) {
-
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, NULL, "an extreme sanity check failed on entry.\n")
-    }
+    if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
+            (H5C_validate_pinned_entry_list(cache_ptr) < 0) ||
+            (H5C_validate_lru_list(cache_ptr) < 0))
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, NULL, "an extreme sanity check failed on entry")
 #endif /* H5C_DO_EXTREME_SANITY_CHECKS */
 
     read_only          = ( (flags & H5C__READ_ONLY_FLAG) != 0 );
@@ -2794,10 +2767,10 @@ H5C_protect(H5F_t *		f,
 
 done:
 #if H5C_DO_EXTREME_SANITY_CHECKS
-    if ( ( H5C_validate_protected_entry_list(cache_ptr) < 0 ) ||
-         ( H5C_validate_pinned_entry_list(cache_ptr) < 0 ) ||
-         ( H5C_validate_lru_list(cache_ptr) < 0 ) )
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, NULL, "an extreme sanity check failed on exit.\n")
+    if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
+            (H5C_validate_pinned_entry_list(cache_ptr) < 0) ||
+            (H5C_validate_lru_list(cache_ptr) < 0))
+        HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, NULL, "an extreme sanity check failed on exit")
 #endif /* H5C_DO_EXTREME_SANITY_CHECKS */
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -3166,13 +3139,10 @@ H5C_unpin_entry(void *_entry_ptr)
     HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC);
 
 #if H5C_DO_EXTREME_SANITY_CHECKS
-    if ( ( H5C_validate_protected_entry_list(cache_ptr) < 0 ) ||
-         ( H5C_validate_pinned_entry_list(cache_ptr) < 0 ) ||
-         ( H5C_validate_lru_list(cache_ptr) < 0 ) ) {
-
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                    "an extreme sanity check failed on entry.\n");
-    }
+    if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
+            (H5C_validate_pinned_entry_list(cache_ptr) < 0) ||
+            (H5C_validate_lru_list(cache_ptr) < 0))
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on entry")
 #endif /* H5C_DO_EXTREME_SANITY_CHECKS */
 
 
@@ -3181,19 +3151,14 @@ H5C_unpin_entry(void *_entry_ptr)
         HGOTO_ERROR(H5E_CACHE, H5E_CANTUNPIN, FAIL, "Can't unpin entry from client")
 
 done:
-
 #if H5C_DO_EXTREME_SANITY_CHECKS
-    if ( ( H5C_validate_protected_entry_list(cache_ptr) < 0 ) ||
-         ( H5C_validate_pinned_entry_list(cache_ptr) < 0 ) ||
-         ( H5C_validate_lru_list(cache_ptr) < 0 ) ) {
-
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                    "an extreme sanity check failed on exit.\n");
-    }
+    if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
+            (H5C_validate_pinned_entry_list(cache_ptr) < 0) ||
+            (H5C_validate_lru_list(cache_ptr) < 0))
+        HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on exit")
 #endif /* H5C_DO_EXTREME_SANITY_CHECKS */
 
     FUNC_LEAVE_NOAPI(ret_value)
-
 } /* H5C_unpin_entry() */
 
 
@@ -3280,13 +3245,10 @@ H5C_unprotect(H5F_t *		  f,
     was_clean = ! ( entry_ptr->is_dirty );
 
 #if H5C_DO_EXTREME_SANITY_CHECKS
-    if ( ( H5C_validate_protected_entry_list(cache_ptr) < 0 ) ||
-         ( H5C_validate_pinned_entry_list(cache_ptr) < 0 ) ||
-         ( H5C_validate_lru_list(cache_ptr) < 0 ) ) {
-
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                    "an extreme sanity check failed on entry.\n");
-    }
+    if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
+            (H5C_validate_pinned_entry_list(cache_ptr) < 0) ||
+            (H5C_validate_lru_list(cache_ptr) < 0))
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on entry")
 #endif /* H5C_DO_EXTREME_SANITY_CHECKS */
 
     /* if the entry has multiple read only protects, just decrement
@@ -3481,19 +3443,14 @@ H5C_unprotect(H5F_t *		  f,
     H5C__UPDATE_STATS_FOR_UNPROTECT(cache_ptr)
 
 done:
-
 #if H5C_DO_EXTREME_SANITY_CHECKS
-    if ( ( H5C_validate_protected_entry_list(cache_ptr) < 0 ) ||
-         ( H5C_validate_pinned_entry_list(cache_ptr) < 0 ) ||
-         ( H5C_validate_lru_list(cache_ptr) < 0 ) ) {
-
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                    "an extreme sanity check failed on exit.\n");
-    }
+    if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
+            (H5C_validate_pinned_entry_list(cache_ptr) < 0) ||
+            (H5C_validate_lru_list(cache_ptr) < 0)) {
+        HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on exit")
 #endif /* H5C_DO_EXTREME_SANITY_CHECKS */
 
     FUNC_LEAVE_NOAPI(ret_value)
-
 } /* H5C_unprotect() */
 
 
@@ -5352,8 +5309,8 @@ H5C_flush_invalidate_cache(H5F_t *f, hid_t dxpl_id, unsigned flags)
 #if H5C_DO_SANITY_CHECKS
 {
     int32_t		i;
-    int32_t		index_len = 0;
-    int32_t		slist_len = 0;
+    uint32_t		index_len = 0;
+    uint32_t		slist_len = 0;
     size_t		index_size = (size_t)0;
     size_t		clean_index_size = (size_t)0;
     size_t		dirty_index_size = (size_t)0;
@@ -5484,7 +5441,7 @@ H5C_flush_invalidate_ring(H5F_t * f, hid_t dxpl_id, H5C_ring_t ring,
 {
     H5C_t              *cache_ptr;
     hbool_t             restart_slist_scan;
-    int32_t             protected_entries = 0;
+    uint32_t            protected_entries = 0;
     int32_t             i;
     int32_t             cur_ring_pel_len;
     int32_t             old_ring_pel_len;
@@ -5925,7 +5882,7 @@ H5C_flush_ring(H5F_t *f, hid_t dxpl_id, H5C_ring_t ring,  unsigned flags)
     hbool_t		ignore_protected;
     hbool_t		tried_to_flush_protected_entry = FALSE;
     hbool_t		restart_slist_scan;
-    int32_t		protected_entries = 0;
+    uint32_t		protected_entries = 0;
     H5SL_node_t * 	node_ptr = NULL;
     H5C_cache_entry_t *	entry_ptr = NULL;
     H5C_cache_entry_t *	next_entry_ptr = NULL;
@@ -5949,7 +5906,7 @@ H5C_flush_ring(H5F_t *f, hid_t dxpl_id, H5C_ring_t ring,  unsigned flags)
     if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
             (H5C_validate_pinned_entry_list(cache_ptr) < 0) ||
             (H5C_validate_lru_list(cache_ptr) < 0))
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on entry.\n")
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on entry")
 #endif /* H5C_DO_EXTREME_SANITY_CHECKS */
 
     ignore_protected = ( (flags & H5C__FLUSH_IGNORE_PROTECTED_FLAG) != 0 );
@@ -7077,8 +7034,8 @@ H5C_make_space_in_cache(H5F_t *	f,
     int32_t             clean_entries_skipped = 0;
     int32_t             total_entries_scanned = 0;
 #endif /* H5C_COLLECT_CACHE_STATS */
-    int32_t		entries_examined = 0;
-    int32_t		initial_list_len;
+    uint32_t		entries_examined = 0;
+    uint32_t		initial_list_len;
     size_t		empty_space;
     hbool_t		prev_is_dirty = FALSE;
     hbool_t             didnt_flush_entry = FALSE;
@@ -7358,9 +7315,7 @@ H5C_make_space_in_cache(H5F_t *	f,
     }
 
 done:
-
     FUNC_LEAVE_NOAPI(ret_value)
-
 } /* H5C_make_space_in_cache() */
 
 
diff --git a/src/H5Cdbg.c b/src/H5Cdbg.c
index 5697bff..6ca18b1 100644
--- a/src/H5Cdbg.c
+++ b/src/H5Cdbg.c
@@ -490,12 +490,12 @@ H5C_stats(H5C_t * cache_ptr,
               average_failed_search_depth);
 
     HDfprintf(stdout,
-             "%s  current (max) index size / length  = %ld (%ld) / %ld (%ld)\n",
+             "%s  current (max) index size / length  = %ld (%ld) / %lu (%lu)\n",
               cache_ptr->prefix,
               (long)(cache_ptr->index_size),
               (long)(cache_ptr->max_index_size),
-              (long)(cache_ptr->index_len),
-              (long)(cache_ptr->max_index_len));
+              (unsigned long)(cache_ptr->index_len),
+              (unsigned long)(cache_ptr->max_index_len));
 
     HDfprintf(stdout,
              "%s  current (max) clean/dirty idx size = %ld (%ld) / %ld (%ld)\n",
@@ -506,46 +506,46 @@ H5C_stats(H5C_t * cache_ptr,
               (long)(cache_ptr->max_dirty_index_size));
 
     HDfprintf(stdout,
-             "%s  current (max) slist size / length  = %ld (%ld) / %ld (%ld)\n",
+             "%s  current (max) slist size / length  = %ld (%ld) / %lu (%lu)\n",
               cache_ptr->prefix,
               (long)(cache_ptr->slist_size),
               (long)(cache_ptr->max_slist_size),
-              (long)(cache_ptr->slist_len),
-              (long)(cache_ptr->max_slist_len));
+              (unsigned long)(cache_ptr->slist_len),
+              (unsigned long)(cache_ptr->max_slist_len));
 
     HDfprintf(stdout,
-             "%s  current (max) PL size / length     = %ld (%ld) / %ld (%ld)\n",
+             "%s  current (max) PL size / length     = %ld (%ld) / %lu (%lu)\n",
               cache_ptr->prefix,
               (long)(cache_ptr->pl_size),
               (long)(cache_ptr->max_pl_size),
-              (long)(cache_ptr->pl_len),
-              (long)(cache_ptr->max_pl_len));
+              (unsigned long)(cache_ptr->pl_len),
+              (unsigned long)(cache_ptr->max_pl_len));
 
     HDfprintf(stdout,
-             "%s  current (max) PEL size / length    = %ld (%ld) / %ld (%ld)\n",
+             "%s  current (max) PEL size / length    = %ld (%ld) / %lu (%lu)\n",
               cache_ptr->prefix,
               (long)(cache_ptr->pel_size),
               (long)(cache_ptr->max_pel_size),
-              (long)(cache_ptr->pel_len),
-              (long)(cache_ptr->max_pel_len));
+              (unsigned long)(cache_ptr->pel_len),
+              (unsigned long)(cache_ptr->max_pel_len));
 
     HDfprintf(stdout,
-              "%s  current LRU list size / length     = %ld / %ld\n",
+              "%s  current LRU list size / length     = %ld / %lu\n",
               cache_ptr->prefix,
               (long)(cache_ptr->LRU_list_size),
-              (long)(cache_ptr->LRU_list_len));
+              (unsigned long)(cache_ptr->LRU_list_len));
 
     HDfprintf(stdout,
-              "%s  current clean LRU size / length    = %ld / %ld\n",
+              "%s  current clean LRU size / length    = %ld / %lu\n",
               cache_ptr->prefix,
               (long)(cache_ptr->cLRU_list_size),
-              (long)(cache_ptr->cLRU_list_len));
+              (unsigned long)(cache_ptr->cLRU_list_len));
 
     HDfprintf(stdout,
-              "%s  current dirty LRU size / length    = %ld / %ld\n",
+              "%s  current dirty LRU size / length    = %ld / %lu\n",
               cache_ptr->prefix,
               (long)(cache_ptr->dLRU_list_size),
-              (long)(cache_ptr->dLRU_list_len));
+              (unsigned long)(cache_ptr->dLRU_list_len));
 
     HDfprintf(stdout,
               "%s  Total hits / misses / hit_rate     = %ld / %ld / %f\n",
diff --git a/src/H5Cpkg.h b/src/H5Cpkg.h
index 6e37bca..1523450 100644
--- a/src/H5Cpkg.h
+++ b/src/H5Cpkg.h
@@ -209,7 +209,6 @@ if ( ( (entry_ptr) == NULL ) ||                                              \
      ( ( ( (head_ptr) == NULL ) || ( (tail_ptr) == NULL ) ) &&               \
        ( (head_ptr) != (tail_ptr) )                                          \
      ) ||                                                                    \
-     ( (len) < 0 ) ||                                                        \
      ( ( (len) == 1 ) &&                                                     \
        ( ( (head_ptr) != (tail_ptr) ) ||                                     \
          ( (head_ptr) == NULL ) || ( (head_ptr)->size != (Size) )            \
@@ -494,7 +493,6 @@ if ( ( (entry_ptr) == NULL ) ||                                               \
      ( ( ( (hd_ptr) == NULL ) || ( (tail_ptr) == NULL ) ) &&                  \
        ( (hd_ptr) != (tail_ptr) )                                             \
      ) ||                                                                     \
-     ( (len) < 0 ) ||                                                         \
      ( ( (len) == 1 ) &&                                                      \
        ( ( (hd_ptr) != (tail_ptr) ) || ( (Size) <= 0 ) ||                     \
          ( (hd_ptr) == NULL ) || ( (hd_ptr)->size != (Size) )                 \
@@ -514,7 +512,6 @@ if ( ( (entry_ptr) == NULL ) ||                                               \
 if ( ( ( ( (head_ptr) == NULL ) || ( (tail_ptr) == NULL ) ) &&             \
        ( (head_ptr) != (tail_ptr) )                                        \
      ) ||                                                                  \
-     ( (len) < 0 ) ||                                                      \
      ( ( (len) == 1 ) &&                                                   \
        ( ( (head_ptr) != (tail_ptr) ) ||                                   \
          ( (head_ptr) == NULL ) || ( (head_ptr)->size != (Size) )          \
@@ -2500,7 +2497,6 @@ if ( ( (cache_ptr)->index_size !=                                           \
                         (cache_ptr)->pel_tail_ptr, 			  \
 			(cache_ptr)->pel_len,                             \
                         (cache_ptr)->pel_size, (fail_val))                \
-        HDassert( (cache_ptr)->pel_len >= 0 );                            \
                                                                           \
     } else {                                                              \
                                                                           \
@@ -2901,7 +2897,6 @@ if ( ( (cache_ptr)->index_size !=                                           \
     H5C__DLL_REMOVE((entry_ptr), (cache_ptr)->pel_head_ptr,            \
                     (cache_ptr)->pel_tail_ptr, (cache_ptr)->pel_len,   \
                     (cache_ptr)->pel_size, (fail_val))                 \
-    HDassert( (cache_ptr)->pel_len >= 0 );                             \
                                                                        \
         /* modified LRU specific code */                               \
                                                                        \
@@ -4392,16 +4387,16 @@ struct H5C_t {
     hbool_t			close_warning_received;
 
     /* Fields for maintaining [hash table] index of entries */
-    int32_t                     index_len;
+    uint32_t                    index_len;
     size_t                      index_size;
-    int32_t			index_ring_len[H5C_RING_NTYPES];
+    uint32_t			index_ring_len[H5C_RING_NTYPES];
     size_t			index_ring_size[H5C_RING_NTYPES];
     size_t 			clean_index_size;
     size_t			clean_index_ring_size[H5C_RING_NTYPES];
     size_t			dirty_index_size;
     size_t			dirty_index_ring_size[H5C_RING_NTYPES];
     H5C_cache_entry_t *	        index[H5C__HASH_TABLE_LEN];
-    int32_t                     il_len;
+    uint32_t                    il_len;
     size_t                      il_size;
     H5C_cache_entry_t *	        il_head;
     H5C_cache_entry_t *	        il_tail;
@@ -4413,12 +4408,12 @@ struct H5C_t {
 
     /* Fields for maintaining list of in-order entries, for flushing */
     hbool_t			slist_changed;
-    int32_t                     slist_len;
+    uint32_t                    slist_len;
     size_t                      slist_size;
-    int32_t			slist_ring_len[H5C_RING_NTYPES];
+    uint32_t			slist_ring_len[H5C_RING_NTYPES];
     size_t			slist_ring_size[H5C_RING_NTYPES];
     H5SL_t *                    slist_ptr;
-    int32_t                     num_last_entries;
+    uint32_t                    num_last_entries;
 #if H5C_DO_SANITY_CHECKS
     int64_t			slist_len_increase;
     int64_t			slist_size_increase;
@@ -4429,38 +4424,38 @@ struct H5C_t {
     hbool_t                     ignore_tags;
 
     /* Fields for tracking protected entries */
-    int32_t                     pl_len;
+    uint32_t                    pl_len;
     size_t                      pl_size;
     H5C_cache_entry_t *	        pl_head_ptr;
     H5C_cache_entry_t *  	pl_tail_ptr;
 
     /* Fields for tracking pinned entries */
-    int32_t                     pel_len;
+    uint32_t                    pel_len;
     size_t                      pel_size;
     H5C_cache_entry_t *	        pel_head_ptr;
     H5C_cache_entry_t *  	pel_tail_ptr;
 
     /* Fields for complete LRU list of entries */
-    int32_t                     LRU_list_len;
+    uint32_t                    LRU_list_len;
     size_t                      LRU_list_size;
     H5C_cache_entry_t *		LRU_head_ptr;
     H5C_cache_entry_t *		LRU_tail_ptr;
 
     /* Fields for clean LRU list of entries */
-    int32_t                     cLRU_list_len;
+    uint32_t                    cLRU_list_len;
     size_t                      cLRU_list_size;
     H5C_cache_entry_t *		cLRU_head_ptr;
     H5C_cache_entry_t *		cLRU_tail_ptr;
 
     /* Fields for dirty LRU list of entries */
-    int32_t                     dLRU_list_len;
+    uint32_t                    dLRU_list_len;
     size_t                      dLRU_list_size;
     H5C_cache_entry_t *		dLRU_head_ptr;
     H5C_cache_entry_t *	        dLRU_tail_ptr;
 
 #ifdef H5_HAVE_PARALLEL
     /* Fields for collective metadata reads */
-    int32_t                     coll_list_len;
+    uint32_t                    coll_list_len;
     size_t                      coll_list_size;
     H5C_cache_entry_t *		coll_head_ptr;
     H5C_cache_entry_t *		coll_tail_ptr;
@@ -4532,21 +4527,21 @@ struct H5C_t {
     int64_t			total_successful_ht_search_depth;
     int64_t			failed_ht_searches;
     int64_t			total_failed_ht_search_depth;
-    int32_t                     max_index_len;
+    uint32_t                    max_index_len;
     size_t                      max_index_size;
     size_t                      max_clean_index_size;
     size_t                      max_dirty_index_size;
 
     /* Fields for in-order skip list */
-    int32_t                     max_slist_len;
+    uint32_t                    max_slist_len;
     size_t                      max_slist_size;
 
     /* Fields for protected entry list */
-    int32_t                     max_pl_len;
+    uint32_t                    max_pl_len;
     size_t                      max_pl_size;
 
     /* Fields for pinned entry list */
-    int32_t                     max_pel_len;
+    uint32_t                    max_pel_len;
     size_t                      max_pel_size;
 
     /* Fields for tracking 'make space in cache' (msic) operations */
diff --git a/src/H5Cprivate.h b/src/H5Cprivate.h
index 654ce35..2d5b510 100644
--- a/src/H5Cprivate.h
+++ b/src/H5Cprivate.h
@@ -1772,7 +1772,7 @@ H5_DLL herr_t H5C_get_cache_auto_resize_config(const H5C_t *cache_ptr,
     H5C_auto_size_ctl_t *config_ptr);
 H5_DLL herr_t H5C_get_cache_size(H5C_t *cache_ptr, size_t *max_size_ptr,
     size_t *min_clean_size_ptr, size_t *cur_size_ptr,
-    int32_t *cur_num_entries_ptr);
+    uint32_t *cur_num_entries_ptr);
 H5_DLL herr_t H5C_get_cache_hit_rate(H5C_t *cache_ptr, double *hit_rate_ptr);
 H5_DLL herr_t H5C_get_entry_status(const H5F_t *f, haddr_t addr,
     size_t *size_ptr, hbool_t *in_cache_ptr, hbool_t *is_dirty_ptr,
diff --git a/src/H5Cquery.c b/src/H5Cquery.c
index f5409f7..03aadb0 100644
--- a/src/H5Cquery.c
+++ b/src/H5Cquery.c
@@ -131,7 +131,7 @@ H5C_get_cache_size(H5C_t * cache_ptr,
                    size_t * max_size_ptr,
                    size_t * min_clean_size_ptr,
                    size_t * cur_size_ptr,
-                   int32_t * cur_num_entries_ptr)
+                   uint32_t * cur_num_entries_ptr)
 {
     herr_t ret_value = SUCCEED;      /* Return value */
 
diff --git a/src/H5F.c b/src/H5F.c
index a43009b..fc36da1 100644
--- a/src/H5F.c
+++ b/src/H5F.c
@@ -1177,7 +1177,7 @@ H5Fget_mdc_size(hid_t file_id, size_t *max_size_ptr, size_t *min_clean_size_ptr,
     size_t *cur_size_ptr, int *cur_num_entries_ptr)
 {
     H5F_t      *file;                   /* File object for file ID */
-    int32_t    cur_num_entries;
+    uint32_t   cur_num_entries;
     herr_t     ret_value = SUCCEED;     /* Return value */
 
     FUNC_ENTER_API(FAIL)
diff --git a/src/H5Fio.c b/src/H5Fio.c
index e215666..afe1278 100644
--- a/src/H5Fio.c
+++ b/src/H5Fio.c
@@ -302,7 +302,7 @@ H5F__evict_cache_entries(H5F_t *f, hid_t dxpl_id)
 #ifndef NDEBUG
 {
     unsigned status = 0;
-    int32_t    cur_num_entries;
+    uint32_t cur_num_entries;
 
     /* Retrieve status of the superblock */
     if(H5AC_get_entry_status(f, (haddr_t)0, &status) < 0)
diff --git a/test/cache.c b/test/cache.c
index 2209d8f..4f097e9 100644
--- a/test/cache.c
+++ b/test/cache.c
@@ -118,12 +118,12 @@ static void check_flush_cache__multi_entry(H5F_t * file_ptr);
 static void check_flush_cache__multi_entry_test(H5F_t * file_ptr,
                                           int test_num,
                                           unsigned int flush_flags,
-                                          int spec_size,
+                                          unsigned int spec_size,
                                           struct flush_cache_test_spec spec[]);
 static void check_flush_cache__pe_multi_entry_test(H5F_t * file_ptr,
                                         int test_num,
                                         unsigned int flush_flags,
-                                        int spec_size,
+                                        unsigned int spec_size,
                                         struct pe_flush_cache_test_spec spec[]);
 static void check_flush_cache__single_entry(H5F_t * file_ptr);
 static void check_flush_cache__single_entry_test(H5F_t * file_ptr,
@@ -155,9 +155,9 @@ static void check_flush_cache__flush_op_test(H5F_t * file_ptr,
                                         unsigned int flush_flags,
                                         int spec_size,
                                         const struct fo_flush_cache_test_spec spec[],
-				        int init_expected_index_len,
+				        unsigned init_expected_index_len,
 				        size_t init_expected_index_size,
-				        int expected_index_len,
+				        unsigned expected_index_len,
 				        size_t expected_index_size,
 					int check_size,
                                         struct fo_flush_entry_check check[]);
@@ -3312,7 +3312,7 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
     {
         int test_num                         = 1;
         unsigned int flush_flags             = H5C__NO_FLAGS_SET;
-        int spec_size                        = 8;
+        unsigned int spec_size               = 8;
         struct flush_cache_test_spec spec[8] =
         {
           {
@@ -3406,7 +3406,7 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
     {
         int test_num                         = 2;
         unsigned int flush_flags             = H5C__FLUSH_INVALIDATE_FLAG;
-        int spec_size                        = 8;
+        unsigned int spec_size               = 8;
         struct flush_cache_test_spec spec[8] =
         {
           {
@@ -3500,7 +3500,7 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
     {
         int test_num                         = 3;
         unsigned int flush_flags             = H5C__FLUSH_CLEAR_ONLY_FLAG;
-        int spec_size                        = 8;
+        unsigned int spec_size               = 8;
         struct flush_cache_test_spec spec[8] =
         {
           {
@@ -3594,7 +3594,7 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
     {
         int test_num                         = 4;
         unsigned int flush_flags             = H5C__FLUSH_MARKED_ENTRIES_FLAG;
-        int spec_size                        = 8;
+        unsigned int spec_size               = 8;
         struct flush_cache_test_spec spec[8] =
         {
           {
@@ -3689,7 +3689,7 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
         int test_num                         = 5;
         unsigned int flush_flags             = H5C__FLUSH_INVALIDATE_FLAG |
                                                H5C__FLUSH_CLEAR_ONLY_FLAG;
-        int spec_size                        = 8;
+        unsigned int spec_size               = 8;
         struct flush_cache_test_spec spec[8] =
         {
           {
@@ -3784,7 +3784,7 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
         int test_num                         = 6;
         unsigned int flush_flags             = H5C__FLUSH_INVALIDATE_FLAG |
                                                H5C__FLUSH_MARKED_ENTRIES_FLAG;
-        int spec_size                        = 8;
+        unsigned int spec_size               = 8;
         struct flush_cache_test_spec spec[8] =
         {
           {
@@ -3879,7 +3879,7 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
         int test_num                         = 7;
         unsigned int flush_flags             = H5C__FLUSH_CLEAR_ONLY_FLAG |
                                                H5C__FLUSH_MARKED_ENTRIES_FLAG;
-        int spec_size                        = 8;
+        unsigned int spec_size               = 8;
         struct flush_cache_test_spec spec[8] =
         {
           {
@@ -3975,7 +3975,7 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
         unsigned int flush_flags             = H5C__FLUSH_INVALIDATE_FLAG |
                                                H5C__FLUSH_CLEAR_ONLY_FLAG |
                                                H5C__FLUSH_MARKED_ENTRIES_FLAG;
-        int spec_size                        = 8;
+        unsigned int spec_size               = 8;
         struct flush_cache_test_spec spec[8] =
         {
           {
@@ -4073,7 +4073,7 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
                                                ~(H5C__FLUSH_INVALIDATE_FLAG |
                                                 H5C__FLUSH_CLEAR_ONLY_FLAG |
                                                 H5C__FLUSH_MARKED_ENTRIES_FLAG);
-        int spec_size                        = 8;
+        unsigned int spec_size               = 8;
         struct flush_cache_test_spec spec[8] =
         {
           {
@@ -4172,7 +4172,7 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
     {
         int test_num                            = 1;
         unsigned int flush_flags                = H5C__NO_FLAGS_SET;
-        int spec_size                           = 8;
+        unsigned int spec_size               = 8;
         struct pe_flush_cache_test_spec spec[8] =
         {
           {
@@ -4318,7 +4318,7 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
     {
         int test_num                            = 2;
         unsigned int flush_flags                = H5C__FLUSH_INVALIDATE_FLAG;
-        int spec_size                           = 8;
+        unsigned int spec_size               = 8;
         struct pe_flush_cache_test_spec spec[8] =
         {
           {
@@ -4448,7 +4448,7 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
         int test_num                            = 3;
         unsigned int flush_flags                = H5C__FLUSH_INVALIDATE_FLAG |
                                                   H5C__FLUSH_CLEAR_ONLY_FLAG;
-        int spec_size                           = 8;
+        unsigned int spec_size               = 8;
         struct pe_flush_cache_test_spec spec[8] =
         {
           {
@@ -4570,7 +4570,7 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
         int test_num                            = 4;
         unsigned int flush_flags                = H5C__FLUSH_INVALIDATE_FLAG |
                                                  H5C__FLUSH_MARKED_ENTRIES_FLAG;
-        int spec_size                           = 8;
+        unsigned int spec_size               = 8;
         struct pe_flush_cache_test_spec spec[8] =
         {
           {
@@ -4701,7 +4701,7 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
         unsigned int flush_flags                = H5C__FLUSH_INVALIDATE_FLAG |
                                                   H5C__FLUSH_CLEAR_ONLY_FLAG |
                                                  H5C__FLUSH_MARKED_ENTRIES_FLAG;
-        int spec_size                           = 8;
+        unsigned int spec_size               = 8;
         struct pe_flush_cache_test_spec spec[8] =
         {
           {
@@ -4845,13 +4845,13 @@ static void
 check_flush_cache__multi_entry_test(H5F_t * file_ptr,
                                     int test_num,
                                     unsigned int flush_flags,
-                                    int spec_size,
+                                    unsigned int spec_size,
                                     struct flush_cache_test_spec spec[])
 {
     H5C_t * cache_ptr = file_ptr->shared->cache;
     static char    msg[128];
     herr_t	   result;
-    int            i;
+    unsigned       u;
     size_t	   total_entry_size = 0;
     test_entry_t * base_addr;
     test_entry_t * entry_ptr;
@@ -4890,43 +4890,43 @@ check_flush_cache__multi_entry_test(H5F_t * file_ptr,
         failure_mssg = msg;
     }
 
-    i = 0;
-    while(pass && (i < spec_size))
+    u = 0;
+    while(pass && (u < spec_size))
     {
-        if((spec[i].entry_num != i) ||
-             (spec[i].entry_type < 0) ||
-             (spec[i].entry_type >= NUMBER_OF_ENTRY_TYPES) ||
-             (spec[i].entry_index < 0) ||
-             (spec[i].entry_index > max_indices[spec[i].entry_type])) {
+        if(((unsigned)spec[u].entry_num != u) ||
+             (spec[u].entry_type < 0) ||
+             (spec[u].entry_type >= NUMBER_OF_ENTRY_TYPES) ||
+             (spec[u].entry_index < 0) ||
+             (spec[u].entry_index > max_indices[spec[u].entry_type])) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128,
-                       "bad data in spec[%d] on entry to multi entry test #%d.",
-                       i, test_num);
+                       "bad data in spec[%u] on entry to multi entry test #%d.",
+                       u, test_num);
             failure_mssg = msg;
         }
-        i++;
+        u++;
     }
 
-    i = 0;
-    while(pass && (i < spec_size))
+    u = 0;
+    while(pass && (u < spec_size))
     {
-        if(spec[i].insert_flag) {
+        if(spec[u].insert_flag) {
 
-            insert_entry(file_ptr, spec[i].entry_type, spec[i].entry_index,
-                    spec[i].flags);
+            insert_entry(file_ptr, spec[u].entry_type, spec[u].entry_index,
+                    spec[u].flags);
 
         } else {
 
-            protect_entry(file_ptr, spec[i].entry_type, spec[i].entry_index);
+            protect_entry(file_ptr, spec[u].entry_type, spec[u].entry_index);
 
-            unprotect_entry(file_ptr, spec[i].entry_type, spec[i].entry_index,
-                    spec[i].flags);
+            unprotect_entry(file_ptr, spec[u].entry_type, spec[u].entry_index,
+                    spec[u].flags);
         }
 
-        total_entry_size += entry_sizes[spec[i].entry_type];
+        total_entry_size += entry_sizes[spec[u].entry_type];
 
-        i++;
+        u++;
     }
 
     if(pass) {
@@ -4943,36 +4943,36 @@ check_flush_cache__multi_entry_test(H5F_t * file_ptr,
         }
     }
 
-    i = 0;
-    while(pass && (i < spec_size))
+    u = 0;
+    while(pass && (u < spec_size))
     {
-        base_addr = entries[spec[i].entry_type];
-        entry_ptr = &(base_addr[spec[i].entry_index]);
+        base_addr = entries[spec[u].entry_type];
+        entry_ptr = &(base_addr[spec[u].entry_index]);
 
-        if((entry_ptr->deserialized != spec[i].expected_deserialized) ||
-             (entry_ptr->serialized != spec[i].expected_serialized) ||
-             (entry_ptr->destroyed != spec[i].expected_destroyed)) {
+        if((entry_ptr->deserialized != spec[u].expected_deserialized) ||
+             (entry_ptr->serialized != spec[u].expected_serialized) ||
+             (entry_ptr->destroyed != spec[u].expected_destroyed)) {
 
 #if 0 /* This is useful debugging code.  Lets keep it around. */
 
             HDfprintf(stdout,
               "deslzd = %d(%d), slzd = %d(%d), dest = %d(%d)\n",
               (int)(entry_ptr->deserialized),
-              (int)(spec[i].expected_deserialized),
+              (int)(spec[u].expected_deserialized),
               (int)(entry_ptr->serialized),
-              (int)(spec[i].expected_serialized),
+              (int)(spec[u].expected_serialized),
               (int)(entry_ptr->destroyed),
-              (int)(spec[i].expected_destroyed));
+              (int)(spec[u].expected_destroyed));
 
 #endif
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128,
-                "Bad status on entry %d after flush in multi entry test #%d.",
-                i, test_num);
+                "Bad status on entry %u after flush in multi entry test #%d.",
+                u, test_num);
             failure_mssg = msg;
         }
-        i++;
+        u++;
     }
 
     if(pass) {
@@ -5027,17 +5027,17 @@ check_flush_cache__multi_entry_test(H5F_t * file_ptr,
         }
     }
 
-    i = 0;
-    while(pass && (i < spec_size))
+    u = 0;
+    while(pass && (u < spec_size))
     {
-        base_addr = entries[spec[i].entry_type];
-        entry_ptr = &(base_addr[spec[i].entry_index]);
+        base_addr = entries[spec[u].entry_type];
+        entry_ptr = &(base_addr[spec[u].entry_index]);
 
         entry_ptr->deserialized = FALSE;
         entry_ptr->serialized   = FALSE;
         entry_ptr->destroyed    = FALSE;
 
-        i++;
+        u++;
     }
 
     return;
@@ -5064,13 +5064,13 @@ static void
 check_flush_cache__pe_multi_entry_test(H5F_t * file_ptr,
                                        int test_num,
                                        unsigned int flush_flags,
-                                       int spec_size,
+                                       unsigned int spec_size,
                                        struct pe_flush_cache_test_spec spec[])
 {
     H5C_t *cache_ptr = file_ptr->shared->cache;
     static char    msg[128];
     herr_t	   result;
-    int            i;
+    unsigned       u;
     int            j;
     size_t	   total_entry_size = 0;
     test_entry_t * base_addr;
@@ -5110,54 +5110,54 @@ check_flush_cache__pe_multi_entry_test(H5F_t * file_ptr,
         failure_mssg = msg;
     }
 
-    i = 0;
-    while(pass && (i < spec_size))
+    u = 0;
+    while(pass && (u < spec_size))
     {
-        if((spec[i].entry_num != i) ||
-             (spec[i].entry_type < 0) ||
-             (spec[i].entry_type >= NUMBER_OF_ENTRY_TYPES) ||
-             (spec[i].entry_index < 0) ||
-             (spec[i].entry_index > max_indices[spec[i].entry_type]) ||
-	     (spec[i].num_pins < 0) ||
-	     (spec[i].num_pins > MAX_PINS)) {
+        if(((unsigned)spec[u].entry_num != u) ||
+             (spec[u].entry_type < 0) ||
+             (spec[u].entry_type >= NUMBER_OF_ENTRY_TYPES) ||
+             (spec[u].entry_index < 0) ||
+             (spec[u].entry_index > max_indices[spec[u].entry_type]) ||
+	     (spec[u].num_pins < 0) ||
+	     (spec[u].num_pins > MAX_PINS)) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128,
-                    "bad data in spec[%d] on entry to pe multi entry test #%d.",
-                    i, test_num);
+                    "bad data in spec[%u] on entry to pe multi entry test #%d.",
+                    u, test_num);
             failure_mssg = msg;
         }
-        i++;
+        u++;
     }
 
-    i = 0;
-    while(pass && (i < spec_size))
+    u = 0;
+    while(pass && (u < spec_size))
     {
-        if(spec[i].insert_flag) {
+        if(spec[u].insert_flag) {
 
-            insert_entry(file_ptr, spec[i].entry_type, spec[i].entry_index,
-                    spec[i].flags);
+            insert_entry(file_ptr, spec[u].entry_type, spec[u].entry_index,
+                    spec[u].flags);
 
         } else {
 
-            protect_entry(file_ptr, spec[i].entry_type, spec[i].entry_index);
+            protect_entry(file_ptr, spec[u].entry_type, spec[u].entry_index);
 
-            unprotect_entry(file_ptr, spec[i].entry_type, spec[i].entry_index,
-                    spec[i].flags);
+            unprotect_entry(file_ptr, spec[u].entry_type, spec[u].entry_index,
+                    spec[u].flags);
         }
 
-        total_entry_size += entry_sizes[spec[i].entry_type];
+        total_entry_size += entry_sizes[spec[u].entry_type];
 
-	for (j = 0; j < spec[i].num_pins; j++)
+	for (j = 0; j < spec[u].num_pins; j++)
 	{
             create_pinned_entry_dependency(file_ptr,
-		                           spec[i].entry_type,
-					   spec[i].entry_index,
-					   spec[i].pin_type[j],
-					   spec[i].pin_idx[j]);
+		                           spec[u].entry_type,
+					   spec[u].entry_index,
+					   spec[u].pin_type[j],
+					   spec[u].pin_idx[j]);
 	}
 
-        i++;
+        u++;
     }
 
     if(pass) {
@@ -5174,36 +5174,36 @@ check_flush_cache__pe_multi_entry_test(H5F_t * file_ptr,
         }
     }
 
-    i = 0;
-    while(pass && (i < spec_size))
+    u = 0;
+    while(pass && (u < spec_size))
     {
-        base_addr = entries[spec[i].entry_type];
-        entry_ptr = &(base_addr[spec[i].entry_index]);
+        base_addr = entries[spec[u].entry_type];
+        entry_ptr = &(base_addr[spec[u].entry_index]);
 
-        if((entry_ptr->deserialized != spec[i].expected_deserialized) ||
-             (entry_ptr->serialized != spec[i].expected_serialized) ||
-             (entry_ptr->destroyed != spec[i].expected_destroyed)) {
+        if((entry_ptr->deserialized != spec[u].expected_deserialized) ||
+             (entry_ptr->serialized != spec[u].expected_serialized) ||
+             (entry_ptr->destroyed != spec[u].expected_destroyed)) {
 
 #if 0 /* This is useful debugging code.  Lets keep it around. */
 
             HDfprintf(stdout,
               "desrlzd = %d(%d), srlzd = %d(%d), dest = %d(%d)\n",
               (int)(entry_ptr->deserialized),
-              (int)(spec[i].expected_deserialized),
+              (int)(spec[u].expected_deserialized),
               (int)(entry_ptr->serialized),
-              (int)(spec[i].expected_serialized),
+              (int)(spec[u].expected_serialized),
               (int)(entry_ptr->destroyed),
-              (int)(spec[i].expected_destroyed));
+              (int)(spec[u].expected_destroyed));
 
 #endif
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128,
-               "Bad status on entry %d after flush in pe multi entry test #%d.",
-               i, test_num);
+               "Bad status on entry %u after flush in pe multi entry test #%d.",
+               u, test_num);
             failure_mssg = msg;
         }
-        i++;
+        u++;
     }
 
     if(pass) {
@@ -5258,17 +5258,17 @@ check_flush_cache__pe_multi_entry_test(H5F_t * file_ptr,
         }
     }
 
-    i = 0;
-    while(pass && (i < spec_size))
+    u = 0;
+    while(pass && (u < spec_size))
     {
-        base_addr = entries[spec[i].entry_type];
-        entry_ptr = &(base_addr[spec[i].entry_index]);
+        base_addr = entries[spec[u].entry_type];
+        entry_ptr = &(base_addr[spec[u].entry_index]);
 
         entry_ptr->deserialized = FALSE;
         entry_ptr->serialized   = FALSE;
         entry_ptr->destroyed    = FALSE;
 
-        i++;
+        u++;
     }
 
     return;
@@ -5323,9 +5323,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
         int test_num			= 1;
 	unsigned int flush_flags	= H5C__NO_FLAGS_SET;
 	int spec_size			= 2;
-	int init_expected_index_len	= 2;
+	unsigned init_expected_index_len	= 2;
 	size_t init_expected_index_size	= 2 * PICO_ENTRY_SIZE;
-	int expected_index_len		= 2;
+	unsigned expected_index_len		= 2;
 	size_t expected_index_size	= 2 * PICO_ENTRY_SIZE;
 	struct fo_flush_cache_test_spec spec[2] =
 	{
@@ -5430,9 +5430,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
         int test_num			= 2;
 	unsigned int flush_flags	= H5C__FLUSH_INVALIDATE_FLAG;
 	int spec_size			= 2;
-	int init_expected_index_len	= 2;
+	unsigned init_expected_index_len	= 2;
 	size_t init_expected_index_size	= 2 * PICO_ENTRY_SIZE;
-	int expected_index_len		= 0;
+	unsigned expected_index_len		= 0;
 	size_t expected_index_size	= 0;
 	struct fo_flush_cache_test_spec spec[2] =
 	{
@@ -5534,9 +5534,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
         int test_num			= 3;
 	unsigned int flush_flags	= H5C__NO_FLAGS_SET;
 	int spec_size			= 1;
-	int init_expected_index_len	= 1;
+	unsigned init_expected_index_len	= 1;
 	size_t init_expected_index_size	= VARIABLE_ENTRY_SIZE / 4;
-	int expected_index_len		= 1;
+	unsigned expected_index_len		= 1;
 	size_t expected_index_size	= VARIABLE_ENTRY_SIZE / 2;
 	struct fo_flush_cache_test_spec spec[1] =
 	{
@@ -5612,9 +5612,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
         int test_num			= 4;
 	unsigned int flush_flags	= H5C__FLUSH_INVALIDATE_FLAG;
 	int spec_size			= 1;
-	int init_expected_index_len	= 1;
+	unsigned init_expected_index_len	= 1;
 	size_t init_expected_index_size	= VARIABLE_ENTRY_SIZE / 4;
-	int expected_index_len		= 0;
+	unsigned expected_index_len		= 0;
 	size_t expected_index_size	= 0;
 	struct fo_flush_cache_test_spec spec[1] =
 	{
@@ -5697,9 +5697,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
         int test_num			= 5; /* and 6 */
 	unsigned int flush_flags	= H5C__NO_FLAGS_SET;
 	int spec_size			= 1;
-	int init_expected_index_len	= 1;
+	unsigned init_expected_index_len	= 1;
 	size_t init_expected_index_size	= VARIABLE_ENTRY_SIZE;
-	int expected_index_len		= 1;
+	unsigned expected_index_len		= 1;
 	size_t expected_index_size	= VARIABLE_ENTRY_SIZE / 2;
 	struct fo_flush_cache_test_spec spec[1] =
 	{
@@ -5814,9 +5814,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
         int test_num			= 7; /* and 8 */
 	unsigned int flush_flags	= H5C__NO_FLAGS_SET;
 	int spec_size			= 1;
-	int init_expected_index_len	= 1;
+	unsigned init_expected_index_len	= 1;
 	size_t init_expected_index_size	= VARIABLE_ENTRY_SIZE;
-	int expected_index_len		= 1;
+	unsigned expected_index_len		= 1;
 	size_t expected_index_size	= VARIABLE_ENTRY_SIZE / 2;
 	struct fo_flush_cache_test_spec spec[1] =
 	{
@@ -5927,9 +5927,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
         int test_num			= 9; /* and 10 */
 	unsigned int flush_flags	= H5C__NO_FLAGS_SET;
 	int spec_size			= 1;
-	int init_expected_index_len	= 1;
+	unsigned init_expected_index_len	= 1;
 	size_t init_expected_index_size	= VARIABLE_ENTRY_SIZE / 2;
-	int expected_index_len		= 1;
+	unsigned expected_index_len		= 1;
 	size_t expected_index_size	= VARIABLE_ENTRY_SIZE / 4;
 	struct fo_flush_cache_test_spec spec[1] =
 	{
@@ -6038,9 +6038,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
         int test_num			= 11; /* and 12 */
 	unsigned int flush_flags	= H5C__NO_FLAGS_SET;
 	int spec_size			= 1;
-	int init_expected_index_len	= 1;
+	unsigned init_expected_index_len	= 1;
 	size_t init_expected_index_size	= VARIABLE_ENTRY_SIZE / 2;
-	int expected_index_len		= 1;
+	unsigned expected_index_len		= 1;
 	size_t expected_index_size	= VARIABLE_ENTRY_SIZE / 4;
 	struct fo_flush_cache_test_spec spec[1] =
 	{
@@ -6152,9 +6152,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
         int test_num			= 13;
 	unsigned int flush_flags	= H5C__NO_FLAGS_SET;
 	int spec_size			= 1;
-	int init_expected_index_len	= 1;
+	unsigned init_expected_index_len	= 1;
 	size_t init_expected_index_size	= 1 * PICO_ENTRY_SIZE;
-	int expected_index_len		= 3;
+	unsigned expected_index_len		= 3;
 	size_t expected_index_size	= 3 * PICO_ENTRY_SIZE;
 	struct fo_flush_cache_test_spec spec[1] =
 	{
@@ -6248,9 +6248,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
         int test_num			= 14;
 	unsigned int flush_flags	= H5C__FLUSH_INVALIDATE_FLAG;
 	int spec_size			= 1;
-	int init_expected_index_len	= 1;
+	unsigned init_expected_index_len	= 1;
 	size_t init_expected_index_size	= 1 * PICO_ENTRY_SIZE;
-	int expected_index_len		= 0;
+	unsigned expected_index_len		= 0;
 	size_t expected_index_size	= (size_t)0;
 	struct fo_flush_cache_test_spec spec[1] =
 	{
@@ -6341,9 +6341,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
         int test_num			= 15;
 	unsigned int flush_flags	= H5C__NO_FLAGS_SET;
 	int spec_size			= 1;
-	int init_expected_index_len	= 1;
+	unsigned init_expected_index_len	= 1;
 	size_t init_expected_index_size	= 1 * VARIABLE_ENTRY_SIZE;
-	int expected_index_len		= 3;
+	unsigned expected_index_len		= 3;
 	size_t expected_index_size	= VARIABLE_ENTRY_SIZE +
 		                          (VARIABLE_ENTRY_SIZE / 4) +
 					  (VARIABLE_ENTRY_SIZE / 2);
@@ -6438,9 +6438,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
         int test_num			= 16;
 	unsigned int flush_flags	= H5C__FLUSH_INVALIDATE_FLAG;
 	int spec_size			= 1;
-	int init_expected_index_len	= 1;
+	unsigned init_expected_index_len	= 1;
 	size_t init_expected_index_size	= 1 * VARIABLE_ENTRY_SIZE;
-	int expected_index_len		= 0;
+	unsigned expected_index_len		= 0;
 	size_t expected_index_size	= (size_t)0;
 	struct fo_flush_cache_test_spec spec[1] =
 	{
@@ -6531,9 +6531,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
         int test_num			= 17; /* and 18 */
 	unsigned int flush_flags	= H5C__NO_FLAGS_SET;
 	int spec_size			= 1;
-	int init_expected_index_len	= 1;
+	unsigned init_expected_index_len	= 1;
 	size_t init_expected_index_size	= 1 * VARIABLE_ENTRY_SIZE;
-	int expected_index_len		= 3;
+	unsigned expected_index_len		= 3;
 	size_t expected_index_size	= VARIABLE_ENTRY_SIZE +
 		                          (VARIABLE_ENTRY_SIZE / 4) +
 					  (VARIABLE_ENTRY_SIZE / 2);
@@ -6658,9 +6658,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
         int test_num			= 19; /* and 20 */
 	unsigned int flush_flags	= H5C__NO_FLAGS_SET;
 	int spec_size			= 1;
-	int init_expected_index_len	= 1;
+	unsigned init_expected_index_len	= 1;
 	size_t init_expected_index_size	= 1 * VARIABLE_ENTRY_SIZE;
-	int expected_index_len		= 3;
+	unsigned expected_index_len		= 3;
 	size_t expected_index_size	= VARIABLE_ENTRY_SIZE +
 		                          (VARIABLE_ENTRY_SIZE / 4) +
 					  (VARIABLE_ENTRY_SIZE / 2);
@@ -6796,9 +6796,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
         int test_num			= 21;
 	unsigned int flush_flags	= H5C__FLUSH_MARKED_ENTRIES_FLAG;
 	int spec_size			= 4;
-	int init_expected_index_len	= 4;
+	unsigned init_expected_index_len	= 4;
 	size_t init_expected_index_size	= (2 * VARIABLE_ENTRY_SIZE) + (2 * PICO_ENTRY_SIZE);
-	int expected_index_len		= 6;
+	unsigned expected_index_len		= 6;
 	size_t expected_index_size	= (2 * VARIABLE_ENTRY_SIZE) +
 		                          (VARIABLE_ENTRY_SIZE / 4) +
 					  (VARIABLE_ENTRY_SIZE / 2) +
@@ -7007,9 +7007,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
         int test_num			= 22;
 	unsigned int flush_flags	= H5C__NO_FLAGS_SET;
 	int spec_size			= 6;
-	int init_expected_index_len	= 6;
+	unsigned init_expected_index_len	= 6;
 	size_t init_expected_index_size	= (2 * VARIABLE_ENTRY_SIZE) + (4 * PICO_ENTRY_SIZE);
-	int expected_index_len		= 10;
+	unsigned expected_index_len		= 10;
 	size_t expected_index_size	= (2 * VARIABLE_ENTRY_SIZE) +
 		                          (2 * (VARIABLE_ENTRY_SIZE / 4)) +
 					  (2 * (VARIABLE_ENTRY_SIZE / 2)) +
@@ -7276,9 +7276,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
         int test_num			= 23;
 	unsigned int flush_flags	= H5C__FLUSH_INVALIDATE_FLAG;
 	int spec_size			= 6;
-	int init_expected_index_len	= 6;
+	unsigned init_expected_index_len	= 6;
 	size_t init_expected_index_size	= (2 * VARIABLE_ENTRY_SIZE) + (4 * PICO_ENTRY_SIZE);
-	int expected_index_len		= 0;
+	unsigned expected_index_len		= 0;
 	size_t expected_index_size	= 0;
 	struct fo_flush_cache_test_spec spec[6] =
 	{
@@ -7538,9 +7538,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
         int test_num			= 24;
 	unsigned int flush_flags	= H5C__NO_FLAGS_SET;
 	int spec_size			= 3;
-	int init_expected_index_len	= 3;
+	unsigned init_expected_index_len	= 3;
 	size_t init_expected_index_size	= 3 * PICO_ENTRY_SIZE;
-	int expected_index_len		= 3;
+	unsigned expected_index_len		= 3;
 	size_t expected_index_size	= 3 * PICO_ENTRY_SIZE;
 	struct fo_flush_cache_test_spec spec[3] =
 	{
@@ -7671,9 +7671,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
         int test_num			= 25;
 	unsigned int flush_flags	= H5C__FLUSH_INVALIDATE_FLAG;
 	int spec_size			= 3;
-	int init_expected_index_len	= 3;
+	unsigned init_expected_index_len	= 3;
 	size_t init_expected_index_size	= 3 * PICO_ENTRY_SIZE;
-	int expected_index_len		= 0;
+	unsigned expected_index_len		= 0;
 	size_t expected_index_size	= (size_t)0;
 	struct fo_flush_cache_test_spec spec[3] =
 	{
@@ -7874,9 +7874,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
         int test_num			= 26;
 	unsigned int flush_flags	= H5C__NO_FLAGS_SET;
 	int spec_size			= 10;
-	int init_expected_index_len	= 10;
+	unsigned init_expected_index_len	= 10;
 	size_t init_expected_index_size	= 10 * VARIABLE_ENTRY_SIZE;
-	int expected_index_len		= 13;
+	unsigned expected_index_len		= 13;
 	size_t expected_index_size	= 9 * VARIABLE_ENTRY_SIZE;
 	struct fo_flush_cache_test_spec spec[10] =
 	{
@@ -8308,9 +8308,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
         int test_num			= 27;
 	unsigned int flush_flags	= H5C__FLUSH_INVALIDATE_FLAG;
 	int spec_size			= 10;
-	int init_expected_index_len	= 10;
+	unsigned init_expected_index_len	= 10;
 	size_t init_expected_index_size	= 10 * VARIABLE_ENTRY_SIZE;
-	int expected_index_len		= 0;
+	unsigned expected_index_len		= 0;
 	size_t expected_index_size	= (size_t)0;
 	struct fo_flush_cache_test_spec spec[10] =
 	{
@@ -8667,9 +8667,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
         int test_num			= 28;
 	unsigned int flush_flags	= H5C__NO_FLAGS_SET;
 	int spec_size			= 5;
-	int init_expected_index_len	= 5;
+	unsigned init_expected_index_len	= 5;
 	size_t init_expected_index_size	= 3 * VARIABLE_ENTRY_SIZE;
-	int expected_index_len		= 5;
+	unsigned expected_index_len		= 5;
 	size_t expected_index_size	= 4 * VARIABLE_ENTRY_SIZE;
 	struct fo_flush_cache_test_spec spec[5] =
 	{
@@ -8859,9 +8859,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
         int test_num			= 29;
 	unsigned int flush_flags	= H5C__FLUSH_INVALIDATE_FLAG;
 	int spec_size			= 5;
-	int init_expected_index_len	= 5;
+	unsigned init_expected_index_len	= 5;
 	size_t init_expected_index_size	= 3 * VARIABLE_ENTRY_SIZE;
-	int expected_index_len		= 0;
+	unsigned expected_index_len		= 0;
 	size_t expected_index_size	= 0;
 	struct fo_flush_cache_test_spec spec[5] =
 	{
@@ -9070,9 +9070,9 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
                                  unsigned int flush_flags,
                                  int spec_size,
                                  const struct fo_flush_cache_test_spec spec[],
-				 int init_expected_index_len,
+				 unsigned init_expected_index_len,
 				 size_t init_expected_index_size,
-				 int expected_index_len,
+				 unsigned expected_index_len,
 				 size_t expected_index_size,
 				 int check_size,
 				 struct fo_flush_entry_check check[])
@@ -27433,7 +27433,7 @@ check_auto_cache_resize_aux_fcns(void)
     size_t max_size;
     size_t min_clean_size;
     size_t cur_size;
-    int32_t cur_num_entries;
+    uint32_t cur_num_entries;
     H5C_auto_size_ctl_t auto_size_ctl =
     {
         /* int32_t     version                = */ H5C__CURR_AUTO_SIZE_CTL_VER,
diff --git a/test/cache_common.c b/test/cache_common.c
index 5151d65..1321968 100644
--- a/test/cache_common.c
+++ b/test/cache_common.c
@@ -6128,7 +6128,7 @@ check_and_validate_cache_size(hid_t file_id,
     size_t min_clean_size;
     size_t expected_cur_size;
     size_t cur_size;
-    int32_t expected_cur_num_entries;
+    uint32_t expected_cur_num_entries;
     int cur_num_entries;
     H5F_t * file_ptr = NULL;
     H5C_t * cache_ptr = NULL;
diff --git a/test/earray.c b/test/earray.c
index 07acbb5..c6f5986 100644
--- a/test/earray.c
+++ b/test/earray.c
@@ -159,15 +159,6 @@ typedef struct earray_test_t {
 
 /* Local prototypes */
 
-/* Metadata cache (H5AC) callbacks */
-static herr_t earray_cache_test_get_initial_load_size(void *udata, size_t *image_len);
-static void *earray_cache_test_deserialize(const void *image_ptr, size_t len,
-    void *udata_ptr, hbool_t *dirty_ptr);
-static herr_t earray_cache_test_image_len(const void *thing, size_t *image_len_ptr);
-static herr_t earray_cache_test_serialize(const H5F_t *f, void *image_ptr,
-    size_t len, void *thing);
-static herr_t earray_cache_test_free_icr(void *thing);
-
 
 /* Local variables */
 const char *FILENAME[] = {
@@ -182,24 +173,6 @@ char filename_g[EARRAY_FILENAME_LEN];
 /* Empty file size */
 h5_stat_size_t empty_size_g;
 
-/* H5EA test object inherits cache-like properties from H5AC */
-const H5AC_class_t H5AC_EARRAY_TEST[1] = {{
-    /* id            */ H5AC_TEST_ID,
-    /* name          */ "earray test",
-    /* mem_type      */ H5FD_MEM_DEFAULT,
-    /* flags         */ H5AC__CLASS_SKIP_READS | H5AC__CLASS_SKIP_WRITES,
-    /* get_initial_load_size */ earray_cache_test_get_initial_load_size,
-    /* get_final_load_size */ NULL,
-    /* verify_chksum */ NULL,
-    /* deserialize   */ earray_cache_test_deserialize,
-    /* image_len     */ earray_cache_test_image_len,
-    /* pre_serialize */ NULL,
-    /* serialize     */ earray_cache_test_serialize,
-    /* notify        */ NULL,
-    /* free_icr      */ earray_cache_test_free_icr,
-    /* fsf_size      */ NULL,
-}};
-
 
 /*-------------------------------------------------------------------------
  * Function:	init_cparam
@@ -619,225 +592,6 @@ error:
 
 
 /*-------------------------------------------------------------------------
- * Function:    earray_cache_test_get_initial_load_size()
- *
- * Purpose: place holder function -- should never be called
- *
- *      A generic discussion of metadata cache callbacks of this type
- *      may be found in H5Cprivate.h.
- *
- * Return:      Success:        SUCCEED
- *              Failure:        FAIL
- *
- * Programmer:  John Mainzer
- *              8/2/14
- *
- *-------------------------------------------------------------------------
- */
-static herr_t
-earray_cache_test_get_initial_load_size( void *udata, size_t *image_len)
-{
-    HDassert(udata);
-    HDassert(image_len);
-
-    /* Should never be called */
-    HDassert(0 && "Can't be called!");
-
-    *image_len = 0;
-
-    return(SUCCEED);
-} /* end earray_cache_test_get_initial_load_size() */
-
-
-/*-------------------------------------------------------------------------
- * Function:    earray_cache_test_deserialize
- *
- * Purpose: place holder function -- should never be called.
- *
- *
- *      A generic discussion of metadata cache callbacks of this type
- *      may be found in H5Cprivate.h:
- *
- * Return:      Success:        Pointer to in core representation
- *              Failure:        NULL
- *
- * Programmer:  John Mainzer
- *              8/2/14
- *
- *-------------------------------------------------------------------------
- */
-static void *
-earray_cache_test_deserialize(const void *image_ptr,
-                              size_t len,
-                              void *udata_ptr,
-                              hbool_t *dirty_ptr)
-{
-    HDassert(image_ptr);
-    HDassert(len > 0 );
-    HDassert(udata_ptr);
-    HDassert(dirty_ptr);
-
-    /* Should never be called */
-    HDassert(0 && "Can't be called!");
-
-    return(NULL);
-} /* end earray_cache_test_deserialize() */
-
-
-/*-------------------------------------------------------------------------
- * Function:    earray_cache_test_image_len
- *
- * Purpose: test code place holder function -- just set *image_len_ptr to 
- *	one.
- *
- *
- *      A generic discussion of metadata cache callbacks of this type
- *      may be found in H5Cprivate.h:
- *
- * Return:      Success:        SUCCEED
- *              Failure:        FAIL
- *
- * Programmer:  John Mainzer
- *              8/2/14
- *
- *-------------------------------------------------------------------------
- */
-static herr_t
-earray_cache_test_image_len(const void *thing, size_t *image_len_ptr)
-{
-    HDassert(thing);
-    HDassert(image_len_ptr);
-
-    /* Set size value */
-    /* (hard-code to 1) */
-    *image_len_ptr = 1;
-
-    return(SUCCEED);
-} /* end earray_cache_test_image_len() */
-
-
-
-/*-------------------------------------------------------------------------
- * Function:    earray_cache_test_serialize
- *
- * Purpose: Validate the contents of the instance of earray_test_t.
- *
- *
- *      A generic discussion of metadata cache callbacks of this type
- *      may be found in H5Cprivate.h:
- *
- *
- * Return:      Success:        SUCCEED
- *              Failure:        FAIL
- *
- * Programmer:  John Mainzer
- *              8/2/14
- *
- *-------------------------------------------------------------------------
- */
-static herr_t
-earray_cache_test_serialize(const H5F_t *f,
-                            void *image_ptr,
-                            H5_ATTR_UNUSED size_t len,
-                            void *thing)
-{
-    earray_test_t *test;
-
-    HDassert(f);
-    HDassert(image_ptr);
-    HDassert(thing);
-    test = (earray_test_t *)thing;
-    HDassert(test);
-    HDassert(test->cache_info.magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
-    HDassert((const H5AC_class_t *)(test->cache_info.type) == 
-             &(H5AC_EARRAY_TEST[0]));
-
-    /* Check for out of order flush */
-    if(test->fd_info->base_obj)
-        TEST_ERROR
-
-    /* Check which index this entry corresponds to */
-    if((uint64_t)0 == test->idx) {
-        /* Check for out of order flush */
-        if(test->fd_info->idx0_obj || test->fd_info->idx0_elem)
-            TEST_ERROR
-
-        /* Set flag for object flush */
-        test->fd_info->idx0_obj = TRUE;
-    } /* end if */
-    else if((uint64_t)1 == test->idx) {
-        /* Check for out of order flush */
-        if(test->fd_info->idx1_obj || test->fd_info->idx1_elem)
-            TEST_ERROR
-
-        /* Set flag for object flush */
-        test->fd_info->idx1_obj = TRUE;
-    } /* end if */
-    else if((uint64_t)10000 == test->idx) {
-        /* Check for out of order flush */
-        if(test->fd_info->idx10000_obj || test->fd_info->idx10000_elem)
-            TEST_ERROR
-
-        /* Set flag for object flush */
-        test->fd_info->idx10000_obj = TRUE;
-    } /* end if */
-    else if((uint64_t)-1 == test->idx) {
-        /* Set flag for object flush */
-        test->fd_info->base_obj = TRUE;
-    } /* end if */
-
-    return(SUCCEED);
-
-error:
-    return(FAIL);
-} /* end earray_cache_test_serialize() */
-
-
-
-/*-------------------------------------------------------------------------
- * Function:    earray_cache_test_free_icr
- *
- * Purpose: Destroy an extensible array test object in memory.
- *
- *
- *      A generic discussion of metadata cache callbacks of this type
- *      may be found in H5Cprivate.h:
- *
- *
- * Return:      Success:        SUCCEED
- *              Failure:        FAIL
- *
- * Programmer:  John Mainzer
- *              8/2/14
- *
- *-------------------------------------------------------------------------
- */
-static herr_t
-earray_cache_test_free_icr(void *thing)
-{
-    earray_test_t *test;
-
-    HDassert(thing);
-    test = (earray_test_t *)thing;
-    HDassert(test);
-
-    /* the metadata cache sets cache_info.magic to
-     * H5C__H5C_CACHE_ENTRY_T_BAD_MAGIC before calling the
-     * free_icr routine.  Hence the following assert:
-     */
-
-    HDassert(test->cache_info.magic == H5C__H5C_CACHE_ENTRY_T_BAD_MAGIC);
-    HDassert((const H5AC_class_t *)(test->cache_info.type) == 
-             &(H5AC_EARRAY_TEST[0]));
-
-    /* Free the shared info itself */
-    HDfree(test);
-
-    return(SUCCEED);
-} /* end earray_cache_test_free_icr() */
-
-
-/*-------------------------------------------------------------------------
  * Function:	test_create
  *
  * Purpose:	Test creating extensible array
diff --git a/test/evict_on_close.c b/test/evict_on_close.c
index e0a7a73..3986d5a 100644
--- a/test/evict_on_close.c
+++ b/test/evict_on_close.c
@@ -600,7 +600,7 @@ check_group_layout(hid_t fid, const char *group_name)
     hid_t   gid1 = -1, gid2 = -1;           /* group IDs                    */
     H5G_t   *grp_ptr = NULL;                /* ptr to internal group struct */
     haddr_t tag1, tag2;                     /* MD cache tags for groups     */
-    int32_t before, during, after;          /* cache sizes                  */
+    uint32_t before, during, after;         /* cache sizes                  */
     int i;                                  /* iterator                     */
 
     /* NOTE: The TESTING() macro is called in main() */
@@ -616,7 +616,7 @@ check_group_layout(hid_t fid, const char *group_name)
     HDprintf("\nCACHE BEFORE GROUP OPEN:\n");
     if(H5AC_dump_cache(file_ptr) < 0)
         TEST_ERROR;
-    HDprintf("NUMBER OF CACHE ENTRIES: %d\n", before);
+    HDprintf("NUMBER OF CACHE ENTRIES: %u\n", before);
 #endif
 
     /* Open the main group and get its tag */
@@ -658,7 +658,7 @@ check_group_layout(hid_t fid, const char *group_name)
     if(H5AC_dump_cache(file_ptr) < 0)
         TEST_ERROR;
     HDprintf("MAIN GROUP TAG: %#X\n", tag1);
-    HDprintf("NUMBER OF CACHE ENTRIES: %d\n", during);
+    HDprintf("NUMBER OF CACHE ENTRIES: %u\n", during);
 #endif
 
     /* Close the main group */
@@ -672,7 +672,7 @@ check_group_layout(hid_t fid, const char *group_name)
     HDprintf("\nCACHE AFTER CLOSING GROUPS:\n");
     if(H5AC_dump_cache(file_ptr) < 0)
         TEST_ERROR;
-    HDprintf("NUMBER OF CACHE ENTRIES: %d\n", after);
+    HDprintf("NUMBER OF CACHE ENTRIES: %u\n", after);
 #endif
 
     /* Ensure that the cache does not contain entries with the tag */
@@ -718,7 +718,7 @@ check_dset_scheme(hid_t fid, const char *dset_name)
     H5D_t   *dset_ptr = NULL;               /* ptr to internal dset struct  */
     haddr_t tag;                            /* MD cache tag for dataset     */
     int     *data = NULL;                   /* buffer for fake data         */
-    int32_t before, during, after;          /* cache sizes                  */
+    uint32_t before, during, after;         /* cache sizes                  */
 
     /* NOTE: The TESTING() macro is called in main() */
 
@@ -737,7 +737,7 @@ check_dset_scheme(hid_t fid, const char *dset_name)
     HDprintf("\nCACHE BEFORE DATASET OPEN:\n");
     if(H5AC_dump_cache(file_ptr) < 0)
         TEST_ERROR;
-    HDprintf("NUMBER OF CACHE ENTRIES: %d\n", before);
+    HDprintf("NUMBER OF CACHE ENTRIES: %u\n", before);
 #endif
 
     /* Open dataset and get the metadata tag */
@@ -761,7 +761,7 @@ check_dset_scheme(hid_t fid, const char *dset_name)
     if(H5AC_dump_cache(file_ptr) < 0)
         TEST_ERROR;
     HDprintf("TAG: %#X\n", tag);
-    HDprintf("NUMBER OF CACHE ENTRIES: %d\n", during);
+    HDprintf("NUMBER OF CACHE ENTRIES: %u\n", during);
 #endif
 
     /* Close the dataset */
@@ -775,7 +775,7 @@ check_dset_scheme(hid_t fid, const char *dset_name)
     HDprintf("\nCACHE AFTER DATASET CLOSE:\n");
     if(H5AC_dump_cache(file_ptr) < 0)
         TEST_ERROR;
-    HDprintf("NUMBER OF CACHE ENTRIES: %d\n", after);
+    HDprintf("NUMBER OF CACHE ENTRIES: %u\n", after);
 #endif
 
     /* Ensure that the cache does not contain entries with the tag */