[svn-r18198] Description:

    Trim trailing whitespace from source code files, with following command:

find . \( -name "*.[ch]" -or -name "*.cpp" -or -name "*.f90" \) -print |xargs -n 1 sed -i "" 's/[[:blank:]]*$//'

Tested on:
    None - eyeballed only

1 files changed, 150 insertions, 150 deletions

diff --git a/test/cache.c b/test/cache.c
index 6afe9e2..ad9f4ce 100644
--- a/test/cache.c
+++ b/test/cache.c
@@ -3007,7 +3007,7 @@ check_flush_cache(void)
 
 	if ( show_progress ) {
 
-	    HDfprintf(stdout, "%s: calling check_flush_cache__empty_cache().\n", 
+	    HDfprintf(stdout, "%s: calling check_flush_cache__empty_cache().\n",
 		      fcn_name);
 	}
 
@@ -9259,7 +9259,7 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
 
     if ( show_progress ) {
 
-	HDfprintf(stdout, "%s:%d:%d: running sanity checks on entry(1).\n", 
+	HDfprintf(stdout, "%s:%d:%d: running sanity checks on entry(1).\n",
 	          fcn_name, test_num, (int)pass);
     }
 
@@ -9292,7 +9292,7 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
 
     if ( show_progress ) {
 
-	HDfprintf(stdout, "%s:%d:%d: running sanity checks on entry(2).\n", 
+	HDfprintf(stdout, "%s:%d:%d: running sanity checks on entry(2).\n",
 	          fcn_name, test_num, (int)pass);
     }
 
@@ -9320,7 +9320,7 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
 
     if ( show_progress ) {
 
-	HDfprintf(stdout, "%s:%d:%d: running sanity checks on entry(3).\n", 
+	HDfprintf(stdout, "%s:%d:%d: running sanity checks on entry(3).\n",
 	          fcn_name, test_num, (int)pass);
     }
 
@@ -9363,7 +9363,7 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
 
     if ( show_progress ) {
 
-	HDfprintf(stdout, "%s:%d:%d: Setting up the test.\n", 
+	HDfprintf(stdout, "%s:%d:%d: Setting up the test.\n",
 	          fcn_name, test_num, (int)pass);
     }
 
@@ -9374,7 +9374,7 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
 
 	    if ( show_progress ) {
 
-	        HDfprintf(stdout, 
+	        HDfprintf(stdout,
 			  "%s:%d: Inserting entry(%d,%d) with flags 0x%x.\n",
 			  fcn_name, test_num,
 			  (int)(spec[i].entry_type),
@@ -9389,7 +9389,7 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
 
 	    if ( show_progress ) {
 
-	        HDfprintf(stdout, 
+	        HDfprintf(stdout,
 			  "%s:%d: Protecting entry(%d,%d).\n",
 			  fcn_name, test_num,
 			  (int)(spec[i].entry_type),
@@ -9400,7 +9400,7 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
 
 	    if ( show_progress ) {
 
-	        HDfprintf(stdout, 
+	        HDfprintf(stdout,
 		    "%s:%d: Unprotecting entry(%d,%d) with flags 0x%x ns = %d.\n",
 		    fcn_name, test_num,
 		    (int)(spec[i].entry_type),
@@ -9452,7 +9452,7 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
 
     if ( show_progress ) {
 
-	HDfprintf(stdout, "%s:%d:%d: Running the test.\n", 
+	HDfprintf(stdout, "%s:%d:%d: Running the test.\n",
 		  fcn_name, test_num, (int)pass);
     }
 
@@ -9473,7 +9473,7 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
 
     if ( show_progress ) {
 
-	HDfprintf(stdout, "%s:%d:%d: Checking test results(1).\n", 
+	HDfprintf(stdout, "%s:%d:%d: Checking test results(1).\n",
 		  fcn_name, test_num, (int)pass);
     }
 
@@ -9516,7 +9516,7 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
 
     if ( show_progress ) {
 
-	HDfprintf(stdout, "%s:%d:%d: Checking test results(2).\n", 
+	HDfprintf(stdout, "%s:%d:%d: Checking test results(2).\n",
 		  fcn_name, test_num, (int)pass);
     }
 
@@ -9640,7 +9640,7 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
 
     if ( show_progress ) {
 
-	HDfprintf(stdout, "%s:%d:%d: Checking test results(3).\n", 
+	HDfprintf(stdout, "%s:%d:%d: Checking test results(3).\n",
 		  fcn_name, test_num, (int)pass);
     }
 
@@ -9675,7 +9675,7 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
 
     if ( show_progress ) {
 
-	HDfprintf(stdout, "%s:%d:%d: Cleaning up after test(1).\n", 
+	HDfprintf(stdout, "%s:%d:%d: Cleaning up after test(1).\n",
 		  fcn_name, test_num, (int)pass);
     }
 
@@ -9718,7 +9718,7 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
 
     if ( show_progress ) {
 
-	HDfprintf(stdout, "%s:%d:%d: Cleaning up after test(2).\n", 
+	HDfprintf(stdout, "%s:%d:%d: Cleaning up after test(2).\n",
 		  fcn_name, test_num, (int)pass);
     }
 
@@ -9740,7 +9740,7 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
 
     if ( show_progress ) {
 
-	HDfprintf(stdout, "%s:%d:%d: Cleaning up after test(3).\n", 
+	HDfprintf(stdout, "%s:%d:%d: Cleaning up after test(3).\n",
 		  fcn_name, test_num, (int)pass);
     }
 
@@ -9881,7 +9881,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
                   ( cache_ptr->min_clean_size != (1 * 1024 * 1024 ) ) ) {
 
 	    pass = FALSE;
-	    failure_mssg = 
+	    failure_mssg =
 	        "unexpected cache config at start of flush op eviction test.";
 
         } else {
@@ -9917,39 +9917,39 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
 	 */
 
 	protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 0);
-	unprotect_entry_with_size_change(file_ptr, VARIABLE_ENTRY_TYPE, 0, 
+	unprotect_entry_with_size_change(file_ptr, VARIABLE_ENTRY_TYPE, 0,
 			           H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG,
 				   (VARIABLE_ENTRY_SIZE / 2));
 
 	protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 1);
-	unprotect_entry_with_size_change(file_ptr, VARIABLE_ENTRY_TYPE, 1, 
+	unprotect_entry_with_size_change(file_ptr, VARIABLE_ENTRY_TYPE, 1,
 			                 H5C__NO_FLAGS_SET, (size_t)0);
 
 	protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 2);
-	unprotect_entry_with_size_change(file_ptr, VARIABLE_ENTRY_TYPE, 2, 
+	unprotect_entry_with_size_change(file_ptr, VARIABLE_ENTRY_TYPE, 2,
 			                 H5C__NO_FLAGS_SET, (size_t)0);
 
 	protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 3);
-	unprotect_entry_with_size_change(file_ptr, VARIABLE_ENTRY_TYPE, 3, 
+	unprotect_entry_with_size_change(file_ptr, VARIABLE_ENTRY_TYPE, 3,
 			           H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG,
 				   (VARIABLE_ENTRY_SIZE / 2));
 
 	protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 4);
-	unprotect_entry_with_size_change(file_ptr, VARIABLE_ENTRY_TYPE, 4, 
+	unprotect_entry_with_size_change(file_ptr, VARIABLE_ENTRY_TYPE, 4,
 			           H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG,
 				   (VARIABLE_ENTRY_SIZE / 2));
 
 	protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 5);
-	unprotect_entry_with_size_change(file_ptr, VARIABLE_ENTRY_TYPE, 5, 
+	unprotect_entry_with_size_change(file_ptr, VARIABLE_ENTRY_TYPE, 5,
 			           H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG,
 				   (VARIABLE_ENTRY_SIZE / 2));
 
 	protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 6);
-	unprotect_entry_with_size_change(file_ptr, VARIABLE_ENTRY_TYPE, 6, 
+	unprotect_entry_with_size_change(file_ptr, VARIABLE_ENTRY_TYPE, 6,
 			                 H5C__NO_FLAGS_SET, (size_t)0);
 
 	protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 7);
-	unprotect_entry_with_size_change(file_ptr, VARIABLE_ENTRY_TYPE, 7, 
+	unprotect_entry_with_size_change(file_ptr, VARIABLE_ENTRY_TYPE, 7,
 			                 H5C__NO_FLAGS_SET, (size_t)0);
 
 	if ( ( cache_ptr->index_len != 8 ) ||
@@ -10052,14 +10052,14 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
 	for ( i = 0; i < 31; i++ )
 	{
 	    protect_entry(file_ptr, MONSTER_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(file_ptr, MONSTER_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(file_ptr, MONSTER_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
 	for ( i = 0; i < 1; i++ )
 	{
 	    protect_entry(file_ptr, LARGE_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
@@ -10127,7 +10127,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
         num_large_entries = 2;
 
 	protect_entry(file_ptr, LARGE_ENTRY_TYPE, 1);
-	unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, 1, 
+	unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, 1,
                                          H5C__DIRTIED_FLAG, (size_t)0);
 
 	if ( ( cache_ptr->index_len != 40 ) ||
@@ -10193,7 +10193,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
         num_large_entries = 3;
 
 	protect_entry(file_ptr, LARGE_ENTRY_TYPE, 2);
-	unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, 2, 
+	unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, 2,
                                          H5C__DIRTIED_FLAG, (size_t)0);
 
 	if ( ( cache_ptr->index_len != 40 ) ||
@@ -10266,11 +10266,11 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
         num_large_entries = 5;
 
 	protect_entry(file_ptr, LARGE_ENTRY_TYPE, 3);
-	unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, 3, 
+	unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, 3,
                                          H5C__DIRTIED_FLAG, (size_t)0);
 
 	protect_entry(file_ptr, LARGE_ENTRY_TYPE, 4);
-	unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, 4, 
+	unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, 4,
                                          H5C__DIRTIED_FLAG, (size_t)0);
 
         /* verify cache size */
@@ -10307,14 +10307,14 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
 	for ( i = 0; i < 31; i++ )
 	{
 	    protect_entry(file_ptr, MONSTER_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(file_ptr, MONSTER_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(file_ptr, MONSTER_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
 	for ( i = 0; i < 5; i++ )
 	{
 	    protect_entry(file_ptr, LARGE_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
@@ -10374,7 +10374,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
 	for ( i = 5; i < 8; i++ )
 	{
 	    protect_entry(file_ptr, LARGE_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
@@ -10436,7 +10436,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
 	for ( i = 8; i < 9; i++ )
 	{
 	    protect_entry(file_ptr, LARGE_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
@@ -10502,7 +10502,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
 	for ( i = 9; i < 10; i++ )
 	{
 	    protect_entry(file_ptr, LARGE_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
@@ -10538,14 +10538,14 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
 	for ( i = 0; i < 31; i++ )
 	{
 	    protect_entry(file_ptr, MONSTER_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(file_ptr, MONSTER_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(file_ptr, MONSTER_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
 	for ( i = 0; i < 10; i++ )
 	{
 	    protect_entry(file_ptr, LARGE_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
@@ -10649,7 +10649,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
 	for ( i = 10; i < 12; i++ )
 	{
 	    protect_entry(file_ptr, LARGE_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
@@ -10682,14 +10682,14 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
 	for ( i = 0; i < num_monster_entries; i++ )
 	{
 	    protect_entry(file_ptr, MONSTER_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(file_ptr, MONSTER_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(file_ptr, MONSTER_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
 	for ( i = 0; i < num_large_entries; i++ )
 	{
 	    protect_entry(file_ptr, LARGE_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
@@ -10776,7 +10776,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
 	for ( i = 12; i < 14; i++ )
 	{
 	    protect_entry(file_ptr, LARGE_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
@@ -14929,7 +14929,7 @@ check_resize_entry(void)
     if ( pass ) {
 
         result = H5C_unprotect(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
-                &(types[LARGE_ENTRY_TYPE]), entry_ptr->addr, (void *)entry_ptr, 
+                &(types[LARGE_ENTRY_TYPE]), entry_ptr->addr, (void *)entry_ptr,
                 H5C__SIZE_CHANGED_FLAG | H5C__DIRTIED_FLAG, (LARGE_ENTRY_SIZE / 2));
 
 	if ( result < 0 ) {
@@ -15000,7 +15000,7 @@ check_resize_entry(void)
     if ( pass ) {
 
         result = H5C_unprotect(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
-                &(types[LARGE_ENTRY_TYPE]), entry_ptr->addr, (void *)entry_ptr, 
+                &(types[LARGE_ENTRY_TYPE]), entry_ptr->addr, (void *)entry_ptr,
                 (H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG), LARGE_ENTRY_SIZE);
 
 	if ( result < 0 ) {
@@ -15100,8 +15100,8 @@ check_resize_entry(void)
 
     if ( pass ) {
 
-        result = H5C_get_entry_status(file_ptr, entry_ptr->addr, 
-			              &reported_entry_size, &in_cache, 
+        result = H5C_get_entry_status(file_ptr, entry_ptr->addr,
+			              &reported_entry_size, &in_cache,
 				      &is_dirty, &is_protected, &is_pinned);
 
 	if ( result < 0 ) {
@@ -15192,7 +15192,7 @@ check_resize_entry(void)
 
     protect_entry(file_ptr, LARGE_ENTRY_TYPE, 0);
 
-    unprotect_entry(file_ptr, LARGE_ENTRY_TYPE, 0, FALSE, 
+    unprotect_entry(file_ptr, LARGE_ENTRY_TYPE, 0, FALSE,
 		    H5C__UNPIN_ENTRY_FLAG | H5C__DELETED_FLAG);
 
     if ( pass ) {
@@ -15335,7 +15335,7 @@ check_resize_entry(void)
     if ( pass ) {
 
         result = H5C_unprotect(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
-                &(types[LARGE_ENTRY_TYPE]), entry_ptr->addr, (void *)entry_ptr, 
+                &(types[LARGE_ENTRY_TYPE]), entry_ptr->addr, (void *)entry_ptr,
                 H5C__SIZE_CHANGED_FLAG | H5C__DIRTIED_FLAG, (LARGE_ENTRY_SIZE / 2));
 
 	if ( result < 0 ) {
@@ -15408,7 +15408,7 @@ check_resize_entry(void)
     if ( pass ) {
 
         result = H5C_unprotect(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
-                &(types[LARGE_ENTRY_TYPE]), entry_ptr->addr, (void *)entry_ptr, 
+                &(types[LARGE_ENTRY_TYPE]), entry_ptr->addr, (void *)entry_ptr,
                 (H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG), LARGE_ENTRY_SIZE);
 
 	if ( result < 0 ) {
@@ -15602,7 +15602,7 @@ check_resize_entry(void)
 
     protect_entry(file_ptr, LARGE_ENTRY_TYPE, 3);
 
-    unprotect_entry(file_ptr, LARGE_ENTRY_TYPE, 3, FALSE, 
+    unprotect_entry(file_ptr, LARGE_ENTRY_TYPE, 3, FALSE,
 		    H5C__UNPIN_ENTRY_FLAG | H5C__DELETED_FLAG);
 
     if ( pass ) {
@@ -15826,7 +15826,7 @@ check_evictions_enabled(void)
     for ( i = 0; i < 16 ; i++ )
     {
         protect_entry(file_ptr, MONSTER_ENTRY_TYPE, i);
-        unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, i, 
+        unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, i,
 			FALSE, H5C__NO_FLAGS_SET);
     }
 
@@ -15857,7 +15857,7 @@ check_evictions_enabled(void)
 
     /* protect and unprotect another entry */
     protect_entry(file_ptr, MONSTER_ENTRY_TYPE, 16);
-    unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, 16, 
+    unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, 16,
 		    FALSE, H5C__NO_FLAGS_SET);
 
     if ( show_progress ) /* 7 */
@@ -16022,7 +16022,7 @@ check_evictions_enabled(void)
 
     /* protect and unprotect another entry */
     protect_entry(file_ptr, MONSTER_ENTRY_TYPE, 18);
-    unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, 18, 
+    unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, 18,
 		    FALSE, H5C__NO_FLAGS_SET);
 
     if ( show_progress ) /* 15 */
@@ -16095,7 +16095,7 @@ check_evictions_enabled(void)
 
     /* protect and unprotect an entry that is in the cache */
     protect_entry(file_ptr, MONSTER_ENTRY_TYPE, 19);
-    unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, 19, 
+    unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, 19,
 		    FALSE, H5C__NO_FLAGS_SET);
 
     if ( show_progress ) /* 20 */
@@ -16124,7 +16124,7 @@ check_evictions_enabled(void)
 
     /* protect and unprotect an entry that isn't in the cache */
     protect_entry(file_ptr, MONSTER_ENTRY_TYPE, 20);
-    unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, 20, 
+    unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, 20,
 		    FALSE, H5C__NO_FLAGS_SET);
 
     if ( show_progress ) /* 22 */
@@ -16247,7 +16247,7 @@ check_evictions_enabled(void)
      * the cache to grow.
      */
     protect_entry(file_ptr, MONSTER_ENTRY_TYPE, 21);
-    unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, 21, 
+    unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, 21,
 		    FALSE, H5C__NO_FLAGS_SET);
 
 
@@ -21619,11 +21619,11 @@ check_auto_cache_resize(void)
     if ( pass ) {
 
         protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 10);
-        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE, 
+        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE,
 			H5C__NO_FLAGS_SET);
 
         protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 11);
-        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE, 
+        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE,
 			H5C__NO_FLAGS_SET);
 
         protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 12);
@@ -21792,7 +21792,7 @@ check_auto_cache_resize(void)
     if ( pass ) {
 
         protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 10);
-        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE, 
+        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE,
 			H5C__PIN_ENTRY_FLAG);
         resize_entry(file_ptr, VARIABLE_ENTRY_TYPE, 10, 2 * 1024, TRUE);
 
@@ -21831,7 +21831,7 @@ check_auto_cache_resize(void)
     if ( pass ) {
 
         protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 11);
-        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE, 
+        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE,
 			H5C__PIN_ENTRY_FLAG);
         resize_entry(file_ptr, VARIABLE_ENTRY_TYPE, 11, 10 * 1024, TRUE);
 
@@ -21852,7 +21852,7 @@ check_auto_cache_resize(void)
     if ( pass ) {
 
         protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 12);
-        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE, 
+        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE,
 			H5C__PIN_ENTRY_FLAG);
         resize_entry(file_ptr, VARIABLE_ENTRY_TYPE, 12, 10 * 1024, TRUE);
 
@@ -21876,15 +21876,15 @@ check_auto_cache_resize(void)
     if ( pass ) {
 
         protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 10);
-        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE, 
+        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE,
 			H5C__UNPIN_ENTRY_FLAG);
 
         protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 11);
-        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE, 
+        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE,
 			H5C__UNPIN_ENTRY_FLAG);
 
         protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 12);
-        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE, 
+        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE,
 			H5C__UNPIN_ENTRY_FLAG);
 
 	if ( ( pass ) &&
@@ -21944,7 +21944,7 @@ check_auto_cache_resize(void)
     if ( pass ) {
 
         protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 10);
-        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE, 
+        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE,
 			H5C__PIN_ENTRY_FLAG);
         resize_pinned_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, 2 * 1024);
 
@@ -21983,7 +21983,7 @@ check_auto_cache_resize(void)
     if ( pass ) {
 
         protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 11);
-        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE, 
+        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE,
 			H5C__PIN_ENTRY_FLAG);
         resize_pinned_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, 10 * 1024);
 
@@ -22004,7 +22004,7 @@ check_auto_cache_resize(void)
     if ( pass ) {
 
         protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 12);
-        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE, 
+        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE,
 			H5C__PIN_ENTRY_FLAG);
         resize_pinned_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12, 10 * 1024);
 
@@ -22028,15 +22028,15 @@ check_auto_cache_resize(void)
     if ( pass ) {
 
         protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 10);
-        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE, 
+        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE,
 			H5C__UNPIN_ENTRY_FLAG);
 
         protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 11);
-        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE, 
+        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE,
 			H5C__UNPIN_ENTRY_FLAG);
 
         protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 12);
-        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE, 
+        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE,
 			H5C__UNPIN_ENTRY_FLAG);
 
 	if ( ( pass ) &&
@@ -22157,7 +22157,7 @@ check_auto_cache_resize(void)
         rpt_fcn_called = FALSE;
 
         protect_entry(file_ptr, LARGE_ENTRY_TYPE, 0);
-        unprotect_entry(file_ptr, LARGE_ENTRY_TYPE, 0, NO_CHANGE, 
+        unprotect_entry(file_ptr, LARGE_ENTRY_TYPE, 0, NO_CHANGE,
 			H5C__NO_FLAGS_SET);
 
 	if ( ( pass ) &&
@@ -22184,7 +22184,7 @@ check_auto_cache_resize(void)
         rpt_fcn_called = FALSE;
 
         protect_entry(file_ptr, LARGE_ENTRY_TYPE, 1);
-        unprotect_entry(file_ptr, LARGE_ENTRY_TYPE, 1, NO_CHANGE, 
+        unprotect_entry(file_ptr, LARGE_ENTRY_TYPE, 1, NO_CHANGE,
 			H5C__NO_FLAGS_SET);
 
 	if ( ( pass ) &&
@@ -22210,10 +22210,10 @@ check_auto_cache_resize(void)
         rpt_fcn_called = FALSE;
 
         protect_entry(file_ptr, LARGE_ENTRY_TYPE, 2);
-        unprotect_entry(file_ptr, LARGE_ENTRY_TYPE, 2, NO_CHANGE, 
+        unprotect_entry(file_ptr, LARGE_ENTRY_TYPE, 2, NO_CHANGE,
 			H5C__NO_FLAGS_SET);
         protect_entry(file_ptr, LARGE_ENTRY_TYPE, 3);
-        unprotect_entry(file_ptr, LARGE_ENTRY_TYPE, 3, NO_CHANGE, 
+        unprotect_entry(file_ptr, LARGE_ENTRY_TYPE, 3, NO_CHANGE,
 			H5C__NO_FLAGS_SET);
 
 	if ( ( pass ) &&
@@ -22267,7 +22267,7 @@ check_auto_cache_resize(void)
         rpt_fcn_called = FALSE;
 
         protect_entry(file_ptr, LARGE_ENTRY_TYPE, 0);
-        unprotect_entry(file_ptr, LARGE_ENTRY_TYPE, 0, NO_CHANGE, 
+        unprotect_entry(file_ptr, LARGE_ENTRY_TYPE, 0, NO_CHANGE,
 			H5C__NO_FLAGS_SET);
 
 	if ( ( pass ) &&
@@ -28742,7 +28742,7 @@ check_auto_cache_resize_aux_fcns(void)
             failure_mssg =
                 "H5C_get_cache_size reports unexpected cur_size 5.\n";
 
-        } 
+        }
     }
 
     if ( pass ) {
@@ -28792,13 +28792,13 @@ check_auto_cache_resize_aux_fcns(void)
  *
  *              A 'metadata blizzard' in this context occurs when the cache
  *              gets completely filled with all dirty entries. Upon needing
- *              to make space in the cache, the cache then has no clean 
+ *              to make space in the cache, the cache then has no clean
  *              entries ready to evict, and must clean every dirty entry
  *              in the cache first, due to the second chance replacement
  *              policy. (i.e. after cleaning an entry, it is bumped to the
  *              top of the LRU to make a second pass before eviction).
- *              The massive amount of sequential writes to disk while 
- *              flushing the entire cache is what constitutes a 'metadata 
+ *              The massive amount of sequential writes to disk while
+ *              flushing the entire cache is what constitutes a 'metadata
  *              blizzard'.
  *
  * Return:	void
@@ -28821,11 +28821,11 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
     H5F_t * file_ptr = NULL;
     H5C_t * cache_ptr = NULL;
     hbool_t show_progress = FALSE;
-    int32_t checkpoint = 0;   
+    int32_t checkpoint = 0;
     int32_t entry_idx = 0;
     int32_t i;
 
-    /* Expected loaded status of entries depends on how they get into 
+    /* Expected loaded status of entries depends on how they get into
      * the cache. Insertions = not loaded, protect/unprotect = loaded.
      */
     hbool_t loaded = (hbool_t)!(fill_via_insertion);
@@ -29001,19 +29001,19 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
     }
 
     if ( show_progress) /* 0 */
-         HDfprintf(stdout, "\n%s: check point %d -- pass %d\n", 
+         HDfprintf(stdout, "\n%s: check point %d -- pass %d\n",
                    fcn_name, checkpoint++, pass);
 
     if ( pass ) {
-    
+
         /* Set up the cache.
          *
-         * The max_cache_size should have room for 50 entries. 
-         * The min_clean_size is half of that, or 25 entries.   
+         * The max_cache_size should have room for 50 entries.
+         * The min_clean_size is half of that, or 25 entries.
          */
         file_ptr = setup_cache((size_t)(50 * entry_size), /* max_cache_size */
                                 (size_t)(25 * entry_size)); /* min_clean_size */
- 
+
         if ( file_ptr == NULL) {
 
             pass = FALSE;
@@ -29022,37 +29022,37 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
         }
         else
             cache_ptr = file_ptr->shared->cache;
-    }        
+    }
 
     if ( show_progress) /* 1 */
-         HDfprintf(stdout, "%s: check point %d -- pass %d\n", 
+         HDfprintf(stdout, "%s: check point %d -- pass %d\n",
                    fcn_name, checkpoint++, pass);
 
     /* ========================================================================
      * ========================================================================
      *  Phase 1:
-     * 
-     *    Inserting dirty entries into an empty cache, until the cache 
+     *
+     *    Inserting dirty entries into an empty cache, until the cache
      *    violates the min_clean_size requirement. The expected result is
      *    that none of the inserted entries during this phase will get
      *    flushed or evicted.
-     * 
+     *
      *    This verifies that while maintaining min_clean_size, we don't go
      *    overboard and flush entries that we don't need to flush.
-     *  
+     *
      * ========================================================================
      * ========================================================================
      */
 
     if ( pass ) {
 
-        /* Insert 26 entries (indexes 0 through 25) into the cache.  
+        /* Insert 26 entries (indexes 0 through 25) into the cache.
          *
-         * Note that we are inserting 26 entries, and not 25, because the cache 
-         * will only try to adhere to the min_clean_size if it's currently 
-         * being violated. Thus, on insertion of the 26th entry, since the 
-         * min_clean_size will not be violated, it will accept the insertion 
-         * without having to make clean space. 
+         * Note that we are inserting 26 entries, and not 25, because the cache
+         * will only try to adhere to the min_clean_size if it's currently
+         * being violated. Thus, on insertion of the 26th entry, since the
+         * min_clean_size will not be violated, it will accept the insertion
+         * without having to make clean space.
          */
 
         for (entry_idx = 0; entry_idx < 26; entry_idx++) {
@@ -29076,8 +29076,8 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
                                 H5C__NO_FLAGS_SET); /* unsigned int flags */
             }
 
-            /* Change expected values, and verify the status of the entries 
-             * after each insertion 
+            /* Change expected values, and verify the status of the entries
+             * after each insertion
              */
             expected[entry_idx].in_cache = TRUE;
             expected[entry_idx].is_dirty = TRUE;
@@ -29091,30 +29091,30 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
     }
 
     if ( show_progress) /* 2 */
-         HDfprintf(stdout, "%s: check point %d -- pass %d\n", 
+         HDfprintf(stdout, "%s: check point %d -- pass %d\n",
                    fcn_name, checkpoint++, pass);
 
     /* ========================================================================
      * ========================================================================
      *  Phase 2:
-     * 
+     *
      *    Inserting entries into a cache that violates the min_clean_size,
      *    until the cache is full. The expected result is that each insertion
-     *    will result in the flushing of a dirty entry in the cache.    
+     *    will result in the flushing of a dirty entry in the cache.
      *
      *    This verifies that we maintain the min_clean_size. By doing so, we
      *    prevent building the situation in which a 'metadata blizzard' would
      *    occur (i.e., the cache being completely filled with dirty entries).
-     *  
+     *
      * ========================================================================
      * ========================================================================
      */
-   
+
     if ( pass ) {
 
         /* Insert the 27th entry (index = 26) into the cache.
-         * 
-         * This should cause the cache to flush its least recently used entry 
+         *
+         * This should cause the cache to flush its least recently used entry
          * before the insertion because it doesn't satisfy the min_clean_size
          * constraint.
          */
@@ -29137,15 +29137,15 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
         }
 
         /* Verify the status of the entries.
-         * 
+         *
          * Expected status is that there are 27 entries in the cache, and
          * entry number 0 has been cleaned.
-         * 
+         *
          * Changes from last entry verification:
          *   - entry w/ index 0 has now been flushed and is now clean.
          *   - entry w/ index 26 is now in the cache and dirty.
          */
-          
+
         /* entry w/ index 0 has now been flushed and is now clean. */
 	expected[0].flushed   = TRUE;
 	expected[0].is_dirty  = FALSE;
@@ -29163,7 +29163,7 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
     }
 
     if ( show_progress) /* 3 */
-         HDfprintf(stdout, "%s: check point %d -- pass %d\n", 
+         HDfprintf(stdout, "%s: check point %d -- pass %d\n",
                    fcn_name, checkpoint++, pass);
 
     if ( pass ) {
@@ -29193,10 +29193,10 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
         }
 
         /* Verify the status of the entries.
-         * 
+         *
          * Expected status is that there are 28 entries in the cache, and
          * entry numbers 0 and 1 have been cleaned.
-         * 
+         *
          * Changes from last entry verification:
          *   - entry w/ index 1 has now been flushed and is now clean.
          *   - entry w/ index 27 is now in the cache and dirty.
@@ -29219,7 +29219,7 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
     }
 
     if ( show_progress) /* 4 */
-         HDfprintf(stdout, "%s: check point %d -- pass %d\n", 
+         HDfprintf(stdout, "%s: check point %d -- pass %d\n",
                    fcn_name, checkpoint++, pass);
 
     if ( pass ) {
@@ -29247,7 +29247,7 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
             }
 
             /* Expected staus is that after each insertion, the entry
-             * inserted 26 insertions ago has been flushed, and the 
+             * inserted 26 insertions ago has been flushed, and the
              * entry currently getting inserted is now in the cache and
              * dirty.
              */
@@ -29257,7 +29257,7 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
 	    expected[entry_idx].in_cache = TRUE;
     	    expected[entry_idx].is_dirty = TRUE;
 	    expected[entry_idx].loaded   = (unsigned char)loaded;
-    
+
             /* verify the status */
             verify_entry_status(cache_ptr, /* H5C_t * cache_ptr */
                                 entry_idx, /* int tag */
@@ -29274,23 +29274,23 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
     }
 
     if ( show_progress) /* 5 */
-         HDfprintf(stdout, "%s: check point %d -- pass %d\n", 
+         HDfprintf(stdout, "%s: check point %d -- pass %d\n",
                    fcn_name, checkpoint++, pass);
 
     /* ========================================================================
      * ========================================================================
      *  Phase 3:
-     * 
-     *    Inserting entries into a cache that is completely full. Insertions 
+     *
+     *    Inserting entries into a cache that is completely full. Insertions
      *    of new entries will force evictions of old entries, but since the
-     *    min_clean_size has been maintained, doing so will not result in 
+     *    min_clean_size has been maintained, doing so will not result in
      *    the entire cache getting flushed in order to evict a single entry,
      *    as a clean entry will be available to flush reasonably close to
      *    the bottom of the LRU.
-     * 
+     *
      *    This verifies that with a maintained min_clean_size, a metadata
      *    blizzard does not occur on insertion.
-     * 
+     *
      * ========================================================================
      * ========================================================================
      */
@@ -29298,7 +29298,7 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
     if ( pass ) {
 
         /* Insert the 51st entry (index = 50) into the cache.
-         * 
+         *
          * The cache is full prior to the insertion, so it will
          * have to evict in order to make room for the new entry.
          */
@@ -29321,13 +29321,13 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
         }
 
         /* Verify the status of the entries.
-         * 
+         *
          * Changes from last entry verification:
          *   - entry w/ index 0 has been evicted.
          *   - entries w/ indices 24,25 have now been flushed and are clean.
          *   - entry w/ index 50 is now in the cache and dirty.
          */
-    
+
         /* entry w/ index 0 has been evicted. */
 	expected[0].in_cache  = FALSE;
 	expected[0].destroyed = TRUE;
@@ -29351,16 +29351,16 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
     }
 
     if ( show_progress) /* 6 */
-         HDfprintf(stdout, "%s: check point %d -- pass %d\n", 
+         HDfprintf(stdout, "%s: check point %d -- pass %d\n",
                    fcn_name, checkpoint++, pass);
 
 
     if ( pass ) {
 
         /* Insert 49 more entries (indices 51-99) into the cache.
-         * 
-         * The cache will be flushing an entry on each insertion, and 
-         * evicting an entry on each insertion. 
+         *
+         * The cache will be flushing an entry on each insertion, and
+         * evicting an entry on each insertion.
          *
          * After each insertion, verify the expected status of the
          * entries in the cache.
@@ -29377,7 +29377,7 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
                 protect_entry(file_ptr,   /* H5F_t * file_ptr */
                               entry_type,  /* int32_t type */
                               entry_idx);   /* int32-t idx */
-    
+
                 unprotect_entry(file_ptr,          /* H5F_t * file_ptr */
                                 entry_type,         /* int32_t type */
                                 entry_idx,        /* int32_t idx */
@@ -29394,21 +29394,21 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
 	    expected[entry_idx - 50].in_cache  = FALSE;
 	    expected[entry_idx - 50].destroyed = TRUE;
 
-            /* If the newly inserted entry is among the first 24 
+            /* If the newly inserted entry is among the first 24
              * insertions in this loop, then the insertion will
              * have resulted in a flush of the entry inserted
              * 25 insertions ago. */
             if (entry_idx < 75) {
-                
+
                 expected[entry_idx - 25].flushed = TRUE;
                 expected[entry_idx - 25].is_dirty = FALSE;
             }
             /* If the newly inserted entry is among the last
              * 25 insertions in this loop, then the insertion will
              * have resulted in a flush of the entry inserted 26
-             * insertions ago. This switch is because there was two 
+             * insertions ago. This switch is because there was two
              * consecutive clean entries in the cache (due to 51/49
-             * dirty/clean ratio when full), so instead of 
+             * dirty/clean ratio when full), so instead of
              * flush-then-evict, it switches to evict-then-flush. */
             else {
 
@@ -29425,13 +29425,13 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
     }
 
     if ( show_progress) /* 7 */
-         HDfprintf(stdout, "%s: check point %d -- pass %d\n", 
+         HDfprintf(stdout, "%s: check point %d -- pass %d\n",
                    fcn_name, checkpoint++, pass);
 
     /* ========================================================================
      * ========================================================================
      *  Phase 4:
-     * 
+     *
      *    Flushing the entire cache, and then inserting entries into a cache
      *    that is completely full, but all clean.
      *
@@ -29439,18 +29439,18 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
      *    into an empty cache, we're inserting into a full cache that's all
      *    clean, thus an eviction occurs before each insertion.
      *
-     *    When the cache finally hits the point of violating the 
+     *    When the cache finally hits the point of violating the
      *    min_clean_size, the bottom half of the LRU will be filled with
      *    clean entries and the top half will be filled with recently inserted
      *    dirty entries. We'll then verify that an insertion will only evict
      *    one entry and flush one entry, and no more.
-     *    
+     *
      * ========================================================================
      * ========================================================================
      */
 
     if ( pass ) {
-    
+
         /* Flush the cache.
          *
          * We're doing this so we can repeat the above insertions, but
@@ -29462,12 +29462,12 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
                     FALSE,     /* hbool_t destory_entries */
                     FALSE,     /* hbool_t dump_stats */
                     FALSE);    /* hbool_t dump_detailed_stats */
-    
+
         /* Verify that the cache is clean */
         verify_clean();
 
         /* Verify the status of the entries.
-         * 
+         *
          * Changes from last entry verification:
          *   - entries w/ indices 74-99 have been flushed.
          */
@@ -29485,7 +29485,7 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
     }
 
     if ( show_progress) /* 8 */
-         HDfprintf(stdout, "%s: check point %d -- pass %d\n", 
+         HDfprintf(stdout, "%s: check point %d -- pass %d\n",
                    fcn_name, checkpoint++, pass);
 
     if ( pass ) {
@@ -29536,7 +29536,7 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
     }
 
     if ( show_progress) /* 9 */
-         HDfprintf(stdout, "%s: check point %d -- pass %d\n", 
+         HDfprintf(stdout, "%s: check point %d -- pass %d\n",
                    fcn_name, checkpoint++, pass);
 
     if ( pass ) {
@@ -29561,7 +29561,7 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
         }
 
         /* Verify the status of the entries.
-         * 
+         *
          * Changes from last entry verification:
          *   - entry w/ index 76 is evicted.
          *   - entry w/ index 100 is cleaned.
@@ -29571,7 +29571,7 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
         /* entry w/ index 76 has been evicted. */
 	expected[76].in_cache  = FALSE;
 	expected[76].destroyed = TRUE;
-          
+
         /* entry w/ index 100 has now been flushed and is now clean. */
 	expected[100].flushed   = TRUE;
 	expected[100].is_dirty  = FALSE;
@@ -29589,7 +29589,7 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
     }
 
     if ( show_progress) /* 10 */
-         HDfprintf(stdout, "%s: check point %d -- pass %d\n", 
+         HDfprintf(stdout, "%s: check point %d -- pass %d\n",
                    fcn_name, checkpoint++, pass);
 
     if ( pass ) {
@@ -29639,18 +29639,18 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
     }
 
     if ( show_progress) /* 11 */
-         HDfprintf(stdout, "%s: check point %d -- pass %d\n", 
+         HDfprintf(stdout, "%s: check point %d -- pass %d\n",
                    fcn_name, checkpoint++, pass);
 
     if ( pass ) {
-        
+
         /* We're done with testing. We can take down the cache. */
         takedown_cache(file_ptr, FALSE, FALSE);
         reset_entries();
     }
 
     if ( show_progress) /* 12 */
-         HDfprintf(stdout, "%s: check point %d -- pass %d\n", 
+         HDfprintf(stdout, "%s: check point %d -- pass %d\n",
                    fcn_name, checkpoint++, pass);
 
     if ( pass ) { PASSED(); } else { H5_FAILED(); }
@@ -29734,8 +29734,8 @@ main(void)
     nerrs += check_auto_cache_resize_epoch_markers();
     nerrs += check_auto_cache_resize_input_errs();
     nerrs += check_auto_cache_resize_aux_fcns();
-    nerrs += check_metadata_blizzard_absence(TRUE);   
-    nerrs += check_metadata_blizzard_absence(FALSE);  
+    nerrs += check_metadata_blizzard_absence(TRUE);
+    nerrs += check_metadata_blizzard_absence(FALSE);
 
     return(nerrs > 0);
 }