[svn-r15629] Description:

   Remove trailing whitespace from C/C++ source files, with the following
script:

   foreach f (*.[ch] *.cpp)
       sed 's/[[:blank:]]*$//' $f > sed.out && mv sed.out $f
   end

Tested on:
   Mac OS X/32 10.5.5 (amazon)
   No need for h5committest, just whitespace changes...

1 files changed, 467 insertions, 467 deletions

diff --git a/test/cache.c b/test/cache.c
index 6ea92ef..7de613e 100644
--- a/test/cache.c
+++ b/test/cache.c
@@ -965,7 +965,7 @@ smoke_check_5(void)
         /* hbool_t     apply_max_increment    = */ TRUE,
         /* size_t      max_increment          = */ (4 * 1024 * 1024),
 
-        /* enum H5C_cache_flash_incr_mode       */   
+        /* enum H5C_cache_flash_incr_mode       */
 	/*                    flash_incr_mode = */ H5C_flash_incr__off,
         /* double      flash_multiple         = */ 2.0,
         /* double      flash_threshold        = */ 0.5,
@@ -1205,7 +1205,7 @@ smoke_check_6(void)
         /* hbool_t     apply_max_increment    = */ TRUE,
         /* size_t      max_increment          = */ (4 * 1024 * 1024),
 
-        /* enum H5C_cache_flash_incr_mode       */   
+        /* enum H5C_cache_flash_incr_mode       */
 	/*                    flash_incr_mode = */ H5C_flash_incr__off,
         /* double      flash_multiple         = */ 2.0,
         /* double      flash_threshold        = */ 0.5,
@@ -1445,7 +1445,7 @@ smoke_check_7(void)
         /* hbool_t     apply_max_increment    = */ TRUE,
         /* size_t      max_increment          = */ (8 * 1024 * 1024),
 
-        /* enum H5C_cache_flash_incr_mode       */   
+        /* enum H5C_cache_flash_incr_mode       */
 	/*                    flash_incr_mode = */ H5C_flash_incr__off,
         /* double      flash_multiple         = */ 2.0,
         /* double      flash_threshold        = */ 0.5,
@@ -1686,7 +1686,7 @@ smoke_check_8(void)
         /* hbool_t     apply_max_increment    = */ TRUE,
         /* size_t      max_increment          = */ (4 * 1024 * 1024),
 
-        /* enum H5C_cache_flash_incr_mode       */   
+        /* enum H5C_cache_flash_incr_mode       */
 	/*                    flash_incr_mode = */ H5C_flash_incr__off,
         /* double      flash_multiple         = */ 2.0,
         /* double      flash_threshold        = */ 0.5,
@@ -1871,9 +1871,9 @@ smoke_check_8(void)
  * Purpose:	A repeat of smoke check 1, only with the cache corked
  * 		part of the time.
  *
- * 		Recall that smoke check 1 is a basic functional test, 
- * 		with inserts, destroys, and renames in the mix, along 
- * 		with repeated protects and unprotects.  All entries are 
+ * 		Recall that smoke check 1 is a basic functional test,
+ * 		with inserts, destroys, and renames in the mix, along
+ * 		with repeated protects and unprotects.  All entries are
  * 		marked as clean.
  *
  * Return:	void
@@ -2178,9 +2178,9 @@ smoke_check_9(void)
  * Purpose:	A repeat of smoke check 2, only with the cache corked
  * 		part of the time.
  *
- * 		Recall that smoke check 2 is a basic functional test, 
- * 		with inserts, destroys, and renames in the mix, along 
- * 		with some repeated protects and unprotects.  About half 
+ * 		Recall that smoke check 2 is a basic functional test,
+ * 		with inserts, destroys, and renames in the mix, along
+ * 		with some repeated protects and unprotects.  About half
  * 		the entries are marked as dirty.
  *
  * Return:	void
@@ -2708,12 +2708,12 @@ check_insert_entry(void)
 
     pass = TRUE;
 
-    /* Allocate a cache, and insert entries into it using all 
+    /* Allocate a cache, and insert entries into it using all
      * combinations of flags.  Verify that the entries are inserted,
      * and that the flags have the desired effects.
      *
      * Note that the dirty parameter in insert_entry is no longer
-     * used, as we have decided that all inserted entries are 
+     * used, as we have decided that all inserted entries are
      * dirty by definition. (Which sounds very reasonable, but didn't
      * used to be the case.)
      */
@@ -2729,10 +2729,10 @@ check_insert_entry(void)
     if ( pass ) {
 
         insert_entry(cache_ptr, entry_type, 0, TRUE, H5C__NO_FLAGS_SET);
-        insert_entry(cache_ptr, entry_type, 1, TRUE, 
+        insert_entry(cache_ptr, entry_type, 1, TRUE,
                      H5C__SET_FLUSH_MARKER_FLAG);
         insert_entry(cache_ptr, entry_type, 2, TRUE, H5C__PIN_ENTRY_FLAG);
-        insert_entry(cache_ptr, entry_type, 3, TRUE, 
+        insert_entry(cache_ptr, entry_type, 3, TRUE,
 		     (H5C__SET_FLUSH_MARKER_FLAG | H5C__PIN_ENTRY_FLAG));
     }
 
@@ -2748,7 +2748,7 @@ check_insert_entry(void)
 	/* Start by checking everything we can via H5C_get_entry_status() */
 
 	result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, &entry_size,
-			              &in_cache, &is_dirty, &is_protected, 
+			              &in_cache, &is_dirty, &is_protected,
 				      &is_pinned);
 
         if ( result < 0 ) {
@@ -2757,10 +2757,10 @@ check_insert_entry(void)
             failure_mssg = "H5AC_get_entry_status() reports failure.";
         }
 
-	if ( pass ) { 
+	if ( pass ) {
 
 	    /* check the universals */
-	    if ( ( ! in_cache ) || ( ! is_dirty ) || ( is_protected ) || 
+	    if ( ( ! in_cache ) || ( ! is_dirty ) || ( is_protected ) ||
                  ( entry_size != entry_sizes[entry_type] ) ) {
 
                 pass = FALSE;
@@ -2819,7 +2819,7 @@ check_insert_entry(void)
 		search_ptr = cache_ptr->pel_head_ptr;
 
 		while ( ( search_ptr != NULL ) &&
-			( search_ptr != 
+			( search_ptr !=
 			  (struct H5C_cache_entry_t *)entry_ptr ) )
 		{
 		    search_ptr = search_ptr->next;
@@ -2841,7 +2841,7 @@ check_insert_entry(void)
 		search_ptr = cache_ptr->LRU_head_ptr;
 
 		while ( ( search_ptr != NULL ) &&
-			( search_ptr != 
+			( search_ptr !=
 			  (struct H5C_cache_entry_t *)entry_ptr ) )
 		{
 		    search_ptr = search_ptr->next;
@@ -2864,7 +2864,7 @@ check_insert_entry(void)
 		search_ptr = cache_ptr->dLRU_head_ptr;
 
 		while ( ( search_ptr != NULL ) &&
-			( search_ptr != 
+			( search_ptr !=
 			  (struct H5C_cache_entry_t *)entry_ptr ) )
 		{
 		    search_ptr = search_ptr->aux_next;
@@ -2884,8 +2884,8 @@ check_insert_entry(void)
     } /* while */
 
 
-    /* So much for looking at the individual entries.  Now verify 
-     * that the various counts and sized in the cache header are 
+    /* So much for looking at the individual entries.  Now verify
+     * that the various counts and sized in the cache header are
      * as expected.
      */
 
@@ -5383,9 +5383,9 @@ check_flush_cache__pe_multi_entry_test(H5C_t * cache_ptr,
 /*-------------------------------------------------------------------------
  * Function:	check_flush_cache__flush_ops()
  *
- * Purpose:	Run the flush ops cache tests. 
+ * Purpose:	Run the flush ops cache tests.
  *
- * 		These are tests that test the cache's ability to handle 
+ * 		These are tests that test the cache's ability to handle
  * 		the case in which the flush callback dirties, resizes,
  * 		and/or renames entries.
  *
@@ -5421,7 +5421,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
     if ( pass ) /* test #1 */
     {
 	/* start with a very simple test, in which there are two entries
-	 * resident in cache, and the second entry dirties the first in 
+	 * resident in cache, and the second entry dirties the first in
 	 * the flush callback.  No size changes, and no flush flags.
 	 */
         int test_num			= 1;
@@ -5431,9 +5431,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	size_t init_expected_index_size	= 2 * PICO_ENTRY_SIZE;
 	int expected_index_len		= 2;
 	size_t expected_index_size	= 2 * PICO_ENTRY_SIZE;
-	struct fo_flush_cache_test_spec spec[2] = 
+	struct fo_flush_cache_test_spec spec[2] =
 	{
-          { 
+          {
             /* entry_num          = */ 0,
             /* entry_type         = */ 0,
 	    /* entry_index        = */ 0,
@@ -5461,7 +5461,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	    /* expected_flushed   = */ TRUE,
 	    /* expected_destroyed = */ FALSE
 	  },
-          { 
+          {
             /* entry_num          = */ 1,
             /* entry_type         = */ 0,
 	    /* entry_index        = */ 1,
@@ -5529,8 +5529,8 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	 * Note that we must repeat all tests with the flush invalidate flag
 	 * as this triggers a different set of code to execute the flush.
 	 *
-	 * Create two entries resident in cache, and have the second entry 
-	 * dirty the first in the flush callback.  
+	 * Create two entries resident in cache, and have the second entry
+	 * dirty the first in the flush callback.
 	 */
         int test_num			= 2;
 	unsigned int flush_flags	= H5C__FLUSH_INVALIDATE_FLAG;
@@ -5539,9 +5539,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	size_t init_expected_index_size	= 2 * PICO_ENTRY_SIZE;
 	int expected_index_len		= 0;
 	size_t expected_index_size	= 0;
-	struct fo_flush_cache_test_spec spec[2] = 
+	struct fo_flush_cache_test_spec spec[2] =
 	{
-          { 
+          {
             /* entry_num          = */ 0,
             /* entry_type         = */ PICO_ENTRY_TYPE,
 	    /* entry_index        = */ 0,
@@ -5569,7 +5569,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	    /* expected_flushed   = */ TRUE,
 	    /* expected_destroyed = */ TRUE
 	  },
-          { 
+          {
             /* entry_num          = */ 1,
             /* entry_type         = */ PICO_ENTRY_TYPE,
 	    /* entry_index        = */ 1,
@@ -5644,9 +5644,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	size_t init_expected_index_size	= VARIABLE_ENTRY_SIZE / 4;
 	int expected_index_len		= 1;
 	size_t expected_index_size	= VARIABLE_ENTRY_SIZE / 2;
-	struct fo_flush_cache_test_spec spec[1] = 
+	struct fo_flush_cache_test_spec spec[1] =
 	{
-          { 
+          {
             /* entry_num          = */ 0,
             /* entry_type         = */ VARIABLE_ENTRY_TYPE,
 	    /* entry_index        = */ 0,
@@ -5723,9 +5723,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	size_t init_expected_index_size	= VARIABLE_ENTRY_SIZE / 4;
 	int expected_index_len		= 0;
 	size_t expected_index_size	= 0;
-	struct fo_flush_cache_test_spec spec[1] = 
+	struct fo_flush_cache_test_spec spec[1] =
 	{
-          { 
+          {
             /* entry_num          = */ 0,
             /* entry_type         = */ VARIABLE_ENTRY_TYPE,
 	    /* entry_index        = */ 0,
@@ -5793,8 +5793,8 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	 * which the call back function renames the entry for which it has
 	 * been called.
 	 *
-	 * Run this entry twice, as the first run moves the entry to its 
-	 * alternate address, and the second moves it back.  
+	 * Run this entry twice, as the first run moves the entry to its
+	 * alternate address, and the second moves it back.
 	 */
         int test_num			= 5; /* and 6 */
 	unsigned int flush_flags	= H5C__NO_FLAGS_SET;
@@ -5803,9 +5803,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	size_t init_expected_index_size	= VARIABLE_ENTRY_SIZE;
 	int expected_index_len		= 1;
 	size_t expected_index_size	= VARIABLE_ENTRY_SIZE;
-	struct fo_flush_cache_test_spec spec[1] = 
+	struct fo_flush_cache_test_spec spec[1] =
 	{
-          { 
+          {
             /* entry_num          = */ 0,
             /* entry_type         = */ VARIABLE_ENTRY_TYPE,
 	    /* entry_index        = */ 0,
@@ -5866,15 +5866,15 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 					 check_size,
 					 checks);
 
-	/* this change forces the rename to move the target entry back to its 
+	/* this change forces the rename to move the target entry back to its
 	 * main address.  The first test moved it to its alternate address.
 	 *
 	 * Note that these two tests are not the same, as in the first test,
-	 * the renamed entry is moved forward in the slist.  In the second 
+	 * the renamed entry is moved forward in the slist.  In the second
 	 * it is moved backwards.
 	 *
 	 * Since there is only one entry in the cache, this doesn't really
-	 * matter in this case.  But we will do similar tests later with 
+	 * matter in this case.  But we will do similar tests later with
 	 * other entries in the cache.
 	 */
 	if ( pass ) {
@@ -5898,15 +5898,15 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 
     if ( pass ) /* test #7 & #8 */
     {
-	/* Run tests 5 & 6 again, using the flush invalidate flag on the 
+	/* Run tests 5 & 6 again, using the flush invalidate flag on the
 	 * second test.
 	 *
 	 * Single entry test verifying that the cache can handle the case in
 	 * which the call back function renames the entry for which it has
 	 * been called.
 	 *
-	 * Run this entry twice, as the first run moves the entry to its 
-	 * alternate address, and the second moves it back.  
+	 * Run this entry twice, as the first run moves the entry to its
+	 * alternate address, and the second moves it back.
 	 */
         int test_num			= 7; /* and 8 */
 	unsigned int flush_flags	= H5C__NO_FLAGS_SET;
@@ -5915,9 +5915,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	size_t init_expected_index_size	= VARIABLE_ENTRY_SIZE;
 	int expected_index_len		= 1;
 	size_t expected_index_size	= VARIABLE_ENTRY_SIZE;
-	struct fo_flush_cache_test_spec spec[1] = 
+	struct fo_flush_cache_test_spec spec[1] =
 	{
-          { 
+          {
             /* entry_num          = */ 0,
             /* entry_type         = */ VARIABLE_ENTRY_TYPE,
 	    /* entry_index        = */ 0,
@@ -5978,15 +5978,15 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 					 check_size,
 					 checks);
 
-	/* this change forces the rename to move the target entry back to its 
+	/* this change forces the rename to move the target entry back to its
 	 * main address.  The first test moved it to its alternate address.
 	 *
 	 * Note that these two tests are not the same, as in the first test,
-	 * the renamed entry is moved forward in the slist.  In the second 
+	 * the renamed entry is moved forward in the slist.  In the second
 	 * it is moved backwards.
 	 *
 	 * Since there is only one entry in the cache, this doesn't really
-	 * matter in this case.  But we will do similar tests later with 
+	 * matter in this case.  But we will do similar tests later with
 	 * other entries in the cache.
 	 */
 
@@ -6016,11 +6016,11 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
     if ( pass ) /* test #9 & #10 */
     {
 	/* Single entry test verifying that the cache can handle the case in
-	 * which the call back function both resizes and renames the entry 
+	 * which the call back function both resizes and renames the entry
 	 * for which it has been called.
 	 *
-	 * Again, we run this entry twice, as the first run moves the entry to its 
-	 * alternate address, and the second moves it back.  
+	 * Again, we run this entry twice, as the first run moves the entry to its
+	 * alternate address, and the second moves it back.
 	 */
         int test_num			= 9; /* and 10 */
 	unsigned int flush_flags	= H5C__NO_FLAGS_SET;
@@ -6029,9 +6029,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	size_t init_expected_index_size	= VARIABLE_ENTRY_SIZE / 2;
 	int expected_index_len		= 1;
 	size_t expected_index_size	= VARIABLE_ENTRY_SIZE / 4;
-	struct fo_flush_cache_test_spec spec[1] = 
+	struct fo_flush_cache_test_spec spec[1] =
 	{
-          { 
+          {
             /* entry_num          = */ 0,
             /* entry_type         = */ VARIABLE_ENTRY_TYPE,
 	    /* entry_index        = */ 0,
@@ -6092,15 +6092,15 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 					 check_size,
 					 checks);
 
-	/* this change forces the rename to move the target entry back to its 
+	/* this change forces the rename to move the target entry back to its
 	 * main address.  The first test moved it to its alternate address.
 	 *
 	 * Note that these two tests are not the same, as in the first test,
-	 * the renamed entry is moved forward in the slist.  In the second 
+	 * the renamed entry is moved forward in the slist.  In the second
 	 * it is moved backwards.
 	 *
 	 * Since there is only one entry in the cache, this doesn't really
-	 * matter in this case.  But we will do similar tests later with 
+	 * matter in this case.  But we will do similar tests later with
 	 * other entries in the cache.
 	 */
 	if ( pass ) {
@@ -6128,11 +6128,11 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	 * second test.
 	 *
 	 * Single entry test verifying that the cache can handle the case in
-	 * which the call back function both resizes and renames the entry 
+	 * which the call back function both resizes and renames the entry
 	 * for which it has been called.
 	 *
-	 * Again, we run this entry twice, as the first run moves the entry to its 
-	 * alternate address, and the second moves it back.  
+	 * Again, we run this entry twice, as the first run moves the entry to its
+	 * alternate address, and the second moves it back.
 	 */
         int test_num			= 11; /* and 12 */
 	unsigned int flush_flags	= H5C__NO_FLAGS_SET;
@@ -6141,9 +6141,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	size_t init_expected_index_size	= VARIABLE_ENTRY_SIZE / 2;
 	int expected_index_len		= 1;
 	size_t expected_index_size	= VARIABLE_ENTRY_SIZE / 4;
-	struct fo_flush_cache_test_spec spec[1] = 
+	struct fo_flush_cache_test_spec spec[1] =
 	{
-          { 
+          {
             /* entry_num          = */ 0,
             /* entry_type         = */ VARIABLE_ENTRY_TYPE,
 	    /* entry_index        = */ 0,
@@ -6204,15 +6204,15 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 					 check_size,
 					 checks);
 
-	/* this change forces the rename to move the target entry back to its 
+	/* this change forces the rename to move the target entry back to its
 	 * main address.  The first test moved it to its alternate address.
 	 *
 	 * Note that these two tests are not the same, as in the first test,
-	 * the renamed entry is moved forward in the slist.  In the second 
+	 * the renamed entry is moved forward in the slist.  In the second
 	 * it is moved backwards.
 	 *
 	 * Since there is only one entry in the cache, this doesn't really
-	 * matter in this case.  But we will do similar tests later with 
+	 * matter in this case.  But we will do similar tests later with
 	 * other entries in the cache.
 	 */
 	if ( pass ) {
@@ -6241,9 +6241,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 
     if ( pass ) /* test #13 */
     {
-	/* Test the ability of the cache to handle the case in which 
-	 * the flush function of an entry that is resident in cache 
-	 * dirties two entries that are not in cache.  No size 
+	/* Test the ability of the cache to handle the case in which
+	 * the flush function of an entry that is resident in cache
+	 * dirties two entries that are not in cache.  No size
 	 * changes.
 	 *
 	 * At present, I am assured that this case will never occur, but
@@ -6256,9 +6256,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	size_t init_expected_index_size	= 1 * PICO_ENTRY_SIZE;
 	int expected_index_len		= 3;
 	size_t expected_index_size	= 3 * PICO_ENTRY_SIZE;
-	struct fo_flush_cache_test_spec spec[1] = 
+	struct fo_flush_cache_test_spec spec[1] =
 	{
-          { 
+          {
             /* entry_num          = */ 0,
             /* entry_type         = */ 0,
 	    /* entry_index        = */ 1,
@@ -6339,9 +6339,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
     {
 	/* Repeat previous test with the flush invalidate flag.
 	 *
-	 * Test the ability of the cache to handle the case in which 
-	 * the flush function of an entry that is resident in cache 
-	 * dirties two entries that are not in cache.  No size 
+	 * Test the ability of the cache to handle the case in which
+	 * the flush function of an entry that is resident in cache
+	 * dirties two entries that are not in cache.  No size
 	 * changes.
 	 *
 	 * At present, I am assured that this case will never occur, but
@@ -6354,9 +6354,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	size_t init_expected_index_size	= 1 * PICO_ENTRY_SIZE;
 	int expected_index_len		= 0;
 	size_t expected_index_size	= (size_t)0;
-	struct fo_flush_cache_test_spec spec[1] = 
+	struct fo_flush_cache_test_spec spec[1] =
 	{
-          { 
+          {
             /* entry_num          = */ 0,
             /* entry_type         = */ 0,
 	    /* entry_index        = */ 1,
@@ -6435,8 +6435,8 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 
     if ( pass ) /* test #15 */
     {
-	/* Test the ability of the cache to handle the case in which 
-	 * the flush function of an entry that is resident in cache 
+	/* Test the ability of the cache to handle the case in which
+	 * the flush function of an entry that is resident in cache
 	 * resizes and dirties two entries that are not in cache.
 	 *
 	 * At present, I am assured that this case will never occur, but
@@ -6451,9 +6451,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	size_t expected_index_size	= VARIABLE_ENTRY_SIZE +
 		                          (VARIABLE_ENTRY_SIZE / 4) +
 					  (VARIABLE_ENTRY_SIZE / 2);
-	struct fo_flush_cache_test_spec spec[1] = 
+	struct fo_flush_cache_test_spec spec[1] =
 	{
-          { 
+          {
             /* entry_num          = */ 0,
             /* entry_type         = */ VARIABLE_ENTRY_TYPE,
 	    /* entry_index        = */ 1,
@@ -6534,8 +6534,8 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
     {
 	/* Repeat previous test with the flush invalidate flag.
 	 *
-	 * Test the ability of the cache to handle the case in which 
-	 * the flush function of an entry that is resident in cache 
+	 * Test the ability of the cache to handle the case in which
+	 * the flush function of an entry that is resident in cache
 	 * resizes and dirties two entries that are not in cache.
 	 *
 	 * At present, I am assured that this case will never occur, but
@@ -6548,9 +6548,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	size_t init_expected_index_size	= 1 * VARIABLE_ENTRY_SIZE;
 	int expected_index_len		= 0;
 	size_t expected_index_size	= (size_t)0;
-	struct fo_flush_cache_test_spec spec[1] = 
+	struct fo_flush_cache_test_spec spec[1] =
 	{
-          { 
+          {
             /* entry_num          = */ 0,
             /* entry_type         = */ VARIABLE_ENTRY_TYPE,
 	    /* entry_index        = */ 1,
@@ -6629,8 +6629,8 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 
     if ( pass ) /* test #17 & #18 */
     {
-	/* Test the ability of the cache to handle the case in which 
-	 * the flush function of an entry that is resident in cache 
+	/* Test the ability of the cache to handle the case in which
+	 * the flush function of an entry that is resident in cache
 	 * resizes, dirties, and renames two entries that are not in cache.
 	 *
 	 * At present, I am assured that this case will never occur, but
@@ -6645,9 +6645,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	size_t expected_index_size	= VARIABLE_ENTRY_SIZE +
 		                          (VARIABLE_ENTRY_SIZE / 4) +
 					  (VARIABLE_ENTRY_SIZE / 2);
-	struct fo_flush_cache_test_spec spec[1] = 
+	struct fo_flush_cache_test_spec spec[1] =
 	{
-          { 
+          {
             /* entry_num          = */ 0,
             /* entry_type         = */ VARIABLE_ENTRY_TYPE,
 	    /* entry_index        = */ 1,
@@ -6710,7 +6710,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	    /* expected_destroyed = */ FALSE
 	  }
 	};
-	
+
         check_flush_cache__flush_op_test(cache_ptr,
                                          test_num,
                                          flush_flags,
@@ -6723,12 +6723,12 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 					 check_size,
 					 checks);
 
-	/* this change forces the renames to move the target entries back to 
-	 * their main address.  The first test moved them to their alternate 
+	/* this change forces the renames to move the target entries back to
+	 * their main address.  The first test moved them to their alternate
 	 * address.
 	 *
 	 * Note that these two tests are not the same, as in the first test,
-	 * the renamed entries are moved forward in the slist.  In the second 
+	 * the renamed entries are moved forward in the slist.  In the second
 	 * they are moved backwards.
 	 */
 	if ( pass ) {
@@ -6758,8 +6758,8 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	/* Repeat the above test with the flush invalidate flag on the
 	 * second test.
 	 *
-	 * Test the ability of the cache to handle the case in which 
-	 * the flush function of an entry that is resident in cache 
+	 * Test the ability of the cache to handle the case in which
+	 * the flush function of an entry that is resident in cache
 	 * resizes, dirties, and renames two entries that are not in cache.
 	 *
 	 * At present, I am assured that this case will never occur, but
@@ -6774,9 +6774,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	size_t expected_index_size	= VARIABLE_ENTRY_SIZE +
 		                          (VARIABLE_ENTRY_SIZE / 4) +
 					  (VARIABLE_ENTRY_SIZE / 2);
-	struct fo_flush_cache_test_spec spec[1] = 
+	struct fo_flush_cache_test_spec spec[1] =
 	{
-          { 
+          {
             /* entry_num          = */ 0,
             /* entry_type         = */ VARIABLE_ENTRY_TYPE,
 	    /* entry_index        = */ 1,
@@ -6852,12 +6852,12 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 					 check_size,
 					 checks);
 
-	/* this change forces the renames to move the target entries back to 
-	 * their main address.  The first test moved them to their alternate 
+	/* this change forces the renames to move the target entries back to
+	 * their main address.  The first test moved them to their alternate
 	 * address.
 	 *
 	 * Note that these two tests are not the same, as in the first test,
-	 * the renamed entries are moved forward in the slist.  In the second 
+	 * the renamed entries are moved forward in the slist.  In the second
 	 * they are moved backwards.
 	 */
 	if ( pass ) {
@@ -6894,14 +6894,14 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
     {
 	/* Now mix things up a bit.
 	 *
-	 * Load several entries, two of which have flush functions that 
-	 * resize, dirty, and rename two entries that are not in the 
-	 * cache.  Mark only one of these entries, and then flush the 
+	 * Load several entries, two of which have flush functions that
+	 * resize, dirty, and rename two entries that are not in the
+	 * cache.  Mark only one of these entries, and then flush the
 	 * cache with the flush marked entries flag.
 	 *
-	 * This is the only test in which we test the 
+	 * This is the only test in which we test the
 	 * H5C__FLUSH_MARKED_ENTRIES_FLAG.  The hope is that since
-	 * we test the two features extensively by themselves, so 
+	 * we test the two features extensively by themselves, so
 	 * it should be sufficient to verify that they play together
 	 * as expected.
 	 */
@@ -6915,9 +6915,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 		                          (VARIABLE_ENTRY_SIZE / 4) +
 					  (VARIABLE_ENTRY_SIZE / 2) +
 					  (2 * PICO_ENTRY_SIZE);
-	struct fo_flush_cache_test_spec spec[4] = 
+	struct fo_flush_cache_test_spec spec[4] =
 	{
-          { 
+          {
             /* entry_num          = */ 0,
             /* entry_type         = */ VARIABLE_ENTRY_TYPE,
 	    /* entry_index        = */ 1,
@@ -6945,7 +6945,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	    /* expected_flushed   = */ TRUE,
 	    /* expected_destroyed = */ FALSE
           },
-          { 
+          {
             /* entry_num          = */ 1,
             /* entry_type         = */ VARIABLE_ENTRY_TYPE,
 	    /* entry_index        = */ 11,
@@ -6973,7 +6973,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	    /* expected_flushed   = */ FALSE,
 	    /* expected_destroyed = */ FALSE
           },
-          { 
+          {
             /* entry_num          = */ 2,
             /* entry_type         = */ PICO_ENTRY_TYPE,
 	    /* entry_index        = */ 0,
@@ -7001,7 +7001,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	    /* expected_flushed   = */ TRUE,
 	    /* expected_destroyed = */ FALSE
           },
-          { 
+          {
             /* entry_num          = */ 3,
             /* entry_type         = */ PICO_ENTRY_TYPE,
 	    /* entry_index        = */ 1,
@@ -7113,9 +7113,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
     {
 	/* Mix things up some more.
 	 *
-	 * Load lots of entries, some of which have flush functions that 
-	 * resize, dirty, and rename two entries that are not in the 
-	 * cache.  
+	 * Load lots of entries, some of which have flush functions that
+	 * resize, dirty, and rename two entries that are not in the
+	 * cache.
 	 *
 	 * Also load entries that have flush ops on entries that are in
 	 * cache.
@@ -7130,9 +7130,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 		                          (2 * (VARIABLE_ENTRY_SIZE / 4)) +
 					  (2 * (VARIABLE_ENTRY_SIZE / 2)) +
 					  (4 * PICO_ENTRY_SIZE);
-	struct fo_flush_cache_test_spec spec[6] = 
+	struct fo_flush_cache_test_spec spec[6] =
 	{
-          { 
+          {
             /* entry_num          = */ 0,
             /* entry_type         = */ VARIABLE_ENTRY_TYPE,
 	    /* entry_index        = */ 1,
@@ -7160,7 +7160,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	    /* expected_flushed   = */ TRUE,
 	    /* expected_destroyed = */ FALSE
           },
-          { 
+          {
             /* entry_num          = */ 1,
             /* entry_type         = */ VARIABLE_ENTRY_TYPE,
 	    /* entry_index        = */ 11,
@@ -7188,7 +7188,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	    /* expected_flushed   = */ TRUE,
 	    /* expected_destroyed = */ FALSE
           },
-          { 
+          {
             /* entry_num          = */ 2,
             /* entry_type         = */ PICO_ENTRY_TYPE,
 	    /* entry_index        = */ 0,
@@ -7216,7 +7216,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	    /* expected_flushed   = */ TRUE,
 	    /* expected_destroyed = */ FALSE
           },
-          { 
+          {
             /* entry_num          = */ 3,
             /* entry_type         = */ PICO_ENTRY_TYPE,
 	    /* entry_index        = */ 1,
@@ -7244,7 +7244,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	    /* expected_flushed   = */ FALSE,
 	    /* expected_destroyed = */ FALSE
           },
-          { 
+          {
             /* entry_num          = */ 4,
             /* entry_type         = */ PICO_ENTRY_TYPE,
 	    /* entry_index        = */ 10,
@@ -7272,7 +7272,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	    /* expected_flushed   = */ TRUE,
 	    /* expected_destroyed = */ FALSE
           },
-          { 
+          {
             /* entry_num          = */ 5,
             /* entry_type         = */ PICO_ENTRY_TYPE,
 	    /* entry_index        = */ 20,
@@ -7386,9 +7386,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	 *
 	 * Mix things up some more.
 	 *
-	 * Load lots of entries, some of which have flush functions that 
-	 * resize, dirty, and rename two entries that are not in the 
-	 * cache.  
+	 * Load lots of entries, some of which have flush functions that
+	 * resize, dirty, and rename two entries that are not in the
+	 * cache.
 	 *
 	 * Also load entries that have flush ops on entries that are in
 	 * cache.
@@ -7400,9 +7400,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	size_t init_expected_index_size	= (2 * VARIABLE_ENTRY_SIZE) + (4 * PICO_ENTRY_SIZE);
 	int expected_index_len		= 0;
 	size_t expected_index_size	= 0;
-	struct fo_flush_cache_test_spec spec[6] = 
+	struct fo_flush_cache_test_spec spec[6] =
 	{
-          { 
+          {
             /* entry_num          = */ 0,
             /* entry_type         = */ VARIABLE_ENTRY_TYPE,
 	    /* entry_index        = */ 1,
@@ -7430,7 +7430,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	    /* expected_flushed   = */ TRUE,
 	    /* expected_destroyed = */ TRUE
           },
-          { 
+          {
             /* entry_num          = */ 1,
             /* entry_type         = */ VARIABLE_ENTRY_TYPE,
 	    /* entry_index        = */ 11,
@@ -7458,7 +7458,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	    /* expected_flushed   = */ TRUE,
 	    /* expected_destroyed = */ TRUE
           },
-          { 
+          {
             /* entry_num          = */ 2,
             /* entry_type         = */ PICO_ENTRY_TYPE,
 	    /* entry_index        = */ 0,
@@ -7486,7 +7486,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	    /* expected_flushed   = */ TRUE,
 	    /* expected_destroyed = */ TRUE
           },
-          { 
+          {
             /* entry_num          = */ 3,
             /* entry_type         = */ PICO_ENTRY_TYPE,
 	    /* entry_index        = */ 1,
@@ -7514,7 +7514,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	    /* expected_flushed   = */ TRUE,
 	    /* expected_destroyed = */ TRUE
           },
-          { 
+          {
             /* entry_num          = */ 4,
             /* entry_type         = */ PICO_ENTRY_TYPE,
 	    /* entry_index        = */ 10,
@@ -7542,7 +7542,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	    /* expected_flushed   = */ TRUE,
 	    /* expected_destroyed = */ TRUE
           },
-          { 
+          {
             /* entry_num          = */ 5,
             /* entry_type         = */ PICO_ENTRY_TYPE,
 	    /* entry_index        = */ 20,
@@ -7666,9 +7666,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	size_t init_expected_index_size	= 3 * PICO_ENTRY_SIZE;
 	int expected_index_len		= 3;
 	size_t expected_index_size	= 3 * PICO_ENTRY_SIZE;
-	struct fo_flush_cache_test_spec spec[3] = 
+	struct fo_flush_cache_test_spec spec[3] =
 	{
-          { 
+          {
             /* entry_num          = */ 0,
             /* entry_type         = */ PICO_ENTRY_TYPE,
 	    /* entry_index        = */ 100,
@@ -7800,9 +7800,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	size_t init_expected_index_size	= 3 * PICO_ENTRY_SIZE;
 	int expected_index_len		= 0;
 	size_t expected_index_size	= (size_t)0;
-	struct fo_flush_cache_test_spec spec[3] = 
+	struct fo_flush_cache_test_spec spec[3] =
 	{
-          { 
+          {
             /* entry_num          = */ 0,
             /* entry_type         = */ PICO_ENTRY_TYPE,
 	    /* entry_index        = */ 100,
@@ -7922,22 +7922,22 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 
     if ( pass ) /* test #26 */
     {
-	/* This one is complex.  
+	/* This one is complex.
 	 *
-	 * In the following overvies table, VET stands for 
+	 * In the following overvies table, VET stands for
 	 * VARIABLE_ENTRY_TYPE.
 	 *
 	 * In trying to follow what happens when we flush the
 	 * set of entries constructed below, recall that each
-	 * flush operation is executed the first time the 
+	 * flush operation is executed the first time the
 	 * entry is flushed, and then not executed again.
-	 * This may be a weakness in the tests, but that 
+	 * This may be a weakness in the tests, but that
 	 * is the way it is for now.
 	 *
-	 * After thinking about it for a while, I'm not sure that 
-	 * the interaction between pins and flush operations needs 
-	 * all that much testing, as the two are essentially 
-	 * orthoginal.  Thus this is a bit of a smoke check to 
+	 * After thinking about it for a while, I'm not sure that
+	 * the interaction between pins and flush operations needs
+	 * all that much testing, as the two are essentially
+	 * orthoginal.  Thus this is a bit of a smoke check to
 	 * verify that we get the expected results.
 	 *
 	 * (VET, 100)	initially not resident in cache
@@ -8004,9 +8004,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	size_t init_expected_index_size	= 10 * VARIABLE_ENTRY_SIZE;
 	int expected_index_len		= 13;
 	size_t expected_index_size	= 9 * VARIABLE_ENTRY_SIZE;
-	struct fo_flush_cache_test_spec spec[10] = 
+	struct fo_flush_cache_test_spec spec[10] =
 	{
-          { 
+          {
             /* entry_num          = */ 0,
             /* entry_type         = */ VARIABLE_ENTRY_TYPE,
 	    /* entry_index        = */ 200,
@@ -8357,24 +8357,24 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
     {
 	/* Repeat test #26 with the flush invalidate flag.
 	 *
-	 * In the following overview table, VET stands for 
+	 * In the following overview table, VET stands for
 	 * VARIABLE_ENTRY_TYPE.
 	 *
 	 * In trying to follow what happens when we flush the
 	 * set of entries constructed below, recall that each
-	 * flush operation is executed the first time the 
+	 * flush operation is executed the first time the
 	 * entry is flushed, and then not executed again.
-	 * This may be a weakness in the tests, but that 
+	 * This may be a weakness in the tests, but that
 	 * is the way it is for now.
 	 *
-	 * After thinking about it for a while, I'm not sure that 
-	 * the interaction between pins and flush operations needs 
-	 * all that much testing, as the two are essentially 
+	 * After thinking about it for a while, I'm not sure that
+	 * the interaction between pins and flush operations needs
+	 * all that much testing, as the two are essentially
 	 * orthoginal.  The big thing is to verify that flushes of
-	 * pinned entries with flush ops result in the expected 
+	 * pinned entries with flush ops result in the expected
 	 * updates of the cache.
 	 *
-	 * Thus this is a bit of a smoke check to * verify that we 
+	 * Thus this is a bit of a smoke check to * verify that we
 	 * get the expected results.
 	 *
 	 * (VET, 100)	initially not resident in cache
@@ -8441,9 +8441,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	size_t init_expected_index_size	= 10 * VARIABLE_ENTRY_SIZE;
 	int expected_index_len		= 0;
 	size_t expected_index_size	= (size_t)0;
-	struct fo_flush_cache_test_spec spec[10] = 
+	struct fo_flush_cache_test_spec spec[10] =
 	{
-          { 
+          {
             /* entry_num          = */ 0,
             /* entry_type         = */ VARIABLE_ENTRY_TYPE,
 	    /* entry_index        = */ 200,
@@ -8793,7 +8793,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
     if ( pass ) /* test #28 */
     {
 	/* Test the expected fheap case, in which an entry dirties
-	 * and resizes itself, and dirties an entry which it has 
+	 * and resizes itself, and dirties an entry which it has
 	 * pinned.
 	 */
         int test_num			= 28;
@@ -8803,9 +8803,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	size_t init_expected_index_size	= 3 * VARIABLE_ENTRY_SIZE;
 	int expected_index_len		= 5;
 	size_t expected_index_size	= 4 * VARIABLE_ENTRY_SIZE;
-	struct fo_flush_cache_test_spec spec[5] = 
+	struct fo_flush_cache_test_spec spec[5] =
 	{
-          { 
+          {
             /* entry_num          = */ 0,
             /* entry_type         = */ VARIABLE_ENTRY_TYPE,
 	    /* entry_index        = */ 100,
@@ -8986,7 +8986,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	/* Repeat test #28 with the flush invalidate flag.
 	 *
 	 * Test the expected fheap case, in which an entry dirties
-	 * and resizes itself, and dirties an entry which it has 
+	 * and resizes itself, and dirties an entry which it has
 	 * pinned.
 	 */
         int test_num			= 29;
@@ -8996,9 +8996,9 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 	size_t init_expected_index_size	= 3 * VARIABLE_ENTRY_SIZE;
 	int expected_index_len		= 0;
 	size_t expected_index_size	= 0;
-	struct fo_flush_cache_test_spec spec[5] = 
+	struct fo_flush_cache_test_spec spec[5] =
 	{
-          { 
+          {
             /* entry_num          = */ 0,
             /* entry_type         = */ VARIABLE_ENTRY_TYPE,
 	    /* entry_index        = */ 100,
@@ -9185,7 +9185,7 @@ check_flush_cache__flush_ops(H5C_t * cache_ptr)
 /*-------------------------------------------------------------------------
  * Function:	check_flush_cache__flush_op_test()
  *
- * Purpose:	Run a flush op flush cache test.  Of the nature of 
+ * Purpose:	Run a flush op flush cache test.  Of the nature of
  * 		flush operations, this is a multi-entry test.
  *
  * Return:	void
@@ -9222,7 +9222,7 @@ check_flush_cache__flush_op_test(H5C_t * cache_ptr,
 #if 0 /* This is useful debugging code -- lets keep it around. */
     HDfprintf(stdout, "check_flush_cache__flush_op_test: test %d\n",
 	      test_num);
-#endif 
+#endif
 
     if ( cache_ptr == NULL ) {
 
@@ -9282,23 +9282,23 @@ check_flush_cache__flush_op_test(H5C_t * cache_ptr,
              ( check[i].entry_index < 0 ) ||
              ( check[i].entry_index > max_indices[check[i].entry_type] ) ||
              ( check[i].expected_size <= (size_t)0 ) ||
-	     ( ( check[i].in_cache != TRUE ) && 
+	     ( ( check[i].in_cache != TRUE ) &&
 	       ( check[i].in_cache != FALSE ) ) ||
-	     ( ( check[i].at_main_addr != TRUE ) && 
+	     ( ( check[i].at_main_addr != TRUE ) &&
 	       ( check[i].at_main_addr != FALSE ) ) ||
-	     ( ( check[i].is_dirty != TRUE ) && 
+	     ( ( check[i].is_dirty != TRUE ) &&
 	       ( check[i].is_dirty != FALSE ) ) ||
-	     ( ( check[i].is_protected != TRUE ) && 
+	     ( ( check[i].is_protected != TRUE ) &&
 	       ( check[i].is_protected != FALSE ) ) ||
-	     ( ( check[i].is_pinned != TRUE ) && 
+	     ( ( check[i].is_pinned != TRUE ) &&
 	       ( check[i].is_pinned != FALSE ) ) ||
-	     ( ( check[i].expected_loaded != TRUE ) && 
+	     ( ( check[i].expected_loaded != TRUE ) &&
 	       ( check[i].expected_loaded != FALSE ) ) ||
-	     ( ( check[i].expected_cleared != TRUE ) && 
+	     ( ( check[i].expected_cleared != TRUE ) &&
 	       ( check[i].expected_cleared != FALSE ) ) ||
-	     ( ( check[i].expected_flushed != TRUE ) && 
+	     ( ( check[i].expected_flushed != TRUE ) &&
 	       ( check[i].expected_flushed != FALSE ) ) ||
-	     ( ( check[i].expected_destroyed != TRUE ) && 
+	     ( ( check[i].expected_destroyed != TRUE ) &&
 	       ( check[i].expected_destroyed != FALSE ) ) ) {
 
             pass = FALSE;
@@ -9338,7 +9338,7 @@ check_flush_cache__flush_op_test(H5C_t * cache_ptr,
 
 	for ( j = 0; j < spec[i].num_flush_ops; j++ )
 	{
-	    add_flush_op(spec[i].entry_type, 
+	    add_flush_op(spec[i].entry_type,
 			 spec[i].entry_index,
 			 spec[i].flush_ops[j].op_code,
 			 spec[i].flush_ops[j].type,
@@ -9420,7 +9420,7 @@ check_flush_cache__flush_op_test(H5C_t * cache_ptr,
         i = 0;
         while ( ( pass ) && ( i < check_size ) )
         {
-	    if ( check[i].in_cache != entry_in_cache(cache_ptr, 
+	    if ( check[i].in_cache != entry_in_cache(cache_ptr,
 				                     check[i].entry_type,
 						     check[i].entry_index) ) {
 
@@ -9460,7 +9460,7 @@ check_flush_cache__flush_op_test(H5C_t * cache_ptr,
 		if ( ( ! entry_ptr->header.destroy_in_progress ) &&
 		     ( check[i].in_cache ) &&
                      ( entry_ptr->header.size != check[i].expected_size ) ) {
-                    HDfprintf(stdout, 
+                    HDfprintf(stdout,
                               "(!destroy in progress and in cache and size (expected) = %d (%d).\n",
                               (int)(entry_ptr->header.size),
 			      (int)(check[i].expected_size));
@@ -9654,9 +9654,9 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
     test_entry_t * base_addr;
     struct expected_entry_status expected[8 + 31 + 14] =
     {
-      /* the expected array is used to maintain a table of the expected status of every 
+      /* the expected array is used to maintain a table of the expected status of every
        * entry used in this test.  Note that since the function that processes this
-       * array only processes as much of it as it is told to, we don't have to 
+       * array only processes as much of it as it is told to, we don't have to
        * worry about maintaining the status of entries that we haven't used yet.
        */
       /* entry			entry				in	at main                                                       */
@@ -9745,9 +9745,9 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
     if ( pass ) {
 
         /* the basic idea in this test is to insert a bunch of entries
-         * with flush operations associated with them, and then load 
-         * other entries into the cache until the cache is full.  At 
-         * that point, load yet more entries into the cache, and see 
+         * with flush operations associated with them, and then load
+         * other entries into the cache until the cache is full.  At
+         * that point, load yet more entries into the cache, and see
          * if the flush operations are performed as expected.
 	 *
 	 * To make things a bit more interesting, we also include a
@@ -9765,43 +9765,43 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	 */
 
 	protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 0);
-	unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 0, 
+	unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 0,
 			           H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG,
 				   (VARIABLE_ENTRY_SIZE / 2));
 
 	protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 1);
-	unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 1, 
+	unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 1,
 			                 H5C__NO_FLAGS_SET, (size_t)0);
 
 	protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 2);
-	unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 2, 
+	unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 2,
 			                 H5C__NO_FLAGS_SET, (size_t)0);
 
 	protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 3);
-	unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 3, 
+	unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 3,
 			           H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG,
 				   (VARIABLE_ENTRY_SIZE / 2));
 
 	protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 4);
-	unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 4, 
+	unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 4,
 			           H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG,
 				   (VARIABLE_ENTRY_SIZE / 2));
 
 	protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 5);
-	unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 5, 
+	unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 5,
 			           H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG,
 				   (VARIABLE_ENTRY_SIZE / 2));
 
 	protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 6);
-	unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 6, 
+	unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 6,
 			                 H5C__NO_FLAGS_SET, (size_t)0);
 
 	protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 7);
-	unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 7, 
+	unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 7,
 			                 H5C__NO_FLAGS_SET, (size_t)0);
 
 	if ( ( cache_ptr->index_len != 8 ) ||
-             ( cache_ptr->index_size != (4 * (VARIABLE_ENTRY_SIZE / 2)) + 
+             ( cache_ptr->index_size != (4 * (VARIABLE_ENTRY_SIZE / 2)) +
 	                                (4 * VARIABLE_ENTRY_SIZE) ) ) {
 
             pass = FALSE;
@@ -9811,7 +9811,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 
     if ( pass ) {
 
-	/* Now set up the pinning relationships: 
+	/* Now set up the pinning relationships:
 	 *
 	 * Briefly, (VET, 0) is pinned by (VET, 1), (VET, 2), and (VET, 3)
 	 *          (VET, 7) is pinned by (VET, 3), and (VET, 5)
@@ -9841,39 +9841,39 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	 *
 	 *          (VET, 7) dirties (VET, 6)
 	 */
-        add_flush_op(VARIABLE_ENTRY_TYPE, 1, FLUSH_OP__DIRTY, 
+        add_flush_op(VARIABLE_ENTRY_TYPE, 1, FLUSH_OP__DIRTY,
                      VARIABLE_ENTRY_TYPE, 0, FALSE, (size_t)0);
-        add_flush_op(VARIABLE_ENTRY_TYPE, 1, FLUSH_OP__RESIZE, 
-                     VARIABLE_ENTRY_TYPE, 0, FALSE, 
+        add_flush_op(VARIABLE_ENTRY_TYPE, 1, FLUSH_OP__RESIZE,
+                     VARIABLE_ENTRY_TYPE, 0, FALSE,
 		     3 * VARIABLE_ENTRY_SIZE / 4);
 
-        add_flush_op(VARIABLE_ENTRY_TYPE, 2, FLUSH_OP__DIRTY, 
+        add_flush_op(VARIABLE_ENTRY_TYPE, 2, FLUSH_OP__DIRTY,
                      VARIABLE_ENTRY_TYPE, 0, FALSE, (size_t)0);
-        add_flush_op(VARIABLE_ENTRY_TYPE, 2, FLUSH_OP__RESIZE, 
+        add_flush_op(VARIABLE_ENTRY_TYPE, 2, FLUSH_OP__RESIZE,
                      VARIABLE_ENTRY_TYPE, 0, FALSE, VARIABLE_ENTRY_SIZE);
-        add_flush_op(VARIABLE_ENTRY_TYPE, 2, FLUSH_OP__RENAME, 
+        add_flush_op(VARIABLE_ENTRY_TYPE, 2, FLUSH_OP__RENAME,
                      VARIABLE_ENTRY_TYPE, 0, FALSE, (size_t)0);
 
-        add_flush_op(VARIABLE_ENTRY_TYPE, 3, FLUSH_OP__DIRTY, 
+        add_flush_op(VARIABLE_ENTRY_TYPE, 3, FLUSH_OP__DIRTY,
                      VARIABLE_ENTRY_TYPE, 0, FALSE, (size_t)0);
-        add_flush_op(VARIABLE_ENTRY_TYPE, 3, FLUSH_OP__RESIZE, 
+        add_flush_op(VARIABLE_ENTRY_TYPE, 3, FLUSH_OP__RESIZE,
                      VARIABLE_ENTRY_TYPE, 3, FALSE, VARIABLE_ENTRY_SIZE);
 
-        add_flush_op(VARIABLE_ENTRY_TYPE, 7, FLUSH_OP__DIRTY, 
+        add_flush_op(VARIABLE_ENTRY_TYPE, 7, FLUSH_OP__DIRTY,
                      VARIABLE_ENTRY_TYPE, 6, FALSE, (size_t)0);
     }
 
     if ( pass ) {
 
-	/* to summarize, at present the following variable size entries 
+	/* to summarize, at present the following variable size entries
 	 * are in cache with the following characteristics:
 	 *
 	 * 		in
 	 * entry:	cache?	size:	dirty?	pinned?	pins:	flush operations:
-	 * 
+	 *
 	 * (VET, 0) 	Y	 5 KB	Y	Y	-	-
 	 *
-	 * (VET, 1)	Y	10 KB	N	N	0	dirty (VET, 0), 
+	 * (VET, 1)	Y	10 KB	N	N	0	dirty (VET, 0),
 	 * 							resize (VET, 0) to 7.5 KB
 	 *
 	 * (VET, 2)	Y	10 KB	N	N	0	dirty (VET, 0)
@@ -9888,11 +9888,11 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	 * (VET, 5)	Y	 5 KB	Y	N	7	-
 	 *
 	 * (VET, 6)	Y	10 KB	N	N	-	-
-	 * 
+	 *
 	 * (VET, 7)	Y	10 KB	N	Y	-	dirty (VET, 6)
 	 *
-	 * Recall that in this test bed, flush operations are excuted the 
-	 * first time the associated entry is flushed, and are then 
+	 * Recall that in this test bed, flush operations are excuted the
+	 * first time the associated entry is flushed, and are then
 	 * deleted.
 	 */
 
@@ -9900,14 +9900,14 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	for ( i = 0; i < 31; i++ )
 	{
 	    protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(cache_ptr, MONSTER_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(cache_ptr, MONSTER_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
 	for ( i = 0; i < 1; i++ )
 	{
 	    protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
@@ -9926,9 +9926,9 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 
 	    /* verify the expected status of all entries we have loaded to date: */
             num_large_entries = 1;
-	    verify_entry_status(cache_ptr, 
+	    verify_entry_status(cache_ptr,
 			        0,
-			        (num_variable_entries + num_monster_entries + num_large_entries), 
+			        (num_variable_entries + num_monster_entries + num_large_entries),
 				expected);
 	}
     }
@@ -9936,8 +9936,8 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 
     if ( pass ) {
 
-	/* Now load a large entry.  This should result in the eviction 
-	 * of (VET,1), and the increase in the size of (VET, 0) from .5 
+	/* Now load a large entry.  This should result in the eviction
+	 * of (VET,1), and the increase in the size of (VET, 0) from .5
 	 * VARIABLE_ENTRY_SIZE to .75 VARIABLE_ENTRY_SIZE.
 	 *
 	 * The following table illustrates the intended state of affairs
@@ -9945,7 +9945,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	 *
 	 * 		in
 	 * entry:	cache?	size:	dirty?	pinned?	pins:	flush operations:
-	 * 
+	 *
 	 * (VET, 0) 	Y	7.5 KB	Y	Y	-	-
 	 *
 	 * (VET, 1)	N	10 KB	N	N	-	-
@@ -9962,7 +9962,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	 * (VET, 5)	Y	 5 KB	Y	N	7	-
 	 *
 	 * (VET, 6)	Y	10 KB	N	N	-	-
-	 * 
+	 *
 	 * (VET, 7)	Y	10 KB	Y	Y	-	dirty (VET, 6)
 	 *
 	 * Start by updating the expected table for the expected changes in entry status:
@@ -9975,7 +9975,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
         num_large_entries = 2;
 
 	protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 1);
-	unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, 1, 
+	unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, 1,
                                          H5C__DIRTIED_FLAG, (size_t)0);
 
 	if ( ( cache_ptr->index_len != 40 ) ||
@@ -9994,25 +9994,25 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	}
 
 	/* verify entry status */
-	verify_entry_status(cache_ptr, 
+	verify_entry_status(cache_ptr,
 			    1,
-                            (num_variable_entries + num_monster_entries + num_large_entries), 
+                            (num_variable_entries + num_monster_entries + num_large_entries),
 			    expected);
     }
 
     if ( pass ) {
 
-	/* Now load another large entry.  This should result in the eviction 
+	/* Now load another large entry.  This should result in the eviction
 	 * of (VET, 2), the increase in the size of (VET, 0) from .75
 	 * VARIABLE_ENTRY_SIZE to 1.0 VARIABLE_ENTRY_SIZE, and the renaming
 	 * of (VET, 0) to its alternate address.
 	 *
-	 * The following table shows the expected states of the variable 
+	 * The following table shows the expected states of the variable
 	 * size entries after the test.
 	 *
 	 * 		in
 	 * entry:	cache?	size:	dirty?	pinned?	pins:	flush operations:
-	 * 
+	 *
 	 * (VET, 0) 	Y	10 KB	Y	Y	-	-
 	 *
 	 * (VET, 1)	N	10 KB	N	N	-	-
@@ -10027,7 +10027,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	 * (VET, 5)	Y	 5 KB	Y	N	7	-
 	 *
 	 * (VET, 6)	Y	10 KB	N	N	-	-
-	 * 
+	 *
 	 * (VET, 7)	Y	10 KB	Y	Y	-	dirty (VET, 6)
 	 *
 	 * Start by updating the expected table for the expected changes in entry status:
@@ -10041,7 +10041,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
         num_large_entries = 3;
 
 	protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 2);
-	unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, 2, 
+	unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, 2,
                                          H5C__DIRTIED_FLAG, (size_t)0);
 
 	if ( ( cache_ptr->index_len != 40 ) ||
@@ -10051,7 +10051,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	                                (2 * LARGE_ENTRY_SIZE) ) ||
 	     ( cache_ptr->index_size != ((3 * VARIABLE_ENTRY_SIZE / 2) +
 				         (3 * VARIABLE_ENTRY_SIZE) +
-				         (31 * MONSTER_ENTRY_SIZE) + 
+				         (31 * MONSTER_ENTRY_SIZE) +
 				         (3 * LARGE_ENTRY_SIZE)) ) ) {
 
             pass = FALSE;
@@ -10059,9 +10059,9 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	}
 
 	/* verify entry status */
-	verify_entry_status(cache_ptr, 
+	verify_entry_status(cache_ptr,
 			    2,
-                            (num_variable_entries + num_monster_entries + num_large_entries), 
+                            (num_variable_entries + num_monster_entries + num_large_entries),
 			    expected);
     }
 
@@ -10071,16 +10071,16 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	 * flushed, and increasing its size from 1/2 VARIABLE_ENTRY_SIZE to
 	 * VARIABLE_ENTRY_SIZE.
 	 *
-	 * As a result of this size increase, the cache will have to look 
+	 * As a result of this size increase, the cache will have to look
 	 * for another entry to evict.  After flushing (VET, 4) and (VET, 5),
 	 * it should evict (VET, 6), yielding the needed memory.
 	 *
-	 * The following table shows the expected states of the variable 
+	 * The following table shows the expected states of the variable
 	 * size entries after the test.
 	 *
 	 * 		in
 	 * entry:	cache?	size:	dirty?	pinned?	pins:	flush operations:
-	 * 
+	 *
 	 * (VET, 0) 	Y	10 KB	Y	Y	-	-
 	 *
 	 * (VET, 1)	N	10 KB	N	N	-	-
@@ -10094,7 +10094,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	 * (VET, 5)	Y	 5 KB	N	N	7	-
 	 *
 	 * (VET, 6)	N	10 KB	N	N	-	-
-	 * 
+	 *
 	 * (VET, 7)	Y	10 KB	Y	Y	-	dirty (VET, 6)
 	 *
 	 * Start by updating the expected table for the expected changes in entry status:
@@ -10114,11 +10114,11 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
         num_large_entries = 5;
 
 	protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 3);
-	unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, 3, 
+	unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, 3,
                                          H5C__DIRTIED_FLAG, (size_t)0);
 
 	protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 4);
-	unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, 4, 
+	unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, 4,
                                          H5C__DIRTIED_FLAG, (size_t)0);
 
         /* verify cache size */
@@ -10137,16 +10137,16 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	}
 
 	/* verify entry status */
-	verify_entry_status(cache_ptr, 
+	verify_entry_status(cache_ptr,
 			    3,
-                            (num_variable_entries + num_monster_entries + num_large_entries), 
+                            (num_variable_entries + num_monster_entries + num_large_entries),
 			    expected);
     }
 
     if ( pass ) {
 
         /* now touch all the non VARIABLE_ENTRY_TYPE entries in the
-	 * cache to bring all the VARIABLE_ENTRY_TYPE entries to the 
+	 * cache to bring all the VARIABLE_ENTRY_TYPE entries to the
 	 * end of the LRU list.
 	 *
 	 * Note that we don't have to worry about (VET, 0) and (VET, 7)
@@ -10155,14 +10155,14 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	for ( i = 0; i < 31; i++ )
 	{
 	    protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(cache_ptr, MONSTER_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(cache_ptr, MONSTER_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
 	for ( i = 0; i < 5; i++ )
 	{
 	    protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
@@ -10177,9 +10177,9 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	}
 
 	/* verify entry status */
-	verify_entry_status(cache_ptr, 
+	verify_entry_status(cache_ptr,
 			    4,
-                            (num_variable_entries + num_monster_entries + num_large_entries), 
+                            (num_variable_entries + num_monster_entries + num_large_entries),
 			    expected);
     }
 
@@ -10188,12 +10188,12 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	/* Now load three more large entries.  This should result
 	 * in the eviction of (VET, 3), and the unpinning of (VET, 0)
 	 *
-	 * The following table shows the expected states of the variable 
+	 * The following table shows the expected states of the variable
 	 * size entries after the test.
 	 *
 	 * 		in
 	 * entry:	cache?	size:	dirty?	pinned?	pins:	flush operations:
-	 * 
+	 *
 	 * (VET, 0) 	Y	10 KB	Y	N	-	-
 	 *
 	 * (VET, 1)	N	10 KB	N	N	-	-
@@ -10207,7 +10207,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	 * (VET, 5)	Y	 5 KB	N	N	7	-
 	 *
 	 * (VET, 6)	N	10 KB	N	N	-	-
-	 * 
+	 *
 	 * (VET, 7)	Y	10 KB	Y	Y	-	dirty (VET, 6)
 	 *
 	 * Start by updating the expected table for the expected changes in entry status:
@@ -10222,7 +10222,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	for ( i = 5; i < 8; i++ )
 	{
 	    protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
@@ -10241,9 +10241,9 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	}
 
 	/* verify entry status */
-	verify_entry_status(cache_ptr, 
+	verify_entry_status(cache_ptr,
 			    5,
-                            (num_variable_entries + num_monster_entries + num_large_entries), 
+                            (num_variable_entries + num_monster_entries + num_large_entries),
 			    expected);
     }
 
@@ -10251,12 +10251,12 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 
 	/* load another large entry.  (VET, 4) should be evicted.
 	 *
-	 * The following table shows the expected states of the variable 
+	 * The following table shows the expected states of the variable
 	 * size entries after the test.
 	 *
 	 * 		in
 	 * entry:	cache?	size:	dirty?	pinned?	pins:	flush operations:
-	 * 
+	 *
 	 * (VET, 0) 	Y	10 KB	Y	N	-	-
 	 *
 	 * (VET, 1)	N	10 KB	N	N	-	-
@@ -10270,7 +10270,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	 * (VET, 5)	Y	 5 KB	N	N	7	-
 	 *
 	 * (VET, 6)	N	10 KB	N	N	-	-
-	 * 
+	 *
 	 * (VET, 7)	Y	10 KB	Y	Y	-	dirty (VET, 6)
 	 *
 	 * Start by updating the expected table for the expected changes in entry status:
@@ -10284,7 +10284,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	for ( i = 8; i < 9; i++ )
 	{
 	    protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
@@ -10304,24 +10304,24 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	}
 
 	/* verify entry status */
-	verify_entry_status(cache_ptr, 
+	verify_entry_status(cache_ptr,
 			    6,
-                            (num_variable_entries + num_monster_entries + num_large_entries), 
+                            (num_variable_entries + num_monster_entries + num_large_entries),
 			    expected);
     }
 
     if ( pass ) {
 
-	/* Load another large entry.  
+	/* Load another large entry.
 	 *
-	 * (VET, 5) should be evicted, and (VET, 7) should be unpinned. 
+	 * (VET, 5) should be evicted, and (VET, 7) should be unpinned.
 	 *
-	 * The following table shows the expected states of the variable 
+	 * The following table shows the expected states of the variable
 	 * size entries after the test.
 	 *
 	 * 		in
 	 * entry:	cache?	size:	dirty?	pinned?	pins:	flush operations:
-	 * 
+	 *
 	 * (VET, 0) 	Y	10 KB	Y	N	-	-
 	 *
 	 * (VET, 1)	N	10 KB	N	N	-	-
@@ -10335,7 +10335,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	 * (VET, 5)	N	 5 KB	N	N	-	-
 	 *
 	 * (VET, 6)	N	10 KB	N	N	-	-
-	 * 
+	 *
 	 * (VET, 7)	Y	10 KB	Y	N	-	dirty (VET, 6)
 	 *
 	 * Start by updating the expected table for the expected changes in entry status:
@@ -10350,7 +10350,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	for ( i = 9; i < 10; i++ )
 	{
 	    protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
@@ -10368,16 +10368,16 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	}
 
 	/* verify entry status */
-	verify_entry_status(cache_ptr, 
+	verify_entry_status(cache_ptr,
 			    7,
-                            (num_variable_entries + num_monster_entries + num_large_entries), 
+                            (num_variable_entries + num_monster_entries + num_large_entries),
 			    expected);
     }
 
     if ( pass ) {
 
         /* Again, touch all the non VARIABLE_ENTRY_TYPE entries in the
-	 * cache to bring all the VARIABLE_ENTRY_TYPE entries to the 
+	 * cache to bring all the VARIABLE_ENTRY_TYPE entries to the
 	 * end of the LRU list.
 	 *
 	 * Both (VET, 0) and (VET, 7) have been unpinned, so they are
@@ -10386,14 +10386,14 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	for ( i = 0; i < 31; i++ )
 	{
 	    protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(cache_ptr, MONSTER_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(cache_ptr, MONSTER_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
 	for ( i = 0; i < 10; i++ )
 	{
 	    protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
@@ -10411,35 +10411,35 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	}
 
 	/* verify entry status */
-	verify_entry_status(cache_ptr, 
+	verify_entry_status(cache_ptr,
 			    8,
-                            (num_variable_entries + num_monster_entries + num_large_entries), 
+                            (num_variable_entries + num_monster_entries + num_large_entries),
 			    expected);
     }
 
     if ( pass ) {
 
-	/* load two more large entries.  
+	/* load two more large entries.
 	 *
 	 * (VET, 0) should be flushed, but not evicted initially since it is dirty.
 	 *
-	 * (VET, 7) should be evicted, but (VET, 7) has an eviction operation that 
-	 * dirties (VET, 6).  Since (VET, 6) is not in the cache, it will be loaded.  
+	 * (VET, 7) should be evicted, but (VET, 7) has an eviction operation that
+	 * dirties (VET, 6).  Since (VET, 6) is not in the cache, it will be loaded.
 	 * Since this results in no net increase in free space, the cache will
 	 * continue to attempt to create free space.
 	 *
 	 * The cache will then flush all the monster and large entries, but since they
-	 * are all dirty, they will not be evicted.  
+	 * are all dirty, they will not be evicted.
 	 *
 	 * Finally, it will reach (VET, 0) again, and evict it on the second pass.
 	 * This finally makes the necessary space.
 	 *
-	 * The following table shows the expected states of the variable 
+	 * The following table shows the expected states of the variable
 	 * size entries after the test.
 	 *
 	 * 		in
 	 * entry:	cache?	size:	dirty?	pinned?	pins:	flush operations:
-	 * 
+	 *
 	 * (VET, 0) 	N	10 KB	N	N	-	-
 	 *
 	 * (VET, 1)	N	10 KB	N	N	-	-
@@ -10453,12 +10453,12 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	 * (VET, 5)	N	 5 KB	N	N	-	-
 	 *
 	 * (VET, 6)	Y	10 KB	Y	N	-	-
-	 * 
+	 *
 	 * (VET, 7)	N	10 KB	N	N	-	-
 	 *
 	 * Start by updating the expected table for the expected changes in entry status:
 	 *
-	 * Note that we reset the loaded, cleared, flushed, and destroyed fields of 
+	 * Note that we reset the loaded, cleared, flushed, and destroyed fields of
 	 * (VET,6) so we can track what is happening.
 	 */
 	base_addr = entries[VARIABLE_ENTRY_TYPE];
@@ -10486,7 +10486,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	/* a newly loaded entry is not inserted in the cache until after space has been
 	 * made for it.  Thus (LET, 11) will not be flushed.
 	 */
-	for ( i = num_variable_entries; 
+	for ( i = num_variable_entries;
 	      i < num_variable_entries + num_monster_entries + num_large_entries - 1;
 	      i++ )
 	{
@@ -10497,7 +10497,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	for ( i = 10; i < 12; i++ )
 	{
 	    protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
@@ -10515,34 +10515,34 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	}
 
 	/* verify entry status */
-	verify_entry_status(cache_ptr, 
+	verify_entry_status(cache_ptr,
 			    9,
-                            (num_variable_entries + num_monster_entries + num_large_entries), 
+                            (num_variable_entries + num_monster_entries + num_large_entries),
 			    expected);
     }
 
     if ( pass ) {
 
         /* Again, touch all the non VARIABLE_ENTRY_TYPE entries in the
-	 * cache to bring the last remaining VARIABLE_ENTRY_TYPE entry to the 
-	 * end of the LRU list. 
+	 * cache to bring the last remaining VARIABLE_ENTRY_TYPE entry to the
+	 * end of the LRU list.
 	 */
 	for ( i = 0; i < num_monster_entries; i++ )
 	{
 	    protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(cache_ptr, MONSTER_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(cache_ptr, MONSTER_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
 	for ( i = 0; i < num_large_entries; i++ )
 	{
 	    protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
 	/* update the expected array to mark all these entries dirty again. */
-	for ( i = num_variable_entries; 
+	for ( i = num_variable_entries;
 	      i < num_variable_entries + num_monster_entries + num_large_entries - 1;
 	      i++ )
 	{
@@ -10563,27 +10563,27 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	}
 
 	/* verify entry status */
-	verify_entry_status(cache_ptr, 
+	verify_entry_status(cache_ptr,
 			    10,
-                            (num_variable_entries + num_monster_entries + num_large_entries), 
+                            (num_variable_entries + num_monster_entries + num_large_entries),
 			    expected);
     }
 
     if ( pass ) {
-	    
-        /* Load two more large entries.  
+
+        /* Load two more large entries.
 	 *
 	 * Since (VET, 6) is dirty, at first this will just cause (VET, 6) to be flushed.
 	 *
 	 * But all other entries in the cache are dirty, so the cache will flush them all,
 	 * and then evict (VET, 6) on the second pass.
 	 *
-	 * The following table shows the expected states of the variable 
+	 * The following table shows the expected states of the variable
 	 * size entries after the test.
 	 *
 	 * 		in
 	 * entry:	cache?	size:	dirty?	pinned?	pins:	flush operations:
-	 * 
+	 *
 	 * (VET, 0) 	N	10 KB	N	N	-	-
 	 *
 	 * (VET, 1)	N	10 KB	N	N	-	-
@@ -10597,7 +10597,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	 * (VET, 5)	N	 5 KB	N	N	-	-
 	 *
 	 * (VET, 6)	N	10 KB	N	N	-	-
-	 * 
+	 *
 	 * (VET, 7)	N	10 KB	N	N	-	-
 	 *
 	 * Start by updating the expected table for the expected changes in entry status:
@@ -10613,7 +10613,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	/* a newly loaded entry is not inserted in the cache until after space has been
 	 * made for it.  Thus (LET, 13) will not be flushed.
 	 */
-	for ( i = num_variable_entries; 
+	for ( i = num_variable_entries;
 	      i < num_variable_entries + num_monster_entries + num_large_entries - 1;
 	      i++ )
 	{
@@ -10624,7 +10624,7 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	for ( i = 12; i < 14; i++ )
 	{
 	    protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
@@ -10641,9 +10641,9 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
 	}
 
 	/* verify entry status */
-	verify_entry_status(cache_ptr, 
+	verify_entry_status(cache_ptr,
 			    11,
-                            (num_variable_entries + num_monster_entries + num_large_entries), 
+                            (num_variable_entries + num_monster_entries + num_large_entries),
 			    expected);
     }
 
@@ -10671,12 +10671,12 @@ check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
         }
     }
 
-#if H5C_COLLECT_CACHE_STATS 
+#if H5C_COLLECT_CACHE_STATS
     /* If we are collecting stats, check to see if we get the expected
      * values.
      *
      * Testing the stats code is fairly new, but given the extent
-     * to which I find myself depending on the stats, I've decided 
+     * to which I find myself depending on the stats, I've decided
      * to start testing the stats whenever it is convenient to do
      * so.
      */
@@ -12544,7 +12544,7 @@ check_flush_cache__single_entry_test(H5C_t * cache_ptr,
               (int)expected_flushed,
               (int)(entry_ptr->destroyed),
               (int)expected_destroyed);
-#endif 
+#endif
             pass = FALSE;
             HDsnprintf(msg, (size_t)128,
                 "Unexpected entry status after flush in single entry test #%d.",
@@ -13084,7 +13084,7 @@ check_expunge_entry(void)
          */
 
         result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, &entry_size,
-                                      &in_cache, &is_dirty, &is_protected, 
+                                      &in_cache, &is_dirty, &is_protected,
 				      &is_pinned);
 
 	if ( result < 0 ) {
@@ -13151,14 +13151,14 @@ check_expunge_entry(void)
     }
 
     /* Expunge the entry and then verify that it is no longer in the cache.
-     * Also verify that the entry was loaded, cleared, and destroyed, but 
+     * Also verify that the entry was loaded, cleared, and destroyed, but
      * not flushed.
      */
     expunge_entry(cache_ptr, 0, 0);
 
     if ( pass ) {
 
-        /* entry shouldn't be in cache -- only in_cache should be touched 
+        /* entry shouldn't be in cache -- only in_cache should be touched
 	 * by the status call.  Thus, only check that boolean.
          */
 
@@ -13193,7 +13193,7 @@ check_expunge_entry(void)
     /* now repeat the process with a different entry.  On unprotect
      * mark the entry as dirty.  Verify that it is not flushed.
      */
-    
+
     base_addr = entries[0];
     entry_ptr = &(base_addr[1]);
 
@@ -13204,7 +13204,7 @@ check_expunge_entry(void)
          */
 
         result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, &entry_size,
-                                      &in_cache, &is_dirty, &is_protected, 
+                                      &in_cache, &is_dirty, &is_protected,
 				      &is_pinned);
 
 	if ( result < 0 ) {
@@ -13243,7 +13243,7 @@ check_expunge_entry(void)
     if ( pass ) {
 
         result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, &entry_size,
-                                      &in_cache, &is_dirty, &is_protected, 
+                                      &in_cache, &is_dirty, &is_protected,
 				      &is_pinned);
 
 	if ( result < 0 ) {
@@ -13279,12 +13279,12 @@ check_expunge_entry(void)
 
     if ( pass ) {
 
-        /* entry shouldn't be in cache -- only in_cache should be touched 
+        /* entry shouldn't be in cache -- only in_cache should be touched
 	 * by the status call.  Thus, only check that boolean.
          */
 
         result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, &entry_size,
-                                      &in_cache, &is_dirty, &is_protected, 
+                                      &in_cache, &is_dirty, &is_protected,
 				      &is_pinned);
 
 	if ( result < 0 ) {
@@ -13333,7 +13333,7 @@ check_expunge_entry(void)
 /*-------------------------------------------------------------------------
  * Function:	check_multiple_read_protect()
  *
- * Purpose:	Verify that multiple, simultaneous read protects of a 
+ * Purpose:	Verify that multiple, simultaneous read protects of a
  * 		single entry perform as expectd.
  *
  * Return:	void
@@ -13390,7 +13390,7 @@ check_multiple_read_protect(void)
 
         entry_ptr = &((entries[0])[0]);
 
-        if ( ( entry_ptr->header.is_protected ) || 
+        if ( ( entry_ptr->header.is_protected ) ||
  	     ( entry_ptr->header.is_read_only ) ||
 	     ( entry_ptr->header.ro_ref_count != 0 ) ) {
 
@@ -13413,7 +13413,7 @@ check_multiple_read_protect(void)
     {
         protect_entry_ro(cache_ptr, 0, 0);
 
-        if ( ( ! ( entry_ptr->header.is_protected ) ) || 
+        if ( ( ! ( entry_ptr->header.is_protected ) ) ||
  	     ( ! ( entry_ptr->header.is_read_only ) ) ||
 	     ( entry_ptr->header.ro_ref_count != 1 ) ) {
 
@@ -13436,7 +13436,7 @@ check_multiple_read_protect(void)
     {
         protect_entry_ro(cache_ptr, 0, 0);
 
-        if ( ( ! ( entry_ptr->header.is_protected ) ) || 
+        if ( ( ! ( entry_ptr->header.is_protected ) ) ||
  	     ( ! ( entry_ptr->header.is_read_only ) ) ||
 	     ( entry_ptr->header.ro_ref_count != 2 ) ) {
 
@@ -13459,7 +13459,7 @@ check_multiple_read_protect(void)
     {
         unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__NO_FLAGS_SET);
 
-        if ( ( ! ( entry_ptr->header.is_protected ) ) || 
+        if ( ( ! ( entry_ptr->header.is_protected ) ) ||
  	     ( ! ( entry_ptr->header.is_read_only ) ) ||
 	     ( entry_ptr->header.ro_ref_count != 1 ) ) {
 
@@ -13482,7 +13482,7 @@ check_multiple_read_protect(void)
     {
         protect_entry_ro(cache_ptr, 0, 0);
 
-        if ( ( ! ( entry_ptr->header.is_protected ) ) || 
+        if ( ( ! ( entry_ptr->header.is_protected ) ) ||
  	     ( ! ( entry_ptr->header.is_read_only ) ) ||
 	     ( entry_ptr->header.ro_ref_count != 2 ) ) {
 
@@ -13505,7 +13505,7 @@ check_multiple_read_protect(void)
     {
         protect_entry_ro(cache_ptr, 0, 0);
 
-        if ( ( ! ( entry_ptr->header.is_protected ) ) || 
+        if ( ( ! ( entry_ptr->header.is_protected ) ) ||
  	     ( ! ( entry_ptr->header.is_read_only ) ) ||
 	     ( entry_ptr->header.ro_ref_count != 3 ) ) {
 
@@ -13528,7 +13528,7 @@ check_multiple_read_protect(void)
     {
         unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__NO_FLAGS_SET);
 
-        if ( ( ! ( entry_ptr->header.is_protected ) ) || 
+        if ( ( ! ( entry_ptr->header.is_protected ) ) ||
  	     ( ! ( entry_ptr->header.is_read_only ) ) ||
 	     ( entry_ptr->header.ro_ref_count != 2 ) ) {
 
@@ -13551,7 +13551,7 @@ check_multiple_read_protect(void)
     {
         unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__NO_FLAGS_SET);
 
-        if ( ( ! ( entry_ptr->header.is_protected ) ) || 
+        if ( ( ! ( entry_ptr->header.is_protected ) ) ||
  	     ( ! ( entry_ptr->header.is_read_only ) ) ||
 	     ( entry_ptr->header.ro_ref_count != 1 ) ) {
 
@@ -13574,7 +13574,7 @@ check_multiple_read_protect(void)
     {
         unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__NO_FLAGS_SET);
 
-        if ( ( entry_ptr->header.is_protected ) || 
+        if ( ( entry_ptr->header.is_protected ) ||
  	     ( entry_ptr->header.is_read_only ) ||
 	     ( entry_ptr->header.ro_ref_count != 0 ) ) {
 
@@ -13594,7 +13594,7 @@ check_multiple_read_protect(void)
 #endif /* H5C_COLLECT_CACHE_STATS */
 
 
-    /* If we get this far, do a write protect and unprotect to verify 
+    /* If we get this far, do a write protect and unprotect to verify
      * that the stats are getting collected properly here as well.
      */
 
@@ -13602,7 +13602,7 @@ check_multiple_read_protect(void)
     {
         protect_entry(cache_ptr, 0, 0);
 
-        if ( ( ! ( entry_ptr->header.is_protected ) ) || 
+        if ( ( ! ( entry_ptr->header.is_protected ) ) ||
  	     ( entry_ptr->header.is_read_only ) ||
 	     ( entry_ptr->header.ro_ref_count != 0 ) ) {
 
@@ -13625,7 +13625,7 @@ check_multiple_read_protect(void)
     {
         unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__NO_FLAGS_SET);
 
-        if ( ( entry_ptr->header.is_protected ) || 
+        if ( ( entry_ptr->header.is_protected ) ||
  	     ( entry_ptr->header.is_read_only ) ||
 	     ( entry_ptr->header.ro_ref_count != 0 ) ) {
 
@@ -13645,7 +13645,7 @@ check_multiple_read_protect(void)
 #endif /* H5C_COLLECT_CACHE_STATS */
 
 
-    /* Finally, mix things up a little, using a mix of reads and 
+    /* Finally, mix things up a little, using a mix of reads and
      * and writes on different entries.  Also include a pin to verify
      * that it works as well.
      *
@@ -14142,7 +14142,7 @@ check_resize_entry(void)
 
     /* Setup a cache and verify that it is empty.
      *
-     * Then force the load of an entry by protecting it, and verify that 
+     * Then force the load of an entry by protecting it, and verify that
      * the entry and cache have the expected sizes.
      *
      * Then unprotect the entry with the size changed flag and a reduced
@@ -14150,10 +14150,10 @@ check_resize_entry(void)
      * sizes.
      *
      * Use a second protect/unprotect cycle to restore the entry to
-     * its original size.  Verify that the entry and cache have the 
+     * its original size.  Verify that the entry and cache have the
      * expected sizes.
      *
-     * Protect and unprotect the entry again to pin it.  Use 
+     * Protect and unprotect the entry again to pin it.  Use
      * H5C_resize_entry to reduce its size.  Verify that the entry
      * and cache have the expected sizes.
      *
@@ -14165,7 +14165,7 @@ check_resize_entry(void)
      *
      *
      * Obesrve that all the above tests have been done with only one
-     * entry in the cache.  Repeat the tests with several entries in 
+     * entry in the cache.  Repeat the tests with several entries in
      * the cache.
      */
 
@@ -14218,8 +14218,8 @@ check_resize_entry(void)
 
     if ( pass ) {
 
-        result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, 
-			              &reported_entry_size, &in_cache, 
+        result = H5C_get_entry_status(cache_ptr, entry_ptr->addr,
+			              &reported_entry_size, &in_cache,
 				      &is_dirty, &is_protected, &is_pinned);
 
 	if ( result < 0 ) {
@@ -14249,9 +14249,9 @@ check_resize_entry(void)
 
     if ( pass ) {
 
-        result = H5C_unprotect(NULL, -1, -1, cache_ptr, 
+        result = H5C_unprotect(NULL, -1, -1, cache_ptr,
 			       &(types[LARGE_ENTRY_TYPE]), entry_ptr->addr,
-			       (void *)entry_ptr, 
+			       (void *)entry_ptr,
 			       H5C__SIZE_CHANGED_FLAG | H5C__DIRTIED_FLAG,
 			       (LARGE_ENTRY_SIZE / 2));
 
@@ -14288,8 +14288,8 @@ check_resize_entry(void)
 
     if ( pass ) {
 
-        result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, 
-			              &reported_entry_size, &in_cache, 
+        result = H5C_get_entry_status(cache_ptr, entry_ptr->addr,
+			              &reported_entry_size, &in_cache,
 				      &is_dirty, &is_protected, &is_pinned);
 
 	if ( result < 0 ) {
@@ -14322,9 +14322,9 @@ check_resize_entry(void)
 
     if ( pass ) {
 
-        result = H5C_unprotect(NULL, -1, -1, cache_ptr, 
+        result = H5C_unprotect(NULL, -1, -1, cache_ptr,
 			       &(types[LARGE_ENTRY_TYPE]), entry_ptr->addr,
-			       (void *)entry_ptr, 
+			       (void *)entry_ptr,
 			       (H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG),
 			       LARGE_ENTRY_SIZE);
 
@@ -14361,8 +14361,8 @@ check_resize_entry(void)
 
     if ( pass ) {
 
-        result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, 
-			              &reported_entry_size, &in_cache, 
+        result = H5C_get_entry_status(cache_ptr, entry_ptr->addr,
+			              &reported_entry_size, &in_cache,
 				      &is_dirty, &is_protected, &is_pinned);
 
 	if ( result < 0 ) {
@@ -14397,17 +14397,17 @@ check_resize_entry(void)
 
     if ( pass ) {
 
-        result = H5C_resize_pinned_entry(cache_ptr, (void *)entry_ptr, 
+        result = H5C_resize_pinned_entry(cache_ptr, (void *)entry_ptr,
 			                 (LARGE_ENTRY_SIZE / 4));
 
 	if ( result < 0 ) {
 
             pass = FALSE;
-            HDsnprintf(msg, (size_t)128, 
+            HDsnprintf(msg, (size_t)128,
 		       "H5C_resize_pinned_entry() reports failure 1.");
             failure_mssg = msg;
 
-	} 
+	}
     }
 
     if ( pass ) {
@@ -14426,8 +14426,8 @@ check_resize_entry(void)
 
     if ( pass ) {
 
-        result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, 
-			              &reported_entry_size, &in_cache, 
+        result = H5C_get_entry_status(cache_ptr, entry_ptr->addr,
+			              &reported_entry_size, &in_cache,
 				      &is_dirty, &is_protected, &is_pinned);
 
 	if ( result < 0 ) {
@@ -14458,17 +14458,17 @@ check_resize_entry(void)
 
     if ( pass ) {
 
-        result = H5C_resize_pinned_entry(cache_ptr, (void *)entry_ptr, 
+        result = H5C_resize_pinned_entry(cache_ptr, (void *)entry_ptr,
 			                 LARGE_ENTRY_SIZE);
 
 	if ( result < 0 ) {
 
             pass = FALSE;
-            HDsnprintf(msg, (size_t)128, 
+            HDsnprintf(msg, (size_t)128,
 		       "H5C_resize_pinned_entry() reports failure 2.");
             failure_mssg = msg;
 
-	} 
+	}
     }
 
     if ( pass ) {
@@ -14487,8 +14487,8 @@ check_resize_entry(void)
 
     if ( pass ) {
 
-        result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, 
-			              &reported_entry_size, &in_cache, 
+        result = H5C_get_entry_status(cache_ptr, entry_ptr->addr,
+			              &reported_entry_size, &in_cache,
 				      &is_dirty, &is_protected, &is_pinned);
 
 	if ( result < 0 ) {
@@ -14519,13 +14519,13 @@ check_resize_entry(void)
 
     protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0);
 
-    unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0, FALSE, 
+    unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0, FALSE,
 		    H5C__UNPIN_ENTRY_FLAG | H5C__DELETED_FLAG);
 
     if ( pass ) {
 
         result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, &entry_size,
-                                      &in_cache, &is_dirty, &is_protected, 
+                                      &in_cache, &is_dirty, &is_protected,
 				      &is_pinned);
 
 	if ( result < 0 ) {
@@ -14630,8 +14630,8 @@ check_resize_entry(void)
 
     if ( pass ) {
 
-        result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, 
-			              &reported_entry_size, &in_cache, 
+        result = H5C_get_entry_status(cache_ptr, entry_ptr->addr,
+			              &reported_entry_size, &in_cache,
 				      &is_dirty, &is_protected, &is_pinned);
 
 	if ( result < 0 ) {
@@ -14661,9 +14661,9 @@ check_resize_entry(void)
 
     if ( pass ) {
 
-        result = H5C_unprotect(NULL, -1, -1, cache_ptr, 
+        result = H5C_unprotect(NULL, -1, -1, cache_ptr,
 			       &(types[LARGE_ENTRY_TYPE]), entry_ptr->addr,
-			       (void *)entry_ptr, 
+			       (void *)entry_ptr,
 			       H5C__SIZE_CHANGED_FLAG | H5C__DIRTIED_FLAG,
 			       (LARGE_ENTRY_SIZE / 2));
 
@@ -14687,10 +14687,10 @@ check_resize_entry(void)
     if ( pass ) {
 
 	if ( ( cache_ptr->index_len != 4 ) ||
-	     ( cache_ptr->index_size != 
+	     ( cache_ptr->index_size !=
 	       ((3 * LARGE_ENTRY_SIZE) + (LARGE_ENTRY_SIZE / 2)) ) ||
 	     ( cache_ptr->slist_len != 2 ) ||
-	     ( cache_ptr->slist_size != 
+	     ( cache_ptr->slist_size !=
 	       (LARGE_ENTRY_SIZE + (LARGE_ENTRY_SIZE / 2)) ) ) {
 
             pass = FALSE;
@@ -14702,8 +14702,8 @@ check_resize_entry(void)
 
     if ( pass ) {
 
-        result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, 
-			              &reported_entry_size, &in_cache, 
+        result = H5C_get_entry_status(cache_ptr, entry_ptr->addr,
+			              &reported_entry_size, &in_cache,
 				      &is_dirty, &is_protected, &is_pinned);
 
 	if ( result < 0 ) {
@@ -14736,9 +14736,9 @@ check_resize_entry(void)
 
     if ( pass ) {
 
-        result = H5C_unprotect(NULL, -1, -1, cache_ptr, 
+        result = H5C_unprotect(NULL, -1, -1, cache_ptr,
 			       &(types[LARGE_ENTRY_TYPE]), entry_ptr->addr,
-			       (void *)entry_ptr, 
+			       (void *)entry_ptr,
 			       (H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG),
 			       LARGE_ENTRY_SIZE);
 
@@ -14775,8 +14775,8 @@ check_resize_entry(void)
 
     if ( pass ) {
 
-        result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, 
-			              &reported_entry_size, &in_cache, 
+        result = H5C_get_entry_status(cache_ptr, entry_ptr->addr,
+			              &reported_entry_size, &in_cache,
 				      &is_dirty, &is_protected, &is_pinned);
 
 	if ( result < 0 ) {
@@ -14811,26 +14811,26 @@ check_resize_entry(void)
 
     if ( pass ) {
 
-        result = H5C_resize_pinned_entry(cache_ptr, (void *)entry_ptr, 
+        result = H5C_resize_pinned_entry(cache_ptr, (void *)entry_ptr,
 			                 (LARGE_ENTRY_SIZE / 4));
 
 	if ( result < 0 ) {
 
             pass = FALSE;
-            HDsnprintf(msg, (size_t)128, 
+            HDsnprintf(msg, (size_t)128,
 		       "H5C_resize_pinned_entry() reports failure 3.");
             failure_mssg = msg;
 
-	} 
+	}
     }
 
     if ( pass ) {
 
 	if ( ( cache_ptr->index_len != 4 ) ||
-	     ( cache_ptr->index_size != 
+	     ( cache_ptr->index_size !=
 	       ((3 * LARGE_ENTRY_SIZE) + (LARGE_ENTRY_SIZE / 4)) ) ||
 	     ( cache_ptr->slist_len != 2 ) ||
-	     ( cache_ptr->slist_size != 
+	     ( cache_ptr->slist_size !=
 	       (LARGE_ENTRY_SIZE + (LARGE_ENTRY_SIZE / 4)) ) ) {
 
             pass = FALSE;
@@ -14842,8 +14842,8 @@ check_resize_entry(void)
 
     if ( pass ) {
 
-        result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, 
-			              &reported_entry_size, &in_cache, 
+        result = H5C_get_entry_status(cache_ptr, entry_ptr->addr,
+			              &reported_entry_size, &in_cache,
 				      &is_dirty, &is_protected, &is_pinned);
 
 	if ( result < 0 ) {
@@ -14874,17 +14874,17 @@ check_resize_entry(void)
 
     if ( pass ) {
 
-        result = H5C_resize_pinned_entry(cache_ptr, (void *)entry_ptr, 
+        result = H5C_resize_pinned_entry(cache_ptr, (void *)entry_ptr,
 			                 LARGE_ENTRY_SIZE);
 
 	if ( result < 0 ) {
 
             pass = FALSE;
-            HDsnprintf(msg, (size_t)128, 
+            HDsnprintf(msg, (size_t)128,
 		       "H5C_resize_pinned_entry() reports failure 4.");
             failure_mssg = msg;
 
-	} 
+	}
     }
 
     if ( pass ) {
@@ -14903,8 +14903,8 @@ check_resize_entry(void)
 
     if ( pass ) {
 
-        result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, 
-			              &reported_entry_size, &in_cache, 
+        result = H5C_get_entry_status(cache_ptr, entry_ptr->addr,
+			              &reported_entry_size, &in_cache,
 				      &is_dirty, &is_protected, &is_pinned);
 
 	if ( result < 0 ) {
@@ -14935,13 +14935,13 @@ check_resize_entry(void)
 
     protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 3);
 
-    unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 3, FALSE, 
+    unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 3, FALSE,
 		    H5C__UNPIN_ENTRY_FLAG | H5C__DELETED_FLAG);
 
     if ( pass ) {
 
         result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, &entry_size,
-                                      &in_cache, &is_dirty, &is_protected, 
+                                      &in_cache, &is_dirty, &is_protected,
 				      &is_pinned);
 
 	if ( result < 0 ) {
@@ -15028,7 +15028,7 @@ check_resize_entry(void)
 /*-------------------------------------------------------------------------
  * Function:	check_evictions_enabled()
  *
- * Purpose:	Verify that H5C_get_evictions_enabled() and 
+ * Purpose:	Verify that H5C_get_evictions_enabled() and
  * 		H5C_set_evictions_enabled() functions perform as expected.
  *
  * Return:	void
@@ -15077,7 +15077,7 @@ check_evictions_enabled(void)
      * Load another entry -- verify that this does not cause an entry
      * to be evicted.
      *
-     * Insert an entry -- verify that this does not cause an entry to 
+     * Insert an entry -- verify that this does not cause an entry to
      * be evicted.
      *
      * Use H5C_set_evictions_enabled() to re-enable evictions.  Verify
@@ -15090,7 +15090,7 @@ check_evictions_enabled(void)
      * Protect an entry not in the cache.  Verify that this causes
      * two evictions.
      *
-     * Used H5C_set_evictions_enabled() to disable evictions again.  
+     * Used H5C_set_evictions_enabled() to disable evictions again.
      * Verify with a call to H5C_get_evictions_enabled().
      *
      * Now flush and discard the cache -- should succeed.
@@ -15159,7 +15159,7 @@ check_evictions_enabled(void)
     for ( i = 0; i < 16 ; i++ )
     {
         protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
-        unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i, 
+        unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i,
 			FALSE, H5C__NO_FLAGS_SET);
     }
 
@@ -15190,7 +15190,7 @@ check_evictions_enabled(void)
 
     /* protect and unprotect another entry */
     protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 16);
-    unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 16, 
+    unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 16,
 		    FALSE, H5C__NO_FLAGS_SET);
 
     if ( show_progress ) /* 7 */
@@ -15221,7 +15221,7 @@ check_evictions_enabled(void)
 
         entry_ptr = &(base_addr[0]);
 
-        result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, 
+        result = H5C_get_entry_status(cache_ptr, entry_ptr->addr,
 			              NULL, &in_cache, NULL, NULL, NULL);
 
 	if ( result < 0 ) {
@@ -15284,7 +15284,7 @@ check_evictions_enabled(void)
 
         entry_ptr = &(base_addr[1]);
 
-        result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, 
+        result = H5C_get_entry_status(cache_ptr, entry_ptr->addr,
 			              NULL, &in_cache, NULL, NULL, NULL);
 
 	if ( result < 0 ) {
@@ -15355,7 +15355,7 @@ check_evictions_enabled(void)
 
     /* protect and unprotect another entry */
     protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 18);
-    unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 18, 
+    unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 18,
 		    FALSE, H5C__NO_FLAGS_SET);
 
     if ( show_progress ) /* 15 */
@@ -15428,7 +15428,7 @@ check_evictions_enabled(void)
 
     /* protect and unprotect an entry that is in the cache */
     protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 19);
-    unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 19, 
+    unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 19,
 		    FALSE, H5C__NO_FLAGS_SET);
 
     if ( show_progress ) /* 20 */
@@ -15457,14 +15457,14 @@ check_evictions_enabled(void)
 
     /* protect and unprotect an entry that isn't in the cache */
     protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 20);
-    unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 20, 
+    unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 20,
 		    FALSE, H5C__NO_FLAGS_SET);
 
     if ( show_progress ) /* 22 */
         HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
                   fcn_name, mile_stone++, (int)pass);
 
-    /* verify that the entries have been evicted to bring the 
+    /* verify that the entries have been evicted to bring the
      * cache back down to its normal size.
      */
 
@@ -15491,7 +15491,7 @@ check_evictions_enabled(void)
 
         entry_ptr = &(base_addr[2]);
 
-        result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, 
+        result = H5C_get_entry_status(cache_ptr, entry_ptr->addr,
 			              NULL, &in_cache, NULL, NULL, NULL);
 
 	if ( result < 0 ) {
@@ -15527,7 +15527,7 @@ check_evictions_enabled(void)
 
         entry_ptr = &(base_addr[3]);
 
-        result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, 
+        result = H5C_get_entry_status(cache_ptr, entry_ptr->addr,
 			              NULL, &in_cache, NULL, NULL, NULL);
 
 	if ( result < 0 ) {
@@ -15576,11 +15576,11 @@ check_evictions_enabled(void)
         HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
                   fcn_name, mile_stone++, (int)pass);
 
-    /* protect and unprotect an entry that isn't in the cache, forcing 
+    /* protect and unprotect an entry that isn't in the cache, forcing
      * the cache to grow.
      */
     protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 21);
-    unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 21, 
+    unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 21,
 		    FALSE, H5C__NO_FLAGS_SET);
 
 
@@ -15656,7 +15656,7 @@ check_evictions_enabled(void)
 
         entry_ptr = &(base_addr[4]);
 
-        result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, 
+        result = H5C_get_entry_status(cache_ptr, entry_ptr->addr,
 			              NULL, &in_cache, NULL, NULL, NULL);
 
 	if ( result < 0 ) {
@@ -16777,7 +16777,7 @@ check_expunge_entry_errs(void)
 
     if ( pass ) {
 
-	result = H5C_expunge_entry(NULL, -1, -1, cache_ptr, 
+	result = H5C_expunge_entry(NULL, -1, -1, cache_ptr,
                                    &(types[0]), entry_ptr->addr);
 
         if ( result > 0 ) {
@@ -16795,7 +16795,7 @@ check_expunge_entry_errs(void)
 
     if ( pass ) {
 
-	result = H5C_expunge_entry(NULL, -1, -1, cache_ptr, 
+	result = H5C_expunge_entry(NULL, -1, -1, cache_ptr,
                                    &(types[0]), entry_ptr->addr);
 
         if ( result > 0 ) {
@@ -16813,7 +16813,7 @@ check_expunge_entry_errs(void)
 
     if ( pass ) {
 
-	result = H5C_expunge_entry(NULL, -1, -1, cache_ptr, 
+	result = H5C_expunge_entry(NULL, -1, -1, cache_ptr,
                                    &(types[0]), entry_ptr->addr);
 
         if ( result < 0 ) {
@@ -16874,11 +16874,11 @@ check_resize_entry_errs(void)
 
     pass = TRUE;
 
-    /* Allocate a cache, protect an entry, and then call 
+    /* Allocate a cache, protect an entry, and then call
      * H5C_resize_pinned_entry() to resize it -- this should fail.
      *
      * Unprotect the the entry with the pinned flag, and then call
-     * H5C_resize_pinned_entry() again with new size of zero.  
+     * H5C_resize_pinned_entry() again with new size of zero.
      * This should fail too.
      *
      * Finally, unpin the entry and destroy the cache.
@@ -16980,7 +16980,7 @@ check_unprotect_ro_dirty_err(void)
 
     pass = TRUE;
 
-    /* allocate a cache, protect an entry read only, and then unprotect it 
+    /* allocate a cache, protect an entry read only, and then unprotect it
      * with the dirtied flag set.  This should fail.  Destroy the cache
      * -- should succeed.
      */
@@ -17022,8 +17022,8 @@ check_unprotect_ro_dirty_err(void)
         takedown_cache(cache_ptr, FALSE, FALSE);
     }
 
-    /* allocate a another cache, protect an entry read only twice, and 
-     * then unprotect it with the dirtied flag set.  This should fail.  
+    /* allocate a another cache, protect an entry read only twice, and
+     * then unprotect it with the dirtied flag set.  This should fail.
      * Unprotect it with no flags set twice and then destroy the cache.
      * This should succeed.
      */
@@ -17110,9 +17110,9 @@ check_protect_ro_rw_err(void)
 
     pass = TRUE;
 
-    /* allocate a cache, protect an entry read only, and then try to protect 
+    /* allocate a cache, protect an entry read only, and then try to protect
      * it again rw.  This should fail.
-     * 
+     *
      * Unprotect the entry and destroy the cache -- should succeed.
      */
 
@@ -17166,7 +17166,7 @@ check_protect_ro_rw_err(void)
 /*-------------------------------------------------------------------------
  * Function:	check_evictions_enabled_err()
  *
- * Purpose:	Verify that H5C_get_evictions_enabled() and 
+ * Purpose:	Verify that H5C_get_evictions_enabled() and
  *              H5C_set_evictions_enabled() generate errors as expected.
  *
  * Return:	void
@@ -17200,7 +17200,7 @@ check_check_evictions_enabled_err(void)
      *
      * Repeat with a NULL evictions_enabled_ptr, should fail as well.
      *
-     * Configure the cache to use auto cache resize.  Call 
+     * Configure the cache to use auto cache resize.  Call
      * H5C_set_evictions_enabled() to disable evictions.  Should fail.
      *
      * Unprotect the entry and destroy the cache -- should succeed.
@@ -17317,7 +17317,7 @@ check_check_evictions_enabled_err(void)
  *
  * 		John Mainzer 1/8/08
  * 		Added a basic set of tests for the flash cache size
- * 		increment code.  
+ * 		increment code.
  *
  *-------------------------------------------------------------------------
  */
@@ -17372,7 +17372,7 @@ check_auto_cache_resize(void)
         /* hbool_t     apply_max_increment    = */ TRUE,
         /* size_t      max_increment          = */ (4 * 1024 * 1024),
 
-        /* enum H5C_cache_flash_incr_mode       */   
+        /* enum H5C_cache_flash_incr_mode       */
 	/*                    flash_incr_mode = */ H5C_flash_incr__off,
         /* double      flash_multiple         = */ 2.0,
         /* double      flash_threshold        = */ 0.5,
@@ -20523,10 +20523,10 @@ check_auto_cache_resize(void)
     }
 
     /* now test the flash cache size increment code.  At least at present,
-     * there should be no interaction between the regular auto-resize 
-     * code and the flash cache size increment code other than a reset 
+     * there should be no interaction between the regular auto-resize
+     * code and the flash cache size increment code other than a reset
      * of the counter and stats collection used by the regular auto-resize
-     * code.  Thus we do only limited tests of the two pieces of code 
+     * code.  Thus we do only limited tests of the two pieces of code
      * operating together.
      *
      * Start with simple test to verify that the flash cache increment
@@ -20535,7 +20535,7 @@ check_auto_cache_resize(void)
 
     if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
 
-    /* allocate a cache, enable the flash cache size increase code, and 
+    /* allocate a cache, enable the flash cache size increase code, and
      * then force the flash size increase code through all its operational
      * modes.  Verify that all performs as expected.
      */
@@ -20648,7 +20648,7 @@ check_auto_cache_resize(void)
 
     /* Now load a monster entry.  Since a monster entry is larger than
      * half the size of the cache, and there is not sufficient space
-     * for a monster entry in the cache, we will add space to the 
+     * for a monster entry in the cache, we will add space to the
      * cache to make room for the entry.
      */
     if ( pass ) {
@@ -20664,7 +20664,7 @@ check_auto_cache_resize(void)
 	     ( ( ( cache_ptr->max_cache_size != (80 * 1024) ) ||
 		 ( cache_ptr->min_clean_size != (40 * 1024) ) ||
 		 ( cache_ptr->index_len != 2 ) ||
-                 ( cache_ptr->index_size != (HUGE_ENTRY_SIZE + 
+                 ( cache_ptr->index_size != (HUGE_ENTRY_SIZE +
 		                             MONSTER_ENTRY_SIZE) ) ||
 		 ( cache_ptr->cache_accesses != 1 ) ) ) ) {
 
@@ -20726,9 +20726,9 @@ check_auto_cache_resize(void)
 
     if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
 
-    /* delete existing entries to prepare for next test, and reset 
+    /* delete existing entries to prepare for next test, and reset
      * the size of the cache.
-     */ 
+     */
     if ( pass ) {
 
 	expunge_entry(cache_ptr, MONSTER_ENTRY_TYPE, 1);
@@ -20736,12 +20736,12 @@ check_auto_cache_resize(void)
 
         if ( pass ) {
 
-            result = H5C_set_cache_auto_resize_config(cache_ptr, 
+            result = H5C_set_cache_auto_resize_config(cache_ptr,
 			                              &auto_size_ctl);
 
             if ( result != SUCCEED ) {
 
-                pass = FALSE; 
+                pass = FALSE;
                 failure_mssg = "H5C_set_cache_auto_resize_config failed 13.\n";
 	    }
         }
@@ -20758,7 +20758,7 @@ check_auto_cache_resize(void)
 	}
     }
 
-    /* repeat the above basic test, only this time, use inserts to add 
+    /* repeat the above basic test, only this time, use inserts to add
      * entries to the cache, not protects.
      */
 
@@ -20793,7 +20793,7 @@ check_auto_cache_resize(void)
 
     /* Now insert a monster entry.  Since a monster entry is larger than
      * half the size of the cache, and there is not sufficient space
-     * for a monster entry in the cache, we will add space to the 
+     * for a monster entry in the cache, we will add space to the
      * cache to make room for the entry.
      */
     if ( pass ) {
@@ -20805,7 +20805,7 @@ check_auto_cache_resize(void)
 	     ( ( ( cache_ptr->max_cache_size != (80 * 1024) ) ||
 		 ( cache_ptr->min_clean_size != (40 * 1024) ) ||
 		 ( cache_ptr->index_len != 2 ) ||
-                 ( cache_ptr->index_size != 
+                 ( cache_ptr->index_size !=
 		   HUGE_ENTRY_SIZE + MONSTER_ENTRY_SIZE ) ||
 		 ( cache_ptr->cache_accesses != 0 ) ) ) ) {
 
@@ -20820,14 +20820,14 @@ check_auto_cache_resize(void)
      */
     if ( pass ) {
 
-        insert_entry(cache_ptr, MONSTER_ENTRY_TYPE, 5, TRUE, 
+        insert_entry(cache_ptr, MONSTER_ENTRY_TYPE, 5, TRUE,
 		     H5C__NO_FLAGS_SET);
 
 	if ( ( pass ) &&
 	     ( ( ( cache_ptr->max_cache_size != (144 * 1024) ) ||
 		 ( cache_ptr->min_clean_size != ( 72 * 1024) ) ||
 		 ( cache_ptr->index_len != 3 ) ||
-                 ( cache_ptr->index_size != 
+                 ( cache_ptr->index_size !=
 		   2 * MONSTER_ENTRY_SIZE + HUGE_ENTRY_SIZE ) ||
 		 ( cache_ptr->cache_accesses != 0 ) ) ) ) {
 
@@ -20862,11 +20862,11 @@ check_auto_cache_resize(void)
 
     if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
 
-    /* delete existing entries to prepare for next test, and reset 
+    /* delete existing entries to prepare for next test, and reset
      * the size of the cache.  We must also change the size of the needed
-     * variable entries before we run the test, so will protect and 
+     * variable entries before we run the test, so will protect and
      * unprotect them now so as to get the correct initial size.
-     */ 
+     */
     if ( pass ) {
 
 	expunge_entry(cache_ptr, MONSTER_ENTRY_TYPE, 5);
@@ -20894,12 +20894,12 @@ check_auto_cache_resize(void)
         if ( pass ) {
 
             auto_size_ctl.initial_size           = 6 * 1024;
-            result = H5C_set_cache_auto_resize_config(cache_ptr, 
+            result = H5C_set_cache_auto_resize_config(cache_ptr,
 			                              &auto_size_ctl);
 
             if ( result != SUCCEED ) {
 
-                pass = FALSE; 
+                pass = FALSE;
                 failure_mssg = "H5C_set_cache_auto_resize_config failed 13.\n";
 	    }
         }
@@ -20922,11 +20922,11 @@ check_auto_cache_resize(void)
     if ( pass ) {
 
         protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10);
-        unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE, 
+        unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE,
 			H5C__NO_FLAGS_SET);
 
         protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11);
-        unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE, 
+        unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE,
 			H5C__NO_FLAGS_SET);
 
         protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12);
@@ -21049,7 +21049,7 @@ check_auto_cache_resize(void)
     if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
 
     /* re-size the variable entries back down to their initial size, and
-     * restore the cache to its initial size as well, in preparation 
+     * restore the cache to its initial size as well, in preparation
      * for the next test.
      */
     if ( pass ) {
@@ -21067,12 +21067,12 @@ check_auto_cache_resize(void)
         if ( pass ) {
 
             auto_size_ctl.initial_size           = 6 * 1024;
-            result = H5C_set_cache_auto_resize_config(cache_ptr, 
+            result = H5C_set_cache_auto_resize_config(cache_ptr,
 			                              &auto_size_ctl);
 
             if ( result != SUCCEED ) {
 
-                pass = FALSE; 
+                pass = FALSE;
                 failure_mssg = "H5C_set_cache_auto_resize_config failed 14.\n";
 	    }
         }
@@ -21096,7 +21096,7 @@ check_auto_cache_resize(void)
     if ( pass ) {
 
         protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10);
-        unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE, 
+        unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE,
 			H5C__PIN_ENTRY_FLAG);
         resize_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, 2 * 1024, TRUE);
 
@@ -21135,7 +21135,7 @@ check_auto_cache_resize(void)
     if ( pass ) {
 
         protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11);
-        unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE, 
+        unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE,
 			H5C__PIN_ENTRY_FLAG);
         resize_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, 10 * 1024, TRUE);
 
@@ -21156,7 +21156,7 @@ check_auto_cache_resize(void)
     if ( pass ) {
 
         protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12);
-        unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE, 
+        unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE,
 			H5C__PIN_ENTRY_FLAG);
         resize_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12, 10 * 1024, TRUE);
 
@@ -21180,15 +21180,15 @@ check_auto_cache_resize(void)
     if ( pass ) {
 
         protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10);
-        unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE, 
+        unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE,
 			H5C__UNPIN_ENTRY_FLAG);
 
         protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11);
-        unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE, 
+        unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE,
 			H5C__UNPIN_ENTRY_FLAG);
 
         protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12);
-        unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE, 
+        unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE,
 			H5C__UNPIN_ENTRY_FLAG);
 
 	if ( ( pass ) &&
@@ -21206,7 +21206,7 @@ check_auto_cache_resize(void)
     if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
 
     /* re-size the variable entries back down to their initial size, and
-     * restore the cache to its initial size as well, in preparation 
+     * restore the cache to its initial size as well, in preparation
      * for the next test.
      */
     if ( pass ) {
@@ -21224,12 +21224,12 @@ check_auto_cache_resize(void)
         if ( pass ) {
 
             auto_size_ctl.initial_size           = 6 * 1024;
-            result = H5C_set_cache_auto_resize_config(cache_ptr, 
+            result = H5C_set_cache_auto_resize_config(cache_ptr,
 			                              &auto_size_ctl);
 
             if ( result != SUCCEED ) {
 
-                pass = FALSE; 
+                pass = FALSE;
                 failure_mssg = "H5C_set_cache_auto_resize_config failed 15.\n";
 	    }
         }
@@ -21249,7 +21249,7 @@ check_auto_cache_resize(void)
     if ( pass ) {
 
         protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10);
-        unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE, 
+        unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE,
 			H5C__PIN_ENTRY_FLAG);
         resize_pinned_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, 2 * 1024);
 
@@ -21288,7 +21288,7 @@ check_auto_cache_resize(void)
     if ( pass ) {
 
         protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11);
-        unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE, 
+        unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE,
 			H5C__PIN_ENTRY_FLAG);
         resize_pinned_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, 10 * 1024);
 
@@ -21309,7 +21309,7 @@ check_auto_cache_resize(void)
     if ( pass ) {
 
         protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12);
-        unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE, 
+        unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE,
 			H5C__PIN_ENTRY_FLAG);
         resize_pinned_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12, 10 * 1024);
 
@@ -21333,15 +21333,15 @@ check_auto_cache_resize(void)
     if ( pass ) {
 
         protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10);
-        unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE, 
+        unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE,
 			H5C__UNPIN_ENTRY_FLAG);
 
         protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11);
-        unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE, 
+        unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE,
 			H5C__UNPIN_ENTRY_FLAG);
 
         protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12);
-        unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE, 
+        unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE,
 			H5C__UNPIN_ENTRY_FLAG);
 
 	if ( ( pass ) &&
@@ -21455,14 +21455,14 @@ check_auto_cache_resize(void)
     if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
 
     /* protect and unprotect a large entry -- no change in cache size since
-     * a large entry will just fill the available space in the cache.  
+     * a large entry will just fill the available space in the cache.
      */
     if ( pass ) {
 
         rpt_fcn_called = FALSE;
 
         protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0);
-        unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0, NO_CHANGE, 
+        unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0, NO_CHANGE,
 			H5C__NO_FLAGS_SET);
 
 	if ( ( pass ) &&
@@ -21480,7 +21480,7 @@ check_auto_cache_resize(void)
 
     if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
 
-    /* protect and unprotect another a large entry -- should trigger a 
+    /* protect and unprotect another a large entry -- should trigger a
      * flash cache size increase to 12 KB (remember that flash_multiple is
      * set to 2.0).
      */
@@ -21489,7 +21489,7 @@ check_auto_cache_resize(void)
         rpt_fcn_called = FALSE;
 
         protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 1);
-        unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 1, NO_CHANGE, 
+        unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 1, NO_CHANGE,
 			H5C__NO_FLAGS_SET);
 
 	if ( ( pass ) &&
@@ -21507,7 +21507,7 @@ check_auto_cache_resize(void)
 
     if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
 
-    /* protect and unprotect two more large entries -- shouldnt trigger a 
+    /* protect and unprotect two more large entries -- shouldnt trigger a
      * flash cache size increase.
      */
     if ( pass ) {
@@ -21515,10 +21515,10 @@ check_auto_cache_resize(void)
         rpt_fcn_called = FALSE;
 
         protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 2);
-        unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 2, NO_CHANGE, 
+        unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 2, NO_CHANGE,
 			H5C__NO_FLAGS_SET);
         protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 3);
-        unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 3, NO_CHANGE, 
+        unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 3, NO_CHANGE,
 			H5C__NO_FLAGS_SET);
 
 	if ( ( pass ) &&
@@ -21536,7 +21536,7 @@ check_auto_cache_resize(void)
 
     if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
 
-    /* do many accesses of a single entry to talk the cache into reducing 
+    /* do many accesses of a single entry to talk the cache into reducing
      * its size to the minimum.
      */
     if ( pass ) {
@@ -21572,17 +21572,17 @@ check_auto_cache_resize(void)
         rpt_fcn_called = FALSE;
 
         protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0);
-        unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0, NO_CHANGE, 
+        unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0, NO_CHANGE,
 			H5C__NO_FLAGS_SET);
 
 	if ( ( pass ) &&
 	     ( ( ( cache_ptr->max_cache_size != (4 * 1024 + 128) ) ||
 		 ( cache_ptr->min_clean_size != (2 * 1024 + 64) ) ||
 		 ( cache_ptr->index_len != 2 ) ||
-                 ( cache_ptr->index_size != 
+                 ( cache_ptr->index_size !=
 		   LARGE_ENTRY_SIZE + TINY_ENTRY_SIZE ) ||
 		 ( cache_ptr->cache_accesses != 1 )  ||
-		 ( rpt_fcn_called == FALSE ) || 
+		 ( rpt_fcn_called == FALSE ) ||
                  ( rpt_status != flash_increase ) ) ) ) {
 
             pass = FALSE;
@@ -21610,7 +21610,7 @@ check_auto_cache_resize(void)
 
         if ( ( cache_ptr->max_cache_size != (20 * 1024) ) ||
              ( cache_ptr->min_clean_size != (10 * 1024) ) ||
-	     ( rpt_fcn_called == FALSE ) || 
+	     ( rpt_fcn_called == FALSE ) ||
              ( rpt_status != at_max_size ) ) {
 
             pass = FALSE;
@@ -21654,7 +21654,7 @@ check_auto_cache_resize(void)
  *
  * Modifications:
  *
- * 		Added code to include the flash cache size increment 
+ * 		Added code to include the flash cache size increment
  * 		code in this test.
  * 							JRM -- 1/10/08
  *
@@ -21695,7 +21695,7 @@ check_auto_cache_resize_disable(void)
         /* hbool_t     apply_max_increment    = */ TRUE,
         /* size_t      max_increment          = */ (4 * 1024 * 1024),
 
-        /* enum H5C_cache_flash_incr_mode       */   
+        /* enum H5C_cache_flash_incr_mode       */
 	/*                    flash_incr_mode = */ H5C_flash_incr__off,
         /* double      flash_multiple         = */ 1.0,
         /* double      flash_threshold        = */ 0.25,
@@ -24207,27 +24207,27 @@ check_auto_cache_resize_disable(void)
     if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
 
     /* Now test the flash cache size increment code to verify that it
-     * is disabled when it should be.  
+     * is disabled when it should be.
      *
-     * Since the flash size increase code doesn't look at hit rate, or 
+     * Since the flash size increase code doesn't look at hit rate, or
      * use epochs (other than to start a new epoch if a flash cache size
      * increase is triggered), we go about these tests somewhat differently
      * than the rest of the tests in this function.
      *
-     * As of this writing, there is only one flash cache size increment 
+     * As of this writing, there is only one flash cache size increment
      * mode (add space), which is triggered whenever the size of a newly
      * loaded or inserted entry, or the delta between old and new entry
      * sizes exceeds some fraction of the current maximum cache size, and
      * the cache doesn't have enough free space to accomodate the new/
      * resize entry without performing evictions.  The range of permissible
      * values for the flash_threshold (0.1 to 1.0 as of this writing), and
-     * for the flash_multiple (0.1 to 10.0) do not permit the facility to 
+     * for the flash_multiple (0.1 to 10.0) do not permit the facility to
      * be turned off by configuration.  Thus, flash cache size increases
-     * can be disabled only via the flash_incr_mode, and by setting the 
+     * can be disabled only via the flash_incr_mode, and by setting the
      * current max_cache_size equal to max_size.
      *
      * We have already tested the latter in check_auto_cache_resize(), so
-     * we need only thest the former here.  Do this by disabling flash 
+     * we need only thest the former here.  Do this by disabling flash
      * cache size increments via the flash_incr_mode, and then creating
      * situations that would trigger flash cache size increases were that
      * code enabled.
@@ -24339,7 +24339,7 @@ check_auto_cache_resize_disable(void)
      * size increment code was active, this would trigger an increase.
      * Verify that it doesn't.
      *
-     * This finishes the additional tests needed for the flash cache 
+     * This finishes the additional tests needed for the flash cache
      * size increase code.
      */
     if ( pass ) {
@@ -24446,7 +24446,7 @@ check_auto_cache_resize_epoch_markers(void)
         /* hbool_t     apply_max_increment    = */ TRUE,
         /* size_t      max_increment          = */ (4 * 1024 * 1024),
 
-        /* enum H5C_cache_flash_incr_mode       */   
+        /* enum H5C_cache_flash_incr_mode       */
 	/*                    flash_incr_mode = */ H5C_flash_incr__off,
         /* double      flash_multiple         = */ 2.0,
         /* double      flash_threshold        = */ 0.5,
@@ -25116,7 +25116,7 @@ check_auto_cache_resize_epoch_markers(void)
  *
  * Modifications:
  *
- * 		Added code to verify that errors in the flash cache size 
+ * 		Added code to verify that errors in the flash cache size
  * 		increment related fields are caught as well.
  *
  * 						JRM -- 1/17/08
@@ -25186,7 +25186,7 @@ check_auto_cache_resize_input_errs(void)
         /* hbool_t     apply_max_increment    = */ TRUE,
         /* size_t      max_increment          = */ (4 * 1024 * 1024),
 
-        /* enum H5C_cache_flash_incr_mode       */   
+        /* enum H5C_cache_flash_incr_mode       */
 	/*                    flash_incr_mode = */ H5C_flash_incr__off,
         /* double      flash_multiple         = */ 2.0,
         /* double      flash_threshold        = */ 0.5,
@@ -26567,7 +26567,7 @@ check_auto_cache_resize_input_errs(void)
         invalid_auto_size_ctl.apply_max_increment    = TRUE;
         invalid_auto_size_ctl.max_increment          = (2 * 1024 * 1024);
 
-	invalid_auto_size_ctl.flash_incr_mode        = 
+	invalid_auto_size_ctl.flash_incr_mode        =
        			(enum H5C_cache_flash_incr_mode) -1; /* INVALID */
 	invalid_auto_size_ctl.flash_multiple         = 2.0;
 	invalid_auto_size_ctl.flash_threshold        = 0.5;
@@ -26643,7 +26643,7 @@ check_auto_cache_resize_input_errs(void)
         invalid_auto_size_ctl.apply_max_increment    = TRUE;
         invalid_auto_size_ctl.max_increment          = (2 * 1024 * 1024);
 
-	invalid_auto_size_ctl.flash_incr_mode        = 
+	invalid_auto_size_ctl.flash_incr_mode        =
 						H5C_flash_incr__add_space;
 	invalid_auto_size_ctl.flash_multiple         = 0.09; /* INVALID */
 	invalid_auto_size_ctl.flash_threshold        = 0.5;
@@ -26717,7 +26717,7 @@ check_auto_cache_resize_input_errs(void)
         invalid_auto_size_ctl.apply_max_increment    = TRUE;
         invalid_auto_size_ctl.max_increment          = (2 * 1024 * 1024);
 
-	invalid_auto_size_ctl.flash_incr_mode        = 
+	invalid_auto_size_ctl.flash_incr_mode        =
 						H5C_flash_incr__add_space;
 	invalid_auto_size_ctl.flash_multiple         = 10.01; /* INVALID */
 	invalid_auto_size_ctl.flash_threshold        = 0.5;
@@ -26793,7 +26793,7 @@ check_auto_cache_resize_input_errs(void)
         invalid_auto_size_ctl.apply_max_increment    = TRUE;
         invalid_auto_size_ctl.max_increment          = (2 * 1024 * 1024);
 
-	invalid_auto_size_ctl.flash_incr_mode        = 
+	invalid_auto_size_ctl.flash_incr_mode        =
 						H5C_flash_incr__add_space;
 	invalid_auto_size_ctl.flash_multiple         = 1.0;
 	invalid_auto_size_ctl.flash_threshold        = 0.09; /* INVALID */
@@ -26867,7 +26867,7 @@ check_auto_cache_resize_input_errs(void)
         invalid_auto_size_ctl.apply_max_increment    = TRUE;
         invalid_auto_size_ctl.max_increment          = (2 * 1024 * 1024);
 
-	invalid_auto_size_ctl.flash_incr_mode        = 
+	invalid_auto_size_ctl.flash_incr_mode        =
 						H5C_flash_incr__add_space;
 	invalid_auto_size_ctl.flash_multiple         = 1.0;
 	invalid_auto_size_ctl.flash_threshold        = 1.001; /* INVALID */
@@ -27632,7 +27632,7 @@ check_auto_cache_resize_aux_fcns(void)
         /* hbool_t     apply_max_increment    = */ TRUE,
         /* size_t      max_increment          = */ (4 * 1024 * 1024),
 
-        /* enum H5C_cache_flash_incr_mode       */   
+        /* enum H5C_cache_flash_incr_mode       */
 	/*                    flash_incr_mode = */ H5C_flash_incr__off,
         /* double      flash_multiple         = */ 2.0,
         /* double      flash_threshold        = */ 0.5,