Brings the MDC skiplist optimizations from develop

5 files changed, 1324 insertions, 1050 deletions

diff --git a/test/cache.c b/test/cache.c
index 10e7bf6..da33052 100644
--- a/test/cache.c
+++ b/test/cache.c
@@ -2933,21 +2933,25 @@ express_test, unsigned paged)
 /*-------------------------------------------------------------------------
  * Function:    check_insert_entry()
  *
- * Purpose:    Verify that H5C_insert_entry behaves as expected.
- *        Test the behaviour with different flags.
+ * Purpose:     Verify that H5C_insert_entry behaves as expected.
+ *              Test the behaviour with different flags.
  *
- *        This test was added primarily to test basic insert
- *        pinned entry functionallity, but I through in explicit
- *        tests for other functionallity that is tested implicitly
- *        elsewhere.
+ *              This test was added primarily to test basic insert
+ *              pinned entry functionallity, but I through in explicit
+ *              tests for other functionallity that is tested implicitly
+ *              elsewhere.
  *
- * Return:    void
+ * Return:      void
  *
- * Programmer:    John Mainzer
+ * Programmer:  John Mainzer
  *              8/10/06
  *
  * Modifications:
  *
+ *              Updated tests to accommodate the case in which the
+ *              slist is disabled.
+ *                                           JRM -- 5/14/20
+ *
  *-------------------------------------------------------------------------
  */
 
@@ -3063,15 +3067,15 @@ check_insert_entry(unsigned paged)
             /* Verify that the flush marker got set correctly */
         if((i == 1) || (i == 3)) {
 
-        if(!((entry_ptr->header).flush_marker)) {
+            if(!((entry_ptr->header).flush_marker)) {
 
                     pass = FALSE;
                     failure_mssg = "Unexpected insert results 5.";
-        }
+            }
         } else if((entry_ptr->header).flush_marker) {
 
-                pass = FALSE;
-                failure_mssg = "Unexpected insert results 6.";
+            pass = FALSE;
+            failure_mssg = "Unexpected insert results 6.";
         }
     }
 
@@ -3154,52 +3158,59 @@ check_insert_entry(unsigned paged)
 
     if(pass) {
 
-    if((cache_ptr->index_len != 4) ||
-        (cache_ptr->index_size != 4 * entry_sizes[entry_type]) ||
-        (cache_ptr->slist_len != 4) ||
-        (cache_ptr->slist_size != 4 * entry_sizes[entry_type]) ||
-        (cache_ptr->pl_len != 0) ||
-        (cache_ptr->pl_size != (size_t)0) ||
-        (cache_ptr->pel_len != 2) ||
-        (cache_ptr->pel_size != 2 * entry_sizes[entry_type]) ||
-        (cache_ptr->LRU_list_len != 2) ||
-        (cache_ptr->LRU_list_size != 2 * entry_sizes[entry_type])
+        if ( ( cache_ptr->index_len != 4 ) ||
+             ( cache_ptr->index_size != 4 * entry_sizes[entry_type] ) ||
+             ( ( cache_ptr->slist_enabled ) &&
+               ( ( cache_ptr->slist_len != 4 ) ||
+                 ( cache_ptr->slist_size != 4 * entry_sizes[entry_type] ) 
+               ) 
+            ) ||
+            ( cache_ptr->pl_len != 0 ) ||
+            ( cache_ptr->pl_size != (size_t)0 ) ||
+            ( cache_ptr->pel_len != 2 ) ||
+            ( cache_ptr->pel_size != 2 * entry_sizes[entry_type] ) ||
+            ( cache_ptr->LRU_list_len != 2 ) ||
+            ( cache_ptr->LRU_list_size != 2 * entry_sizes[entry_type] )
 #if H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS
-        || (cache_ptr->dLRU_list_len != 2) ||
-        (cache_ptr->dLRU_list_size != 2 * entry_sizes[entry_type]) ||
-        (cache_ptr->cLRU_list_len != 0) ||
-        (cache_ptr->cLRU_list_size != (size_t)0)
+            || 
+            ( cache_ptr->dLRU_list_len != 2 ) ||
+            ( cache_ptr->dLRU_list_size != 2 * entry_sizes[entry_type] ) ||
+            ( cache_ptr->cLRU_list_len != 0 ) ||
+            ( cache_ptr->cLRU_list_size != (size_t)0 )
 #endif /* H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS */
-             ) {
+          ) {
 
-            pass = FALSE;
-            failure_mssg = "Unexpected insert results 10.";
-    }
+                pass = FALSE;
+                failure_mssg = "Unexpected insert results 10.";
+        }
     }
 
     /* Finally, if stats collection is enabled, verify that the expected
      * stats are collected.
      */
 #if H5C_COLLECT_CACHE_STATS
-    if(pass) {
-
-    if((cache_ptr->insertions[entry_type] != 4) ||
-        (cache_ptr->pinned_insertions[entry_type] != 2) ||
-        (cache_ptr->pins[entry_type] != 2) ||
-        (cache_ptr->unpins[entry_type] != 0) ||
-             (cache_ptr->dirty_pins[entry_type] != 0) ||
-        (cache_ptr->max_index_len != 4) ||
-        (cache_ptr->max_index_size != 4 * entry_sizes[entry_type]) ||
-        (cache_ptr->max_slist_len != 4) ||
-        (cache_ptr->max_slist_size != 4 * entry_sizes[entry_type]) ||
-        (cache_ptr->max_pl_len != 0) ||
-        (cache_ptr->max_pl_size != (size_t)0) ||
-        (cache_ptr->max_pel_len != 2) ||
-        (cache_ptr->max_pel_size != 2 * entry_sizes[entry_type])) {
-
-            pass = FALSE;
-            failure_mssg = "Unexpected insert results 11.";
-    }
+    if ( pass ) {
+
+        if ( ( cache_ptr->insertions[entry_type] != 4 ) ||
+             ( cache_ptr->pinned_insertions[entry_type] != 2 ) ||
+             ( cache_ptr->pins[entry_type] != 2 ) ||
+             ( cache_ptr->unpins[entry_type] != 0 ) ||
+             ( cache_ptr->dirty_pins[entry_type] != 0 ) ||
+             ( cache_ptr->max_index_len != 4 ) ||
+             ( cache_ptr->max_index_size != 4 * entry_sizes[entry_type] ) ||
+             ( ( cache_ptr->slist_enabled ) &&
+               ( ( cache_ptr->slist_len != 4 ) ||
+                 ( cache_ptr->slist_size != 4 * entry_sizes[entry_type] ) 
+               ) 
+             ) ||
+             ( cache_ptr->max_pl_len != 0 ) ||
+             ( cache_ptr->max_pl_size != (size_t)0 ) ||
+             ( cache_ptr->max_pel_len != 2 ) ||
+             ( cache_ptr->max_pel_size != 2 * entry_sizes[entry_type] ) ) {
+    
+                pass = FALSE;
+                failure_mssg = "Unexpected insert results 11.";
+        }
     }
 #endif /* H5C_COLLECT_CACHE_STATS */
 
@@ -3208,7 +3219,7 @@ check_insert_entry(unsigned paged)
     if(pass) {
 
         unpin_entry(entry_type, 2);
-    unpin_entry(entry_type, 3);
+        unpin_entry(entry_type, 3);
     }
 
     if(pass) {
@@ -3316,18 +3327,25 @@ check_flush_cache(unsigned paged)
 
 
 /*-------------------------------------------------------------------------
+ *
  * Function:    check_flush_cache__empty_cache()
  *
- * Purpose:    Verify that flush_cache behaves as expected with an empty
+ * Purpose :    Verify that flush_cache behaves as expected with an empty
  *              cache.
  *
- * Return:    void
+ * Return:      void
  *
- * Programmer:    John Mainzer
+ * Programmer:  John Mainzer
  *              1/12/05
  *
  * Modifications:
  *
+ *              Added code to setup and take down the skip list before
+ *              and after calls to H5C_flush_cache().  Do this via the
+ *              H5C_FLUSH_CACHE macro.
+ *
+ *                                          JRM -- 5/14/20
+ *
  *-------------------------------------------------------------------------
  */
 
@@ -3335,7 +3353,6 @@ static void
 check_flush_cache__empty_cache(H5F_t * file_ptr)
 {
     H5C_t * cache_ptr = file_ptr->shared->cache;
-    herr_t     result;
 
     if(cache_ptr == NULL) {
 
@@ -3352,53 +3369,37 @@ check_flush_cache__empty_cache(H5F_t * file_ptr)
 
     /* Test behaviour on an empty cache.  Can't do much sanity
      * checking in this case, so simply check the return values.
+     *
+     * Check of return values is done in the H5C_FLUSH_CACHE() macro.
      */
 
-    if(pass) {
-
-        result = H5C_flush_cache(file_ptr, H5C__NO_FLAGS_SET);
-
-        if(result < 0) {
+    if ( pass ) {
 
-            pass = FALSE;
-            failure_mssg = "flush with flags = 0x00 failed on empty cache.\n";
-        }
+        H5C_FLUSH_CACHE(file_ptr, H5C__NO_FLAGS_SET, \
+                        "flush with flags = 0x00 failed on empty cache.\n")
     }
 
-    if(pass) {
+    if ( pass ) {
 
-        result = H5C_flush_cache(file_ptr, H5C__FLUSH_INVALIDATE_FLAG);
-
-        if(result < 0) {
-
-            pass = FALSE;
-            failure_mssg = "flush with flags = 0x04 failed on empty cache.\n";
-        }
+        H5C_FLUSH_CACHE(file_ptr, H5C__FLUSH_INVALIDATE_FLAG, \
+                        "flush with flags = 0x04 failed on empty cache.\n")
     }
 
-    if(pass) {
+    if ( pass ) {
 
-        result = H5C_flush_cache(file_ptr, H5C__FLUSH_CLEAR_ONLY_FLAG);
-
-        if(result < 0) {
-
-            pass = FALSE;
-            failure_mssg = "flush with flags = 0x08 failed on empty cache.\n";
-        }
+        H5C_FLUSH_CACHE(file_ptr, H5C__FLUSH_CLEAR_ONLY_FLAG, \
+                        "flush with flags = 0x08 failed on empty cache.\n")
     }
 
 
-    if(pass) {
-
-        result = H5C_flush_cache(file_ptr, H5C__FLUSH_MARKED_ENTRIES_FLAG);
-
-        if(result < 0) {
+    if ( pass ) {
 
-            pass = FALSE;
-            failure_mssg = "flush with flags = 0x10 failed on empty cache.\n";
-        }
+        H5C_FLUSH_CACHE(file_ptr, H5C__FLUSH_MARKED_ENTRIES_FLAG, \
+                        "flush with flags = 0x10 failed on empty cache.\n")
     }
 
+    return;
+
 } /* check_flush_cache__empty_cache() */
 
 
@@ -4959,15 +4960,21 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
 /*-------------------------------------------------------------------------
  * Function:    check_flush_cache__multi_entry_test()
  *
- * Purpose:    Run a multi entry flush cache test.
+ * Purpose :    Run a multi entry flush cache test.
  *
- * Return:    void
- *
- * Programmer:    John Mainzer
+ * Return:      void
+ *          
+ * Programmer:  John Mainzer
  *              1/13/05
  *
  * Modifications:
  *
+ *              Added code to setup and take down the skip list before
+ *              and after calls to H5C_flush_cache().  Do this via the
+ *              H5C_FLUSH_CACHE macro.
+ *
+ *                                          JRM -- 5/14/20
+ *
  *-------------------------------------------------------------------------
  */
 
@@ -4980,7 +4987,6 @@ check_flush_cache__multi_entry_test(H5F_t * file_ptr,
 {
     H5C_t * cache_ptr = file_ptr->shared->cache;
     static char    msg[128];
-    herr_t       result;
     unsigned       u;
     size_t       total_entry_size = 0;
     test_entry_t * base_addr;
@@ -4989,8 +4995,8 @@ check_flush_cache__multi_entry_test(H5F_t * file_ptr,
 #if 0 /* JRM */
     /* This gets used a lot, so lets leave it in. */
 
-    HDfprintf(stdout, "check_flush_cache__multi_entry_test: test %d\n",
-        test_num);
+    HDfprintf(stdout, "check_flush_cache__multi_entry_test: test %d\n", 
+              test_num);
 #endif /* JRM */
 
     if(cache_ptr == NULL) {
@@ -5001,8 +5007,8 @@ check_flush_cache__multi_entry_test(H5F_t * file_ptr,
                    test_num);
         failure_mssg = msg;
     }
-    else if((cache_ptr->index_len != 0) ||
-              (cache_ptr->index_size != 0)) {
+    else if ( ( cache_ptr->index_len != 0 ) ||
+              ( cache_ptr->index_size != 0 ) ) {
 
         pass = FALSE;
 
@@ -5021,13 +5027,13 @@ check_flush_cache__multi_entry_test(H5F_t * file_ptr,
     }
 
     u = 0;
-    while(pass && (u < spec_size))
-    {
-        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])) {
+    while ( pass && ( u < spec_size ) ) {
+    
+        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,
@@ -5039,8 +5045,8 @@ check_flush_cache__multi_entry_test(H5F_t * file_ptr,
     }
 
     u = 0;
-    while(pass && (u < spec_size))
-    {
+    while ( pass && (u < spec_size) ) {
+    
         if(spec[u].insert_flag) {
 
             insert_entry(file_ptr, spec[u].entry_type, spec[u].entry_index,
@@ -5061,11 +5067,10 @@ check_flush_cache__multi_entry_test(H5F_t * file_ptr,
 
     if(pass) {
 
-        result = H5C_flush_cache(file_ptr, flush_flags);
+        H5C_FLUSH_CACHE(file_ptr, flush_flags, "dummy failure message.\n")
 
-        if(result < 0) {
+        if ( ! pass ) {
 
-            pass = FALSE;
             HDsnprintf(msg, (size_t)128,
                        "flush with flags 0x%x failed in multi entry test #%d.",
                        flush_flags, test_num);
@@ -5107,22 +5112,22 @@ check_flush_cache__multi_entry_test(H5F_t * file_ptr,
 
     if(pass) {
 
-        if((((flush_flags & H5C__FLUSH_INVALIDATE_FLAG) == 0)
+        if ( ( ( (flush_flags & H5C__FLUSH_INVALIDATE_FLAG) == 0)
                &&
-               ((cache_ptr->index_len != spec_size)
+               ( ( cache_ptr->index_len != spec_size )
                  ||
-                 (cache_ptr->index_size != total_entry_size)
-              )
-            )
+                 ( cache_ptr->index_size != total_entry_size )
+               )
+             )
              ||
-             (((flush_flags & H5C__FLUSH_INVALIDATE_FLAG) != 0)
+             ( ( (flush_flags & H5C__FLUSH_INVALIDATE_FLAG) != 0)
                &&
-               ((cache_ptr->index_len != 0)
+               ( ( cache_ptr->index_len != 0 )
                  ||
-                 (cache_ptr->index_size != 0)
-              )
-            )
-          ) {
+                 ( cache_ptr->index_size != 0 )
+               )
+             )
+           ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128,
@@ -5135,9 +5140,9 @@ check_flush_cache__multi_entry_test(H5F_t * file_ptr,
     /* clean up the cache to prep for the next test */
     if(pass) {
 
-        result = H5C_flush_cache(file_ptr, H5C__FLUSH_INVALIDATE_FLAG);
+        H5C_FLUSH_CACHE(file_ptr, H5C__FLUSH_INVALIDATE_FLAG, "dummy mssg.\n")
 
-        if(result < 0) {
+        if ( ! pass ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128,
@@ -5145,8 +5150,8 @@ check_flush_cache__multi_entry_test(H5F_t * file_ptr,
                        test_num);
             failure_mssg = msg;
         }
-        else if((cache_ptr->index_len != 0) ||
-                  (cache_ptr->index_size != 0)) {
+        else if ( ( cache_ptr->index_len != 0 ) ||
+                  ( cache_ptr->index_size != 0 ) ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128,
@@ -5158,8 +5163,8 @@ check_flush_cache__multi_entry_test(H5F_t * file_ptr,
     }
 
     u = 0;
-    while(pass && (u < spec_size))
-    {
+    while ( pass && ( u < spec_size ) ) {
+    
         base_addr = entries[spec[u].entry_type];
         entry_ptr = &(base_addr[spec[u].entry_index]);
 
@@ -5176,17 +5181,24 @@ check_flush_cache__multi_entry_test(H5F_t * file_ptr,
 
 
 /*-------------------------------------------------------------------------
+ *
  * Function:    check_flush_cache__pe_multi_entry_test()
  *
- * Purpose:    Run a multi entry flush cache test.
+ * Purpose:     Run a multi entry flush cache test.
  *
- * Return:    void
+ * Return:      void
  *
- * Programmer:    John Mainzer
+ * Programmer:  John Mainzer
  *              4/5/06
  *
  * Modifications:
  *
+ *              Added code to setup and take down the skip list before
+ *              and after calls to H5C_flush_cache().  Do this via the
+ *              H5C_FLUSH_CACHE macro.
+ *
+ *                                           JRM -- 5/16/20
+ *
  *-------------------------------------------------------------------------
  */
 
@@ -5199,7 +5211,6 @@ check_flush_cache__pe_multi_entry_test(H5F_t * file_ptr,
 {
     H5C_t *cache_ptr = file_ptr->shared->cache;
     static char    msg[128];
-    herr_t       result;
     unsigned       u;
     int            j;
     size_t       total_entry_size = 0;
@@ -5221,8 +5232,8 @@ check_flush_cache__pe_multi_entry_test(H5F_t * file_ptr,
                    test_num);
         failure_mssg = msg;
     }
-    else if((cache_ptr->index_len != 0) ||
-              (cache_ptr->index_size != 0)) {
+    else if ( ( cache_ptr->index_len != 0 ) ||
+              ( cache_ptr->index_size != 0 ) ) {
 
         pass = FALSE;
 
@@ -5241,15 +5252,15 @@ check_flush_cache__pe_multi_entry_test(H5F_t * file_ptr,
     }
 
     u = 0;
-    while(pass && (u < spec_size))
-    {
-        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)) {
+    while ( pass && ( u < spec_size ) ) {
+
+        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,
@@ -5278,25 +5289,24 @@ check_flush_cache__pe_multi_entry_test(H5F_t * file_ptr,
 
         total_entry_size += entry_sizes[spec[u].entry_type];
 
-    for (j = 0; j < spec[u].num_pins; j++)
-    {
+        for (j = 0; j < spec[u].num_pins; j++) {
+
             create_pinned_entry_dependency(file_ptr,
-                                spec[u].entry_type,
-                    spec[u].entry_index,
-                    spec[u].pin_type[j],
-                    spec[u].pin_idx[j]);
-    }
+                                           spec[u].entry_type,
+                                           spec[u].entry_index,
+                                           spec[u].pin_type[j],
+                                           spec[u].pin_idx[j]);
+        }
 
         u++;
     }
 
     if(pass) {
 
-        result = H5C_flush_cache(file_ptr, flush_flags);
+        H5C_FLUSH_CACHE(file_ptr, flush_flags, "dummy failure message.\n")
 
-        if(result < 0) {
+        if ( ! pass ) {
 
-            pass = FALSE;
             HDsnprintf(msg, (size_t)128,
                      "flush with flags 0x%x failed in pe multi entry test #%d.",
                      flush_flags, test_num);
@@ -5305,14 +5315,14 @@ check_flush_cache__pe_multi_entry_test(H5F_t * file_ptr,
     }
 
     u = 0;
-    while(pass && (u < spec_size))
-    {
+    while ( pass && ( u < spec_size ) ) {
+
         base_addr = entries[spec[u].entry_type];
         entry_ptr = &(base_addr[spec[u].entry_index]);
 
-        if((entry_ptr->deserialized != spec[u].expected_deserialized) ||
-             (entry_ptr->serialized != spec[u].expected_serialized) ||
-             (entry_ptr->destroyed != spec[u].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. */
 
@@ -5338,22 +5348,22 @@ check_flush_cache__pe_multi_entry_test(H5F_t * file_ptr,
 
     if(pass) {
 
-        if((((flush_flags & H5C__FLUSH_INVALIDATE_FLAG) == 0)
+        if ( ( ( (flush_flags & H5C__FLUSH_INVALIDATE_FLAG) == 0)
                &&
-               ((cache_ptr->index_len != spec_size)
+               ( ( cache_ptr->index_len != spec_size )
                  ||
-                 (cache_ptr->index_size != total_entry_size)
-              )
-            )
+                 ( cache_ptr->index_size != total_entry_size )
+               )
+             )
              ||
-             (((flush_flags & H5C__FLUSH_INVALIDATE_FLAG) != 0)
+             ( ( (flush_flags & H5C__FLUSH_INVALIDATE_FLAG) != 0 )
                &&
-               ((cache_ptr->index_len != 0)
+               ( ( cache_ptr->index_len != 0 )
                  ||
-                 (cache_ptr->index_size != 0)
-              )
-            )
-          ) {
+                 ( cache_ptr->index_size != 0 )
+               )
+             )
+           ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128,
@@ -5364,11 +5374,11 @@ check_flush_cache__pe_multi_entry_test(H5F_t * file_ptr,
     }
 
     /* clean up the cache to prep for the next test */
-    if(pass) {
+    if ( pass ) {
 
-        result = H5C_flush_cache(file_ptr, H5C__FLUSH_INVALIDATE_FLAG);
+        H5C_FLUSH_CACHE(file_ptr, H5C__FLUSH_INVALIDATE_FLAG, "dummy mssg.\n")
 
-        if(result < 0) {
+        if ( ! pass ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128,
@@ -5376,8 +5386,8 @@ check_flush_cache__pe_multi_entry_test(H5F_t * file_ptr,
                        test_num);
             failure_mssg = msg;
         }
-        else if((cache_ptr->index_len != 0) ||
-                  (cache_ptr->index_size != 0)) {
+        else if ( ( cache_ptr->index_len != 0 ) ||
+                  ( cache_ptr->index_size != 0 ) ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128,
@@ -5389,8 +5399,8 @@ check_flush_cache__pe_multi_entry_test(H5F_t * file_ptr,
     }
 
     u = 0;
-    while(pass && (u < spec_size))
-    {
+    while ( pass && ( u < spec_size ) ) {
+
         base_addr = entries[spec[u].entry_type];
         entry_ptr = &(base_addr[spec[u].entry_index]);
 
@@ -9181,16 +9191,22 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 /*-------------------------------------------------------------------------
  * Function:    check_flush_cache__flush_op_test()
  *
- * Purpose:    Run a flush op flush cache test.  Of the nature of
- *         flush operations, this is a multi-entry test.
+ * Purpose:     Run a flush op flush cache test.  Of the nature of
+ *              flush operations, this is a multi-entry test.
  *
- * Return:    void
+ * Return:      void
  *
- * Programmer:    John Mainzer
+ * Programmer:  John Mainzer
  *              9/3/06
  *
  * Modifications:
  *
+ *              Added code to setup and take down the skip list before
+ *              and after calls to H5C_flush_cache().  Do this via the
+ *              H5C_FLUSH_CACHE macro.
+ *
+ *                                           JRM -- 5/16/20
+ *
  *-------------------------------------------------------------------------
  */
 
@@ -9200,16 +9216,15 @@ 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[],
-                unsigned init_expected_index_len,
-                size_t init_expected_index_size,
-                unsigned expected_index_len,
-                size_t expected_index_size,
-                int check_size,
-                struct fo_flush_entry_check check[])
+                                 unsigned init_expected_index_len,
+                                 size_t init_expected_index_size,
+                                 unsigned expected_index_len,
+                                 size_t expected_index_size,
+                                 int check_size,
+                                 struct fo_flush_entry_check check[])
 {
     H5C_t *       cache_ptr = file_ptr->shared->cache;
     static char    msg[128];
-    herr_t       result;
     int            i;
     int            j;
     test_entry_t * base_addr;
@@ -9228,8 +9243,8 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
                    test_num);
         failure_mssg = msg;
     }
-    else if((cache_ptr->index_len != 0) ||
-              (cache_ptr->index_size != 0)) {
+    else if ( ( cache_ptr->index_len != 0 ) ||
+              ( cache_ptr->index_size != 0 ) ) {
 
         pass = FALSE;
 
@@ -9248,17 +9263,17 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
     }
 
     i = 0;
-    while(pass && (i < 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) ||
-        (spec[i].num_flush_ops < 0) ||
-        (spec[i].num_flush_ops > MAX_FLUSH_OPS)) {
+    while ( pass && ( i < 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 ) ||
+             ( spec[i].num_flush_ops < 0 ) ||
+             ( spec[i].num_flush_ops > MAX_FLUSH_OPS ) ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128,
@@ -9270,36 +9285,36 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
     }
 
     i = 0;
-    while(pass && (i < check_size))
-    {
-        if((check[i].entry_num != i) ||
-             (check[i].entry_type < 0) ||
-             (check[i].entry_type >= NUMBER_OF_ENTRY_TYPES) ||
-             (check[i].entry_index < 0) ||
-             (check[i].entry_index > max_indices[check[i].entry_type]) ||
+    while ( pass && ( i < check_size ) ) {
+
+        if ( ( check[i].entry_num != i) ||
+             ( check[i].entry_type < 0) ||
+             ( check[i].entry_type >= NUMBER_OF_ENTRY_TYPES) ||
+             ( check[i].entry_index < 0) ||
+             ( check[i].entry_index > max_indices[check[i].entry_type]) ||
 #ifndef H5_HAVE_STDBOOL_H
                 /* Check for nonsense values if hbool_t is an integral
                  * type instead of a real Boolean.
                  */
-            ((check[i].in_cache != TRUE) &&
-            (check[i].in_cache != FALSE)) ||
-            ((check[i].at_main_addr != TRUE) &&
-            (check[i].at_main_addr != FALSE)) ||
-            ((check[i].is_dirty != TRUE) &&
-            (check[i].is_dirty != FALSE)) ||
-            ((check[i].is_protected != TRUE) &&
-            (check[i].is_protected != FALSE)) ||
-            ((check[i].is_pinned != TRUE) &&
-            (check[i].is_pinned != FALSE)) ||
-            ((check[i].expected_deserialized != TRUE) &&
-            (check[i].expected_deserialized != FALSE)) ||
-            ((check[i].expected_serialized != TRUE) &&
-            (check[i].expected_serialized != FALSE)) ||
-            ((check[i].expected_destroyed != TRUE) &&
-            (check[i].expected_destroyed != FALSE)) ||
+             ( ( check[i].in_cache != TRUE ) &&
+               ( check[i].in_cache != FALSE ) ) ||
+             ( ( check[i].at_main_addr != TRUE ) &&
+               ( check[i].at_main_addr != FALSE ) ) ||
+             ( ( check[i].is_dirty != TRUE ) &&
+               ( check[i].is_dirty != FALSE ) ) ||
+             ( ( check[i].is_protected != TRUE ) &&
+               ( check[i].is_protected != FALSE ) ) ||
+             ( ( check[i].is_pinned != TRUE ) &&
+               ( check[i].is_pinned != FALSE ) ) ||
+             ( ( check[i].expected_deserialized != TRUE ) &&
+               ( check[i].expected_deserialized != FALSE ) ) ||
+             ( ( check[i].expected_serialized != TRUE ) &&
+               ( check[i].expected_serialized != FALSE ) ) ||
+             ( ( check[i].expected_destroyed != TRUE ) &&
+               ( check[i].expected_destroyed != FALSE ) ) ||
 #endif /* H5_HAVE_STDBOOL_H */
-             (check[i].expected_size <= (size_t)0)
-        ) {
+             ( check[i].expected_size <= (size_t)0 )
+           ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128,
@@ -9311,8 +9326,8 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
     }
 
     i = 0;
-    while(pass && (i < spec_size))
-    {
+    while ( pass && ( i < spec_size ) ) {
+
         if(spec[i].insert_flag) {
 
             insert_entry(file_ptr, spec[i].entry_type, spec[i].entry_index,
@@ -9330,34 +9345,34 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
                         spec[i].flags);
         }
 
-    for (j = 0; j < spec[i].num_pins; j++)
-    {
+        for (j = 0; j < spec[i].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]);
-    }
+        }
 
-    for (j = 0; j < spec[i].num_flush_ops; j++)
-    {
-        add_flush_op(spec[i].entry_type,
-            spec[i].entry_index,
-            spec[i].flush_ops[j].op_code,
-            spec[i].flush_ops[j].type,
-            spec[i].flush_ops[j].idx,
-            spec[i].flush_ops[j].flag,
-            spec[i].flush_ops[j].size,
+        for (j = 0; j < spec[i].num_flush_ops; j++) {
+
+            add_flush_op(spec[i].entry_type,
+                         spec[i].entry_index,
+                         spec[i].flush_ops[j].op_code,
+                         spec[i].flush_ops[j].type,
+                         spec[i].flush_ops[j].idx,
+                         spec[i].flush_ops[j].flag,
+                         spec[i].flush_ops[j].size,
                          spec[i].flush_ops[j].order_ptr);
-    }
+        }
 
         i++;
     }
 
-    if(pass) {
+    if ( pass ) {
 
-        if((cache_ptr->index_len != init_expected_index_len) ||
-             (cache_ptr->index_size != init_expected_index_size)) {
+        if ( ( cache_ptr->index_len != init_expected_index_len ) ||
+             ( cache_ptr->index_size != init_expected_index_size ) ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128,
@@ -9369,9 +9384,9 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
 
     if(pass) {
 
-        result = H5C_flush_cache(file_ptr, flush_flags);
+        H5C_FLUSH_CACHE(file_ptr, flush_flags, "dummy failure message")
 
-        if(result < 0) {
+        if ( ! pass ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128,
@@ -9383,14 +9398,14 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
 
 
     i = 0;
-    while(pass && (i < spec_size))
-    {
+    while ( pass && ( i < spec_size ) ) {
+
         base_addr = entries[spec[i].entry_type];
         entry_ptr = &(base_addr[spec[i].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[i].expected_deserialized ) ||
+             ( entry_ptr->serialized != spec[i].expected_serialized ) ||
+             ( entry_ptr->destroyed != spec[i].expected_destroyed ) ) {
 
 #if 0 /* This is useful debugging code.  Lets keep it around. */
 
@@ -9419,136 +9434,166 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
     if(pass) {
 
         i = 0;
-        while(pass && (i < check_size))
-        {
-        if(check[i].in_cache != entry_in_cache(cache_ptr,
-                                    check[i].entry_type,
-                            check[i].entry_index)) {
+        while ( pass && (i < check_size ) ) {
+
+            if ( check[i].in_cache != entry_in_cache(cache_ptr,
+                                                     check[i].entry_type,
+                                                     check[i].entry_index) ) {
 
                 pass = FALSE;
                 HDsnprintf(msg, (size_t)128,
                            "Check1 failed on entry %d after flush op test #%d.",
                            i, test_num);
                 failure_mssg = msg;
-        }
+            }
 
             base_addr = entries[check[i].entry_type];
             entry_ptr = &(base_addr[check[i].entry_index]);
 
-        if((entry_ptr->size != check[i].expected_size) ||
-        ((!entry_ptr->header.destroy_in_progress) &&
-        (check[i].in_cache) &&
-        (entry_ptr->header.size != check[i].expected_size)) ||
-        (entry_ptr->at_main_addr != check[i].at_main_addr) ||
-        (entry_ptr->is_dirty != check[i].is_dirty) ||
-        (entry_ptr->header.is_dirty != check[i].is_dirty) ||
-        (entry_ptr->is_protected != check[i].is_protected) ||
-        (entry_ptr->header.is_protected != check[i].is_protected) ||
-                 (entry_ptr->is_pinned != check[i].is_pinned) ||
-                 (entry_ptr->header.is_pinned != check[i].is_pinned) ||
-        (entry_ptr->deserialized != check[i].expected_deserialized) ||
-        (entry_ptr->serialized != check[i].expected_serialized) ||
-        (entry_ptr->destroyed != check[i].expected_destroyed)) {
+            if ( ( entry_ptr->size != check[i].expected_size) ||
+                 ( ( !entry_ptr->header.destroy_in_progress) &&
+                   ( check[i].in_cache ) &&
+                   ( entry_ptr->header.size != check[i].expected_size ) ) ||
+                 ( entry_ptr->at_main_addr != check[i].at_main_addr ) ||
+                 ( entry_ptr->is_dirty != check[i].is_dirty ) ||
+                 ( entry_ptr->header.is_dirty != check[i].is_dirty ) ||
+                 ( entry_ptr->is_protected != check[i].is_protected ) ||
+                 ( entry_ptr->header.is_protected != check[i].is_protected ) ||
+                 ( entry_ptr->is_pinned != check[i].is_pinned ) ||
+                 ( entry_ptr->header.is_pinned != check[i].is_pinned ) ||
+                 ( entry_ptr->deserialized != check[i].expected_deserialized ) ||
+                 ( entry_ptr->serialized != check[i].expected_serialized ) ||
+                 ( entry_ptr->destroyed != check[i].expected_destroyed ) ) {
 
 #if 0 /* This is useful debugging code.  Lets keep it around for a while. */
 
-        if(entry_ptr->size != check[i].expected_size) {
-            HDfprintf(stdout, "entry_ptr->size (expected) = %d (%d).\n",
-                (int)(entry_ptr->size),
-                (int)(check[i].expected_size));
-        }
-        if((!entry_ptr->header.destroy_in_progress) &&
-            (check[i].in_cache) &&
-                     (entry_ptr->header.size != check[i].expected_size)) {
-                    HDfprintf(stdout,
+                if ( entry_ptr->size != check[i].expected_size ) {
+
+                    HDfprintf(stdout, "entry_ptr->size (expected) = %d (%d).\n",
+                              (int)(entry_ptr->size),
+                              (int)(check[i].expected_size));
+                }
+
+                if ( ( ! entry_ptr->header.destroy_in_progress ) &&
+                     ( check[i].in_cache ) &&
+                     ( entry_ptr->header.size != check[i].expected_size ) ) {
+
+                        HDfprintf(stdout,
                               "(!destroy in progress and in cache and size (expected) = %d (%d).\n",
                               (int)(entry_ptr->header.size),
-                (int)(check[i].expected_size));
-        }
-        if(entry_ptr->at_main_addr != check[i].at_main_addr) {
-            HDfprintf(stdout, "(%d,%d) at main addr (expected) = %d (%d).\n",
-                (int)(check[i].entry_type),
-                (int)(check[i].entry_index),
+                              (int)(check[i].expected_size));
+                }
+
+                if ( entry_ptr->at_main_addr != check[i].at_main_addr ) {
+
+                    HDfprintf(stdout, 
+                              "(%d,%d) at main addr (expected) = %d (%d).\n",
+                              (int)(check[i].entry_type),
+                              (int)(check[i].entry_index),
                               (int)(entry_ptr->at_main_addr),
-                (int)(check[i].at_main_addr));
+                              (int)(check[i].at_main_addr));
+                }
+
+                if ( entry_ptr->is_dirty != check[i].is_dirty ) {
+
+                    HDfprintf(stdout, 
+                              "entry_ptr->is_dirty (expected) = %d (%d).\n",
+                              (int)(entry_ptr->is_dirty),
+                              (int)(check[i].is_dirty));
+                }
+
+                if ( entry_ptr->header.is_dirty != check[i].is_dirty ) {
+
+                    HDfprintf(stdout, 
+                          "entry_ptr->header.is_dirty (expected) = %d (%d).\n",
+                          (int)(entry_ptr->header.is_dirty),
+                          (int)(check[i].is_dirty));
+                }
+
+                if ( entry_ptr->is_protected != check[i].is_protected ) {
+
+                    HDfprintf(stdout, 
+                              "entry_ptr->is_protected (expected) = %d (%d).\n",
+                              (int)(entry_ptr->is_protected),
+                              (int)(check[i].is_protected));
+                }
+
+                if ( entry_ptr->header.is_protected != check[i].is_protected ) {
+
+                     HDfprintf(stdout, 
+                       "entry_ptr->header.is_protected (expected) = %d (%d).\n",
+                       (int)(entry_ptr->is_protected),
+                       (int)(check[i].is_protected));
+                }
+
+                if ( entry_ptr->is_pinned != check[i].is_pinned ) {
+
+                     HDfprintf(stdout, 
+                              "entry_ptr->is_pinned (expected) = %d (%d).\n",
+                              (int)(entry_ptr->is_pinned),
+                              (int)(check[i].is_pinned));
+                }
+
+                if ( entry_ptr->header.is_pinned != check[i].is_pinned ) {
+
+                    HDfprintf(stdout, 
+                          "entry_ptr->header.is_pinned (expected) = %d (%d).\n",
+                          (int)(entry_ptr->header.is_pinned),
+                          (int)(check[i].is_pinned));
+                }
+
+                if ( entry_ptr->deserialized != check[i].expected_deserialized ) {
+
+                    HDfprintf(stdout,
+                              "entry_ptr->deserialized (expected) = %d (%d).\n",
+                              (int)(entry_ptr->deserialized),
+                              (int)(check[i].expected_deserialized));
+                }
+
+                if ( entry_ptr->serialized != check[i].expected_serialized ) {
+
+                    HDfprintf(stdout,
+                              "entry_ptr->serialized (expected) = %d (%d).\n",
+                              (int)(entry_ptr->serialized),
+                              (int)(check[i].expected_serialized));
+                }
+
+                if ( entry_ptr->destroyed != check[i].expected_destroyed ) {
+
+                    HDfprintf(stdout, \
+                              "entry_ptr->destroyed (expected) = %d (%d).\n",
+                              (int)(entry_ptr->destroyed),
+                              (int)(check[i].expected_destroyed));
                 }
-        if(entry_ptr->is_dirty != check[i].is_dirty) {
-            HDfprintf(stdout, "entry_ptr->is_dirty (expected) = %d (%d).\n",
-                    (int)(entry_ptr->is_dirty),
-                (int)(check[i].is_dirty));
-        }
-        if(entry_ptr->header.is_dirty != check[i].is_dirty) {
-            HDfprintf(stdout, "entry_ptr->header.is_dirty (expected) = %d (%d).\n",
-                    (int)(entry_ptr->header.is_dirty),
-                (int)(check[i].is_dirty));
-        }
-            if(entry_ptr->is_protected != check[i].is_protected) {
-                    HDfprintf(stdout, "entry_ptr->is_protected (expected) = %d (%d).\n",
-                (int)(entry_ptr->is_protected),
-                (int)(check[i].is_protected));
-        }
-            if(entry_ptr->header.is_protected != check[i].is_protected) {
-                    HDfprintf(stdout, "entry_ptr->header.is_protected (expected) = %d (%d).\n",
-                (int)(entry_ptr->is_protected),
-                (int)(check[i].is_protected));
-        }
-        if(entry_ptr->is_pinned != check[i].is_pinned) {
-            HDfprintf(stdout, "entry_ptr->is_pinned (expected) = %d (%d).\n",
-                (int)(entry_ptr->is_pinned),
-                (int)(check[i].is_pinned));
-        }
-        if(entry_ptr->header.is_pinned != check[i].is_pinned) {
-            HDfprintf(stdout, "entry_ptr->header.is_pinned (expected) = %d (%d).\n",
-                (int)(entry_ptr->header.is_pinned),
-                (int)(check[i].is_pinned));
-        }
-        if(entry_ptr->deserialized !=
-                check[i].expected_deserialized) {
-            HDfprintf(stdout,
-                "entry_ptr->deserialized (expected) = %d (%d).\n",
-                (int)(entry_ptr->deserialized),
-                (int)(check[i].expected_deserialized));
-        }
-        if(entry_ptr->serialized != check[i].expected_serialized) {
-            HDfprintf(stdout,
-                "entry_ptr->serialized (expected) = %d (%d).\n",
-                (int)(entry_ptr->serialized),
-                (int)(check[i].expected_serialized));
-        }
-        if(entry_ptr->destroyed != check[i].expected_destroyed) {
-            HDfprintf(stdout, "entry_ptr->destroyed (expected) = %d (%d).\n",
-                (int)(entry_ptr->destroyed),
-                (int)(check[i].expected_destroyed));
-        }
 #endif
                 pass = FALSE;
                 HDsnprintf(msg, (size_t)128,
                            "Check2 failed on entry %d after flush op test #%d.",
                            i, test_num);
                 failure_mssg = msg;
-        }
-        i++;
+            }
+            i++;
         }
     }
 
-    if(pass) {
+    if ( pass ) {
 
-        if((((flush_flags & H5C__FLUSH_INVALIDATE_FLAG) == 0)
+        if ( ( ( (flush_flags & H5C__FLUSH_INVALIDATE_FLAG) == 0 )
                &&
-               ((cache_ptr->index_len != expected_index_len)
+               ( ( cache_ptr->index_len != expected_index_len )
                  ||
-                 (cache_ptr->index_size != expected_index_size)
-              )
-            )
+                 ( cache_ptr->index_size != expected_index_size )
+               )
+             )
              ||
-             (((flush_flags & H5C__FLUSH_INVALIDATE_FLAG) != 0)
+             ( ( (flush_flags & H5C__FLUSH_INVALIDATE_FLAG) != 0 )
                &&
-               ((cache_ptr->index_len != 0)
+               ( ( cache_ptr->index_len != 0 )
                  ||
-                 (cache_ptr->index_size != 0)
-              )
-            )
-          ) {
+                 ( cache_ptr->index_size != 0 )
+               )
+             )
+           ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128,
@@ -9561,20 +9606,19 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
     /* clean up the cache to prep for the next test */
     if(pass) {
 
-        result = H5C_flush_cache(file_ptr, H5C__FLUSH_INVALIDATE_FLAG);
+        H5C_FLUSH_CACHE(file_ptr, H5C__FLUSH_INVALIDATE_FLAG, "dummy mssg.")
 
-        if(result < 0) {
+        if ( ! pass ) {
 
-            pass = FALSE;
             HDsnprintf(msg, (size_t)128,
                        "Flush failed on cleanup in flush op test #%d.",
                        test_num);
             failure_mssg = msg;
         }
-        else if((cache_ptr->index_len != 0) ||
-                  (cache_ptr->index_size != 0) ||
-        (cache_ptr->clean_index_size != 0) ||
-        (cache_ptr->dirty_index_size != 0)) {
+        else if ( ( cache_ptr->index_len != 0 ) ||
+                  ( cache_ptr->index_size != 0 ) ||
+                  ( cache_ptr->clean_index_size != 0 ) ||
+                  ( cache_ptr->dirty_index_size != 0 ) ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128,
@@ -9586,12 +9630,12 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
     }
 
     i = 0;
-    while(pass && (i < spec_size))
-    {
-        base_addr = entries[spec[i].entry_type];
-        entry_ptr = &(base_addr[spec[i].entry_index]);
+    while ( pass && ( i < spec_size ) ) {
+
+        base_addr               = entries[spec[i].entry_type];
+        entry_ptr               = &(base_addr[spec[i].entry_index]);
 
-    entry_ptr->size      = entry_sizes[spec[i].entry_type];
+        entry_ptr->size         = entry_sizes[spec[i].entry_type];
 
         entry_ptr->deserialized = FALSE;
         entry_ptr->serialized   = FALSE;
@@ -9601,12 +9645,12 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
     }
 
     i = 0;
-    while(pass && (i < check_size))
-    {
-        base_addr = entries[check[i].entry_type];
-        entry_ptr = &(base_addr[check[i].entry_index]);
+    while ( pass && ( i < check_size ) ) {
+
+        base_addr               = entries[check[i].entry_type];
+        entry_ptr               = &(base_addr[check[i].entry_index]);
 
-    entry_ptr->size      = entry_sizes[check[i].entry_type];
+        entry_ptr->size         = entry_sizes[check[i].entry_type];
 
         entry_ptr->deserialized = FALSE;
         entry_ptr->serialized   = FALSE;
@@ -9623,22 +9667,28 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
 /*-------------------------------------------------------------------------
  * Function:    check_flush_cache__flush_op_eviction_test()
  *
- * Purpose:    Verify that flush operations work as expected when an
+ * Purpose:     Verify that flush operations work as expected when an
  *              entry is evicted.
  *
  *              Do nothing if pass is FALSE on entry.
  *
- * Return:    void
+ * Return:      void
  *
- * Programmer:    John Mainzer
+ * Programmer:  John Mainzer
  *              10/3/06
  *
  * Modifications:
  *
- *        Updated test for minor changes in the behaviour
- *        of H5C__flush_single_entry().
+ *              Updated test for minor changes in the behaviour
+ *              of H5C__flush_single_entry().
+ *
+ *                                          JRM -- 2/16/15
  *
- *                    JRM -- 2/16/15
+ *              Added code to setup and take down the skip list before
+ *              and after calls to H5C_flush_cache().  Do this via the
+ *              H5C_FLUSH_CACHE macro.
+ *
+ *                                           JRM -- 5/16/20
  *
  *-------------------------------------------------------------------------
  */
@@ -9651,7 +9701,6 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
     int           num_variable_entries = 10;
     int           num_monster_entries = 31;
     int           num_large_entries = 0;
-    herr_t       result;
     test_entry_t * entry_ptr;
     test_entry_t * base_addr;
     struct expected_entry_status expected[10 + 31 + 14] =
@@ -10840,15 +10889,12 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
 
     if(pass) {
 
-        result = H5C_flush_cache(file_ptr, H5C__FLUSH_INVALIDATE_FLAG);
+        H5C_FLUSH_CACHE(file_ptr, H5C__FLUSH_INVALIDATE_FLAG, \
+                  "Cache flush invalidate failed after flush op eviction test")
 
-        if(result < 0) {
-
-            pass = FALSE;
-            failure_mssg = "Cache flush invalidate failed after flush op eviction test";
-        }
-        else if((cache_ptr->index_len != 0) ||
-                  (cache_ptr->index_size != 0)) {
+        if ( ( pass ) &&
+             ( ( cache_ptr->index_len != 0 ) ||
+               ( cache_ptr->index_size != 0 ) ) ) {
 
             pass = FALSE;
             failure_mssg = "Unexpected cache len/size after cleanup of flush op eviction test";
@@ -12493,15 +12539,21 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
 /*-------------------------------------------------------------------------
  * Function:    check_flush_cache__single_entry_test()
  *
- * Purpose:    Run a single entry flush cache test.
+ * Purpose:     Run a single entry flush cache test.
  *
- * Return:    void
+ * Return:      void
  *
- * Programmer:    John Mainzer
+ * Programmer:  John Mainzer
  *              1/12/05
  *
  * Modifications:
  *
+ *              Added code to setup and take down the skip list before
+ *              and after calls to H5C_flush_cache().  Do this via the
+ *              H5C_FLUSH_CACHE macro.
+ *
+ *                                          JRM -- 5/14/20
+ *
  *-------------------------------------------------------------------------
  */
 
@@ -12519,7 +12571,6 @@ check_flush_cache__single_entry_test(H5F_t * file_ptr,
 {
     H5C_t *        cache_ptr = file_ptr->shared->cache;
     static char    msg[128];
-    herr_t       result;
     test_entry_t * base_addr;
     test_entry_t * entry_ptr = NULL;
 
@@ -12531,8 +12582,8 @@ check_flush_cache__single_entry_test(H5F_t * file_ptr,
                    test_num);
         failure_mssg = msg;
     }
-    else if((cache_ptr->index_len != 0) ||
-              (cache_ptr->index_size != 0)) {
+    else if ( ( cache_ptr->index_len != 0 ) ||
+              ( cache_ptr->index_size != 0 ) ) {
 
         pass = FALSE;
         HDsnprintf(msg, (size_t)128,
@@ -12540,8 +12591,10 @@ check_flush_cache__single_entry_test(H5F_t * file_ptr,
                    test_num);
         failure_mssg = msg;
     }
-    else if((entry_type < 0) || (entry_type >= NUMBER_OF_ENTRY_TYPES) ||
-              (entry_idx < 0) || (entry_idx > max_indices[entry_type])) {
+    else if ( ( entry_type < 0 ) || 
+              ( entry_type >= NUMBER_OF_ENTRY_TYPES ) ||
+              ( entry_idx < 0 ) || 
+              ( entry_idx > max_indices[entry_type] ) ) {
 
         pass = FALSE;
         HDsnprintf(msg, (size_t)128,
@@ -12569,19 +12622,20 @@ check_flush_cache__single_entry_test(H5F_t * file_ptr,
 
     if(pass) {
 
-        result = H5C_flush_cache(file_ptr, flush_flags);
+        H5C_FLUSH_CACHE(file_ptr, flush_flags, "dummy failure mssg.")
 
-        if(result < 0) {
+        if ( ! pass ) { /* construct and set actual failure message */
 
-            pass = FALSE;
             HDsnprintf(msg, (size_t)128,
                        "flush with flags 0x%x failed in single entry test #%d.",
                        flush_flags, test_num);
+
             failure_mssg = msg;
         }
-        else if((entry_ptr->deserialized != expected_deserialized) ||
-                  (entry_ptr->serialized != expected_serialized) ||
-                  (entry_ptr->destroyed != expected_destroyed)) {
+        else if ( ( entry_ptr->deserialized != expected_deserialized ) ||
+                  ( entry_ptr->serialized != expected_serialized ) ||
+                  ( entry_ptr->destroyed != expected_destroyed ) ) {
+
 #if 0 /* This is useful debugging code -- lets keep it for a while */
 
             HDfprintf(stdout,
@@ -12599,22 +12653,22 @@ check_flush_cache__single_entry_test(H5F_t * file_ptr,
                 test_num);
             failure_mssg = msg;
         }
-        else if((((flush_flags & H5C__FLUSH_INVALIDATE_FLAG) == 0)
+        else if ( ( ( (flush_flags & H5C__FLUSH_INVALIDATE_FLAG) == 0)
                     &&
-                    ((cache_ptr->index_len != 1)
+                    ( ( cache_ptr->index_len != 1 )
                       ||
-                      (cache_ptr->index_size != entry_sizes[entry_type])
-                   )
-                 )
+                      ( cache_ptr->index_size != entry_sizes[entry_type] )
+                    )
+                  )
                   ||
-                  (((flush_flags & H5C__FLUSH_INVALIDATE_FLAG) != 0)
+                  ( ( (flush_flags & H5C__FLUSH_INVALIDATE_FLAG) != 0)
                     &&
-                    ((cache_ptr->index_len != 0)
+                    ( ( cache_ptr->index_len != 0 )
                       ||
-                      (cache_ptr->index_size != 0)
-                   )
-                 )
-               ) {
+                      ( cache_ptr->index_size != 0 )
+                    )
+                  )
+                ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128,
@@ -12628,18 +12682,18 @@ check_flush_cache__single_entry_test(H5F_t * file_ptr,
     /* clean up the cache to prep for the next test */
     if(pass) {
 
-        result = H5C_flush_cache(file_ptr, H5C__FLUSH_INVALIDATE_FLAG);
+        H5C_FLUSH_CACHE(file_ptr, H5C__FLUSH_INVALIDATE_FLAG, \
+                        "dummy failure mssg.")
 
-        if(result < 0) {
+        if ( ! pass ) { /* construct and set actual failure message */
 
-            pass = FALSE;
             HDsnprintf(msg, (size_t)128,
                        "Flush failed on cleanup in single entry test #%d.",
                        test_num);
             failure_mssg = msg;
         }
-        else if((cache_ptr->index_len != 0) ||
-                  (cache_ptr->index_size != 0)) {
+        else if ( ( cache_ptr->index_len != 0 ) ||
+                  ( cache_ptr->index_size != 0 ) ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128,
@@ -12663,22 +12717,27 @@ check_flush_cache__single_entry_test(H5F_t * file_ptr,
 /*-------------------------------------------------------------------------
  * Function:    check_flush_cache__pinned_single_entry_test()
  *
- * Purpose:    Run a pinned single entry flush cache test.
+ * Purpose:     Run a pinned single entry flush cache test.
  *
- * Return:    void
+ * Return:      void
  *
- * Programmer:    John Mainzer
+ * Programmer:  John Mainzer
  *              3/28/06
  *
  * Modifications:
  *
- *         JRM -- 5/17/06
- *         Added the pop_mark_dirty_prot and pop_mark_dirty_pinned
- *         flags and supporting code to allow us to test the
- *         H5C_mark_entry_dirty() call.  Use the
- *         call to mark the entry dirty while the entry is protected
- *         if pop_mark_dirty_prot is TRUE, and to mark the entry
- *         dirty while it is pinned if pop_mark_dirty_pinned is TRUE.
+ *              JRM -- 5/17/06
+ *              Added the pop_mark_dirty_prot and pop_mark_dirty_pinned
+ *              flags and supporting code to allow us to test the
+ *              H5C_mark_entry_dirty() call.  Use the
+ *              call to mark the entry dirty while the entry is protected
+ *              if pop_mark_dirty_prot is TRUE, and to mark the entry
+ *              dirty while it is pinned if pop_mark_dirty_pinned is TRUE.
+ *
+ *              JRM -- 5/14/20
+ *              Added code to setup and take down the skip list before
+ *              and after calls to H5C_flush_cache().  Do this via the
+ *              H5C_FLUSH_CACHE macro.
  *
  *-------------------------------------------------------------------------
  */
@@ -12689,10 +12748,10 @@ check_flush_cache__pinned_single_entry_test(H5F_t * file_ptr,
                                             int entry_type,
                                             int entry_idx,
                                             hbool_t unprot_dirty_flag,
-                        hbool_t mark_dirty,
-                        hbool_t pop_mark_dirty_prot,
-                        hbool_t pop_mark_dirty_pinned,
-                        hbool_t unprotect_unpin,
+                                            hbool_t mark_dirty,
+                                            hbool_t pop_mark_dirty_prot,
+                                            hbool_t pop_mark_dirty_pinned,
+                                            hbool_t unprotect_unpin,
                                             unsigned int flags,
                                             unsigned int flush_flags,
                                             hbool_t expected_serialized,
@@ -12701,7 +12760,6 @@ check_flush_cache__pinned_single_entry_test(H5F_t * file_ptr,
     H5C_t *       cache_ptr = file_ptr->shared->cache;
     static char    msg[128];
     hbool_t        expected_deserialized = TRUE;
-    herr_t       result;
     test_entry_t * base_addr;
     test_entry_t * entry_ptr = NULL;
 
@@ -12713,8 +12771,8 @@ check_flush_cache__pinned_single_entry_test(H5F_t * file_ptr,
                    test_num);
         failure_mssg = msg;
     }
-    else if((cache_ptr->index_len != 0) ||
-              (cache_ptr->index_size != 0)) {
+    else if ( ( cache_ptr->index_len != 0 ) ||
+              ( cache_ptr->index_size != 0 ) ) {
 
         pass = FALSE;
         HDsnprintf(msg, (size_t)128,
@@ -12722,7 +12780,7 @@ check_flush_cache__pinned_single_entry_test(H5F_t * file_ptr,
                test_num);
         failure_mssg = msg;
     }
-    else if((entry_type < 0) || (entry_type >= NUMBER_OF_ENTRY_TYPES) ||
+    else if ( (entry_type < 0) || (entry_type >= NUMBER_OF_ENTRY_TYPES) ||
               (entry_idx < 0) || (entry_idx > max_indices[entry_type])) {
 
         pass = FALSE;
@@ -12739,41 +12797,41 @@ check_flush_cache__pinned_single_entry_test(H5F_t * file_ptr,
 
         protect_entry(file_ptr, entry_type, entry_idx);
 
-    if(pop_mark_dirty_prot) {
+        if(pop_mark_dirty_prot) {
 
-        mark_entry_dirty(entry_type, entry_idx);
-    }
+            mark_entry_dirty(entry_type, entry_idx);
+        }
 
         unprotect_entry(file_ptr, entry_type, entry_idx,
                 (unprot_dirty_flag ? H5C__DIRTIED_FLAG : H5C__NO_FLAGS_SET) |
                 (flags | H5C__PIN_ENTRY_FLAG));
 
-    if(mark_dirty) {
+        if(mark_dirty) {
 
             mark_entry_dirty(entry_type, entry_idx);
-    }
+        }
 
-    if(pop_mark_dirty_pinned) {
+        if(pop_mark_dirty_pinned) {
 
-        mark_entry_dirty(entry_type, entry_idx);
-    }
+            mark_entry_dirty(entry_type, entry_idx);
+        }
     }
 
     if(pass) {
 
-        result = H5C_flush_cache(file_ptr, flush_flags);
+        H5C_FLUSH_CACHE(file_ptr, flush_flags, "dummy failure message\n")
 
-        if(result < 0) {
+        if ( ! pass ) { /* construct and set the correct failure message */
 
-            pass = FALSE;
             HDsnprintf(msg, (size_t)128,
                "flush with flags 0x%x failed in pinned single entry test #%d.",
-               flush_flags, test_num);
+                flush_flags, test_num);
             failure_mssg = msg;
         }
-        else if((entry_ptr->deserialized != expected_deserialized) ||
-                  (entry_ptr->serialized != expected_serialized) ||
-                  (entry_ptr->destroyed != expected_destroyed)) {
+        else if ( ( entry_ptr->deserialized != expected_deserialized ) ||
+                  ( entry_ptr->serialized != expected_serialized ) ||
+                  ( entry_ptr->destroyed != expected_destroyed ) ) {
+
 #if 0 /* this is useful debugging code -- keep it around */
             HDfprintf(stdout,
               "desrlzd = %d(%d), srlzd = %d(%d), dest = %d(%d)\n",
@@ -12790,22 +12848,22 @@ check_flush_cache__pinned_single_entry_test(H5F_t * file_ptr,
                 test_num);
             failure_mssg = msg;
         }
-        else if((((flush_flags & H5C__FLUSH_INVALIDATE_FLAG) == 0)
+        else if ( ( ( ( flush_flags & H5C__FLUSH_INVALIDATE_FLAG) == 0 )
                     &&
-                    ((cache_ptr->index_len != 1)
+                    ( ( cache_ptr->index_len != 1 )
                       ||
-                      (cache_ptr->index_size != entry_sizes[entry_type])
-                   )
-                 )
+                      ( cache_ptr->index_size != entry_sizes[entry_type] )
+                    )
+                  )
                   ||
-                  (((flush_flags & H5C__FLUSH_INVALIDATE_FLAG) != 0)
+                  ( ( ( flush_flags & H5C__FLUSH_INVALIDATE_FLAG) != 0 )
                     &&
-                    ((cache_ptr->index_len != 0)
+                    ( ( cache_ptr->index_len != 0 )
                       ||
-                      (cache_ptr->index_size != 0)
-                   )
-                 )
-               ) {
+                      ( cache_ptr->index_size != 0 )
+                    )
+                  )
+                ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128,
@@ -12836,18 +12894,17 @@ check_flush_cache__pinned_single_entry_test(H5F_t * file_ptr,
 
     if(pass) {
 
-        result = H5C_flush_cache(file_ptr, H5C__FLUSH_INVALIDATE_FLAG);
+        H5C_FLUSH_CACHE(file_ptr, H5C__FLUSH_INVALIDATE_FLAG, "dummy mssg\n")
 
-        if(result < 0) {
+        if ( ! pass ) {
 
-            pass = FALSE;
             HDsnprintf(msg, (size_t)128,
                     "Flush failed on cleanup in pinned single entry test #%d.",
                     test_num);
             failure_mssg = msg;
         }
-        else if((cache_ptr->index_len != 0) ||
-                  (cache_ptr->index_size != 0)) {
+        else if ( ( cache_ptr->index_len != 0 ) ||
+                  ( cache_ptr->index_size != 0 ) ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128,
@@ -14233,14 +14290,20 @@ check_pin_protected_entry(unsigned paged)
 /*-------------------------------------------------------------------------
  * Function:    check_resize_entry()
  *
- * Purpose:    Verify that H5C_resize_entry() and H5C_unprotect() resize
- *         entries as expected.
- *
- * Return:    void
+ * Purpose:     Verify that H5C_resize_entry() and H5C_unprotect() resize
+ *              entries as expected.
+ * 
+ * Return:      void
  *
- * Programmer:    John Mainzer
+ * Programmer:  John Mainzer
  *              7/7/06
  *
+ * Modifications:
+ *
+ *              Updated function to allow for disabling of the slist.
+ *
+ *                                             JRM -- 5/18/20
+ *
  *-------------------------------------------------------------------------
  */
 
@@ -14421,16 +14484,16 @@ check_resize_entry(unsigned paged)
 
     if(pass) {
 
-    if((cache_ptr->index_len != 1) ||
-        (cache_ptr->index_size != (LARGE_ENTRY_SIZE / 2)) ||
-        (cache_ptr->slist_len != 1) ||
-        (cache_ptr->slist_size != (LARGE_ENTRY_SIZE / 2))) {
+        if ( ( cache_ptr->index_len != 1 ) ||
+             ( cache_ptr->index_size != (LARGE_ENTRY_SIZE / 2) ) ||
+             ( ( cache_ptr->slist_enabled ) &&
+               ( ( cache_ptr->slist_len != 1 ) ||
+                 ( cache_ptr->slist_size != (LARGE_ENTRY_SIZE / 2) ) ) ) ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128, "Unexpected cache status 3.");
             failure_mssg = msg;
-
-    }
+        }
     }
 
     if(pass) {
@@ -14506,16 +14569,16 @@ check_resize_entry(unsigned paged)
 
     if(pass) {
 
-    if((cache_ptr->index_len != 1) ||
-        (cache_ptr->index_size != LARGE_ENTRY_SIZE) ||
-        (cache_ptr->slist_len != 1) ||
-        (cache_ptr->slist_size != LARGE_ENTRY_SIZE)) {
+        if ( ( cache_ptr->index_len != 1 ) ||
+             ( cache_ptr->index_size != LARGE_ENTRY_SIZE ) ||
+             ( ( cache_ptr->slist_enabled ) &&
+               ( ( cache_ptr->slist_len != 1 ) ||
+                 ( cache_ptr->slist_size != LARGE_ENTRY_SIZE ) ) ) ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128, "Unexpected cache status 4.");
             failure_mssg = msg;
-
-    }
+        }
     }
 
     if(pass) {
@@ -14574,16 +14637,17 @@ check_resize_entry(unsigned paged)
 
     if(pass) {
 
-    if((cache_ptr->index_len != 1) ||
-        (cache_ptr->index_size != (LARGE_ENTRY_SIZE / 4)) ||
-        (cache_ptr->slist_len != 1) ||
-        (cache_ptr->slist_size != (LARGE_ENTRY_SIZE / 4))) {
+        if ( ( cache_ptr->index_len != 1 ) ||
+             ( cache_ptr->index_size != (LARGE_ENTRY_SIZE / 4) ) ||
+             ( ( cache_ptr->slist_enabled ) &&
+               ( ( cache_ptr->slist_len != 1 ) ||
+                 ( cache_ptr->slist_size != (LARGE_ENTRY_SIZE / 4) ) ) ) ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128, "Unexpected cache status 5.");
             failure_mssg = msg;
 
-    }
+        }
     }
 
     if(pass) {
@@ -14634,16 +14698,17 @@ check_resize_entry(unsigned paged)
 
     if(pass) {
 
-    if((cache_ptr->index_len != 1) ||
-        (cache_ptr->index_size != LARGE_ENTRY_SIZE) ||
-        (cache_ptr->slist_len != 1) ||
-        (cache_ptr->slist_size != LARGE_ENTRY_SIZE)) {
+        if ( ( cache_ptr->index_len != 1 ) ||
+             ( cache_ptr->index_size != LARGE_ENTRY_SIZE ) ||
+             ( ( cache_ptr->slist_enabled ) &&
+               ( ( cache_ptr->slist_len != 1 ) ||
+                 ( cache_ptr->slist_size != LARGE_ENTRY_SIZE) ) ) ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128, "Unexpected cache status 6.");
             failure_mssg = msg;
 
-    }
+        }
     }
 
     if(pass) {
@@ -14719,16 +14784,16 @@ check_resize_entry(unsigned paged)
 
     if(pass) {
 
-    if((cache_ptr->index_len != 0) ||
-        (cache_ptr->index_size != 0) ||
-        (cache_ptr->slist_len != 0) ||
-        (cache_ptr->slist_size != 0)) {
+        if ( ( cache_ptr->index_len != 0 ) ||
+             ( cache_ptr->index_size != 0 ) ||
+             ( ( cache_ptr->slist_enabled ) &&
+               ( ( cache_ptr->slist_len != 0 ) ||
+                 ( cache_ptr->slist_size != 0) ) ) ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128, "Unexpected cache status 7.");
             failure_mssg = msg;
-
-    }
+        }
     }
 
 
@@ -14736,19 +14801,20 @@ check_resize_entry(unsigned paged)
 
     if(pass) {
 
-    if((cache_ptr->index_len != 0) ||
-        (cache_ptr->index_size != 0) ||
-        (cache_ptr->slist_len != 0) ||
-        (cache_ptr->slist_size != 0)) {
+        if ( ( cache_ptr->index_len != 0 ) ||
+             ( cache_ptr->index_size != 0 ) ||
+             ( ( cache_ptr->slist_enabled ) &&
+               ( ( cache_ptr->slist_len != 0 ) ||
+                 ( cache_ptr->slist_size != 0) ) ) ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128, "Unexpected cache status 8.");
             failure_mssg = msg;
+        }
 
-    }
         base_addr = entries[LARGE_ENTRY_TYPE];
         entry_ptr = &(base_addr[3]);
-    entry_size = LARGE_ENTRY_SIZE;
+        entry_size = LARGE_ENTRY_SIZE;
     }
 
     if(pass) {
@@ -14766,17 +14832,17 @@ check_resize_entry(unsigned paged)
 
     if(pass) {
 
-    if((cache_ptr->index_len != 3) ||
-        (cache_ptr->index_size != 3 * LARGE_ENTRY_SIZE) ||
-        (cache_ptr->slist_len != 1) ||
-        (cache_ptr->slist_size != LARGE_ENTRY_SIZE)) {
-
+    if ( ( cache_ptr->index_len != 3 ) ||
+         ( cache_ptr->index_size != 3 * LARGE_ENTRY_SIZE ) ||
+         ( ( cache_ptr->slist_enabled ) &&
+           ( ( cache_ptr->slist_len != 1 ) ||
+             ( cache_ptr->slist_size != LARGE_ENTRY_SIZE) ) ) ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128, "Unexpected cache status 9.");
             failure_mssg = msg;
 
-    }
+        }
     }
 
     if(pass) {
@@ -14787,10 +14853,11 @@ check_resize_entry(unsigned paged)
 
     if(pass) {
 
-    if((cache_ptr->index_len != 4) ||
-        (cache_ptr->index_size != 4 * LARGE_ENTRY_SIZE) ||
-        (cache_ptr->slist_len != 1) ||
-        (cache_ptr->slist_size != LARGE_ENTRY_SIZE)) {
+        if ( ( cache_ptr->index_len != 4 ) ||
+             ( cache_ptr->index_size != 4 * LARGE_ENTRY_SIZE ) ||
+             ( ( cache_ptr->slist_enabled ) &&
+               ( ( cache_ptr->slist_len != 1) ||
+                 ( cache_ptr->slist_size != LARGE_ENTRY_SIZE) ) ) ) {
 
 
             pass = FALSE;
@@ -14866,18 +14933,18 @@ check_resize_entry(unsigned paged)
 
     if(pass) {
 
-    if((cache_ptr->index_len != 4) ||
-        (cache_ptr->index_size !=
-        ((3 * LARGE_ENTRY_SIZE) + (LARGE_ENTRY_SIZE / 2))) ||
-        (cache_ptr->slist_len != 2) ||
-        (cache_ptr->slist_size !=
-        (LARGE_ENTRY_SIZE + (LARGE_ENTRY_SIZE / 2)))) {
+        if ( ( cache_ptr->index_len != 4 ) ||
+             ( cache_ptr->index_size !=
+               ((3 * LARGE_ENTRY_SIZE) + (LARGE_ENTRY_SIZE / 2)) ) ||
+             ( ( cache_ptr->slist_enabled ) &&
+               ( ( cache_ptr->slist_len != 2 ) ||
+                 ( cache_ptr->slist_size !=
+                   (LARGE_ENTRY_SIZE + (LARGE_ENTRY_SIZE / 2)) ) ) ) ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128, "Unexpected cache status 11.");
             failure_mssg = msg;
-
-    }
+        }
     }
 
     if(pass) {
@@ -14953,16 +15020,16 @@ check_resize_entry(unsigned paged)
 
     if(pass) {
 
-    if((cache_ptr->index_len != 4) ||
-        (cache_ptr->index_size != 4 * LARGE_ENTRY_SIZE) ||
-        (cache_ptr->slist_len != 2) ||
-        (cache_ptr->slist_size != 2 * LARGE_ENTRY_SIZE)) {
+        if ( ( cache_ptr->index_len != 4 ) ||
+             ( cache_ptr->index_size != 4 * LARGE_ENTRY_SIZE ) ||
+             ( ( cache_ptr->slist_enabled ) &&
+               ( ( cache_ptr->slist_len != 2 ) ||
+                 ( cache_ptr->slist_size != 2 * LARGE_ENTRY_SIZE ) ) ) ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128, "Unexpected cache status 12.");
             failure_mssg = msg;
-
-    }
+        }
     }
 
     if(pass) {
@@ -15021,18 +15088,18 @@ check_resize_entry(unsigned paged)
 
     if(pass) {
 
-    if((cache_ptr->index_len != 4) ||
-        (cache_ptr->index_size !=
-        ((3 * LARGE_ENTRY_SIZE) + (LARGE_ENTRY_SIZE / 4))) ||
-        (cache_ptr->slist_len != 2) ||
-        (cache_ptr->slist_size !=
-        (LARGE_ENTRY_SIZE + (LARGE_ENTRY_SIZE / 4)))) {
+        if ( ( cache_ptr->index_len != 4 ) ||
+             ( cache_ptr->index_size !=
+               ((3 * LARGE_ENTRY_SIZE) + (LARGE_ENTRY_SIZE / 4)) ) ||
+             ( ( cache_ptr->slist_enabled ) &&
+               ( ( cache_ptr->slist_len != 2 ) ||
+                 ( cache_ptr->slist_size !=
+                   (LARGE_ENTRY_SIZE + (LARGE_ENTRY_SIZE / 4)) ) ) ) ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128, "Unexpected cache status 13.");
             failure_mssg = msg;
-
-    }
+        }
     }
 
     if(pass) {
@@ -15083,16 +15150,16 @@ check_resize_entry(unsigned paged)
 
     if(pass) {
 
-    if((cache_ptr->index_len != 4) ||
-        (cache_ptr->index_size != (4 * LARGE_ENTRY_SIZE)) ||
-        (cache_ptr->slist_len != 2) ||
-        (cache_ptr->slist_size != (2 * LARGE_ENTRY_SIZE))) {
+        if ( ( cache_ptr->index_len != 4 ) ||
+             ( cache_ptr->index_size != (4 * LARGE_ENTRY_SIZE) ) ||
+             ( ( cache_ptr->slist_enabled ) &&
+               ( ( cache_ptr->slist_len != 2 ) ||
+                 ( cache_ptr->slist_size != (2 * LARGE_ENTRY_SIZE)) ) ) ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128, "Unexpected cache status 14.");
             failure_mssg = msg;
-
-    }
+        }
     }
 
     if(pass) {
@@ -15168,16 +15235,16 @@ check_resize_entry(unsigned paged)
 
     if(pass) {
 
-    if((cache_ptr->index_len != 3) ||
-        (cache_ptr->index_size != (3 * LARGE_ENTRY_SIZE)) ||
-        (cache_ptr->slist_len != 1) ||
-        (cache_ptr->slist_size != LARGE_ENTRY_SIZE)) {
+        if ( ( cache_ptr->index_len != 3 ) ||
+             ( cache_ptr->index_size != (3 * LARGE_ENTRY_SIZE) ) ||
+             ( ( cache_ptr->slist_enabled ) &&
+               ( ( cache_ptr->slist_len != 1 ) ||
+                 ( cache_ptr->slist_size != LARGE_ENTRY_SIZE) ) ) ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128, "Unexpected cache status 15.");
             failure_mssg = msg;
-
-    }
+        }
     }
 
     if(pass) {
@@ -15195,16 +15262,16 @@ check_resize_entry(unsigned paged)
 
     if(pass) {
 
-    if((cache_ptr->index_len != 0) ||
-        (cache_ptr->index_size != 0) ||
-        (cache_ptr->slist_len != 0) ||
-        (cache_ptr->slist_size != 0)) {
+        if ( ( cache_ptr->index_len != 0 ) ||
+             ( cache_ptr->index_size != 0 ) ||
+             ( ( cache_ptr->slist_enabled ) &&
+               ( ( cache_ptr->slist_len != 0 ) ||
+                 ( cache_ptr->slist_size != 0 ) ) ) ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128, "Unexpected cache status 16.");
             failure_mssg = msg;
-
-    }
+        }
     }
 
     if(pass) {
@@ -15228,16 +15295,19 @@ check_resize_entry(unsigned paged)
 /*-------------------------------------------------------------------------
  * Function:    check_evictions_enabled()
  *
- * Purpose:    Verify that H5C_get_evictions_enabled() and
- *         H5C_set_evictions_enabled() functions perform as expected.
+ * Purpose:     Verify that H5C_get_evictions_enabled() and
+ *              H5C_set_evictions_enabled() functions perform as expected.
  *
- * Return:    void
+ * Return:      void
  *
- * Programmer:    John Mainzer
+ * Programmer:  John Mainzer
  *              8/2/07
  *
  * Modifications:
  *
+ *              Updated function to allow for disabling of the slist.
+ *
+ *                                             JRM -- 5/18/20
  *
  *-------------------------------------------------------------------------
  */
@@ -15331,17 +15401,17 @@ check_evictions_enabled(unsigned paged)
     /* verify that it is empty */
     if(pass) {
 
-    if((cache_ptr->index_len != 0) ||
-        (cache_ptr->index_size != 0) ||
-        (cache_ptr->slist_len != 0) ||
-        (cache_ptr->slist_size != 0) ||
-        (cache_ptr->evictions_enabled != TRUE)) {
+        if ( ( cache_ptr->index_len != 0 ) ||
+             ( cache_ptr->index_size != 0 ) ||
+             ( ( cache_ptr->slist_enabled ) &&
+               ( ( cache_ptr->slist_len != 0 ) ||
+                 ( cache_ptr->slist_size != 0 ) ) ) ||
+             ( cache_ptr->evictions_enabled != TRUE ) ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128, "Unexpected cache status 1.");
             failure_mssg = msg;
-
-    }
+        }
     }
 
     if(show_progress) /* 3 */
@@ -15383,18 +15453,17 @@ check_evictions_enabled(unsigned paged)
     /* verify that the cache is full */
     if(pass) {
 
-    if((cache_ptr->index_len != 16) ||
-        (cache_ptr->index_size != 16 * MONSTER_ENTRY_SIZE) ||
-        (cache_ptr->slist_len != 0) ||
-        (cache_ptr->slist_size != 0) ||
-        (cache_ptr->evictions_enabled != TRUE)) {
-
+        if ( ( cache_ptr->index_len != 16 ) ||
+             ( cache_ptr->index_size != 16 * MONSTER_ENTRY_SIZE ) ||
+             ( ( cache_ptr->slist_enabled ) &&
+               ( ( cache_ptr->slist_len != 0 ) ||
+                 ( cache_ptr->slist_size != 0 ) ) ) ||
+             ( cache_ptr->evictions_enabled != TRUE ) ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128, "Unexpected cache status 2.");
             failure_mssg = msg;
-
-    }
+        }
     }
 
     if(show_progress) /* 6 */
@@ -15416,17 +15485,17 @@ check_evictions_enabled(unsigned paged)
     /* verify that an entry has been evicted */
     if(pass) {
 
-    if((cache_ptr->index_len != 16) ||
-        (cache_ptr->index_size != 16 * MONSTER_ENTRY_SIZE) ||
-        (cache_ptr->slist_len != 0) ||
-        (cache_ptr->slist_size != 0) ||
-        (cache_ptr->evictions_enabled != TRUE)) {
+        if ( ( cache_ptr->index_len != 16 ) ||
+             ( cache_ptr->index_size != 16 * MONSTER_ENTRY_SIZE ) ||
+             ( ( cache_ptr->slist_enabled ) &&
+               ( ( cache_ptr->slist_len != 0 ) ||
+                 ( cache_ptr->slist_size != 0 ) ) ) ||
+             ( cache_ptr->evictions_enabled != TRUE ) ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128, "Unexpected cache status 3.");
             failure_mssg = msg;
-
-    }
+        }
     }
 
     if(show_progress) /* 8 */
@@ -15483,17 +15552,17 @@ check_evictions_enabled(unsigned paged)
     /* verify that another entry has been evicted */
     if(pass) {
 
-    if((cache_ptr->index_len != 16) ||
-        (cache_ptr->index_size != 16 * MONSTER_ENTRY_SIZE) ||
-        (cache_ptr->slist_len != 1) ||
-        (cache_ptr->slist_size != MONSTER_ENTRY_SIZE) ||
-        (cache_ptr->evictions_enabled != TRUE)) {
+        if ( ( cache_ptr->index_len != 16 ) ||
+             ( cache_ptr->index_size != 16 * MONSTER_ENTRY_SIZE ) ||
+             ( ( cache_ptr->slist_enabled ) &&
+               ( ( cache_ptr->slist_len != 1 ) ||
+                 ( cache_ptr->slist_size != MONSTER_ENTRY_SIZE ) ) ) ||
+             ( cache_ptr->evictions_enabled != TRUE ) ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128, "Unexpected cache status 4.");
             failure_mssg = msg;
-
-    }
+        }
     }
 
     if(show_progress) /* 11 */
@@ -15555,17 +15624,17 @@ check_evictions_enabled(unsigned paged)
     /* verify that evictions are disabled */
     if(pass) {
 
-    if((cache_ptr->index_len != 16) ||
-        (cache_ptr->index_size != 16 * MONSTER_ENTRY_SIZE) ||
-        (cache_ptr->slist_len != 1) ||
-        (cache_ptr->slist_size != MONSTER_ENTRY_SIZE) ||
-        (cache_ptr->evictions_enabled != FALSE)) {
+        if ( ( cache_ptr->index_len != 16 ) ||
+             ( cache_ptr->index_size != 16 * MONSTER_ENTRY_SIZE ) ||
+             ( ( cache_ptr->slist_enabled ) &&
+               ( ( cache_ptr->slist_len != 1 ) ||
+                 ( cache_ptr->slist_size != MONSTER_ENTRY_SIZE ) ) ) ||
+             ( cache_ptr->evictions_enabled != FALSE ) ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128, "Unexpected cache status 5.");
             failure_mssg = msg;
-
-    }
+        }
     }
 
     if(show_progress) /* 14 */
@@ -15587,17 +15656,17 @@ check_evictions_enabled(unsigned paged)
     /* verify that no entry has been evicted */
     if(pass) {
 
-    if((cache_ptr->index_len != 17) ||
-        (cache_ptr->index_size != 17 * MONSTER_ENTRY_SIZE) ||
-        (cache_ptr->slist_len != 1) ||
-        (cache_ptr->slist_size != MONSTER_ENTRY_SIZE) ||
-        (cache_ptr->evictions_enabled != FALSE)) {
+        if ( ( cache_ptr->index_len != 17 ) ||
+             ( cache_ptr->index_size != 17 * MONSTER_ENTRY_SIZE ) ||
+             ( ( cache_ptr->slist_enabled ) &&
+               ( ( cache_ptr->slist_len != 1 ) ||
+                 ( cache_ptr->slist_size != MONSTER_ENTRY_SIZE ) ) ) ||
+             ( cache_ptr->evictions_enabled != FALSE ) ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128, "Unexpected cache status 6.");
             failure_mssg = msg;
-
-    }
+        }
     }
 
     if(show_progress) /* 16 */
@@ -15618,17 +15687,17 @@ check_evictions_enabled(unsigned paged)
     /* verify that no entry has been evicted */
     if(pass) {
 
-    if((cache_ptr->index_len != 18) ||
-        (cache_ptr->index_size != 18 * MONSTER_ENTRY_SIZE) ||
-        (cache_ptr->slist_len != 2) ||
-        (cache_ptr->slist_size != 2 * MONSTER_ENTRY_SIZE) ||
-        (cache_ptr->evictions_enabled != FALSE)) {
+        if ( ( cache_ptr->index_len != 18 ) ||
+             ( cache_ptr->index_size != 18 * MONSTER_ENTRY_SIZE ) ||
+             ( ( cache_ptr->slist_enabled ) &&
+               ( ( cache_ptr->slist_len != 2 ) ||
+                 ( cache_ptr->slist_size != 2 * MONSTER_ENTRY_SIZE ) ) ) ||
+             ( cache_ptr->evictions_enabled != FALSE ) ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128, "Unexpected cache status 7.");
             failure_mssg = msg;
-
-    }
+        }
     }
 
     if(show_progress) /* 18 */
@@ -15667,17 +15736,17 @@ check_evictions_enabled(unsigned paged)
     /* verify that no entries have been evicted */
     if(pass) {
 
-    if((cache_ptr->index_len != 18) ||
-        (cache_ptr->index_size != 18 * MONSTER_ENTRY_SIZE) ||
-        (cache_ptr->slist_len != 2) ||
-        (cache_ptr->slist_size != 2 * MONSTER_ENTRY_SIZE) ||
-        (cache_ptr->evictions_enabled != TRUE)) {
+        if ( ( cache_ptr->index_len != 18 ) ||
+             ( cache_ptr->index_size != 18 * MONSTER_ENTRY_SIZE ) ||
+             ( ( cache_ptr->slist_enabled ) &&
+               ( ( cache_ptr->slist_len != 2 ) ||
+                 ( cache_ptr->slist_size != 2 * MONSTER_ENTRY_SIZE ) ) ) ||
+             ( cache_ptr->evictions_enabled != TRUE ) ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128, "Unexpected cache status 8.");
             failure_mssg = msg;
-
-    }
+        }
     }
 
     if(show_progress) /* 21 */
@@ -15702,17 +15771,17 @@ check_evictions_enabled(unsigned paged)
 
     if(pass) {
 
-    if((cache_ptr->index_len != 16) ||
-        (cache_ptr->index_size != 16 * MONSTER_ENTRY_SIZE) ||
-        (cache_ptr->slist_len != 2) ||
-        (cache_ptr->slist_size != 2 * MONSTER_ENTRY_SIZE) ||
-        (cache_ptr->evictions_enabled != TRUE)) {
+        if ( ( cache_ptr->index_len != 16 ) ||
+             ( cache_ptr->index_size != 16 * MONSTER_ENTRY_SIZE ) ||
+             ( ( cache_ptr->slist_enabled ) &&
+               ( ( cache_ptr->slist_len != 2 ) ||
+                 ( cache_ptr->slist_size != 2 * MONSTER_ENTRY_SIZE ) ) ) ||
+             ( cache_ptr->evictions_enabled != TRUE ) ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128, "Unexpected cache status 9.");
             failure_mssg = msg;
-
-    }
+        }
     }
 
     if(show_progress) /* 23 */
@@ -15823,17 +15892,17 @@ check_evictions_enabled(unsigned paged)
     /* verify that the cache has grown */
     if(pass) {
 
-    if((cache_ptr->index_len != 17) ||
-        (cache_ptr->index_size != 17 * MONSTER_ENTRY_SIZE) ||
-        (cache_ptr->slist_len != 2) ||
-        (cache_ptr->slist_size != 2 * MONSTER_ENTRY_SIZE) ||
-        (cache_ptr->evictions_enabled != FALSE)) {
+        if ( ( cache_ptr->index_len != 17 ) ||
+             ( cache_ptr->index_size != 17 * MONSTER_ENTRY_SIZE ) ||
+             ( ( cache_ptr->slist_enabled ) &&
+               ( ( cache_ptr->slist_len != 2 ) ||
+                 ( cache_ptr->slist_size != 2 * MONSTER_ENTRY_SIZE ) ) ) ||
+             ( cache_ptr->evictions_enabled != FALSE ) ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128, "Unexpected cache status 10.");
             failure_mssg = msg;
-
-    }
+        }
     }
 
     if(show_progress) /* 28 */
@@ -15871,17 +15940,17 @@ check_evictions_enabled(unsigned paged)
     /* verify that the cache has returned to its maximum size */
     if(pass) {
 
-    if((cache_ptr->index_len != 16) ||
-        (cache_ptr->index_size != 16 * MONSTER_ENTRY_SIZE) ||
-        (cache_ptr->slist_len != 3) ||
-        (cache_ptr->slist_size != 3 * MONSTER_ENTRY_SIZE) ||
-        (cache_ptr->evictions_enabled != TRUE)) {
+        if ( ( cache_ptr->index_len != 16 ) ||
+             ( cache_ptr->index_size != 16 * MONSTER_ENTRY_SIZE ) ||
+             ( ( cache_ptr->slist_enabled ) &&
+               ( ( cache_ptr->slist_len != 3 ) ||
+                 ( cache_ptr->slist_size != 3 * MONSTER_ENTRY_SIZE ) ) ) ||
+             ( cache_ptr->evictions_enabled != TRUE ) ) {
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128, "Unexpected cache status 11.");
             failure_mssg = msg;
-
-    }
+        }
     }
 
     if(show_progress) /* 31 */
@@ -15964,17 +16033,22 @@ check_evictions_enabled(unsigned paged)
 
 /*-------------------------------------------------------------------------
  * Function:    check_flush_protected_err()
+ *              
+ * Purpose:     Verify that an attempt to flush the cache when it contains
+ *              a protected entry will generate an error.
  *
- * Purpose:    Verify that an attempt to flush the cache when it contains
- *        a protected entry will generate an error.
- *
- * Return:    void
+ * Return:      void
  *
- * Programmer:    John Mainzer
+ * Programmer:  John Mainzer
  *              6/24/04
  *
  * Modifications:
  *
+ *              Added code to setup and take down the skip list before
+ *              and after calls to H5C_flush_cache().  
+ *
+ *                                          JRM -- 5/14/20
+ *
  *-------------------------------------------------------------------------
  */
 
@@ -15982,6 +16056,7 @@ static unsigned
 check_flush_protected_err(unsigned paged)
 {
     H5F_t * file_ptr = NULL;
+    H5C_t * cache_ptr = NULL;
 
     if(paged)
         TESTING("flush cache with protected entry error (paged aggregation)")
@@ -16001,27 +16076,45 @@ check_flush_protected_err(unsigned paged)
 
         file_ptr = setup_cache((size_t)(2 * 1024), (size_t)(1 * 1024), paged);
 
+        if ( pass ) {
+
+            cache_ptr = file_ptr->shared->cache;
+        }
+
         protect_entry(file_ptr, 0, 0);
 
-        if(H5C_flush_cache(file_ptr, H5C__NO_FLAGS_SET) >= 0) {
+        /* enable slist prior to flush */
+        if ( ( pass ) &&
+             ( H5C_set_slist_enabled(cache_ptr, TRUE, FALSE) < 0 ) ) {
 
             pass = FALSE;
-            failure_mssg = "flush succeeded on cache with protected entry.\n";
+            failure_mssg = "unable to enable slist prior to flush.\n";
+        }
 
-        } else {
+        if ( ( pass ) &&
+             ( H5C_flush_cache(file_ptr, H5C__NO_FLAGS_SET) >= 0 ) ) {
 
-            unprotect_entry(file_ptr, 0, 0, H5C__DIRTIED_FLAG);
+            pass = FALSE;
+            failure_mssg = "flush succeeded on cache with protected entry.\n";
+        }
 
-            if(H5C_flush_cache(file_ptr, H5C__NO_FLAGS_SET) < 0) {
+        /* disable the slist after the flush */
+        if ( ( pass ) &&
+             ( H5C_set_slist_enabled(cache_ptr, FALSE, FALSE) < 0 ) ) {
 
-                pass = FALSE;
-                failure_mssg = "flush failed after unprotect.\n";
+            pass = FALSE;
+            failure_mssg = "unable to disable slist after  flush.\n";
+        }
 
-            } else {
+        unprotect_entry(file_ptr, 0, 0, H5C__DIRTIED_FLAG);
 
-                takedown_cache(file_ptr, FALSE, FALSE);
-            }
+        if ( pass ) {
+
+            H5C_FLUSH_CACHE(file_ptr, H5C__NO_FLAGS_SET, \
+                            "flush failed after unprotect.\n")
         }
+
+        takedown_cache(file_ptr, FALSE, FALSE);
     }
 
     if(pass) { PASSED(); } else { H5_FAILED(); }
@@ -17075,12 +17168,12 @@ check_move_entry_errs(unsigned paged)
 /*-------------------------------------------------------------------------
  * Function:    check_resize_entry_errs()
  *
- * Purpose:    Verify that invalid calls to H5C_resize_entry()
- *         generates errors as expected.
+ * Purpose:     Verify that invalid calls to H5C_resize_entry()
+ *              generates errors as expected.
  *
- * Return:    void
+ * Return:      void
  *
- * Programmer:    John Mainzer
+ * Programmer:  John Mainzer
  *              7/7/06
  *
  *-------------------------------------------------------------------------
@@ -17135,9 +17228,9 @@ check_resize_entry_errs(unsigned paged)
 
         } else {
 
-        unprotect_entry(file_ptr, 0, 0, H5C__PIN_ENTRY_FLAG);
+            unprotect_entry(file_ptr, 0, 0, H5C__PIN_ENTRY_FLAG);
 
-    }
+        }
     }
 
     if(pass) {
@@ -17152,9 +17245,9 @@ check_resize_entry_errs(unsigned paged)
 
         } else {
 
-        unpin_entry(0, 0);
+            unpin_entry(0, 0);
 
-    }
+        }
     }
 
     if(pass) {
@@ -30951,13 +31044,21 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    check_flush_deps_order()
  *
- * Purpose:    Verify that the order that entries with flush dependencies
+ * Purpose:     Verify that the order that entries with flush dependencies
  *              is correct
  *
- * Return:    0 on success, non-zero on failure
+ * Return:      0 on success, non-zero on failure
+ *  
+ * Programmer:  Quincey Koziol
+ *              3/17/09
  *
- * Programmer:    Quincey Koziol
- *               3/17/09
+ * Modifications: 
+ *
+ *              Added code to setup and take down the skip list before
+ *              and after calls to H5C_flush_cache().  Do this via the
+ *              H5C_FLUSH_CACHE macro.
+ *
+ *                                          JRM -- 5/14/20
  *
  *-------------------------------------------------------------------------
  */
@@ -31048,8 +31149,6 @@ check_flush_deps_order(unsigned paged)
 
     /* Flush the cache and verify that the entries were flushed in correct order */
     {
-        herr_t result;                  /* Generic return value */
-
         add_flush_op(entry_type, 0, FLUSH_OP__ORDER,
                      entry_type, 0, FALSE, (size_t)0, &flush_order);
         add_flush_op(entry_type, 1, FLUSH_OP__ORDER,
@@ -31064,8 +31163,8 @@ check_flush_deps_order(unsigned paged)
         /* Reset index for tracking flush order */
         flush_order = 0;
 
-        result = H5C_flush_cache(file_ptr, H5C__NO_FLAGS_SET);
-        if(result < 0) CACHE_ERROR("flushing entries with flush dependendices")
+        H5C_FLUSH_CACHE(file_ptr, H5C__NO_FLAGS_SET, "dummy mssg")
+        if(!pass) CACHE_ERROR("flushing entries with flush dependendices")
 
         /* Change expected values, and verify the status of the entries
          * after destroy flush dependency
@@ -31143,8 +31242,6 @@ check_flush_deps_order(unsigned paged)
 
     /* Flush the cache and verify that the entries were flushed in correct order */
     {
-        herr_t result;                  /* Generic return value */
-
         add_flush_op(entry_type, 0, FLUSH_OP__ORDER,
                      entry_type, 0, FALSE, (size_t)0, &flush_order);
         add_flush_op(entry_type, 1, FLUSH_OP__ORDER,
@@ -31170,8 +31267,8 @@ check_flush_deps_order(unsigned paged)
         /* Reset index for tracking flush order */
         flush_order = 0;
 
-        result = H5C_flush_cache(file_ptr, H5C__NO_FLAGS_SET);
-        if(result < 0) CACHE_ERROR("flushing entries with flush dependendices")
+        H5C_FLUSH_CACHE(file_ptr, H5C__NO_FLAGS_SET, "dummy mssg")
+        if(!pass) CACHE_ERROR("flushing entries with flush dependendices")
 
         /* Change expected values, and verify the status of the entries
          * after destroy flush dependency
@@ -31250,8 +31347,6 @@ check_flush_deps_order(unsigned paged)
 
     /* Flush the cache and verify that the entries were flushed in correct order */
     {
-        herr_t result;                  /* Generic return value */
-
         add_flush_op(entry_type, 0, FLUSH_OP__ORDER,
                      entry_type, 0, FALSE, (size_t)0, &flush_order);
         add_flush_op(entry_type, 1, FLUSH_OP__ORDER,
@@ -31282,8 +31377,8 @@ check_flush_deps_order(unsigned paged)
         /* Reset index for tracking flush order */
         flush_order = 0;
 
-        result = H5C_flush_cache(file_ptr, H5C__NO_FLAGS_SET);
-        if(result < 0) CACHE_ERROR("flushing entries with flush dependendices")
+        H5C_FLUSH_CACHE(file_ptr, H5C__NO_FLAGS_SET, "dummy mssg")
+        if(!pass) CACHE_ERROR("flushing entries with flush dependendices")
 
         /* Change expected values, and verify the status of the entries
          * after destroy flush dependency
@@ -31369,8 +31464,6 @@ check_flush_deps_order(unsigned paged)
 
     /* Flush the cache and verify that the entries were flushed in correct order */
     {
-        herr_t result;                  /* Generic return value */
-
         add_flush_op(entry_type, 0, FLUSH_OP__ORDER,
                      entry_type, 0, FALSE, (size_t)0, &flush_order);
         add_flush_op(entry_type, 1, FLUSH_OP__ORDER,
@@ -31401,8 +31494,8 @@ check_flush_deps_order(unsigned paged)
         /* Reset index for tracking flush order */
         flush_order = 0;
 
-        result = H5C_flush_cache(file_ptr, H5C__NO_FLAGS_SET);
-        if(result < 0) CACHE_ERROR("flushing entries with flush dependendices")
+        H5C_FLUSH_CACHE(file_ptr, H5C__NO_FLAGS_SET, "dummy mssg")
+        if(!pass) CACHE_ERROR("flushing entries with flush dependendices")
 
         /* Change expected values, and verify the status of the entries
          * after destroy flush dependency
@@ -31528,8 +31621,6 @@ check_flush_deps_order(unsigned paged)
 
     /* Flush the cache and verify that the entries were flushed in correct order */
     {
-        herr_t result;                  /* Generic return value */
-
         add_flush_op(entry_type, 0, FLUSH_OP__ORDER,
                      entry_type, 0, FALSE, (size_t)0, &flush_order);
         add_flush_op(entry_type, 1, FLUSH_OP__ORDER,
@@ -31577,8 +31668,8 @@ check_flush_deps_order(unsigned paged)
         /* Reset index for tracking flush order */
         flush_order = 0;
 
-        result = H5C_flush_cache(file_ptr, H5C__NO_FLAGS_SET);
-        if(result < 0) CACHE_ERROR("flushing entries with flush dependendices")
+        H5C_FLUSH_CACHE(file_ptr, H5C__NO_FLAGS_SET, "dummy mssg")
+        if(!pass) CACHE_ERROR("flushing entries with flush dependendices")
 
         /* Change expected values, and verify the status of the entries
          * after destroy flush dependency
@@ -31738,8 +31829,6 @@ check_flush_deps_order(unsigned paged)
 
     /* Flush the cache and verify that the entries were flushed in correct order */
     {
-        herr_t result;                  /* Generic return value */
-
         add_flush_op(entry_type, 0, FLUSH_OP__ORDER,
                      entry_type, 0, FALSE, (size_t)0, &flush_order);
         add_flush_op(entry_type, 1, FLUSH_OP__ORDER,
@@ -31787,8 +31876,8 @@ check_flush_deps_order(unsigned paged)
         /* Reset index for tracking flush order */
         flush_order = 0;
 
-        result = H5C_flush_cache(file_ptr, H5C__NO_FLAGS_SET);
-        if(result < 0) CACHE_ERROR("flushing entries with flush dependendices")
+        H5C_FLUSH_CACHE(file_ptr, H5C__NO_FLAGS_SET, "dummy mssg")
+        if(!pass) CACHE_ERROR("flushing entries with flush dependendices")
 
         /* Change expected values, and verify the status of the entries
          * after destroy flush dependency
@@ -31903,8 +31992,6 @@ check_flush_deps_order(unsigned paged)
 
     /* Flush the cache and verify that the entries were flushed in correct order */
     {
-        herr_t result;                  /* Generic return value */
-
         add_flush_op(entry_type, 0, FLUSH_OP__ORDER,
                      entry_type, 0, FALSE, (size_t)0, &flush_order);
         add_flush_op(entry_type, 1, FLUSH_OP__ORDER,
@@ -31945,8 +32032,8 @@ check_flush_deps_order(unsigned paged)
         /* Reset index for tracking flush order */
         flush_order = 0;
 
-        result = H5C_flush_cache(file_ptr, H5C__NO_FLAGS_SET);
-        if(result < 0) CACHE_ERROR("flushing entries with flush dependendices")
+        H5C_FLUSH_CACHE(file_ptr, H5C__NO_FLAGS_SET, "dummy mssg")
+        if(!pass) CACHE_ERROR("flushing entries with flush dependendices")
 
         /* Change expected values, and verify the status of the entries
          * after destroy flush dependency
@@ -32037,8 +32124,6 @@ check_flush_deps_order(unsigned paged)
 
     /* Flush the cache and verify that the entries were flushed in correct order */
     {
-        herr_t result;                  /* Generic return value */
-
         add_flush_op(entry_type, 0, FLUSH_OP__ORDER,
                      entry_type, 0, FALSE, (size_t)0, &flush_order);
         add_flush_op(entry_type, 1, FLUSH_OP__ORDER,
@@ -32079,8 +32164,8 @@ check_flush_deps_order(unsigned paged)
         /* Reset index for tracking flush order */
         flush_order = 0;
 
-        result = H5C_flush_cache(file_ptr, H5C__NO_FLAGS_SET);
-        if(result < 0) CACHE_ERROR("flushing entries with flush dependendices")
+        H5C_FLUSH_CACHE(file_ptr, H5C__NO_FLAGS_SET, "dummy mssg")
+        if(!pass) CACHE_ERROR("flushing entries with flush dependendices")
 
         /* Change expected values, and verify the status of the entries
          * after destroy flush dependency
@@ -32220,8 +32305,6 @@ check_flush_deps_order(unsigned paged)
 
     /* Flush the cache and verify that the entries were flushed in correct order */
     {
-        herr_t result;                  /* Generic return value */
-
         add_flush_op(entry_type, 0, FLUSH_OP__ORDER,
                      entry_type, 0, FALSE, (size_t)0, &flush_order);
         add_flush_op(entry_type, 1, FLUSH_OP__ORDER,
@@ -32272,8 +32355,8 @@ check_flush_deps_order(unsigned paged)
         /* Reset index for tracking flush order */
         flush_order = 0;
 
-        result = H5C_flush_cache(file_ptr, H5C__NO_FLAGS_SET);
-        if(result < 0) CACHE_ERROR("flushing entries with flush dependendices")
+        H5C_FLUSH_CACHE(file_ptr, H5C__NO_FLAGS_SET, "dummy mssg")
+        if(!pass) CACHE_ERROR("flushing entries with flush dependendices")
 
         /* Change expected values, and verify the status of the entries
          * after destroy flush dependency
@@ -32457,8 +32540,6 @@ check_flush_deps_order(unsigned paged)
 
     /* Flush the cache and verify that the entries were flushed in correct order */
     {
-        herr_t result;                  /* Generic return value */
-
         add_flush_op(entry_type, 0, FLUSH_OP__ORDER,
                      entry_type, 0, FALSE, (size_t)0, &flush_order);
         add_flush_op(entry_type, 1, FLUSH_OP__ORDER,
@@ -32511,8 +32592,8 @@ check_flush_deps_order(unsigned paged)
         /* Reset index for tracking flush order */
         flush_order = 0;
 
-        result = H5C_flush_cache(file_ptr, H5C__NO_FLAGS_SET);
-        if(result < 0) CACHE_ERROR("flushing entries with flush dependendices")
+        H5C_FLUSH_CACHE(file_ptr, H5C__NO_FLAGS_SET, "dummy mssg")
+        if(!pass) CACHE_ERROR("flushing entries with flush dependendices")
 
         /* Change expected values, and verify the status of the entries
          * after destroy flush dependency
@@ -32714,8 +32795,6 @@ check_flush_deps_order(unsigned paged)
 
     /* Flush the cache and verify that the entries were flushed in correct order */
     {
-        herr_t result;                  /* Generic return value */
-
         add_flush_op(entry_type, 0, FLUSH_OP__ORDER,
                      entry_type, 0, FALSE, (size_t)0, &flush_order);
         add_flush_op(entry_type, 1, FLUSH_OP__ORDER,
@@ -32768,8 +32847,8 @@ check_flush_deps_order(unsigned paged)
         /* Reset index for tracking flush order */
         flush_order = 0;
 
-        result = H5C_flush_cache(file_ptr, H5C__NO_FLAGS_SET);
-        if(result < 0) CACHE_ERROR("flushing entries with flush dependendices")
+        H5C_FLUSH_CACHE(file_ptr, H5C__NO_FLAGS_SET, "dummy mssg")
+        if(!pass) CACHE_ERROR("flushing entries with flush dependendices")
 
         /* Change expected values, and verify the status of the entries
          * after destroy flush dependency
@@ -33006,8 +33085,6 @@ check_flush_deps_order(unsigned paged)
 
     /* Flush the cache and verify that the entries were flushed in correct order */
     {
-        herr_t result;                  /* Generic return value */
-
         add_flush_op(entry_type, 0, FLUSH_OP__ORDER,
                      entry_type, 0, FALSE, (size_t)0, &flush_order);
         add_flush_op(entry_type, 1, FLUSH_OP__ORDER,
@@ -33055,8 +33132,8 @@ check_flush_deps_order(unsigned paged)
         /* Reset index for tracking flush order */
         flush_order = 0;
 
-        result = H5C_flush_cache(file_ptr, H5C__NO_FLAGS_SET);
-        if(result < 0) CACHE_ERROR("flushing entries with flush dependendices")
+        H5C_FLUSH_CACHE(file_ptr, H5C__NO_FLAGS_SET, "dummy mssg")
+        if(!pass) CACHE_ERROR("flushing entries with flush dependendices")
 
         /* Change expected values, and verify the status of the entries
          * after destroy flush dependency
@@ -33322,8 +33399,6 @@ check_flush_deps_order(unsigned paged)
 
     /* Flush the cache and verify that the entries were flushed in correct order */
     {
-        herr_t result;                  /* Generic return value */
-
         add_flush_op(entry_type, 0, FLUSH_OP__ORDER,
                      entry_type, 0, FALSE, (size_t)0, &flush_order);
         add_flush_op(entry_type, 1, FLUSH_OP__ORDER,
@@ -33371,8 +33446,8 @@ check_flush_deps_order(unsigned paged)
         /* Reset index for tracking flush order */
         flush_order = 0;
 
-        result = H5C_flush_cache(file_ptr, H5C__NO_FLAGS_SET);
-        if(result < 0) CACHE_ERROR("flushing entries with flush dependendices")
+        H5C_FLUSH_CACHE(file_ptr, H5C__NO_FLAGS_SET, "dummy mssg")
+        if(!pass) CACHE_ERROR("flushing entries with flush dependendices")
 
         /* Change expected values, and verify the status of the entries
          * after destroy flush dependency
@@ -34550,30 +34625,35 @@ check_entry_deletions_during_scans(unsigned paged)
 
 
 /*-------------------------------------------------------------------------
+ *
  * Function:    cedds__expunge_dirty_entry_in_flush_test()
  *
- * Purpose:    Verify that H5C_flush_cache() can handle the removal of
- *        a dirty entry from the cache during its scan of the
- *        skip list.
+ * Purpose:     Verify that H5C_flush_cache() can handle the removal of
+ *              a dirty entry from the cache during its scan of the
+ *              skip list.
  *
- *        Do this by setting up a full cache, with the last entry
- *        on the LRU being both dirty and having a flush operation
- *        that deletes the second to last entry on the LRU.  Then
- *        flush the cache, triggering the flush of the last
- *        item, and thereby the deletion of the second to last item.
+ *              Do this by setting up a full cache, with the last entry
+ *              on the LRU being both dirty and having a flush operation
+ *              that deletes the second to last entry on the LRU.  Then
+ *              flush the cache, triggering the flush of the last
+ *              item, and thereby the deletion of the second to last item.
  *
- *        H5C_flush_cache() should handle this deletion gracefully.
+ *              H5C_flush_cache() should handle this deletion gracefully.
  *
  *              Do nothing if pass is FALSE on entry.
  *
- * Return:    void
+ * Return:      void
  *
- * Programmer:    John Mainzer
+ * Programmer:  John Mainzer
  *              4/4/15
  *
  * Modifications:
  *
- *        None.
+ *              Added code to setup and take down the skip list before
+ *              and after calls to H5C_flush_cache().  Do this via the
+ *              H5C_FLUSH_CACHE macro.
+ *
+ *                                          JRM -- 5/14/20
  *
  *-------------------------------------------------------------------------
  */
@@ -34583,7 +34663,6 @@ cedds__expunge_dirty_entry_in_flush_test(H5F_t * file_ptr)
 {
     H5C_t *        cache_ptr = file_ptr->shared->cache;
     int           i;
-    herr_t       result;
     struct expected_entry_status expected[36] =
     {
       /* the expected array is used to maintain a table of the expected status of every
@@ -34680,44 +34759,41 @@ cedds__expunge_dirty_entry_in_flush_test(H5F_t * file_ptr)
 
     }
 
-    if(pass) {
+    if ( pass ) {
 
-    /* to summarize, at present the following entries
-    * are in cache with the following characteristics:
-    *
-    *         in
-    * entry:    cache?    size:    dirty?    pinned?    pins:    flush operations:
-    *
-    * (HET, 0)     Y    16 KB    Y    N    -    expunge (HET 1)
-    *
-    * (HET, 1)    Y    16 KB    Y    N    -    -
+        /* to summarize, at present the following entries
+         * are in cache with the following characteristics:
          *
-    * (HET, 2)    Y    16 KB    Y    N    -    -
+         *         in
+         * entry:  cache?   size:  dirty?  pinned?    pins:    flush operations:
          *
-    * (HET, 3)    Y    16 KB    Y    N    -    -
-    *
-    * Recall that in this test bed, flush operations are excuted the
-    * first time the associated entry is flushed, and are then
-    * deleted.
-    */
+         * (HET, 0)    Y    16 KB    Y       N          -      expunge (HET 1)
+         *
+         * (HET, 1)    Y    16 KB    Y       N          -      -
+         *
+         * (HET, 2)    Y    16 KB    Y       N          -      -
+         *
+         * (HET, 3)    Y    16 KB    Y       N          -      -
+         *
+         * Recall that in this test bed, flush operations are excuted the
+         * first time the associated entry is flushed, and are then
+         * deleted.
+         */
 
-    /* verify the expected status of all entries we have loaded to date: */
-    verify_entry_status(cache_ptr, 0, 4, expected);
+        /* verify the expected status of all entries we have loaded to date: */
+        verify_entry_status(cache_ptr, 0, 4, expected);
     }
 
     /* flush the cache to run the test.  In the process, clean up after test. */
 
-    if(pass) {
-
-        result = H5C_flush_cache(file_ptr, H5C__FLUSH_INVALIDATE_FLAG);
+    if ( pass ) {
 
-        if(result < 0) {
+        H5C_FLUSH_CACHE(file_ptr, H5C__FLUSH_INVALIDATE_FLAG, \
+          "Cache flush inval failed in cedds expunge dirty entry in flush test")
 
-            pass = FALSE;
-            failure_mssg = "Cache flush invalidate failed in cedds expunge dirty entry in flush test";
-        }
-        else if((cache_ptr->index_len != 0) ||
-                  (cache_ptr->index_size != 0)) {
+        if ( ( pass ) &&
+             ( ( cache_ptr->index_len != 0 ) ||
+               ( cache_ptr->index_size != 0 ) ) ) {
 
             pass = FALSE;
             failure_mssg = "Unexpected cache len/size after cedds expunge dirty entry in flush test";
@@ -34729,7 +34805,7 @@ cedds__expunge_dirty_entry_in_flush_test(H5F_t * file_ptr)
     /* If we are collecting stats, check to see if we get the expected
      * values.
      */
-    if(pass)
+    if(pass) 
     if((cache_ptr->insertions[HUGE_ENTRY_TYPE] != 0) ||
              (cache_ptr->pinned_insertions[HUGE_ENTRY_TYPE] != 0) ||
              (cache_ptr->clears[HUGE_ENTRY_TYPE] != 1) ||
@@ -34777,30 +34853,34 @@ cedds__expunge_dirty_entry_in_flush_test(H5F_t * file_ptr)
 /*-------------------------------------------------------------------------
  * Function:    cedds__H5C_make_space_in_cache()
  *
- * Purpose:    Verify that H5C__make_space_in_cache() can handle the
- *        removal from the cache of the next item in its reverse scan
- *        of the LRU list.
+ * Purpose:     Verify that H5C__make_space_in_cache() can handle the
+ *              removal from the cache of the next item in its reverse scan
+ *              of the LRU list.
  *
- *        Do this by setting up a full cache, with the last entry
- *        on the LRU being both dirty and having a flush operation
- *        that deleted the second to last entry on the LRU.  Then
- *        load an additional entry, triggering the flush of the last
- *        item, and thereby the deletion of the second to last item.
+ *              Do this by setting up a full cache, with the last entry
+ *              on the LRU being both dirty and having a flush operation
+ *              that deleted the second to last entry on the LRU.  Then
+ *              load an additional entry, triggering the flush of the last
+ *              item, and thereby the deletion of the second to last item.
  *
- *        H5C__make_space_in_cache() should detect this deletion, and
- *        restart its scan of the LRU from the tail, instead of
- *        examining the now deleted next item up on the LRU.
+ *              H5C__make_space_in_cache() should detect this deletion, and
+ *              restart its scan of the LRU from the tail, instead of
+ *              examining the now deleted next item up on the LRU.
  *
  *              Do nothing if pass is FALSE on entry.
  *
- * Return:    void
+ * Return:      void
  *
- * Programmer:    John Mainzer
+ * Programmer:  John Mainzer
  *              4/4/15
  *
  * Modifications:
  *
- *        None.
+ *              Added code to setup and take down the skip list before
+ *              and after calls to H5C_flush_cache().  Do this via the
+ *              H5C_FLUSH_CACHE macro.
+ *
+ *                                          JRM -- 5/14/20
  *
  *-------------------------------------------------------------------------
  */
@@ -34812,7 +34892,6 @@ cedds__H5C_make_space_in_cache(H5F_t * file_ptr)
     int           i;
     const int       num_huge_entries = 4;
     const int       num_monster_entries = 32;
-    herr_t       result;
     struct expected_entry_status expected[36] =
     {
       /* the expected array is used to maintain a table of the expected status of every
@@ -35059,17 +35138,14 @@ cedds__H5C_make_space_in_cache(H5F_t * file_ptr)
 
     /* flush the cache and end the test. */
 
-    if(pass) {
+    if ( pass ) {
 
-        result = H5C_flush_cache(file_ptr, H5C__FLUSH_INVALIDATE_FLAG);
+        H5C_FLUSH_CACHE(file_ptr, H5C__FLUSH_INVALIDATE_FLAG, \
+                "Cache flush invalidate failed after flush op eviction test")
 
-        if(result < 0) {
-
-            pass = FALSE;
-            failure_mssg = "Cache flush invalidate failed after flush op eviction test";
-        }
-        else if((cache_ptr->index_len != 0) ||
-                  (cache_ptr->index_size != 0)) {
+        if ( ( pass ) &&
+             ( ( cache_ptr->index_len != 0 ) ||
+               ( cache_ptr->index_size != 0 ) ) ) {
 
             pass = FALSE;
             failure_mssg = "Unexpected cache len/size after cleanup of flush op eviction test";
@@ -35158,30 +35234,34 @@ cedds__H5C_make_space_in_cache(H5F_t * file_ptr)
 /*-------------------------------------------------------------------------
  * Function:    cedds__H5C__autoadjust__ageout__evict_aged_out_entries()
  *
- * Purpose:    Verify that H5C__autoadjust__ageout__evict_aged_out_entries()
- *        can handle the removal from the cache of the next item in
- *        its reverse scan of the LRU list.
+ * Purpose:     Verify that H5C__autoadjust__ageout__evict_aged_out_entries()
+ *              can handle the removal from the cache of the next item in
+ *              its reverse scan of the LRU list.
  *
- *        Do this by setting up a full cache, with the last entry
- *        on the LRU being both dirty and having a flush operation
- *        that deletes the second to last entry on the LRU.  Then
- *        access the first item in the LRU repeatedly until the
- *        item, and thereby the deletion of the second to last item.
+ *              Do this by setting up a full cache, with the last entry
+ *              on the LRU being both dirty and having a flush operation
+ *              that deletes the second to last entry on the LRU.  Then
+ *              access the first item in the LRU repeatedly until the
+ *              item, and thereby the deletion of the second to last item.
  *
- *        H5C__make_space_in_cache() should detect this deletion, and
- *        restart its scan of the LRU from the tail, instead of
- *        examining the now deleted next item up on the LRU.
+ *              H5C__make_space_in_cache() should detect this deletion, and
+ *              restart its scan of the LRU from the tail, instead of
+ *              examining the now deleted next item up on the LRU.
  *
  *              Do nothing if pass is FALSE on entry.
  *
- * Return:    void
+ * Return:      void
  *
- * Programmer:    John Mainzer
+ * Programmer:  John Mainzer
  *              4/4/15
  *
  * Modifications:
  *
- *        None.
+ *              Added code to setup and take down the skip list before
+ *              and after calls to H5C_flush_cache().  Do this via the
+ *              H5C_FLUSH_CACHE macro.
+ *
+ *                                          JRM -- 5/14/20
  *
  *-------------------------------------------------------------------------
  */
@@ -35495,17 +35575,14 @@ cedds__H5C__autoadjust__ageout__evict_aged_out_entries(H5F_t * file_ptr)
 
     /* flush the cache and end the test. */
 
-    if(pass) {
-
-        result = H5C_flush_cache(file_ptr, H5C__FLUSH_INVALIDATE_FLAG);
+    if ( pass ) {
 
-        if(result < 0) {
+        H5C_FLUSH_CACHE(file_ptr, H5C__FLUSH_INVALIDATE_FLAG, \
+                  "Cache flush invalidate failed after flush op eviction test")
 
-            pass = FALSE;
-            failure_mssg = "Cache flush invalidate failed after flush op eviction test";
-        }
-        else if((cache_ptr->index_len != 0) ||
-                  (cache_ptr->index_size != 0)) {
+        if ( ( pass ) &&
+             ( ( cache_ptr->index_len != 0 ) ||
+               ( cache_ptr->index_size != 0 ) ) ) {
 
             pass = FALSE;
             failure_mssg = "Unexpected cache len/size after cleanup of flush op eviction test";
@@ -35568,91 +35645,95 @@ cedds__H5C__autoadjust__ageout__evict_aged_out_entries(H5F_t * file_ptr)
 /*-------------------------------------------------------------------------
  * Function:    cedds__H5C_flush_invalidate_cache__bucket_scan()
  *
- * Purpose:    Note:      We now use the index list when we scan the
- *            contents of the metadata cache, so in principal,
- *            this test is obsolete.  However, even using the
- *            index list, restarts are possible, and must be
- *            handled gracefully.
- *
- *            As it turns out, this test triggers index list
- *            scan restarts, and thus with minor changes is
- *            still a useful test.
- *
- *            For this reason, with the exception of changing
- *            to check the index_scan_restart stat instead of
- *            hash bucket restarts, I'm leaving the test
- *            alone.  If and when it starts to fail due to
- *            other changes, we can re-work it to test
- *            index list scan restarts explicitly.
- *
- *                        JRM -- 11/2/16
- *
- *        Verify that H5C_flush_invalidate_cache() can handle
- *        the removal from the cache of the next item in
- *        its scans of hash buckets.
- *
- *        !!!!!!!!!!WARNING !!!!!!!!!!
- *
- *        This test may fail to function correctly if the hash
- *        table size or hash function is altered.
- *
- *        To setup the test, this function depends on the fact that
- *        H5C_flush_invalidate_cache() does alternating scans of the
- *        slist and the index.  If this changes, the test will likely
- *        also cease to function correctly.
- *
- *        The test relies on a known hash function and hash table
- *        size to select a set of test entries that will all hash
- *        to the same hash bucket -- call it the test hash bucket.
- *        It also relies on known behavior of the cache to place
- *        the entries in the test bucket in a known order.
- *
- *        To avoid pre-mature flushes of the entries in the
- *        test hash bucket, all entries are initially clean,
- *        with the exception of the first entry which is dirty.
- *        It avoids premature flushing by being the parent in
- *        a flush dependency.  The first entry in the test bucket
- *        also has a flush op which expunges the second entry --
- *        setting up the failure.
- *
- *        An additional dirty entry is added (which must hash
- *        to a different bucket, and must have a higher address
- *        than at least the first entry in the test hash bucket.
- *        This entry is the child in a flush dependency with the
- *        first entry in the above hash bucket, and contains
- *        a flush op to destroy this flush dependency.
- *
- *        Since the first entry in the test hash bucket has a lower
- *        address that the other dirty entry, the scan of the
- *        slist encounters it first, and passes over it because
- *        it has a flush dependency height of 1.
- *
- *        The scan then encounters the second dirty entry and flushes
- *        it -- causing it to destroy the flush dependency and thus
- *        reducing the flush dependency height of the first entry in
- *        the test hash bucket to zero.
- *
- *        After completing a scan of the slist,
- *        H5C_flush_invalidate_cache() then scans the index,
- *        flushing all entries of flush dependency height zero.
- *
- *        This sets up the potential error when the first entry
- *        in the test hash bucket is flushed -- expunging the
- *        second entry as a side effect.  If
- *        H5C_flush_invalidate_cache() fails to detect this,
- *        it will attempt to continue its scan of the bucket with
- *        an entry that has been deleted from the cache.
+ * Purpose:     Note:      We now use the index list when we scan the
+ *              contents of the metadata cache, so in principal,
+ *              this test is obsolete.  However, even using the
+ *              index list, restarts are possible, and must be
+ *              handled gracefully.
+ *
+ *              As it turns out, this test triggers index list
+ *              scan restarts, and thus with minor changes is
+ *              still a useful test.
+ *
+ *              For this reason, with the exception of changing
+ *              to check the index_scan_restart stat instead of
+ *              hash bucket restarts, I'm leaving the test
+ *              alone.  If and when it starts to fail due to
+ *              other changes, we can re-work it to test
+ *              index list scan restarts explicitly.
+ *
+ *                                        JRM -- 11/2/16
+ *
+ *              Verify that H5C_flush_invalidate_cache() can handle
+ *              the removal from the cache of the next item in
+ *              its scans of hash buckets.
+ *
+ *              !!!!!!!!!!WARNING !!!!!!!!!!
+ *
+ *              This test may fail to function correctly if the hash
+ *              table size or hash function is altered.
+ *
+ *              To setup the test, this function depends on the fact that
+ *              H5C_flush_invalidate_cache() does alternating scans of the
+ *              slist and the index.  If this changes, the test will likely
+ *              also cease to function correctly.
+ *
+ *              The test relies on a known hash function and hash table
+ *              size to select a set of test entries that will all hash
+ *              to the same hash bucket -- call it the test hash bucket.
+ *              It also relies on known behavior of the cache to place
+ *              the entries in the test bucket in a known order.
+ *
+ *              To avoid pre-mature flushes of the entries in the
+ *              test hash bucket, all entries are initially clean,
+ *              with the exception of the first entry which is dirty.
+ *              It avoids premature flushing by being the parent in
+ *              a flush dependency.  The first entry in the test bucket
+ *              also has a flush op which expunges the second entry --
+ *              setting up the failure.
+ *
+ *              An additional dirty entry is added (which must hash
+ *              to a different bucket, and must have a higher address
+ *              than at least the first entry in the test hash bucket.
+ *              This entry is the child in a flush dependency with the
+ *              first entry in the above hash bucket, and contains
+ *              a flush op to destroy this flush dependency.
+ *
+ *              Since the first entry in the test hash bucket has a lower
+ *              address that the other dirty entry, the scan of the
+ *              slist encounters it first, and passes over it because
+ *              it has a flush dependency height of 1.
+ *
+ *              The scan then encounters the second dirty entry and flushes
+ *              it -- causing it to destroy the flush dependency and thus
+ *              reducing the flush dependency height of the first entry in
+ *              the test hash bucket to zero.
+ *
+ *              After completing a scan of the slist,
+ *              H5C_flush_invalidate_cache() then scans the index,
+ *              flushing all entries of flush dependency height zero.
+ *
+ *              This sets up the potential error when the first entry
+ *              in the test hash bucket is flushed -- expunging the
+ *              second entry as a side effect.  If
+ *              H5C_flush_invalidate_cache() fails to detect this,
+ *              it will attempt to continue its scan of the bucket with
+ *              an entry that has been deleted from the cache.
  *
  *              Do nothing if pass is FALSE on entry.
  *
- * Return:    void
+ * Return:      void
  *
- * Programmer:    John Mainzer
+ * Programmer:  John Mainzer
  *              4/9/15
  *
  * Modifications:
  *
- *        None.
+ *              Added code to setup and take down the skip list before
+ *              and after calls to H5C_flush_cache().  Do this via the
+ *              H5C_FLUSH_CACHE macro.
+ *
+ *                                          JRM -- 5/14/20
  *
  *-------------------------------------------------------------------------
  */
@@ -35663,7 +35744,6 @@ cedds__H5C_flush_invalidate_cache__bucket_scan(H5F_t * file_ptr)
     H5C_t *                    cache_ptr = file_ptr->shared->cache;
     int                       i;
     int                       expected_hash_bucket = 0;
-    herr_t                   result;
     haddr_t                    entry_addr;
     test_entry_t *             entry_ptr;
     test_entry_t *             base_addr = NULL;
@@ -35882,17 +35962,14 @@ cedds__H5C_flush_invalidate_cache__bucket_scan(H5F_t * file_ptr)
 
     /* test setup complete -- flush the cache to run and end the test. */
 
-    if(pass) {
-
-        result = H5C_flush_cache(file_ptr, H5C__FLUSH_INVALIDATE_FLAG);
+    if ( pass ) {
 
-        if(result < 0) {
+        H5C_FLUSH_CACHE(file_ptr, H5C__FLUSH_INVALIDATE_FLAG, \
+                "Cache flush invalidate failed after flush op eviction test")
 
-            pass = FALSE;
-            failure_mssg = "Cache flush invalidate failed after flush op eviction test";
-        }
-        else if((cache_ptr->index_len != 0) ||
-                  (cache_ptr->index_size != 0)) {
+        if ( ( pass ) && 
+             ( ( cache_ptr->index_len != 0 ) ||
+               ( cache_ptr->index_size != 0 ) ) ) {
 
             pass = FALSE;
             failure_mssg = "Unexpected cache len/size after cleanup of flush op eviction test";
@@ -36035,26 +36112,34 @@ check_stats(unsigned paged)
 /*-------------------------------------------------------------------------
  * Function:    check_stats__smoke_check_1()
  *
- * Purpose:    Test to see if the statistics collection code is working
- *        more or less as expected.  Do this by performing a number
- *        of operations in the cache, and checking to verify that
- *        they result in the expected statistics.
+ * Purpose:     Test to see if the statistics collection code is working
+ *              more or less as expected.  Do this by performing a number
+ *              of operations in the cache, and checking to verify that
+ *              they result in the expected statistics.
  *
- *        Note that this function is not intended to be a full test
- *        of the statistics collection facility -- only a cursory
- *        check that will serve as a place holder until more complete
- *        tests are implemented.
+ *              Note that this function is not intended to be a full test
+ *              of the statistics collection facility -- only a cursory
+ *              check that will serve as a place holder until more complete
+ *              tests are implemented.
  *
  *              Do nothing if pass is FALSE on entry.
  *
- * Return:    void
+ * Return:      void
  *
- * Programmer:    John Mainzer
+ * Programmer:  John Mainzer
  *              4/22/15
  *
  * Modifications:
  *
- *        None.
+ *              Modified slist stats checks to allow for the case that 
+ *              the slist is disabled.
+ *
+ *              Also added code to setup and take down the skip list before
+ *              and after calls to H5C_flush_cache().  Do this via the
+ *              H5C_FLUSH_CACHE macro.
+ *
+ *                                          JRM -- 5/14/20
+ *
  *
  *-------------------------------------------------------------------------
  */
@@ -36062,9 +36147,8 @@ check_stats(unsigned paged)
 static void
 check_stats__smoke_check_1(H5F_t * file_ptr)
 {
-    H5C_t *        cache_ptr = file_ptr->shared->cache;
+    H5C_t *       cache_ptr = file_ptr->shared->cache;
     int           i;
-    herr_t       result;
 
     if(pass) {
         if(cache_ptr == NULL) {
@@ -36128,36 +36212,39 @@ check_stats__smoke_check_1(H5F_t * file_ptr)
             failure_mssg = "Unexpected monster size entry stats in check_stats__smoke_check_1(1).";
         } /* end if */
 
-    if(pass)
-        if((cache_ptr->total_ht_insertions != 32) ||
-             (cache_ptr->total_ht_deletions != 0) ||
-             (cache_ptr->successful_ht_searches != 0) ||
-             (cache_ptr->total_successful_ht_search_depth != 0) ||
-             (cache_ptr->failed_ht_searches != 32) ||
-             (cache_ptr->total_failed_ht_search_depth != 48) ||
-             (cache_ptr->max_index_len != 32) ||
-             (cache_ptr->max_index_size != 2 * 1024 * 1024) ||
-             (cache_ptr->max_clean_index_size != 0) ||
-             (cache_ptr->max_dirty_index_size != 2 * 1024 * 1024) ||
-             (cache_ptr->max_slist_len != 32) ||
-             (cache_ptr->max_slist_size != 2 * 1024 * 1024) ||
-             (cache_ptr->max_pl_len != 0) ||
-             (cache_ptr->max_pl_size != 0) ||
-             (cache_ptr->max_pel_len != 0) ||
-             (cache_ptr->max_pel_size != 0) ||
-             (cache_ptr->calls_to_msic != 0) ||
-             (cache_ptr->total_entries_skipped_in_msic != 0) ||
-             (cache_ptr->total_entries_scanned_in_msic != 0) ||
-             (cache_ptr->max_entries_skipped_in_msic != 0) ||
-             (cache_ptr->max_entries_scanned_in_msic != 0) ||
-             (cache_ptr->entries_scanned_to_make_space != 0) ||
-             (cache_ptr->slist_scan_restarts != 0) ||
-             (cache_ptr->LRU_scan_restarts != 0) ||
-             (cache_ptr->index_scan_restarts != 0)) {
+    if ( pass ) {
+
+        if ( ( cache_ptr->total_ht_insertions != 32 ) ||
+             ( cache_ptr->total_ht_deletions != 0 ) ||
+             ( cache_ptr->successful_ht_searches != 0 ) ||
+             ( cache_ptr->total_successful_ht_search_depth != 0 ) ||
+             ( cache_ptr->failed_ht_searches != 32 ) ||
+             ( cache_ptr->total_failed_ht_search_depth != 48 ) ||
+             ( cache_ptr->max_index_len != 32 ) ||
+             ( cache_ptr->max_index_size != 2 * 1024 * 1024 ) ||
+             ( cache_ptr->max_clean_index_size != 0 ) ||
+             ( cache_ptr->max_dirty_index_size != 2 * 1024 * 1024 ) ||
+             ( ( cache_ptr->slist_enabled ) &&
+               ( ( cache_ptr->max_slist_len != 32 ) ||
+                 ( cache_ptr->max_slist_size != 2 * 1024 * 1024 ) ) ) ||
+             ( cache_ptr->max_pl_len != 0 ) ||
+             ( cache_ptr->max_pl_size != 0 ) ||
+             ( cache_ptr->max_pel_len != 0 ) ||
+             ( cache_ptr->max_pel_size != 0 ) ||
+             ( cache_ptr->calls_to_msic != 0 ) ||
+             ( cache_ptr->total_entries_skipped_in_msic != 0 ) ||
+             ( cache_ptr->total_entries_scanned_in_msic != 0 )  ||
+             ( cache_ptr->max_entries_skipped_in_msic != 0 ) ||
+             ( cache_ptr->max_entries_scanned_in_msic != 0 ) ||
+             ( cache_ptr->entries_scanned_to_make_space != 0 ) ||
+             ( cache_ptr->slist_scan_restarts != 0 ) ||
+             ( cache_ptr->LRU_scan_restarts != 0 ) ||
+             ( cache_ptr->index_scan_restarts != 0 ) ) {
 
             pass = FALSE;
             failure_mssg = "Unexpected cache stats in check_stats__smoke_check_1(1).";
         } /* end if */
+    }
 
 #if H5C_COLLECT_CACHE_ENTRY_STATS
     if(pass)
@@ -36213,36 +36300,39 @@ check_stats__smoke_check_1(H5F_t * file_ptr)
             failure_mssg = "Unexpected monster size entry stats in check_stats__smoke_check_1(2).";
         } /* end if */
 
-    if(pass)
-        if((cache_ptr->total_ht_insertions != 32) ||
-             (cache_ptr->total_ht_deletions != 0) ||
-             (cache_ptr->successful_ht_searches != 32) ||
-             (cache_ptr->total_successful_ht_search_depth != 96) ||
-             (cache_ptr->failed_ht_searches != 32) ||
-             (cache_ptr->total_failed_ht_search_depth != 48) ||
-             (cache_ptr->max_index_len != 32) ||
-             (cache_ptr->max_index_size != 2 * 1024 * 1024) ||
-             (cache_ptr->max_clean_index_size != 0) ||
-             (cache_ptr->max_dirty_index_size != 2 * 1024 * 1024) ||
-             (cache_ptr->max_slist_len != 32) ||
-             (cache_ptr->max_slist_size != 2 * 1024 * 1024) ||
-             (cache_ptr->max_pl_len != 1) ||
-             (cache_ptr->max_pl_size != 64 * 1024) ||
-             (cache_ptr->max_pel_len != 0) ||
-             (cache_ptr->max_pel_size != 0) ||
-             (cache_ptr->calls_to_msic != 0) ||
-             (cache_ptr->total_entries_skipped_in_msic != 0) ||
-             (cache_ptr->total_entries_scanned_in_msic != 0) ||
-             (cache_ptr->max_entries_skipped_in_msic != 0) ||
-             (cache_ptr->max_entries_scanned_in_msic != 0) ||
-             (cache_ptr->entries_scanned_to_make_space != 0) ||
-             (cache_ptr->slist_scan_restarts != 0) ||
-             (cache_ptr->LRU_scan_restarts != 0) ||
-             (cache_ptr->index_scan_restarts != 0)) {
+    if ( pass ) {
+
+        if ( ( cache_ptr->total_ht_insertions != 32 ) ||
+             ( cache_ptr->total_ht_deletions != 0 ) ||
+             ( cache_ptr->successful_ht_searches != 32 ) ||
+             ( cache_ptr->total_successful_ht_search_depth != 96 ) ||
+             ( cache_ptr->failed_ht_searches != 32 ) ||
+             ( cache_ptr->total_failed_ht_search_depth != 48 ) ||
+             ( cache_ptr->max_index_len != 32 ) ||
+             ( cache_ptr->max_index_size != 2 * 1024 * 1024 ) ||
+             ( cache_ptr->max_clean_index_size != 0 ) ||
+             ( cache_ptr->max_dirty_index_size != 2 * 1024 * 1024 ) ||
+             ( ( cache_ptr->slist_enabled ) &&
+               ( ( cache_ptr->max_slist_len != 32 ) ||
+                 ( cache_ptr->max_slist_size != 2 * 1024 * 1024 ) ) ) ||
+             ( cache_ptr->max_pl_len != 1 ) ||
+             ( cache_ptr->max_pl_size != 64 * 1024 ) ||
+             ( cache_ptr->max_pel_len != 0 ) ||
+             ( cache_ptr->max_pel_size != 0 ) ||
+             ( cache_ptr->calls_to_msic != 0 ) ||
+             ( cache_ptr->total_entries_skipped_in_msic != 0 ) ||
+             ( cache_ptr->total_entries_scanned_in_msic != 0 ) ||
+             ( cache_ptr->max_entries_skipped_in_msic != 0 ) ||
+             ( cache_ptr->max_entries_scanned_in_msic != 0 ) ||
+             ( cache_ptr->entries_scanned_to_make_space != 0 ) ||
+             ( cache_ptr->slist_scan_restarts != 0 ) ||
+             ( cache_ptr->LRU_scan_restarts != 0 ) ||
+             ( cache_ptr->index_scan_restarts != 0 ) ) {
 
             pass = FALSE;
             failure_mssg = "Unexpected cache stats in check_stats__smoke_check_1(2).";
         } /* end if */
+    }
 
 #if H5C_COLLECT_CACHE_ENTRY_STATS
     if(pass)
@@ -36298,36 +36388,39 @@ check_stats__smoke_check_1(H5F_t * file_ptr)
             failure_mssg = "Unexpected monster size entry stats in check_stats__smoke_check_1(3).";
         } /* end if */
 
-    if(pass)
-        if((cache_ptr->total_ht_insertions != 33) ||
-             (cache_ptr->total_ht_deletions != 1) ||
-             (cache_ptr->successful_ht_searches != 32) ||
-             (cache_ptr->total_successful_ht_search_depth != 96) ||
-             (cache_ptr->failed_ht_searches != 33) ||
-             (cache_ptr->total_failed_ht_search_depth != 52) ||
-             (cache_ptr->max_index_len != 32) ||
-             (cache_ptr->max_index_size != 2 * 1024 * 1024) ||
-             (cache_ptr->max_clean_index_size != 2 * 1024 * 1024) ||
-             (cache_ptr->max_dirty_index_size != 2 * 1024 * 1024) ||
-             (cache_ptr->max_slist_len != 32) ||
-             (cache_ptr->max_slist_size != 2 * 1024 * 1024) ||
-             (cache_ptr->max_pl_len != 1) ||
-             (cache_ptr->max_pl_size != 64 * 1024) ||
-             (cache_ptr->max_pel_len != 0) ||
-             (cache_ptr->max_pel_size != 0) ||
-             (cache_ptr->calls_to_msic != 1) ||
-             (cache_ptr->total_entries_skipped_in_msic != 0) ||
-             (cache_ptr->total_entries_scanned_in_msic != 33) ||
-             (cache_ptr->max_entries_skipped_in_msic != 0) ||
-             (cache_ptr->max_entries_scanned_in_msic != 33) ||
-             (cache_ptr->entries_scanned_to_make_space != 33) ||
-             (cache_ptr->slist_scan_restarts != 0) ||
-             (cache_ptr->LRU_scan_restarts != 0) ||
-             (cache_ptr->index_scan_restarts != 0)) {
+    if ( pass ) {
+
+        if ( ( cache_ptr->total_ht_insertions != 33 ) ||
+             ( cache_ptr->total_ht_deletions != 1 ) ||
+             ( cache_ptr->successful_ht_searches != 32 ) ||
+             ( cache_ptr->total_successful_ht_search_depth != 96 ) ||
+             ( cache_ptr->failed_ht_searches != 33 ) ||
+             ( cache_ptr->total_failed_ht_search_depth != 52 ) ||
+             ( cache_ptr->max_index_len != 32 ) ||
+             ( cache_ptr->max_index_size != 2 * 1024 * 1024 ) ||
+             ( cache_ptr->max_clean_index_size != 2 * 1024 * 1024 ) ||
+             ( cache_ptr->max_dirty_index_size != 2 * 1024 * 1024 ) ||
+             ( ( cache_ptr->slist_enabled ) &&
+               ( ( cache_ptr->max_slist_len != 32 ) ||
+                 ( cache_ptr->max_slist_size != 2 * 1024 * 1024 ) ) ) ||
+             ( cache_ptr->max_pl_len != 1 ) ||
+             ( cache_ptr->max_pl_size != 64 * 1024 ) ||
+             ( cache_ptr->max_pel_len != 0 ) ||
+             ( cache_ptr->max_pel_size != 0 ) ||
+             ( cache_ptr->calls_to_msic != 1 ) ||
+             ( cache_ptr->total_entries_skipped_in_msic != 0 ) ||
+             ( cache_ptr->total_entries_scanned_in_msic != 33 ) ||
+             ( cache_ptr->max_entries_skipped_in_msic != 0 ) ||
+             ( cache_ptr->max_entries_scanned_in_msic != 33 ) ||
+             ( cache_ptr->entries_scanned_to_make_space != 33 ) ||
+             ( cache_ptr->slist_scan_restarts != 0 ) ||
+             ( cache_ptr->LRU_scan_restarts != 0 ) ||
+             ( cache_ptr->index_scan_restarts != 0 ) ) {
 
             pass = FALSE;
             failure_mssg = "Unexpected cache stats in check_stats__smoke_check_1(3).";
         } /* end if */
+    }
 
 #if H5C_COLLECT_CACHE_ENTRY_STATS
     if(pass)
@@ -36355,17 +36448,14 @@ check_stats__smoke_check_1(H5F_t * file_ptr)
 
     /* flush the cache to end the test and collect all entry stats */
 
-    if(pass) {
-
-        result = H5C_flush_cache(file_ptr, H5C__FLUSH_INVALIDATE_FLAG);
+    if ( pass ) {
 
-        if(result < 0) {
+        H5C_FLUSH_CACHE(file_ptr, H5C__FLUSH_INVALIDATE_FLAG, \
+               "Cache flush invalidate failed in check_stats__smoke_check_1()")
 
-            pass = FALSE;
-            failure_mssg = "Cache flush invalidate failed in check_stats__smoke_check_1()";
-        } /* end if */
-        else if((cache_ptr->index_len != 0) ||
-                  (cache_ptr->index_size != 0)) {
+        if ( ( pass ) && 
+             ( ( cache_ptr->index_len != 0 ) ||
+               ( cache_ptr->index_size != 0 ) ) ) {
 
             pass = FALSE;
             failure_mssg = "Unexpected cache len/size after check_stats__smoke_check_1()";
@@ -36402,36 +36492,39 @@ check_stats__smoke_check_1(H5F_t * file_ptr)
             failure_mssg = "Unexpected monster size entry stats in check_stats__smoke_check_1(4).";
         } /* end if */
 
-    if(pass)
-        if((cache_ptr->total_ht_insertions != 33) ||
-             (cache_ptr->total_ht_deletions != 33) ||
-             (cache_ptr->successful_ht_searches != 33) ||
-             (cache_ptr->total_successful_ht_search_depth != 99) ||
-             (cache_ptr->failed_ht_searches != 33) ||
-             (cache_ptr->total_failed_ht_search_depth != 52) ||
-             (cache_ptr->max_index_len != 32) ||
-             (cache_ptr->max_index_size != 2 * 1024 * 1024) ||
-             (cache_ptr->max_clean_index_size != 2 * 1024 * 1024) ||
-             (cache_ptr->max_dirty_index_size != 2 * 1024 * 1024) ||
-             (cache_ptr->max_slist_len != 32) ||
-             (cache_ptr->max_slist_size != 2 * 1024 * 1024) ||
-             (cache_ptr->max_pl_len != 1) ||
-             (cache_ptr->max_pl_size != 64 * 1024) ||
-             (cache_ptr->max_pel_len != 0) ||
-             (cache_ptr->max_pel_size != 0) ||
-             (cache_ptr->calls_to_msic != 1) ||
-             (cache_ptr->total_entries_skipped_in_msic != 0) ||
-             (cache_ptr->total_entries_scanned_in_msic != 33) ||
-             (cache_ptr->max_entries_skipped_in_msic != 0) ||
-             (cache_ptr->max_entries_scanned_in_msic != 33) ||
-             (cache_ptr->entries_scanned_to_make_space != 33) ||
-             (cache_ptr->slist_scan_restarts != 0) ||
-             (cache_ptr->LRU_scan_restarts != 0) ||
-             (cache_ptr->index_scan_restarts != 0)) {
+    if ( pass ) {
+
+        if ( ( cache_ptr->total_ht_insertions != 33 ) ||
+             ( cache_ptr->total_ht_deletions != 33 ) ||
+             ( cache_ptr->successful_ht_searches != 33 ) ||
+             ( cache_ptr->total_successful_ht_search_depth != 99 ) ||
+             ( cache_ptr->failed_ht_searches != 33 ) ||
+             ( cache_ptr->total_failed_ht_search_depth != 52 ) ||
+             ( cache_ptr->max_index_len != 32 ) ||
+             ( cache_ptr->max_index_size != 2 * 1024 * 1024 ) ||
+             ( cache_ptr->max_clean_index_size != 2 * 1024 * 1024 ) ||
+             ( cache_ptr->max_dirty_index_size != 2 * 1024 * 1024 ) ||
+             ( ( cache_ptr->slist_enabled ) &&
+               ( ( cache_ptr->max_slist_len != 32 ) ||
+                 ( cache_ptr->max_slist_size != 2 * 1024 * 1024 ) ) ) ||
+             ( cache_ptr->max_pl_len != 1 ) ||
+             ( cache_ptr->max_pl_size != 64 * 1024 ) ||
+             ( cache_ptr->max_pel_len != 0 ) ||
+             ( cache_ptr->max_pel_size != 0 ) ||
+             ( cache_ptr->calls_to_msic != 1 ) ||
+             ( cache_ptr->total_entries_skipped_in_msic != 0 ) ||
+             ( cache_ptr->total_entries_scanned_in_msic != 33 ) ||
+             ( cache_ptr->max_entries_skipped_in_msic != 0 ) ||
+             ( cache_ptr->max_entries_scanned_in_msic != 33 ) ||
+             ( cache_ptr->entries_scanned_to_make_space != 33 ) ||
+             ( cache_ptr->slist_scan_restarts != 0 ) ||
+             ( cache_ptr->LRU_scan_restarts != 0 ) ||
+             ( cache_ptr->index_scan_restarts != 0 ) ) {
 
             pass = FALSE;
             failure_mssg = "Unexpected cache stats in check_stats__smoke_check_1(4).";
         } /* end if */
+    }
 
 #if H5C_COLLECT_CACHE_ENTRY_STATS
     if(pass)
diff --git a/test/cache_common.c b/test/cache_common.c
index ae2a9cc..84c8114 100644
--- a/test/cache_common.c
+++ b/test/cache_common.c
@@ -3134,12 +3134,25 @@ expunge_entry(H5F_t * file_ptr,
  * Function:    flush_cache()
  *
  * Purpose:    Flush the specified cache, destroying all entries if
-                requested.  If requested, dump stats first.
+ *             requested.  If requested, dump stats first.
  *
  * Return:    void
  *
  * Programmer:    John Mainzer
- *              6/23/04
+ *                6/23/04
+ *
+ * Changes:    Added code to setup and take down the skip list before 
+ *             and after calls to H5C_flush_cache().  Do this via calls
+ *             to the H5C_FLUSH_CACHE macro.
+ *
+ *             This is necessary, as H5C_flush() is called repeatedly
+ *             during file flush.  If we setup and took down the 
+ *             skip list on H5C_flush_cache(), we would find ourselves
+ *             doing this repeatedly -- which is contrary to the 
+ *             objective of the exercise (avoiding as many skip list
+ *             operations as possible).
+ *
+ *                                          JRM -- 5/14/20
  *
  *-------------------------------------------------------------------------
  */
@@ -3162,25 +3175,30 @@ flush_cache(H5F_t * file_ptr,
 
         cache_ptr = file_ptr->shared->cache;
 
-        if(destroy_entries)
-            result = H5C_flush_cache(file_ptr, H5C__FLUSH_INVALIDATE_FLAG);
+        if ( destroy_entries )  {
 
-        else
-            result = H5C_flush_cache(file_ptr, H5C__NO_FLAGS_SET);
+            H5C_FLUSH_CACHE(file_ptr, H5C__FLUSH_INVALIDATE_FLAG, \
+                            "error in H5C_flush_cache().")
 
-        if(dump_stats)
-            H5C_stats(cache_ptr, "test cache", dump_detailed_stats);
+        } else {
 
-        if(result < 0) {
-            pass = FALSE;
-            failure_mssg = "error in H5C_flush_cache().";
+            H5C_FLUSH_CACHE(file_ptr, H5C__NO_FLAGS_SET, \
+                            "error in H5C_flush_cache().")
+        }
+
+        if ( dump_stats ) {
+
+            H5C_stats(cache_ptr, "test cache", dump_detailed_stats);
         }
-        else if((destroy_entries) && ((cache_ptr->index_len != 0)
-                || (cache_ptr->index_size != 0)
-                || (cache_ptr->clean_index_size != 0)
-                || (cache_ptr->dirty_index_size != 0))) {
 
-            if(verbose) {
+        if ( ( pass ) && ( destroy_entries ) && 
+             ( ( cache_ptr->index_len != 0 ) || 
+               ( cache_ptr->index_size != 0 ) || 
+               ( cache_ptr->clean_index_size != 0 ) || 
+               ( cache_ptr->dirty_index_size != 0 ) ) ) {
+
+            if ( verbose ) {
+
                 HDfprintf(stdout,
                         "%s: unexpected il/is/cis/dis = %lld/%lld/%lld/%lld.\n",
                         FUNC,
@@ -3984,14 +4002,19 @@ unprotect_entry(H5F_t * file_ptr,
  * Function:    row_major_scan_forward()
  *
  * Purpose:    Do a sequence of inserts, protects, unprotects, moves,
- *        destroys while scanning through the set of entries.  If
- *        pass is false on entry, do nothing.
+ *             destroys while scanning through the set of entries.  If
+ *             pass is false on entry, do nothing.
  *
  * Return:    void
  *
  * Programmer:    John Mainzer
  *              6/12/04
  *
+ * Changes:     Updated slist size == dirty index size checks to 
+ *              bypass the test if cache_ptr->slist_enabled is FALSE.
+ *
+ *                                           JRM -- 5/8/20
+ *
  *-------------------------------------------------------------------------
  */
 void
@@ -4006,7 +4029,7 @@ row_major_scan_forward(H5F_t * file_ptr,
                        hbool_t do_moves,
                        hbool_t move_to_main_addr,
                        hbool_t do_destroys,
-            hbool_t do_mult_ro_protects,
+                       hbool_t do_mult_ro_protects,
                        int dirty_destroys,
                        int dirty_unprotects)
 {
@@ -4045,7 +4068,10 @@ row_major_scan_forward(H5F_t * file_ptr,
                     HDfprintf(stdout, "1(i, %d, %d) ", type, tmp_idx);
 
                 insert_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
-        HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
+
+                HDassert( ( ! cache_ptr->slist_enabled ) || \
+                          ( cache_ptr->slist_size == \
+                            cache_ptr->dirty_index_size ) );
             } /* end if */
 
             tmp_idx--;
@@ -4056,7 +4082,10 @@ row_major_scan_forward(H5F_t * file_ptr,
                     HDfprintf(stdout, "2(p, %d, %d) ", type, tmp_idx);
 
                 protect_entry(file_ptr, type, tmp_idx);
-        HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
+
+                HDassert( ( ! cache_ptr->slist_enabled ) || \
+                          ( cache_ptr->slist_size == \
+                            cache_ptr->dirty_index_size ) );
             } /* end if */
 
             tmp_idx--;
@@ -4067,7 +4096,10 @@ row_major_scan_forward(H5F_t * file_ptr,
                     HDfprintf(stdout, "3(u, %d, %d) ", type, tmp_idx);
 
                 unprotect_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
-        HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
+
+                HDassert( ( ! cache_ptr->slist_enabled ) || \
+                          ( cache_ptr->slist_size == \
+                            cache_ptr->dirty_index_size ) );
             } /* end if */
 
             /* (don't decrement tmp_idx) */
@@ -4078,7 +4110,10 @@ row_major_scan_forward(H5F_t * file_ptr,
                     HDfprintf(stdout, "4(r, %d, %d, %d) ", type, tmp_idx, (int)move_to_main_addr);
 
                 move_entry(cache_ptr, type, tmp_idx, move_to_main_addr);
-        HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
+
+                HDassert( ( ! cache_ptr->slist_enabled ) || \
+                          ( cache_ptr->slist_size == \
+                            cache_ptr->dirty_index_size ) );
             } /* end if */
 
             tmp_idx--;
@@ -4089,7 +4124,10 @@ row_major_scan_forward(H5F_t * file_ptr,
                     HDfprintf(stdout, "5(p, %d, %d) ", type, tmp_idx);
 
                 protect_entry(file_ptr, type, tmp_idx);
-        HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
+
+                HDassert( ( ! cache_ptr->slist_enabled ) || \
+                          ( cache_ptr->slist_size == \
+                            cache_ptr->dirty_index_size ) );
             } /* end if */
 
             tmp_idx -= 2;
@@ -4100,7 +4138,10 @@ row_major_scan_forward(H5F_t * file_ptr,
                     HDfprintf(stdout, "6(u, %d, %d) ", type, tmp_idx);
 
                 unprotect_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
-        HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
+
+                HDassert( ( ! cache_ptr->slist_enabled ) || \
+                          ( cache_ptr->slist_size == \
+                            cache_ptr->dirty_index_size ) );
             } /* end if */
 
         if(do_mult_ro_protects) {
@@ -4112,7 +4153,10 @@ row_major_scan_forward(H5F_t * file_ptr,
                         HDfprintf(stdout, "7(p-ro, %d, %d) ", type, tmp_idx);
 
             protect_entry_ro(file_ptr, type, tmp_idx);
-            HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
+
+            HDassert( ( ! cache_ptr->slist_enabled ) || \
+                      ( cache_ptr->slist_size == \
+                        cache_ptr->dirty_index_size ) );
         } /* end if */
 
                 tmp_idx--;
@@ -4123,7 +4167,10 @@ row_major_scan_forward(H5F_t * file_ptr,
                         HDfprintf(stdout, "8(p-ro, %d, %d) ", type, tmp_idx);
 
             protect_entry_ro(file_ptr, type, tmp_idx);
-            HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
+
+            HDassert( ( ! cache_ptr->slist_enabled ) || \
+                      ( cache_ptr->slist_size == \
+                        cache_ptr->dirty_index_size ) );
         } /* end if */
 
                 tmp_idx--;
@@ -4134,7 +4181,10 @@ row_major_scan_forward(H5F_t * file_ptr,
                         HDfprintf(stdout, "9(p-ro, %d, %d) ", type, tmp_idx);
 
             protect_entry_ro(file_ptr, type, tmp_idx);
-            HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
+
+            HDassert( ( ! cache_ptr->slist_enabled ) || \
+                      ( cache_ptr->slist_size == \
+                        cache_ptr->dirty_index_size ) );
         } /* end if */
 
                 /* (don't decrement tmp_idx) */
@@ -4145,7 +4195,10 @@ row_major_scan_forward(H5F_t * file_ptr,
                         HDfprintf(stdout, "10(u-ro, %d, %d) ", type, tmp_idx);
 
             unprotect_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
-            HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
+
+            HDassert( ( ! cache_ptr->slist_enabled ) || \
+                      ( cache_ptr->slist_size == \
+                        cache_ptr->dirty_index_size ) );
         } /* end if */
 
                 tmp_idx--;
@@ -4156,7 +4209,10 @@ row_major_scan_forward(H5F_t * file_ptr,
                         HDfprintf(stdout, "11(u-ro, %d, %d) ", type, tmp_idx);
 
             unprotect_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
-            HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
+
+            HDassert( ( ! cache_ptr->slist_enabled ) || \
+                      ( cache_ptr->slist_size == \
+                        cache_ptr->dirty_index_size ) );
         } /* end if */
 
                 tmp_idx--;
@@ -4167,7 +4223,10 @@ row_major_scan_forward(H5F_t * file_ptr,
                         HDfprintf(stdout, "12(u-ro, %d, %d) ", type, tmp_idx);
 
             unprotect_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
-            HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
+
+            HDassert( ( ! cache_ptr->slist_enabled ) || \
+                      ( cache_ptr->slist_size == \
+                        cache_ptr->dirty_index_size ) );
         } /* end if */
         } /* if ( do_mult_ro_protects ) */
 
@@ -4176,7 +4235,10 @@ row_major_scan_forward(H5F_t * file_ptr,
                     HDfprintf(stdout, "13(p, %d, %d) ", type, idx);
 
                 protect_entry(file_ptr, type, idx);
-        HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
+
+                HDassert( ( ! cache_ptr->slist_enabled ) || \
+                          ( cache_ptr->slist_size == \
+                            cache_ptr->dirty_index_size ) );
             } /* end if */
 
             tmp_idx = idx - lag + 2;
@@ -4187,7 +4249,10 @@ row_major_scan_forward(H5F_t * file_ptr,
                     HDfprintf(stdout, "14(u, %d, %d) ", type, tmp_idx);
 
                 unprotect_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
-        HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
+
+                HDassert( ( ! cache_ptr->slist_enabled ) || \
+                          ( cache_ptr->slist_size == \
+                            cache_ptr->dirty_index_size ) );
             } /* end if */
 
             tmp_idx--;
@@ -4198,7 +4263,10 @@ row_major_scan_forward(H5F_t * file_ptr,
                     HDfprintf(stdout, "15(p, %d, %d) ", type, tmp_idx);
 
                 protect_entry(file_ptr, type, tmp_idx);
-        HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
+
+                HDassert( ( ! cache_ptr->slist_enabled ) || \
+                          ( cache_ptr->slist_size == \
+                            cache_ptr->dirty_index_size ) );
             } /* end if */
 
             if(do_destroys) {
@@ -4210,7 +4278,10 @@ row_major_scan_forward(H5F_t * file_ptr,
                                 HDfprintf(stdout, "16(u, %d, %d) ", type, tmp_idx);
 
                             unprotect_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
-                HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
+
+                            HDassert( ( ! cache_ptr->slist_enabled ) || \
+                                      ( cache_ptr->slist_size == \
+                                        cache_ptr->dirty_index_size ) );
                             break;
 
                         case 1:
@@ -4219,14 +4290,20 @@ row_major_scan_forward(H5F_t * file_ptr,
                                     HDfprintf(stdout, "17(u, %d, %d) ", type, tmp_idx);
 
                                 unprotect_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
-                HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
+
+                                HDassert( ( ! cache_ptr->slist_enabled ) || \
+                                          ( cache_ptr->slist_size == \
+                                            cache_ptr->dirty_index_size ) );
                             } /* end if */
                             else {
                                 if(verbose)
                                     HDfprintf(stdout, "18(u, %d, %d) ", type, tmp_idx);
 
                                 unprotect_entry(file_ptr, type, tmp_idx, (dirty_unprotects ? H5C__DIRTIED_FLAG : H5C__NO_FLAGS_SET));
-                HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
+
+                                HDassert( ( ! cache_ptr->slist_enabled ) || \
+                                          ( cache_ptr->slist_size == \
+                                            cache_ptr->dirty_index_size ) );
                             } /* end else */
                             break;
 
@@ -4235,7 +4312,10 @@ row_major_scan_forward(H5F_t * file_ptr,
                                 HDfprintf(stdout, "19(u-del, %d, %d) ", type, tmp_idx);
 
                             unprotect_entry(file_ptr, type, tmp_idx, H5C__DELETED_FLAG);
-                HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
+
+                            HDassert( ( ! cache_ptr->slist_enabled ) || \
+                                      ( cache_ptr->slist_size == \
+                                        cache_ptr->dirty_index_size ) );
                             break;
 
                         case 3:
@@ -4244,14 +4324,20 @@ row_major_scan_forward(H5F_t * file_ptr,
                                     HDfprintf(stdout, "20(u-del, %d, %d) ", type, tmp_idx);
 
                                 unprotect_entry(file_ptr, type, tmp_idx, H5C__DELETED_FLAG);
-                    HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
+
+                            HDassert( ( ! cache_ptr->slist_enabled ) || \
+                                      ( cache_ptr->slist_size == \
+                                        cache_ptr->dirty_index_size ) );
                             } /* end if */
                             else {
                                 if(verbose)
                                     HDfprintf(stdout, "21(u-del, %d, %d) ", type, tmp_idx);
 
                                 unprotect_entry(file_ptr, type, tmp_idx, (dirty_destroys ? H5C__DIRTIED_FLAG : H5C__NO_FLAGS_SET) | H5C__DELETED_FLAG);
-                    HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
+
+                                HDassert( ( ! cache_ptr->slist_enabled ) || \
+                                          ( cache_ptr->slist_size == \
+                                            cache_ptr->dirty_index_size ) );
                             } /* end else */
                             break;
 
@@ -4268,7 +4354,10 @@ row_major_scan_forward(H5F_t * file_ptr,
                         HDfprintf(stdout, "22(u, %d, %d) ", type, tmp_idx);
 
                     unprotect_entry(file_ptr, type, tmp_idx, (dirty_unprotects ? H5C__DIRTIED_FLAG : H5C__NO_FLAGS_SET));
-            HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
+
+                    HDassert( ( ! cache_ptr->slist_enabled ) || \
+                              ( cache_ptr->slist_size == \
+                                cache_ptr->dirty_index_size ) );
                 } /* end if */
             } /* end elsef */
 
diff --git a/test/cache_common.h b/test/cache_common.h
index afe1646..18ea4ec 100644
--- a/test/cache_common.h
+++ b/test/cache_common.h
@@ -132,6 +132,65 @@
                 (NOTIFY_ENTRY_SIZE * NUM_NOTIFY_ENTRIES))
 #define ADDR_SPACE_SIZE        (haddr_t)(MAX_ADDR - BASE_ADDR)
 
+
+/***********************************************************************
+ *
+ * Macro:       H5C_FLUSH_CACHE
+ *
+ * Purpose:     Wrap a call to H5C_flush_cache() in calls to 
+ *              H5C_set_slist_enabled() to setup and take down the slist.
+ *
+ *              This is necessary, as H5C_flush_cache() needs the
+ *              slist to be active.  Further, since it is called 
+ *              repeatedly during file flush, it would be inefficient 
+ *              for it to setup the slist on entry, and take it down
+ *              on exit.  
+ *
+ *              Note that the slist need not be empty if the flags
+ *              indicate a partial flush (i.e. 
+ *              H5C__FLUSH_MARKED_ENTRIES_FLAG).  Compute clear_slist
+ *              and pass it into H5C_set_slist_enabled as appropriate.
+ *
+ *              On error, set pass to FALSE, and set failure_mssg
+ *              to the supplied error message.
+ *
+ * Return:      N/A
+ *
+ * Programmer:  John Mainzer
+ *              5/14/20
+ *
+ * Changes:     None.
+ *
+ ***********************************************************************/
+
+#define H5C_FLUSH_CACHE(file, flags, fail_mssg)                        \
+{                                                                      \
+    hbool_t  clear_slist;                                              \
+    herr_t   rslt;                                                     \
+                                                                       \
+    clear_slist = ( (flags & H5C__FLUSH_MARKED_ENTRIES_FLAG) != 0 );   \
+                                                                       \
+    rslt = H5C_set_slist_enabled((file)->shared->cache, TRUE, FALSE);  \
+                                                                       \
+    if ( rslt >= 0 ) {                                                 \
+                                                                       \
+        rslt = H5C_flush_cache((file), (flags));                       \
+    }                                                                  \
+                                                                       \
+    if ( rslt >= 0 ) {                                                 \
+                                                                       \
+        rslt = H5C_set_slist_enabled((file)->shared->cache, FALSE,     \
+                                     clear_slist);                     \
+    }                                                                  \
+                                                                       \
+    if( rslt < 0 ) {                                                   \
+                                                                       \
+        pass = FALSE;                                                  \
+        failure_mssg = (fail_mssg);                                    \
+    }                                                                  \
+} /* H5C_FLUSH_CACHE */
+
+
 #define MAX_PINS    8    /* Maximum number of entries that can be
                 * directly pinned by a single entry.
                 */
diff --git a/test/cache_tagging.c b/test/cache_tagging.c
index aaf7d9a..dbea394 100644
--- a/test/cache_tagging.c
+++ b/test/cache_tagging.c
@@ -347,11 +347,20 @@ evict_entries(hid_t fid)
     /* Mark all entries investigated */
     mark_all_entries_investigated(fid);
 
+    /* setup the skip list prior to calling H5C_flush_cache() */
+    if ( H5C_set_slist_enabled(f->shared->cache, TRUE, FALSE) < 0 )
+        TEST_ERROR;
+
     /* Evict all we can from the cache to examine full tag creation tree */
-        /* This function will likely return failure since the root group
-         * is still protected. Thus, don't check its return value. */
+    /* This function will likely return failure since the root group
+     * is still protected. Thus, don't check its return value. 
+     */
     H5C_flush_cache(f, H5C__FLUSH_INVALIDATE_FLAG);
 
+    /* shutdown the slist -- allow it to be non-empty */
+    if ( H5C_set_slist_enabled(f->shared->cache, FALSE, TRUE) < 0 )
+        TEST_ERROR;
+
     return 0;
 
 error:
diff --git a/test/ohdr.c b/test/ohdr.c
index 36a7742..1d6cf99 100644
--- a/test/ohdr.c
+++ b/test/ohdr.c
@@ -125,8 +125,12 @@ test_cont(char *filename, hid_t fapl)
         FAIL_STACK_ERROR
     if(1 != H5O_link(&oh_locB, 1))
         FAIL_STACK_ERROR
+    if(H5AC_prep_for_file_flush(f) < 0)
+        FAIL_STACK_ERROR
     if(H5AC_flush(f) < 0)
         FAIL_STACK_ERROR
+    if(H5AC_secure_from_file_flush(f) < 0)
+        FAIL_STACK_ERROR
     if(H5O__expunge_chunks_test(&oh_locA) < 0)
         FAIL_STACK_ERROR
 
@@ -1680,8 +1684,12 @@ main(void)
             FAIL_STACK_ERROR
         if(1 != H5O_link(&oh_loc, 1))
             FAIL_STACK_ERROR
+        if(H5AC_prep_for_file_flush(f) < 0)
+            FAIL_STACK_ERROR
         if(H5AC_flush(f) < 0)
             FAIL_STACK_ERROR
+        if(H5AC_secure_from_file_flush(f) < 0)
+            FAIL_STACK_ERROR
         if(H5AC_expunge_entry(f, H5AC_OHDR, oh_loc.addr, H5AC__NO_FLAGS_SET) < 0)
             FAIL_STACK_ERROR
         if(NULL == H5O_msg_read(&oh_loc, H5O_MTIME_NEW_ID, &ro))
@@ -1697,8 +1705,12 @@ main(void)
         time_new = 33333333;
         if(H5O_msg_write(&oh_loc, H5O_MTIME_NEW_ID, 0, 0, &time_new) < 0)
             FAIL_STACK_ERROR
+        if(H5AC_prep_for_file_flush(f) < 0)
+            FAIL_STACK_ERROR
         if(H5AC_flush(f) < 0)
             FAIL_STACK_ERROR
+        if(H5AC_secure_from_file_flush(f) < 0)
+            FAIL_STACK_ERROR
         if(H5AC_expunge_entry(f, H5AC_OHDR, oh_loc.addr, H5AC__NO_FLAGS_SET) < 0)
             FAIL_STACK_ERROR
         if(NULL == H5O_msg_read(&oh_loc, H5O_MTIME_NEW_ID, &ro))
@@ -1728,8 +1740,12 @@ main(void)
             if(H5O_msg_create(&oh_loc, H5O_MTIME_ID, 0, 0, &time_new) < 0)
                 FAIL_STACK_ERROR
         } /* end for */
+        if(H5AC_prep_for_file_flush(f) < 0)
+            FAIL_STACK_ERROR
         if(H5AC_flush(f) < 0)
             FAIL_STACK_ERROR
+        if(H5AC_secure_from_file_flush(f) < 0)
+            FAIL_STACK_ERROR
         if(H5AC_expunge_entry(f, H5AC_OHDR, oh_loc.addr, H5AC__NO_FLAGS_SET) < 0)
             FAIL_STACK_ERROR
 
@@ -1771,8 +1787,12 @@ main(void)
             time_new = (i + 1) * 1000 + 10;
             if(H5O_msg_create(&oh_loc, H5O_MTIME_NEW_ID, 0, 0, &time_new) < 0)
                 FAIL_STACK_ERROR
+            if(H5AC_prep_for_file_flush(f) < 0)
+                FAIL_STACK_ERROR
             if(H5AC_flush(f) < 0)
                 FAIL_STACK_ERROR
+            if(H5AC_secure_from_file_flush(f) < 0)
+                FAIL_STACK_ERROR
             if(H5AC_expunge_entry(f, H5AC_OHDR, oh_loc.addr, H5AC__NO_FLAGS_SET) < 0)
                 FAIL_STACK_ERROR
         } /* end for */
@@ -1801,8 +1821,12 @@ main(void)
         time_new = 22222222;
         if(H5O_msg_create(&oh_loc, H5O_MTIME_NEW_ID, H5O_MSG_FLAG_CONSTANT, 0, &time_new) < 0)
             FAIL_STACK_ERROR
+        if(H5AC_prep_for_file_flush(f) < 0)
+            FAIL_STACK_ERROR
         if(H5AC_flush(f) < 0)
             FAIL_STACK_ERROR
+        if(H5AC_secure_from_file_flush(f) < 0)
+            FAIL_STACK_ERROR
         if(H5AC_expunge_entry(f, H5AC_OHDR, oh_loc.addr, H5AC__NO_FLAGS_SET) < 0)
             FAIL_STACK_ERROR
         if(NULL == H5O_msg_read(&oh_loc, H5O_MTIME_NEW_ID, &ro))