[svn-r18197] Description:

    Trim trailing whitespace from source code files with this command:

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

Tested on:
    None - eyeballed only

23 files changed, 1162 insertions, 1162 deletions

diff --git a/test/cache.c b/test/cache.c
index 74900ec..8d989f7 100644
--- a/test/cache.c
+++ b/test/cache.c
@@ -3011,7 +3011,7 @@ check_flush_cache(void)
 
 	if ( show_progress ) {
 
-	    HDfprintf(stdout, "%s: calling check_flush_cache__empty_cache().\n", 
+	    HDfprintf(stdout, "%s: calling check_flush_cache__empty_cache().\n",
 		      fcn_name);
 	}
 
@@ -9263,7 +9263,7 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
 
     if ( show_progress ) {
 
-	HDfprintf(stdout, "%s:%d:%d: running sanity checks on entry(1).\n", 
+	HDfprintf(stdout, "%s:%d:%d: running sanity checks on entry(1).\n",
 	          fcn_name, test_num, (int)pass);
     }
 
@@ -9296,7 +9296,7 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
 
     if ( show_progress ) {
 
-	HDfprintf(stdout, "%s:%d:%d: running sanity checks on entry(2).\n", 
+	HDfprintf(stdout, "%s:%d:%d: running sanity checks on entry(2).\n",
 	          fcn_name, test_num, (int)pass);
     }
 
@@ -9324,7 +9324,7 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
 
     if ( show_progress ) {
 
-	HDfprintf(stdout, "%s:%d:%d: running sanity checks on entry(3).\n", 
+	HDfprintf(stdout, "%s:%d:%d: running sanity checks on entry(3).\n",
 	          fcn_name, test_num, (int)pass);
     }
 
@@ -9367,7 +9367,7 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
 
     if ( show_progress ) {
 
-	HDfprintf(stdout, "%s:%d:%d: Setting up the test.\n", 
+	HDfprintf(stdout, "%s:%d:%d: Setting up the test.\n",
 	          fcn_name, test_num, (int)pass);
     }
 
@@ -9378,7 +9378,7 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
 
 	    if ( show_progress ) {
 
-	        HDfprintf(stdout, 
+	        HDfprintf(stdout,
 			  "%s:%d: Inserting entry(%d,%d) with flags 0x%x.\n",
 			  fcn_name, test_num,
 			  (int)(spec[i].entry_type),
@@ -9393,7 +9393,7 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
 
 	    if ( show_progress ) {
 
-	        HDfprintf(stdout, 
+	        HDfprintf(stdout,
 			  "%s:%d: Protecting entry(%d,%d).\n",
 			  fcn_name, test_num,
 			  (int)(spec[i].entry_type),
@@ -9404,7 +9404,7 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
 
 	    if ( show_progress ) {
 
-	        HDfprintf(stdout, 
+	        HDfprintf(stdout,
 		    "%s:%d: Unprotecting entry(%d,%d) with flags 0x%x ns = %d.\n",
 		    fcn_name, test_num,
 		    (int)(spec[i].entry_type),
@@ -9457,7 +9457,7 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
 
     if ( show_progress ) {
 
-	HDfprintf(stdout, "%s:%d:%d: Running the test.\n", 
+	HDfprintf(stdout, "%s:%d:%d: Running the test.\n",
 		  fcn_name, test_num, (int)pass);
     }
 
@@ -9478,7 +9478,7 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
 
     if ( show_progress ) {
 
-	HDfprintf(stdout, "%s:%d:%d: Checking test results(1).\n", 
+	HDfprintf(stdout, "%s:%d:%d: Checking test results(1).\n",
 		  fcn_name, test_num, (int)pass);
     }
 
@@ -9521,7 +9521,7 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
 
     if ( show_progress ) {
 
-	HDfprintf(stdout, "%s:%d:%d: Checking test results(2).\n", 
+	HDfprintf(stdout, "%s:%d:%d: Checking test results(2).\n",
 		  fcn_name, test_num, (int)pass);
     }
 
@@ -9645,7 +9645,7 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
 
     if ( show_progress ) {
 
-	HDfprintf(stdout, "%s:%d:%d: Checking test results(3).\n", 
+	HDfprintf(stdout, "%s:%d:%d: Checking test results(3).\n",
 		  fcn_name, test_num, (int)pass);
     }
 
@@ -9680,7 +9680,7 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
 
     if ( show_progress ) {
 
-	HDfprintf(stdout, "%s:%d:%d: Cleaning up after test(1).\n", 
+	HDfprintf(stdout, "%s:%d:%d: Cleaning up after test(1).\n",
 		  fcn_name, test_num, (int)pass);
     }
 
@@ -9723,7 +9723,7 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
 
     if ( show_progress ) {
 
-	HDfprintf(stdout, "%s:%d:%d: Cleaning up after test(2).\n", 
+	HDfprintf(stdout, "%s:%d:%d: Cleaning up after test(2).\n",
 		  fcn_name, test_num, (int)pass);
     }
 
@@ -9745,7 +9745,7 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
 
     if ( show_progress ) {
 
-	HDfprintf(stdout, "%s:%d:%d: Cleaning up after test(3).\n", 
+	HDfprintf(stdout, "%s:%d:%d: Cleaning up after test(3).\n",
 		  fcn_name, test_num, (int)pass);
     }
 
@@ -9886,7 +9886,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
                   ( cache_ptr->min_clean_size != (1 * 1024 * 1024 ) ) ) {
 
 	    pass = FALSE;
-	    failure_mssg = 
+	    failure_mssg =
 	        "unexpected cache config at start of flush op eviction test.";
 
         } else {
@@ -9922,39 +9922,39 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
 	 */
 
 	protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 0);
-	unprotect_entry_with_size_change(file_ptr, VARIABLE_ENTRY_TYPE, 0, 
+	unprotect_entry_with_size_change(file_ptr, VARIABLE_ENTRY_TYPE, 0,
 			           H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG,
 				   (VARIABLE_ENTRY_SIZE / 2));
 
 	protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 1);
-	unprotect_entry_with_size_change(file_ptr, VARIABLE_ENTRY_TYPE, 1, 
+	unprotect_entry_with_size_change(file_ptr, VARIABLE_ENTRY_TYPE, 1,
 			                 H5C__NO_FLAGS_SET, (size_t)0);
 
 	protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 2);
-	unprotect_entry_with_size_change(file_ptr, VARIABLE_ENTRY_TYPE, 2, 
+	unprotect_entry_with_size_change(file_ptr, VARIABLE_ENTRY_TYPE, 2,
 			                 H5C__NO_FLAGS_SET, (size_t)0);
 
 	protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 3);
-	unprotect_entry_with_size_change(file_ptr, VARIABLE_ENTRY_TYPE, 3, 
+	unprotect_entry_with_size_change(file_ptr, VARIABLE_ENTRY_TYPE, 3,
 			           H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG,
 				   (VARIABLE_ENTRY_SIZE / 2));
 
 	protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 4);
-	unprotect_entry_with_size_change(file_ptr, VARIABLE_ENTRY_TYPE, 4, 
+	unprotect_entry_with_size_change(file_ptr, VARIABLE_ENTRY_TYPE, 4,
 			           H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG,
 				   (VARIABLE_ENTRY_SIZE / 2));
 
 	protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 5);
-	unprotect_entry_with_size_change(file_ptr, VARIABLE_ENTRY_TYPE, 5, 
+	unprotect_entry_with_size_change(file_ptr, VARIABLE_ENTRY_TYPE, 5,
 			           H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG,
 				   (VARIABLE_ENTRY_SIZE / 2));
 
 	protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 6);
-	unprotect_entry_with_size_change(file_ptr, VARIABLE_ENTRY_TYPE, 6, 
+	unprotect_entry_with_size_change(file_ptr, VARIABLE_ENTRY_TYPE, 6,
 			                 H5C__NO_FLAGS_SET, (size_t)0);
 
 	protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 7);
-	unprotect_entry_with_size_change(file_ptr, VARIABLE_ENTRY_TYPE, 7, 
+	unprotect_entry_with_size_change(file_ptr, VARIABLE_ENTRY_TYPE, 7,
 			                 H5C__NO_FLAGS_SET, (size_t)0);
 
 	if ( ( cache_ptr->index_len != 8 ) ||
@@ -10057,14 +10057,14 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
 	for ( i = 0; i < 31; i++ )
 	{
 	    protect_entry(file_ptr, MONSTER_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(file_ptr, MONSTER_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(file_ptr, MONSTER_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
 	for ( i = 0; i < 1; i++ )
 	{
 	    protect_entry(file_ptr, LARGE_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
@@ -10132,7 +10132,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
         num_large_entries = 2;
 
 	protect_entry(file_ptr, LARGE_ENTRY_TYPE, 1);
-	unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, 1, 
+	unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, 1,
                                          H5C__DIRTIED_FLAG, (size_t)0);
 
 	if ( ( cache_ptr->index_len != 40 ) ||
@@ -10198,7 +10198,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
         num_large_entries = 3;
 
 	protect_entry(file_ptr, LARGE_ENTRY_TYPE, 2);
-	unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, 2, 
+	unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, 2,
                                          H5C__DIRTIED_FLAG, (size_t)0);
 
 	if ( ( cache_ptr->index_len != 40 ) ||
@@ -10271,11 +10271,11 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
         num_large_entries = 5;
 
 	protect_entry(file_ptr, LARGE_ENTRY_TYPE, 3);
-	unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, 3, 
+	unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, 3,
                                          H5C__DIRTIED_FLAG, (size_t)0);
 
 	protect_entry(file_ptr, LARGE_ENTRY_TYPE, 4);
-	unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, 4, 
+	unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, 4,
                                          H5C__DIRTIED_FLAG, (size_t)0);
 
         /* verify cache size */
@@ -10312,14 +10312,14 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
 	for ( i = 0; i < 31; i++ )
 	{
 	    protect_entry(file_ptr, MONSTER_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(file_ptr, MONSTER_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(file_ptr, MONSTER_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
 	for ( i = 0; i < 5; i++ )
 	{
 	    protect_entry(file_ptr, LARGE_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
@@ -10379,7 +10379,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
 	for ( i = 5; i < 8; i++ )
 	{
 	    protect_entry(file_ptr, LARGE_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
@@ -10441,7 +10441,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
 	for ( i = 8; i < 9; i++ )
 	{
 	    protect_entry(file_ptr, LARGE_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
@@ -10507,7 +10507,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
 	for ( i = 9; i < 10; i++ )
 	{
 	    protect_entry(file_ptr, LARGE_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
@@ -10543,14 +10543,14 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
 	for ( i = 0; i < 31; i++ )
 	{
 	    protect_entry(file_ptr, MONSTER_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(file_ptr, MONSTER_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(file_ptr, MONSTER_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
 	for ( i = 0; i < 10; i++ )
 	{
 	    protect_entry(file_ptr, LARGE_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
@@ -10654,7 +10654,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
 	for ( i = 10; i < 12; i++ )
 	{
 	    protect_entry(file_ptr, LARGE_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
@@ -10687,14 +10687,14 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
 	for ( i = 0; i < num_monster_entries; i++ )
 	{
 	    protect_entry(file_ptr, MONSTER_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(file_ptr, MONSTER_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(file_ptr, MONSTER_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
 	for ( i = 0; i < num_large_entries; i++ )
 	{
 	    protect_entry(file_ptr, LARGE_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
@@ -10781,7 +10781,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
 	for ( i = 12; i < 14; i++ )
 	{
 	    protect_entry(file_ptr, LARGE_ENTRY_TYPE, i);
-	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i, 
+	    unprotect_entry_with_size_change(file_ptr, LARGE_ENTRY_TYPE, i,
 			                     H5C__DIRTIED_FLAG, (size_t)0);
 	}
 
@@ -14902,8 +14902,8 @@ check_resize_entry(void)
 
     if ( pass ) {
 
-        result = H5C_get_entry_status(file_ptr, entry_ptr->addr, 
-			              &reported_entry_size, &in_cache, 
+        result = H5C_get_entry_status(file_ptr, entry_ptr->addr,
+			              &reported_entry_size, &in_cache,
 				      &is_dirty, &is_protected, &is_pinned,
                                       NULL, NULL);
 
@@ -14935,7 +14935,7 @@ check_resize_entry(void)
     if ( pass ) {
 
         result = H5C_unprotect(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
-                &(types[LARGE_ENTRY_TYPE]), entry_ptr->addr, (void *)entry_ptr, 
+                &(types[LARGE_ENTRY_TYPE]), entry_ptr->addr, (void *)entry_ptr,
                 H5C__SIZE_CHANGED_FLAG | H5C__DIRTIED_FLAG, (LARGE_ENTRY_SIZE / 2));
 
 	if ( result < 0 ) {
@@ -14971,8 +14971,8 @@ check_resize_entry(void)
 
     if ( pass ) {
 
-        result = H5C_get_entry_status(file_ptr, entry_ptr->addr, 
-			              &reported_entry_size, &in_cache, 
+        result = H5C_get_entry_status(file_ptr, entry_ptr->addr,
+			              &reported_entry_size, &in_cache,
 				      &is_dirty, &is_protected, &is_pinned,
                                       NULL, NULL);
 
@@ -15007,7 +15007,7 @@ check_resize_entry(void)
     if ( pass ) {
 
         result = H5C_unprotect(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
-                &(types[LARGE_ENTRY_TYPE]), entry_ptr->addr, (void *)entry_ptr, 
+                &(types[LARGE_ENTRY_TYPE]), entry_ptr->addr, (void *)entry_ptr,
                 (H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG), LARGE_ENTRY_SIZE);
 
 	if ( result < 0 ) {
@@ -15043,8 +15043,8 @@ check_resize_entry(void)
 
     if ( pass ) {
 
-        result = H5C_get_entry_status(file_ptr, entry_ptr->addr, 
-			              &reported_entry_size, &in_cache, 
+        result = H5C_get_entry_status(file_ptr, entry_ptr->addr,
+			              &reported_entry_size, &in_cache,
 				      &is_dirty, &is_protected, &is_pinned,
                                       NULL, NULL);
 
@@ -15108,8 +15108,8 @@ check_resize_entry(void)
 
     if ( pass ) {
 
-        result = H5C_get_entry_status(file_ptr, entry_ptr->addr, 
-			              &reported_entry_size, &in_cache, 
+        result = H5C_get_entry_status(file_ptr, entry_ptr->addr,
+			              &reported_entry_size, &in_cache,
 				      &is_dirty, &is_protected, &is_pinned,
                                       NULL, NULL);
 
@@ -15169,8 +15169,8 @@ check_resize_entry(void)
 
     if ( pass ) {
 
-        result = H5C_get_entry_status(file_ptr, entry_ptr->addr, 
-			              &reported_entry_size, &in_cache, 
+        result = H5C_get_entry_status(file_ptr, entry_ptr->addr,
+			              &reported_entry_size, &in_cache,
 				      &is_dirty, &is_protected, &is_pinned,
                                       NULL, NULL);
 
@@ -15202,7 +15202,7 @@ check_resize_entry(void)
 
     protect_entry(file_ptr, LARGE_ENTRY_TYPE, 0);
 
-    unprotect_entry(file_ptr, LARGE_ENTRY_TYPE, 0, FALSE, 
+    unprotect_entry(file_ptr, LARGE_ENTRY_TYPE, 0, FALSE,
 		    H5C__UNPIN_ENTRY_FLAG | H5C__DELETED_FLAG);
 
     if ( pass ) {
@@ -15313,8 +15313,8 @@ check_resize_entry(void)
 
     if ( pass ) {
 
-        result = H5C_get_entry_status(file_ptr, entry_ptr->addr, 
-			              &reported_entry_size, &in_cache, 
+        result = H5C_get_entry_status(file_ptr, entry_ptr->addr,
+			              &reported_entry_size, &in_cache,
 				      &is_dirty, &is_protected, &is_pinned,
                                       NULL, NULL);
 
@@ -15346,7 +15346,7 @@ check_resize_entry(void)
     if ( pass ) {
 
         result = H5C_unprotect(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
-                &(types[LARGE_ENTRY_TYPE]), entry_ptr->addr, (void *)entry_ptr, 
+                &(types[LARGE_ENTRY_TYPE]), entry_ptr->addr, (void *)entry_ptr,
                 H5C__SIZE_CHANGED_FLAG | H5C__DIRTIED_FLAG, (LARGE_ENTRY_SIZE / 2));
 
 	if ( result < 0 ) {
@@ -15384,8 +15384,8 @@ check_resize_entry(void)
 
     if ( pass ) {
 
-        result = H5C_get_entry_status(file_ptr, entry_ptr->addr, 
-			              &reported_entry_size, &in_cache, 
+        result = H5C_get_entry_status(file_ptr, entry_ptr->addr,
+			              &reported_entry_size, &in_cache,
 				      &is_dirty, &is_protected, &is_pinned,
                                       NULL, NULL);
 
@@ -15420,7 +15420,7 @@ check_resize_entry(void)
     if ( pass ) {
 
         result = H5C_unprotect(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
-                &(types[LARGE_ENTRY_TYPE]), entry_ptr->addr, (void *)entry_ptr, 
+                &(types[LARGE_ENTRY_TYPE]), entry_ptr->addr, (void *)entry_ptr,
                 (H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG), LARGE_ENTRY_SIZE);
 
 	if ( result < 0 ) {
@@ -15456,8 +15456,8 @@ check_resize_entry(void)
 
     if ( pass ) {
 
-        result = H5C_get_entry_status(file_ptr, entry_ptr->addr, 
-			              &reported_entry_size, &in_cache, 
+        result = H5C_get_entry_status(file_ptr, entry_ptr->addr,
+			              &reported_entry_size, &in_cache,
 				      &is_dirty, &is_protected, &is_pinned,
                                       NULL, NULL);
 
@@ -15523,8 +15523,8 @@ check_resize_entry(void)
 
     if ( pass ) {
 
-        result = H5C_get_entry_status(file_ptr, entry_ptr->addr, 
-			              &reported_entry_size, &in_cache, 
+        result = H5C_get_entry_status(file_ptr, entry_ptr->addr,
+			              &reported_entry_size, &in_cache,
 				      &is_dirty, &is_protected, &is_pinned,
                                       NULL, NULL);
 
@@ -15584,8 +15584,8 @@ check_resize_entry(void)
 
     if ( pass ) {
 
-        result = H5C_get_entry_status(file_ptr, entry_ptr->addr, 
-			              &reported_entry_size, &in_cache, 
+        result = H5C_get_entry_status(file_ptr, entry_ptr->addr,
+			              &reported_entry_size, &in_cache,
 				      &is_dirty, &is_protected, &is_pinned,
                                       NULL, NULL);
 
@@ -15617,7 +15617,7 @@ check_resize_entry(void)
 
     protect_entry(file_ptr, LARGE_ENTRY_TYPE, 3);
 
-    unprotect_entry(file_ptr, LARGE_ENTRY_TYPE, 3, FALSE, 
+    unprotect_entry(file_ptr, LARGE_ENTRY_TYPE, 3, FALSE,
 		    H5C__UNPIN_ENTRY_FLAG | H5C__DELETED_FLAG);
 
     if ( pass ) {
@@ -15841,7 +15841,7 @@ check_evictions_enabled(void)
     for ( i = 0; i < 16 ; i++ )
     {
         protect_entry(file_ptr, MONSTER_ENTRY_TYPE, i);
-        unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, i, 
+        unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, i,
 			FALSE, H5C__NO_FLAGS_SET);
     }
 
@@ -15872,7 +15872,7 @@ check_evictions_enabled(void)
 
     /* protect and unprotect another entry */
     protect_entry(file_ptr, MONSTER_ENTRY_TYPE, 16);
-    unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, 16, 
+    unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, 16,
 		    FALSE, H5C__NO_FLAGS_SET);
 
     if ( show_progress ) /* 7 */
@@ -15903,7 +15903,7 @@ check_evictions_enabled(void)
 
         entry_ptr = &(base_addr[0]);
 
-        result = H5C_get_entry_status(file_ptr, entry_ptr->addr, 
+        result = H5C_get_entry_status(file_ptr, entry_ptr->addr,
 			              NULL, &in_cache, NULL, NULL, NULL,
                                       NULL, NULL);
 
@@ -16038,7 +16038,7 @@ check_evictions_enabled(void)
 
     /* protect and unprotect another entry */
     protect_entry(file_ptr, MONSTER_ENTRY_TYPE, 18);
-    unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, 18, 
+    unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, 18,
 		    FALSE, H5C__NO_FLAGS_SET);
 
     if ( show_progress ) /* 15 */
@@ -16111,7 +16111,7 @@ check_evictions_enabled(void)
 
     /* protect and unprotect an entry that is in the cache */
     protect_entry(file_ptr, MONSTER_ENTRY_TYPE, 19);
-    unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, 19, 
+    unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, 19,
 		    FALSE, H5C__NO_FLAGS_SET);
 
     if ( show_progress ) /* 20 */
@@ -16140,7 +16140,7 @@ check_evictions_enabled(void)
 
     /* protect and unprotect an entry that isn't in the cache */
     protect_entry(file_ptr, MONSTER_ENTRY_TYPE, 20);
-    unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, 20, 
+    unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, 20,
 		    FALSE, H5C__NO_FLAGS_SET);
 
     if ( show_progress ) /* 22 */
@@ -16263,7 +16263,7 @@ check_evictions_enabled(void)
      * the cache to grow.
      */
     protect_entry(file_ptr, MONSTER_ENTRY_TYPE, 21);
-    unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, 21, 
+    unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, 21,
 		    FALSE, H5C__NO_FLAGS_SET);
 
 
@@ -21635,11 +21635,11 @@ check_auto_cache_resize(void)
     if ( pass ) {
 
         protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 10);
-        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE, 
+        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE,
 			H5C__NO_FLAGS_SET);
 
         protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 11);
-        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE, 
+        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE,
 			H5C__NO_FLAGS_SET);
 
         protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 12);
@@ -21808,7 +21808,7 @@ check_auto_cache_resize(void)
     if ( pass ) {
 
         protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 10);
-        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE, 
+        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE,
 			H5C__PIN_ENTRY_FLAG);
         resize_entry(file_ptr, VARIABLE_ENTRY_TYPE, 10, 2 * 1024, TRUE);
 
@@ -21847,7 +21847,7 @@ check_auto_cache_resize(void)
     if ( pass ) {
 
         protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 11);
-        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE, 
+        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE,
 			H5C__PIN_ENTRY_FLAG);
         resize_entry(file_ptr, VARIABLE_ENTRY_TYPE, 11, 10 * 1024, TRUE);
 
@@ -21868,7 +21868,7 @@ check_auto_cache_resize(void)
     if ( pass ) {
 
         protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 12);
-        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE, 
+        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE,
 			H5C__PIN_ENTRY_FLAG);
         resize_entry(file_ptr, VARIABLE_ENTRY_TYPE, 12, 10 * 1024, TRUE);
 
@@ -21892,15 +21892,15 @@ check_auto_cache_resize(void)
     if ( pass ) {
 
         protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 10);
-        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE, 
+        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE,
 			H5C__UNPIN_ENTRY_FLAG);
 
         protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 11);
-        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE, 
+        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE,
 			H5C__UNPIN_ENTRY_FLAG);
 
         protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 12);
-        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE, 
+        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE,
 			H5C__UNPIN_ENTRY_FLAG);
 
 	if ( ( pass ) &&
@@ -21960,7 +21960,7 @@ check_auto_cache_resize(void)
     if ( pass ) {
 
         protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 10);
-        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE, 
+        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE,
 			H5C__PIN_ENTRY_FLAG);
         resize_pinned_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, 2 * 1024);
 
@@ -21999,7 +21999,7 @@ check_auto_cache_resize(void)
     if ( pass ) {
 
         protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 11);
-        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE, 
+        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE,
 			H5C__PIN_ENTRY_FLAG);
         resize_pinned_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, 10 * 1024);
 
@@ -22020,7 +22020,7 @@ check_auto_cache_resize(void)
     if ( pass ) {
 
         protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 12);
-        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE, 
+        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE,
 			H5C__PIN_ENTRY_FLAG);
         resize_pinned_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12, 10 * 1024);
 
@@ -22044,15 +22044,15 @@ check_auto_cache_resize(void)
     if ( pass ) {
 
         protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 10);
-        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE, 
+        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE,
 			H5C__UNPIN_ENTRY_FLAG);
 
         protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 11);
-        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE, 
+        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE,
 			H5C__UNPIN_ENTRY_FLAG);
 
         protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 12);
-        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE, 
+        unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE,
 			H5C__UNPIN_ENTRY_FLAG);
 
 	if ( ( pass ) &&
@@ -22173,7 +22173,7 @@ check_auto_cache_resize(void)
         rpt_fcn_called = FALSE;
 
         protect_entry(file_ptr, LARGE_ENTRY_TYPE, 0);
-        unprotect_entry(file_ptr, LARGE_ENTRY_TYPE, 0, NO_CHANGE, 
+        unprotect_entry(file_ptr, LARGE_ENTRY_TYPE, 0, NO_CHANGE,
 			H5C__NO_FLAGS_SET);
 
 	if ( ( pass ) &&
@@ -22200,7 +22200,7 @@ check_auto_cache_resize(void)
         rpt_fcn_called = FALSE;
 
         protect_entry(file_ptr, LARGE_ENTRY_TYPE, 1);
-        unprotect_entry(file_ptr, LARGE_ENTRY_TYPE, 1, NO_CHANGE, 
+        unprotect_entry(file_ptr, LARGE_ENTRY_TYPE, 1, NO_CHANGE,
 			H5C__NO_FLAGS_SET);
 
 	if ( ( pass ) &&
@@ -22226,10 +22226,10 @@ check_auto_cache_resize(void)
         rpt_fcn_called = FALSE;
 
         protect_entry(file_ptr, LARGE_ENTRY_TYPE, 2);
-        unprotect_entry(file_ptr, LARGE_ENTRY_TYPE, 2, NO_CHANGE, 
+        unprotect_entry(file_ptr, LARGE_ENTRY_TYPE, 2, NO_CHANGE,
 			H5C__NO_FLAGS_SET);
         protect_entry(file_ptr, LARGE_ENTRY_TYPE, 3);
-        unprotect_entry(file_ptr, LARGE_ENTRY_TYPE, 3, NO_CHANGE, 
+        unprotect_entry(file_ptr, LARGE_ENTRY_TYPE, 3, NO_CHANGE,
 			H5C__NO_FLAGS_SET);
 
 	if ( ( pass ) &&
@@ -22283,7 +22283,7 @@ check_auto_cache_resize(void)
         rpt_fcn_called = FALSE;
 
         protect_entry(file_ptr, LARGE_ENTRY_TYPE, 0);
-        unprotect_entry(file_ptr, LARGE_ENTRY_TYPE, 0, NO_CHANGE, 
+        unprotect_entry(file_ptr, LARGE_ENTRY_TYPE, 0, NO_CHANGE,
 			H5C__NO_FLAGS_SET);
 
 	if ( ( pass ) &&
@@ -28786,7 +28786,7 @@ check_auto_cache_resize_aux_fcns(void)
             failure_mssg =
                 "H5C_get_cache_size reports unexpected cur_size 5.\n";
 
-        } 
+        }
     }
 
     if ( pass ) {
@@ -28836,13 +28836,13 @@ check_auto_cache_resize_aux_fcns(void)
  *
  *              A 'metadata blizzard' in this context occurs when the cache
  *              gets completely filled with all dirty entries. Upon needing
- *              to make space in the cache, the cache then has no clean 
+ *              to make space in the cache, the cache then has no clean
  *              entries ready to evict, and must clean every dirty entry
  *              in the cache first, due to the second chance replacement
  *              policy. (i.e. after cleaning an entry, it is bumped to the
  *              top of the LRU to make a second pass before eviction).
- *              The massive amount of sequential writes to disk while 
- *              flushing the entire cache is what constitutes a 'metadata 
+ *              The massive amount of sequential writes to disk while
+ *              flushing the entire cache is what constitutes a 'metadata
  *              blizzard'.
  *
  * Return:	void
@@ -28865,11 +28865,11 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
     H5F_t * file_ptr = NULL;
     H5C_t * cache_ptr = NULL;
     hbool_t show_progress = FALSE;
-    int32_t checkpoint = 0;   
+    int32_t checkpoint = 0;
     int32_t entry_idx = 0;
     int32_t i;
 
-    /* Expected loaded status of entries depends on how they get into 
+    /* Expected loaded status of entries depends on how they get into
      * the cache. Insertions = not loaded, protect/unprotect = loaded.
      */
     hbool_t loaded = (hbool_t)!(fill_via_insertion);
@@ -29045,19 +29045,19 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
     }
 
     if ( show_progress) /* 0 */
-         HDfprintf(stdout, "\n%s: check point %d -- pass %d\n", 
+         HDfprintf(stdout, "\n%s: check point %d -- pass %d\n",
                    fcn_name, checkpoint++, pass);
 
     if ( pass ) {
-    
+
         /* Set up the cache.
          *
-         * The max_cache_size should have room for 50 entries. 
-         * The min_clean_size is half of that, or 25 entries.   
+         * The max_cache_size should have room for 50 entries.
+         * The min_clean_size is half of that, or 25 entries.
          */
         file_ptr = setup_cache((size_t)(50 * entry_size), /* max_cache_size */
                                 (size_t)(25 * entry_size)); /* min_clean_size */
- 
+
         if ( file_ptr == NULL) {
 
             pass = FALSE;
@@ -29066,37 +29066,37 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
         }
         else
             cache_ptr = file_ptr->shared->cache;
-    }        
+    }
 
     if ( show_progress) /* 1 */
-         HDfprintf(stdout, "%s: check point %d -- pass %d\n", 
+         HDfprintf(stdout, "%s: check point %d -- pass %d\n",
                    fcn_name, checkpoint++, pass);
 
     /* ========================================================================
      * ========================================================================
      *  Phase 1:
-     * 
-     *    Inserting dirty entries into an empty cache, until the cache 
+     *
+     *    Inserting dirty entries into an empty cache, until the cache
      *    violates the min_clean_size requirement. The expected result is
      *    that none of the inserted entries during this phase will get
      *    flushed or evicted.
-     * 
+     *
      *    This verifies that while maintaining min_clean_size, we don't go
      *    overboard and flush entries that we don't need to flush.
-     *  
+     *
      * ========================================================================
      * ========================================================================
      */
 
     if ( pass ) {
 
-        /* Insert 26 entries (indexes 0 through 25) into the cache.  
+        /* Insert 26 entries (indexes 0 through 25) into the cache.
          *
-         * Note that we are inserting 26 entries, and not 25, because the cache 
-         * will only try to adhere to the min_clean_size if it's currently 
-         * being violated. Thus, on insertion of the 26th entry, since the 
-         * min_clean_size will not be violated, it will accept the insertion 
-         * without having to make clean space. 
+         * Note that we are inserting 26 entries, and not 25, because the cache
+         * will only try to adhere to the min_clean_size if it's currently
+         * being violated. Thus, on insertion of the 26th entry, since the
+         * min_clean_size will not be violated, it will accept the insertion
+         * without having to make clean space.
          */
 
         for (entry_idx = 0; entry_idx < 26; entry_idx++) {
@@ -29120,8 +29120,8 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
                                 H5C__NO_FLAGS_SET); /* unsigned int flags */
             }
 
-            /* Change expected values, and verify the status of the entries 
-             * after each insertion 
+            /* Change expected values, and verify the status of the entries
+             * after each insertion
              */
             expected[entry_idx].in_cache = TRUE;
             expected[entry_idx].is_dirty = TRUE;
@@ -29135,30 +29135,30 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
     }
 
     if ( show_progress) /* 2 */
-         HDfprintf(stdout, "%s: check point %d -- pass %d\n", 
+         HDfprintf(stdout, "%s: check point %d -- pass %d\n",
                    fcn_name, checkpoint++, pass);
 
     /* ========================================================================
      * ========================================================================
      *  Phase 2:
-     * 
+     *
      *    Inserting entries into a cache that violates the min_clean_size,
      *    until the cache is full. The expected result is that each insertion
-     *    will result in the flushing of a dirty entry in the cache.    
+     *    will result in the flushing of a dirty entry in the cache.
      *
      *    This verifies that we maintain the min_clean_size. By doing so, we
      *    prevent building the situation in which a 'metadata blizzard' would
      *    occur (i.e., the cache being completely filled with dirty entries).
-     *  
+     *
      * ========================================================================
      * ========================================================================
      */
-   
+
     if ( pass ) {
 
         /* Insert the 27th entry (index = 26) into the cache.
-         * 
-         * This should cause the cache to flush its least recently used entry 
+         *
+         * This should cause the cache to flush its least recently used entry
          * before the insertion because it doesn't satisfy the min_clean_size
          * constraint.
          */
@@ -29181,15 +29181,15 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
         }
 
         /* Verify the status of the entries.
-         * 
+         *
          * Expected status is that there are 27 entries in the cache, and
          * entry number 0 has been cleaned.
-         * 
+         *
          * Changes from last entry verification:
          *   - entry w/ index 0 has now been flushed and is now clean.
          *   - entry w/ index 26 is now in the cache and dirty.
          */
-          
+
         /* entry w/ index 0 has now been flushed and is now clean. */
 	expected[0].flushed   = TRUE;
 	expected[0].is_dirty  = FALSE;
@@ -29207,7 +29207,7 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
     }
 
     if ( show_progress) /* 3 */
-         HDfprintf(stdout, "%s: check point %d -- pass %d\n", 
+         HDfprintf(stdout, "%s: check point %d -- pass %d\n",
                    fcn_name, checkpoint++, pass);
 
     if ( pass ) {
@@ -29237,10 +29237,10 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
         }
 
         /* Verify the status of the entries.
-         * 
+         *
          * Expected status is that there are 28 entries in the cache, and
          * entry numbers 0 and 1 have been cleaned.
-         * 
+         *
          * Changes from last entry verification:
          *   - entry w/ index 1 has now been flushed and is now clean.
          *   - entry w/ index 27 is now in the cache and dirty.
@@ -29263,7 +29263,7 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
     }
 
     if ( show_progress) /* 4 */
-         HDfprintf(stdout, "%s: check point %d -- pass %d\n", 
+         HDfprintf(stdout, "%s: check point %d -- pass %d\n",
                    fcn_name, checkpoint++, pass);
 
     if ( pass ) {
@@ -29291,7 +29291,7 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
             }
 
             /* Expected staus is that after each insertion, the entry
-             * inserted 26 insertions ago has been flushed, and the 
+             * inserted 26 insertions ago has been flushed, and the
              * entry currently getting inserted is now in the cache and
              * dirty.
              */
@@ -29301,7 +29301,7 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
 	    expected[entry_idx].in_cache = TRUE;
     	    expected[entry_idx].is_dirty = TRUE;
 	    expected[entry_idx].loaded   = (unsigned char)loaded;
-    
+
             /* verify the status */
             verify_entry_status(cache_ptr, /* H5C_t * cache_ptr */
                                 entry_idx, /* int tag */
@@ -29318,23 +29318,23 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
     }
 
     if ( show_progress) /* 5 */
-         HDfprintf(stdout, "%s: check point %d -- pass %d\n", 
+         HDfprintf(stdout, "%s: check point %d -- pass %d\n",
                    fcn_name, checkpoint++, pass);
 
     /* ========================================================================
      * ========================================================================
      *  Phase 3:
-     * 
-     *    Inserting entries into a cache that is completely full. Insertions 
+     *
+     *    Inserting entries into a cache that is completely full. Insertions
      *    of new entries will force evictions of old entries, but since the
-     *    min_clean_size has been maintained, doing so will not result in 
+     *    min_clean_size has been maintained, doing so will not result in
      *    the entire cache getting flushed in order to evict a single entry,
      *    as a clean entry will be available to flush reasonably close to
      *    the bottom of the LRU.
-     * 
+     *
      *    This verifies that with a maintained min_clean_size, a metadata
      *    blizzard does not occur on insertion.
-     * 
+     *
      * ========================================================================
      * ========================================================================
      */
@@ -29342,7 +29342,7 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
     if ( pass ) {
 
         /* Insert the 51st entry (index = 50) into the cache.
-         * 
+         *
          * The cache is full prior to the insertion, so it will
          * have to evict in order to make room for the new entry.
          */
@@ -29365,13 +29365,13 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
         }
 
         /* Verify the status of the entries.
-         * 
+         *
          * Changes from last entry verification:
          *   - entry w/ index 0 has been evicted.
          *   - entries w/ indices 24,25 have now been flushed and are clean.
          *   - entry w/ index 50 is now in the cache and dirty.
          */
-    
+
         /* entry w/ index 0 has been evicted. */
 	expected[0].in_cache  = FALSE;
 	expected[0].destroyed = TRUE;
@@ -29395,16 +29395,16 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
     }
 
     if ( show_progress) /* 6 */
-         HDfprintf(stdout, "%s: check point %d -- pass %d\n", 
+         HDfprintf(stdout, "%s: check point %d -- pass %d\n",
                    fcn_name, checkpoint++, pass);
 
 
     if ( pass ) {
 
         /* Insert 49 more entries (indices 51-99) into the cache.
-         * 
-         * The cache will be flushing an entry on each insertion, and 
-         * evicting an entry on each insertion. 
+         *
+         * The cache will be flushing an entry on each insertion, and
+         * evicting an entry on each insertion.
          *
          * After each insertion, verify the expected status of the
          * entries in the cache.
@@ -29421,7 +29421,7 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
                 protect_entry(file_ptr,   /* H5F_t * file_ptr */
                               entry_type,  /* int32_t type */
                               entry_idx);   /* int32-t idx */
-    
+
                 unprotect_entry(file_ptr,          /* H5F_t * file_ptr */
                                 entry_type,         /* int32_t type */
                                 entry_idx,        /* int32_t idx */
@@ -29438,21 +29438,21 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
 	    expected[entry_idx - 50].in_cache  = FALSE;
 	    expected[entry_idx - 50].destroyed = TRUE;
 
-            /* If the newly inserted entry is among the first 24 
+            /* If the newly inserted entry is among the first 24
              * insertions in this loop, then the insertion will
              * have resulted in a flush of the entry inserted
              * 25 insertions ago. */
             if (entry_idx < 75) {
-                
+
                 expected[entry_idx - 25].flushed = TRUE;
                 expected[entry_idx - 25].is_dirty = FALSE;
             }
             /* If the newly inserted entry is among the last
              * 25 insertions in this loop, then the insertion will
              * have resulted in a flush of the entry inserted 26
-             * insertions ago. This switch is because there was two 
+             * insertions ago. This switch is because there was two
              * consecutive clean entries in the cache (due to 51/49
-             * dirty/clean ratio when full), so instead of 
+             * dirty/clean ratio when full), so instead of
              * flush-then-evict, it switches to evict-then-flush. */
             else {
 
@@ -29469,13 +29469,13 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
     }
 
     if ( show_progress) /* 7 */
-         HDfprintf(stdout, "%s: check point %d -- pass %d\n", 
+         HDfprintf(stdout, "%s: check point %d -- pass %d\n",
                    fcn_name, checkpoint++, pass);
 
     /* ========================================================================
      * ========================================================================
      *  Phase 4:
-     * 
+     *
      *    Flushing the entire cache, and then inserting entries into a cache
      *    that is completely full, but all clean.
      *
@@ -29483,18 +29483,18 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
      *    into an empty cache, we're inserting into a full cache that's all
      *    clean, thus an eviction occurs before each insertion.
      *
-     *    When the cache finally hits the point of violating the 
+     *    When the cache finally hits the point of violating the
      *    min_clean_size, the bottom half of the LRU will be filled with
      *    clean entries and the top half will be filled with recently inserted
      *    dirty entries. We'll then verify that an insertion will only evict
      *    one entry and flush one entry, and no more.
-     *    
+     *
      * ========================================================================
      * ========================================================================
      */
 
     if ( pass ) {
-    
+
         /* Flush the cache.
          *
          * We're doing this so we can repeat the above insertions, but
@@ -29506,12 +29506,12 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
                     FALSE,     /* hbool_t destory_entries */
                     FALSE,     /* hbool_t dump_stats */
                     FALSE);    /* hbool_t dump_detailed_stats */
-    
+
         /* Verify that the cache is clean */
         verify_clean();
 
         /* Verify the status of the entries.
-         * 
+         *
          * Changes from last entry verification:
          *   - entries w/ indices 74-99 have been flushed.
          */
@@ -29529,7 +29529,7 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
     }
 
     if ( show_progress) /* 8 */
-         HDfprintf(stdout, "%s: check point %d -- pass %d\n", 
+         HDfprintf(stdout, "%s: check point %d -- pass %d\n",
                    fcn_name, checkpoint++, pass);
 
     if ( pass ) {
@@ -29580,7 +29580,7 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
     }
 
     if ( show_progress) /* 9 */
-         HDfprintf(stdout, "%s: check point %d -- pass %d\n", 
+         HDfprintf(stdout, "%s: check point %d -- pass %d\n",
                    fcn_name, checkpoint++, pass);
 
     if ( pass ) {
@@ -29605,7 +29605,7 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
         }
 
         /* Verify the status of the entries.
-         * 
+         *
          * Changes from last entry verification:
          *   - entry w/ index 76 is evicted.
          *   - entry w/ index 100 is cleaned.
@@ -29615,7 +29615,7 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
         /* entry w/ index 76 has been evicted. */
 	expected[76].in_cache  = FALSE;
 	expected[76].destroyed = TRUE;
-          
+
         /* entry w/ index 100 has now been flushed and is now clean. */
 	expected[100].flushed   = TRUE;
 	expected[100].is_dirty  = FALSE;
@@ -29633,7 +29633,7 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
     }
 
     if ( show_progress) /* 10 */
-         HDfprintf(stdout, "%s: check point %d -- pass %d\n", 
+         HDfprintf(stdout, "%s: check point %d -- pass %d\n",
                    fcn_name, checkpoint++, pass);
 
     if ( pass ) {
@@ -29683,18 +29683,18 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
     }
 
     if ( show_progress) /* 11 */
-         HDfprintf(stdout, "%s: check point %d -- pass %d\n", 
+         HDfprintf(stdout, "%s: check point %d -- pass %d\n",
                    fcn_name, checkpoint++, pass);
 
     if ( pass ) {
-        
+
         /* We're done with testing. We can take down the cache. */
         takedown_cache(file_ptr, FALSE, FALSE);
         reset_entries();
     }
 
     if ( show_progress) /* 12 */
-         HDfprintf(stdout, "%s: check point %d -- pass %d\n", 
+         HDfprintf(stdout, "%s: check point %d -- pass %d\n",
                    fcn_name, checkpoint++, pass);
 
     if ( pass ) { PASSED(); } else { H5_FAILED(); }
@@ -29756,8 +29756,8 @@ check_flush_deps(void)
         insert_entry(file_ptr, entry_type, (int32_t)u, TRUE, H5C__NO_FLAGS_SET);
         if ( !pass ) CACHE_ERROR("insert_entry failed")
 
-        /* Change expected values, and verify the status of the entries 
-         * after each insertion 
+        /* Change expected values, and verify the status of the entries
+         * after each insertion
          */
         expected[u].in_cache = TRUE;
         expected[u].is_dirty = TRUE;
@@ -29779,7 +29779,7 @@ check_flush_deps(void)
 
         protect_entry(file_ptr, entry_type, 1);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         /* Check the parent's entry status */
 	entry_ptr = &(base_addr[1]);
 	if(H5C_get_entry_status(file_ptr, entry_ptr->addr, NULL, &in_cache,
@@ -29815,7 +29815,7 @@ check_flush_deps(void)
         if(!in_cache || is_flush_dep_parent || !is_flush_dep_child)
             CACHE_ERROR("invalid entry status")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[0].flush_dep_par_type = entry_type;
@@ -29845,7 +29845,7 @@ check_flush_deps(void)
                         H5C__NO_FLAGS_SET); /* unsigned int flags */
         if ( !pass ) CACHE_ERROR("unprotect_entry failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroy flush dependency
          */
         expected[0].flush_dep_par_type = -1;
@@ -29869,14 +29869,14 @@ check_flush_deps(void)
     {
         protect_entry(file_ptr, entry_type, 2);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 2, entry_type, 0);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
         create_flush_dependency(entry_type, 2, entry_type, 1);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[0].flush_dep_par_type = entry_type;
@@ -29911,7 +29911,7 @@ check_flush_deps(void)
                         H5C__NO_FLAGS_SET); /* unsigned int flags */
         if ( !pass ) CACHE_ERROR("unprotect_entry failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroy flush dependency
          */
         expected[0].flush_dep_par_type = -1;
@@ -29939,11 +29939,11 @@ check_flush_deps(void)
     {
         protect_entry(file_ptr, entry_type, 1);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 1, entry_type, 0);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[0].flush_dep_par_type = entry_type;
@@ -29962,11 +29962,11 @@ check_flush_deps(void)
 
         protect_entry(file_ptr, entry_type, 2);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 2, entry_type, 1);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[1].flush_dep_par_type = entry_type;
@@ -29985,11 +29985,11 @@ check_flush_deps(void)
 
         protect_entry(file_ptr, entry_type, 3);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 3, entry_type, 2);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[2].flush_dep_par_type = entry_type;
@@ -30019,7 +30019,7 @@ check_flush_deps(void)
                         H5C__NO_FLAGS_SET); /* unsigned int flags */
         if ( !pass ) CACHE_ERROR("unprotect_entry failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[2].flush_dep_par_type = -1;
@@ -30046,7 +30046,7 @@ check_flush_deps(void)
                         H5C__NO_FLAGS_SET); /* unsigned int flags */
         if ( !pass ) CACHE_ERROR("unprotect_entry failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[1].flush_dep_par_type = -1;
@@ -30073,7 +30073,7 @@ check_flush_deps(void)
                         H5C__NO_FLAGS_SET); /* unsigned int flags */
         if ( !pass ) CACHE_ERROR("unprotect_entry failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[0].flush_dep_par_type = -1;
@@ -30099,11 +30099,11 @@ check_flush_deps(void)
     {
         protect_entry(file_ptr, entry_type, 1);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 1, entry_type, 0);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[0].flush_dep_par_type = entry_type;
@@ -30122,11 +30122,11 @@ check_flush_deps(void)
 
         protect_entry(file_ptr, entry_type, 2);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 2, entry_type, 1);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[1].flush_dep_par_type = entry_type;
@@ -30145,11 +30145,11 @@ check_flush_deps(void)
 
         protect_entry(file_ptr, entry_type, 3);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 3, entry_type, 2);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[2].flush_dep_par_type = entry_type;
@@ -30179,7 +30179,7 @@ check_flush_deps(void)
                         H5C__NO_FLAGS_SET); /* unsigned int flags */
         if ( !pass ) CACHE_ERROR("unprotect_entry failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[0].flush_dep_par_type = -1;
@@ -30212,7 +30212,7 @@ check_flush_deps(void)
                         H5C__NO_FLAGS_SET); /* unsigned int flags */
         if ( !pass ) CACHE_ERROR("unprotect_entry failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[1].flush_dep_par_type = -1;
@@ -30242,7 +30242,7 @@ check_flush_deps(void)
                         H5C__NO_FLAGS_SET); /* unsigned int flags */
         if ( !pass ) CACHE_ERROR("unprotect_entry failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[2].flush_dep_par_type = -1;
@@ -30268,11 +30268,11 @@ check_flush_deps(void)
     {
         protect_entry(file_ptr, entry_type, 3);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 3, entry_type, 2);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[2].flush_dep_par_type = entry_type;
@@ -30291,11 +30291,11 @@ check_flush_deps(void)
 
         protect_entry(file_ptr, entry_type, 2);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 2, entry_type, 1);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[1].flush_dep_par_type = entry_type;
@@ -30317,11 +30317,11 @@ check_flush_deps(void)
 
         protect_entry(file_ptr, entry_type, 1);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 1, entry_type, 0);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[0].flush_dep_par_type = entry_type;
@@ -30357,7 +30357,7 @@ check_flush_deps(void)
                         H5C__NO_FLAGS_SET); /* unsigned int flags */
         if ( !pass ) CACHE_ERROR("unprotect_entry failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[2].flush_dep_par_type = -1;
@@ -30384,7 +30384,7 @@ check_flush_deps(void)
                         H5C__NO_FLAGS_SET); /* unsigned int flags */
         if ( !pass ) CACHE_ERROR("unprotect_entry failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[1].flush_dep_par_type = -1;
@@ -30411,7 +30411,7 @@ check_flush_deps(void)
                         H5C__NO_FLAGS_SET); /* unsigned int flags */
         if ( !pass ) CACHE_ERROR("unprotect_entry failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[0].flush_dep_par_type = -1;
@@ -30437,11 +30437,11 @@ check_flush_deps(void)
     {
         protect_entry(file_ptr, entry_type, 3);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 3, entry_type, 2);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[2].flush_dep_par_type = entry_type;
@@ -30460,11 +30460,11 @@ check_flush_deps(void)
 
         protect_entry(file_ptr, entry_type, 2);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 2, entry_type, 1);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[1].flush_dep_par_type = entry_type;
@@ -30486,11 +30486,11 @@ check_flush_deps(void)
 
         protect_entry(file_ptr, entry_type, 1);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 1, entry_type, 0);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[0].flush_dep_par_type = entry_type;
@@ -30526,7 +30526,7 @@ check_flush_deps(void)
                         H5C__NO_FLAGS_SET); /* unsigned int flags */
         if ( !pass ) CACHE_ERROR("unprotect_entry failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[0].flush_dep_par_type = -1;
@@ -30559,7 +30559,7 @@ check_flush_deps(void)
                         H5C__NO_FLAGS_SET); /* unsigned int flags */
         if ( !pass ) CACHE_ERROR("unprotect_entry failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[1].flush_dep_par_type = -1;
@@ -30589,7 +30589,7 @@ check_flush_deps(void)
                         H5C__NO_FLAGS_SET); /* unsigned int flags */
         if ( !pass ) CACHE_ERROR("unprotect_entry failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[2].flush_dep_par_type = -1;
@@ -30613,12 +30613,12 @@ check_flush_deps(void)
     {
         protect_entry(file_ptr, entry_type, 4);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         for(u = 0; u < 4; u++) {
             create_flush_dependency(entry_type, 4, entry_type, (int32_t)u);
             if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-            /* Change expected values, and verify the status of the entries 
+            /* Change expected values, and verify the status of the entries
              * after creating flush dependency
              */
             expected[u].flush_dep_par_type = entry_type;
@@ -30643,7 +30643,7 @@ check_flush_deps(void)
             destroy_flush_dependency(entry_type, 4, entry_type, (int32_t)u);
             if ( !pass ) CACHE_ERROR("destroy_flush_dependency failed")
 
-            /* Change expected values, and verify the status of the entries 
+            /* Change expected values, and verify the status of the entries
              * after destroying flush dependency
              */
             expected[u].flush_dep_par_type = -1;
@@ -30659,7 +30659,7 @@ check_flush_deps(void)
                                 H5C__NO_FLAGS_SET); /* unsigned int flags */
                 if ( !pass ) CACHE_ERROR("unprotect_entry failed")
 
-                /* Change expected values, and verify the status of the entries 
+                /* Change expected values, and verify the status of the entries
                  * after destroying flush dependency
                  */
                 expected[4].is_protected = FALSE;
@@ -30686,11 +30686,11 @@ check_flush_deps(void)
     {
         protect_entry(file_ptr, entry_type, 1);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 1, entry_type, 0);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[0].flush_dep_par_type = entry_type;
@@ -30709,11 +30709,11 @@ check_flush_deps(void)
 
         protect_entry(file_ptr, entry_type, 4);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 4, entry_type, 3);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[3].flush_dep_par_type = entry_type;
@@ -30732,11 +30732,11 @@ check_flush_deps(void)
 
         protect_entry(file_ptr, entry_type, 0);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 0, entry_type, 4);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[4].flush_dep_par_type = entry_type;
@@ -30770,7 +30770,7 @@ check_flush_deps(void)
                         H5C__NO_FLAGS_SET); /* unsigned int flags */
         if ( !pass ) CACHE_ERROR("unprotect_entry failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[4].flush_dep_par_type = -1;
@@ -30800,7 +30800,7 @@ check_flush_deps(void)
                         H5C__NO_FLAGS_SET); /* unsigned int flags */
         if ( !pass ) CACHE_ERROR("unprotect_entry failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[3].flush_dep_par_type = -1;
@@ -30827,7 +30827,7 @@ check_flush_deps(void)
                         H5C__NO_FLAGS_SET); /* unsigned int flags */
         if ( !pass ) CACHE_ERROR("unprotect_entry failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[0].flush_dep_par_type = -1;
@@ -30855,11 +30855,11 @@ check_flush_deps(void)
     {
         protect_entry(file_ptr, entry_type, 1);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 1, entry_type, 0);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[0].flush_dep_par_type = entry_type;
@@ -30878,11 +30878,11 @@ check_flush_deps(void)
 
         protect_entry(file_ptr, entry_type, 2);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 2, entry_type, 1);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[1].flush_dep_par_type = entry_type;
@@ -30901,11 +30901,11 @@ check_flush_deps(void)
 
         protect_entry(file_ptr, entry_type, 4);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 4, entry_type, 3);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[3].flush_dep_par_type = entry_type;
@@ -30925,7 +30925,7 @@ check_flush_deps(void)
         create_flush_dependency(entry_type, 1, entry_type, 4);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[4].flush_dep_par_type = entry_type;
@@ -30950,7 +30950,7 @@ check_flush_deps(void)
         destroy_flush_dependency(entry_type, 1, entry_type, 4);
         if ( !pass ) CACHE_ERROR("destroy_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[4].flush_dep_par_type = -1;
@@ -30978,7 +30978,7 @@ check_flush_deps(void)
                         H5C__NO_FLAGS_SET); /* unsigned int flags */
         if ( !pass ) CACHE_ERROR("unprotect_entry failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[3].flush_dep_par_type = -1;
@@ -31005,7 +31005,7 @@ check_flush_deps(void)
                         H5C__NO_FLAGS_SET); /* unsigned int flags */
         if ( !pass ) CACHE_ERROR("unprotect_entry failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[1].flush_dep_par_type = -1;
@@ -31032,7 +31032,7 @@ check_flush_deps(void)
                         H5C__NO_FLAGS_SET); /* unsigned int flags */
         if ( !pass ) CACHE_ERROR("unprotect_entry failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[0].flush_dep_par_type = -1;
@@ -31060,11 +31060,11 @@ check_flush_deps(void)
     {
         protect_entry(file_ptr, entry_type, 1);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 1, entry_type, 0);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[0].flush_dep_par_type = entry_type;
@@ -31083,11 +31083,11 @@ check_flush_deps(void)
 
         protect_entry(file_ptr, entry_type, 2);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 2, entry_type, 1);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[1].flush_dep_par_type = entry_type;
@@ -31106,11 +31106,11 @@ check_flush_deps(void)
 
         protect_entry(file_ptr, entry_type, 4);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 4, entry_type, 3);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[3].flush_dep_par_type = entry_type;
@@ -31130,7 +31130,7 @@ check_flush_deps(void)
         create_flush_dependency(entry_type, 2, entry_type, 4);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[4].flush_dep_par_type = entry_type;
@@ -31151,7 +31151,7 @@ check_flush_deps(void)
         destroy_flush_dependency(entry_type, 2, entry_type, 4);
         if ( !pass ) CACHE_ERROR("destroy_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[4].flush_dep_par_type = -1;
@@ -31175,7 +31175,7 @@ check_flush_deps(void)
                         H5C__NO_FLAGS_SET); /* unsigned int flags */
         if ( !pass ) CACHE_ERROR("unprotect_entry failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[3].flush_dep_par_type = -1;
@@ -31202,7 +31202,7 @@ check_flush_deps(void)
                         H5C__NO_FLAGS_SET); /* unsigned int flags */
         if ( !pass ) CACHE_ERROR("unprotect_entry failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[1].flush_dep_par_type = -1;
@@ -31229,7 +31229,7 @@ check_flush_deps(void)
                         H5C__NO_FLAGS_SET); /* unsigned int flags */
         if ( !pass ) CACHE_ERROR("unprotect_entry failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[0].flush_dep_par_type = -1;
@@ -31255,14 +31255,14 @@ check_flush_deps(void)
     {
         protect_entry(file_ptr, entry_type, 1);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         pin_entry(entry_type, 1);
         if ( !pass ) CACHE_ERROR("pin_entry failed")
 
         create_flush_dependency(entry_type, 1, entry_type, 0);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[0].flush_dep_par_type = entry_type;
@@ -31295,7 +31295,7 @@ check_flush_deps(void)
                         H5C__NO_FLAGS_SET); /* unsigned int flags */
         if ( !pass ) CACHE_ERROR("unprotect_entry failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroy flush dependency
          */
         expected[0].flush_dep_par_type = -1;
@@ -31321,14 +31321,14 @@ check_flush_deps(void)
     {
         protect_entry(file_ptr, entry_type, 1);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         pin_entry(entry_type, 1);
         if ( !pass ) CACHE_ERROR("pin_entry failed")
 
         create_flush_dependency(entry_type, 1, entry_type, 0);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[0].flush_dep_par_type = entry_type;
@@ -31368,7 +31368,7 @@ check_flush_deps(void)
                         H5C__NO_FLAGS_SET); /* unsigned int flags */
         if ( !pass ) CACHE_ERROR("unprotect_entry failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroy flush dependency
          */
         expected[0].flush_dep_par_type = -1;
@@ -31388,7 +31388,7 @@ check_flush_deps(void)
 
 
 done:
-    if(file_ptr) 
+    if(file_ptr)
         takedown_cache(file_ptr, FALSE, FALSE);
 
     if ( pass )
@@ -31456,7 +31456,7 @@ check_flush_deps_err(void)
             case 1:
                 protect_entry(file_ptr, entry_type, 0);
                 if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
                 result = H5C_create_flush_dependency(&((entries[entry_type])[0]), &((entries[entry_type])[0]));
                 if( result != FAIL ) CACHE_ERROR("Creating flush dependency with parent == child")
 
@@ -31472,13 +31472,13 @@ check_flush_deps_err(void)
             case 2:
                 protect_entry(file_ptr, entry_type, 0);
                 if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
                 create_flush_dependency(entry_type, 0, entry_type, 2);
                 if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
                 protect_entry(file_ptr, entry_type, 1);
                 if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
                 result = H5C_create_flush_dependency(&((entries[entry_type])[1]), &((entries[entry_type])[2]));
                 if( result != FAIL ) CACHE_ERROR("Creating second flush dependency for child")
 
@@ -31504,43 +31504,43 @@ check_flush_deps_err(void)
             case 3:
                 protect_entry(file_ptr, entry_type, 0);
                 if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
                 create_flush_dependency(entry_type, 0, entry_type, 1);
                 if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
                 protect_entry(file_ptr, entry_type, 1);
                 if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
                 create_flush_dependency(entry_type, 1, entry_type, 2);
                 if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
                 protect_entry(file_ptr, entry_type, 2);
                 if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
                 create_flush_dependency(entry_type, 2, entry_type, 3);
                 if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
                 protect_entry(file_ptr, entry_type, 3);
                 if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
                 create_flush_dependency(entry_type, 3, entry_type, 4);
                 if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
                 protect_entry(file_ptr, entry_type, 4);
                 if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
                 create_flush_dependency(entry_type, 4, entry_type, 5);
                 if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
                 protect_entry(file_ptr, entry_type, 5);
                 if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
                 create_flush_dependency(entry_type, 5, entry_type, 6);
                 if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
                 protect_entry(file_ptr, entry_type, 6);
                 if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
                 result = H5C_create_flush_dependency(&((entries[entry_type])[6]), &((entries[entry_type])[7]));
                 if( result != FAIL ) CACHE_ERROR("Creating flush dependency that's too tall")
 
@@ -31553,7 +31553,7 @@ check_flush_deps_err(void)
 
                 protect_entry(file_ptr, entry_type, 7);
                 if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
                 result = H5C_create_flush_dependency(&((entries[entry_type])[7]), &((entries[entry_type])[0]));
                 if( result != FAIL ) CACHE_ERROR("Creating flush dependency that's too tall")
 
@@ -31630,7 +31630,7 @@ check_flush_deps_err(void)
                 result = H5C_destroy_flush_dependency(&((entries[entry_type])[0]), &((entries[entry_type])[1]));
                 if( result != FAIL ) CACHE_ERROR("Destroying [non-existant] dependency when parent isn't protected")
                 break;
-        
+
             /* Verify that parent entry has flush dependency */
             case 5:
                 protect_entry(file_ptr, entry_type, 0);
@@ -31646,7 +31646,7 @@ check_flush_deps_err(void)
                                 H5C__NO_FLAGS_SET); /* unsigned int flags */
                 if ( !pass ) CACHE_ERROR("unprotect_entry failed")
                 break;
-        
+
             /* Verify that child entry is in flush dependency relationship */
             case 6:
                 protect_entry(file_ptr, entry_type, 0);
@@ -31773,7 +31773,7 @@ check_flush_deps_err(void)
 
 
 done:
-    if(file_ptr) 
+    if(file_ptr)
         takedown_cache(file_ptr, FALSE, FALSE);
 
     if ( pass )
@@ -31839,8 +31839,8 @@ check_flush_deps_order(void)
         insert_entry(file_ptr, entry_type, (int32_t)u, TRUE, H5C__NO_FLAGS_SET);
         if ( !pass ) CACHE_ERROR("insert_entry failed")
 
-        /* Change expected values, and verify the status of the entries 
-         * after each insertion 
+        /* Change expected values, and verify the status of the entries
+         * after each insertion
          */
         expected[u].in_cache = TRUE;
         expected[u].is_dirty = TRUE;
@@ -31859,11 +31859,11 @@ check_flush_deps_order(void)
     {
         protect_entry(file_ptr, entry_type, 1);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 1, entry_type, 0);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[0].flush_dep_par_type = entry_type;
@@ -31903,7 +31903,7 @@ check_flush_deps_order(void)
         result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
         if( result < 0 ) CACHE_ERROR("flushing entries with flush dependendices")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroy flush dependency
          */
         expected[0].is_dirty = FALSE;
@@ -31933,7 +31933,7 @@ check_flush_deps_order(void)
         destroy_flush_dependency(entry_type, 1, entry_type, 0);
         if ( !pass ) CACHE_ERROR("destroy_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroy flush dependency
          */
         expected[0].flush_dep_par_type = -1;
@@ -31956,11 +31956,11 @@ check_flush_deps_order(void)
     {
         protect_entry(file_ptr, entry_type, 0);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 0, entry_type, 1);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[0].is_protected = TRUE;
@@ -32011,7 +32011,7 @@ check_flush_deps_order(void)
         result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
         if( result < 0 ) CACHE_ERROR("flushing entries with flush dependendices")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroy flush dependency
          */
         expected[0].is_dirty = FALSE;
@@ -32035,7 +32035,7 @@ check_flush_deps_order(void)
         destroy_flush_dependency(entry_type, 0, entry_type, 1);
         if ( !pass ) CACHE_ERROR("destroy_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroy flush dependency
          */
         expected[0].is_pinned = FALSE;
@@ -32060,14 +32060,14 @@ check_flush_deps_order(void)
     {
         protect_entry(file_ptr, entry_type, 2);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 2, entry_type, 0);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
         create_flush_dependency(entry_type, 2, entry_type, 1);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[0].flush_dep_par_type = entry_type;
@@ -32125,7 +32125,7 @@ check_flush_deps_order(void)
         result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
         if( result < 0 ) CACHE_ERROR("flushing entries with flush dependendices")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroy flush dependency
          */
         expected[0].is_dirty = FALSE;
@@ -32155,7 +32155,7 @@ check_flush_deps_order(void)
         destroy_flush_dependency(entry_type, 2, entry_type, 1);
         if ( !pass ) CACHE_ERROR("destroy_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroy flush dependency
          */
         expected[0].flush_dep_par_type = -1;
@@ -32182,14 +32182,14 @@ check_flush_deps_order(void)
     {
         protect_entry(file_ptr, entry_type, 0);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 0, entry_type, 1);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
         create_flush_dependency(entry_type, 0, entry_type, 2);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[0].is_protected = TRUE;
@@ -32247,7 +32247,7 @@ check_flush_deps_order(void)
         result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
         if( result < 0 ) CACHE_ERROR("flushing entries with flush dependendices")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroy flush dependency
          */
         expected[0].is_dirty = FALSE;
@@ -32277,7 +32277,7 @@ check_flush_deps_order(void)
         destroy_flush_dependency(entry_type, 0, entry_type, 2);
         if ( !pass ) CACHE_ERROR("destroy_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroy flush dependency
          */
         expected[0].is_pinned = FALSE;
@@ -32304,11 +32304,11 @@ check_flush_deps_order(void)
     {
         protect_entry(file_ptr, entry_type, 1);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 1, entry_type, 0);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[0].flush_dep_par_type = entry_type;
@@ -32327,11 +32327,11 @@ check_flush_deps_order(void)
 
         protect_entry(file_ptr, entry_type, 2);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 2, entry_type, 1);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[1].flush_dep_par_type = entry_type;
@@ -32350,11 +32350,11 @@ check_flush_deps_order(void)
 
         protect_entry(file_ptr, entry_type, 3);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 3, entry_type, 2);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[2].flush_dep_par_type = entry_type;
@@ -32429,7 +32429,7 @@ check_flush_deps_order(void)
         result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
         if( result < 0 ) CACHE_ERROR("flushing entries with flush dependendices")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroy flush dependency
          */
         expected[0].is_dirty = FALSE;
@@ -32460,7 +32460,7 @@ check_flush_deps_order(void)
         destroy_flush_dependency(entry_type, 3, entry_type, 2);
         if ( !pass ) CACHE_ERROR("destroy_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[2].flush_dep_par_type = -1;
@@ -32479,7 +32479,7 @@ check_flush_deps_order(void)
         destroy_flush_dependency(entry_type, 2, entry_type, 1);
         if ( !pass ) CACHE_ERROR("destroy_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[1].flush_dep_par_type = -1;
@@ -32498,7 +32498,7 @@ check_flush_deps_order(void)
         destroy_flush_dependency(entry_type, 1, entry_type, 0);
         if ( !pass ) CACHE_ERROR("destroy_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[0].flush_dep_par_type = -1;
@@ -32523,11 +32523,11 @@ check_flush_deps_order(void)
     {
         protect_entry(file_ptr, entry_type, 0);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 0, entry_type, 1);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[0].is_protected = TRUE;
@@ -32546,11 +32546,11 @@ check_flush_deps_order(void)
 
         protect_entry(file_ptr, entry_type, 1);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 1, entry_type, 2);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[0].child_flush_dep_height_rc[0] = 0;
@@ -32572,11 +32572,11 @@ check_flush_deps_order(void)
 
         protect_entry(file_ptr, entry_type, 2);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 2, entry_type, 3);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[0].child_flush_dep_height_rc[1] = 0;
@@ -32657,7 +32657,7 @@ check_flush_deps_order(void)
         result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
         if( result < 0 ) CACHE_ERROR("flushing entries with flush dependendices")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroy flush dependency
          */
         expected[0].is_dirty = FALSE;
@@ -32689,7 +32689,7 @@ check_flush_deps_order(void)
         destroy_flush_dependency(entry_type, 2, entry_type, 3);
         if ( !pass ) CACHE_ERROR("destroy_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[0].child_flush_dep_height_rc[2] = 0;
@@ -32714,7 +32714,7 @@ check_flush_deps_order(void)
         destroy_flush_dependency(entry_type, 1, entry_type, 2);
         if ( !pass ) CACHE_ERROR("destroy_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[0].child_flush_dep_height_rc[1] = 0;
@@ -32736,7 +32736,7 @@ check_flush_deps_order(void)
         destroy_flush_dependency(entry_type, 0, entry_type, 1);
         if ( !pass ) CACHE_ERROR("destroy_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[0].is_pinned = FALSE;
@@ -32759,12 +32759,12 @@ check_flush_deps_order(void)
     {
         protect_entry(file_ptr, entry_type, 4);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         for(u = 0; u < 4; u++) {
             create_flush_dependency(entry_type, 4, entry_type, (int32_t)u);
             if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-            /* Change expected values, and verify the status of the entries 
+            /* Change expected values, and verify the status of the entries
              * after creating flush dependency
              */
             expected[u].flush_dep_par_type = entry_type;
@@ -32831,7 +32831,7 @@ check_flush_deps_order(void)
         result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
         if( result < 0 ) CACHE_ERROR("flushing entries with flush dependendices")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroy flush dependency
          */
         expected[0].is_dirty = FALSE;
@@ -32865,7 +32865,7 @@ check_flush_deps_order(void)
             destroy_flush_dependency(entry_type, 4, entry_type, (int32_t)u);
             if ( !pass ) CACHE_ERROR("destroy_flush_dependency failed")
 
-            /* Change expected values, and verify the status of the entries 
+            /* Change expected values, and verify the status of the entries
              * after destroying flush dependency
              */
             expected[u].flush_dep_par_type = -1;
@@ -32874,7 +32874,7 @@ check_flush_deps_order(void)
 
             /* Check for destroying flush dependency on last entry */
             if(3 == u) {
-                /* Change expected values, and verify the status of the entries 
+                /* Change expected values, and verify the status of the entries
                  * after destroying flush dependency
                  */
                 expected[4].is_pinned = FALSE;
@@ -32896,12 +32896,12 @@ check_flush_deps_order(void)
     {
         protect_entry(file_ptr, entry_type, 0);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         for(u = 1; u < 5; u++) {
             create_flush_dependency(entry_type, 0, entry_type, (int32_t)u);
             if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-            /* Change expected values, and verify the status of the entries 
+            /* Change expected values, and verify the status of the entries
              * after creating flush dependency
              */
             expected[u].flush_dep_par_type = entry_type;
@@ -32968,7 +32968,7 @@ check_flush_deps_order(void)
         result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
         if( result < 0 ) CACHE_ERROR("flushing entries with flush dependendices")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroy flush dependency
          */
         expected[0].is_dirty = FALSE;
@@ -33002,7 +33002,7 @@ check_flush_deps_order(void)
             destroy_flush_dependency(entry_type, 0, entry_type, (int32_t)u);
             if ( !pass ) CACHE_ERROR("destroy_flush_dependency failed")
 
-            /* Change expected values, and verify the status of the entries 
+            /* Change expected values, and verify the status of the entries
              * after destroying flush dependency
              */
             expected[u].flush_dep_par_type = -1;
@@ -33011,7 +33011,7 @@ check_flush_deps_order(void)
 
             /* Check for destroying flush dependency on last entry */
             if(4 == u) {
-                /* Change expected values, and verify the status of the entries 
+                /* Change expected values, and verify the status of the entries
                  * after destroying flush dependency
                  */
                 expected[0].is_pinned = FALSE;
@@ -33037,11 +33037,11 @@ check_flush_deps_order(void)
     {
         protect_entry(file_ptr, entry_type, 1);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 1, entry_type, 0);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[0].flush_dep_par_type = entry_type;
@@ -33060,11 +33060,11 @@ check_flush_deps_order(void)
 
         protect_entry(file_ptr, entry_type, 4);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 4, entry_type, 3);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[3].flush_dep_par_type = entry_type;
@@ -33083,11 +33083,11 @@ check_flush_deps_order(void)
 
         protect_entry(file_ptr, entry_type, 0);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 0, entry_type, 4);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[4].flush_dep_par_type = entry_type;
@@ -33169,7 +33169,7 @@ check_flush_deps_order(void)
         result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
         if( result < 0 ) CACHE_ERROR("flushing entries with flush dependendices")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroy flush dependency
          */
         expected[0].is_dirty = FALSE;
@@ -33203,7 +33203,7 @@ check_flush_deps_order(void)
         destroy_flush_dependency(entry_type, 0, entry_type, 4);
         if ( !pass ) CACHE_ERROR("destroy_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[4].flush_dep_par_type = -1;
@@ -33225,7 +33225,7 @@ check_flush_deps_order(void)
         destroy_flush_dependency(entry_type, 4, entry_type, 3);
         if ( !pass ) CACHE_ERROR("destroy_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[3].flush_dep_par_type = -1;
@@ -33244,7 +33244,7 @@ check_flush_deps_order(void)
         destroy_flush_dependency(entry_type, 1, entry_type, 0);
         if ( !pass ) CACHE_ERROR("destroy_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[0].flush_dep_par_type = -1;
@@ -33271,11 +33271,11 @@ check_flush_deps_order(void)
     {
         protect_entry(file_ptr, entry_type, 1);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 1, entry_type, 0);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[0].flush_dep_par_type = entry_type;
@@ -33294,11 +33294,11 @@ check_flush_deps_order(void)
 
         protect_entry(file_ptr, entry_type, 2);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 2, entry_type, 1);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[1].flush_dep_par_type = entry_type;
@@ -33317,11 +33317,11 @@ check_flush_deps_order(void)
 
         protect_entry(file_ptr, entry_type, 4);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 4, entry_type, 3);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[3].flush_dep_par_type = entry_type;
@@ -33341,7 +33341,7 @@ check_flush_deps_order(void)
         create_flush_dependency(entry_type, 1, entry_type, 4);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[4].flush_dep_par_type = entry_type;
@@ -33423,7 +33423,7 @@ check_flush_deps_order(void)
         result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
         if( result < 0 ) CACHE_ERROR("flushing entries with flush dependendices")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroy flush dependency
          */
         expected[0].is_dirty = FALSE;
@@ -33459,7 +33459,7 @@ check_flush_deps_order(void)
         destroy_flush_dependency(entry_type, 1, entry_type, 4);
         if ( !pass ) CACHE_ERROR("destroy_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[4].flush_dep_par_type = -1;
@@ -33480,7 +33480,7 @@ check_flush_deps_order(void)
         destroy_flush_dependency(entry_type, 4, entry_type, 3);
         if ( !pass ) CACHE_ERROR("destroy_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[3].flush_dep_par_type = -1;
@@ -33499,7 +33499,7 @@ check_flush_deps_order(void)
         destroy_flush_dependency(entry_type, 2, entry_type, 1);
         if ( !pass ) CACHE_ERROR("destroy_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[1].flush_dep_par_type = -1;
@@ -33518,7 +33518,7 @@ check_flush_deps_order(void)
         destroy_flush_dependency(entry_type, 1, entry_type, 0);
         if ( !pass ) CACHE_ERROR("destroy_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[0].flush_dep_par_type = -1;
@@ -33545,11 +33545,11 @@ check_flush_deps_order(void)
     {
         protect_entry(file_ptr, entry_type, 1);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 1, entry_type, 0);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[0].flush_dep_par_type = entry_type;
@@ -33568,11 +33568,11 @@ check_flush_deps_order(void)
 
         protect_entry(file_ptr, entry_type, 2);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 2, entry_type, 1);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[1].flush_dep_par_type = entry_type;
@@ -33591,11 +33591,11 @@ check_flush_deps_order(void)
 
         protect_entry(file_ptr, entry_type, 4);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
-        
+
         create_flush_dependency(entry_type, 4, entry_type, 3);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[3].flush_dep_par_type = entry_type;
@@ -33615,7 +33615,7 @@ check_flush_deps_order(void)
         create_flush_dependency(entry_type, 2, entry_type, 4);
         if ( !pass ) CACHE_ERROR("create_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after creating flush dependency
          */
         expected[4].flush_dep_par_type = entry_type;
@@ -33693,7 +33693,7 @@ check_flush_deps_order(void)
         result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
         if( result < 0 ) CACHE_ERROR("flushing entries with flush dependendices")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroy flush dependency
          */
         expected[0].is_dirty = FALSE;
@@ -33729,7 +33729,7 @@ check_flush_deps_order(void)
         destroy_flush_dependency(entry_type, 2, entry_type, 4);
         if ( !pass ) CACHE_ERROR("destroy_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[4].flush_dep_par_type = -1;
@@ -33746,7 +33746,7 @@ check_flush_deps_order(void)
         destroy_flush_dependency(entry_type, 4, entry_type, 3);
         if ( !pass ) CACHE_ERROR("destroy_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[3].flush_dep_par_type = -1;
@@ -33765,7 +33765,7 @@ check_flush_deps_order(void)
         destroy_flush_dependency(entry_type, 2, entry_type, 1);
         if ( !pass ) CACHE_ERROR("destroy_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[1].flush_dep_par_type = -1;
@@ -33784,7 +33784,7 @@ check_flush_deps_order(void)
         destroy_flush_dependency(entry_type, 1, entry_type, 0);
         if ( !pass ) CACHE_ERROR("destroy_flush_dependency failed")
 
-        /* Change expected values, and verify the status of the entries 
+        /* Change expected values, and verify the status of the entries
          * after destroying flush dependency
          */
         expected[0].flush_dep_par_type = -1;
@@ -33803,7 +33803,7 @@ check_flush_deps_order(void)
 
 
 done:
-    if(file_ptr) 
+    if(file_ptr)
         takedown_cache(file_ptr, FALSE, FALSE);
 
     if ( pass )
@@ -33870,8 +33870,8 @@ check_notify_cb(void)
         insert_entry(file_ptr, entry_type, (int32_t)u, TRUE, H5C__NO_FLAGS_SET);
         if ( !pass ) CACHE_ERROR("insert_entry failed")
 
-        /* Change expected values, and verify the status of the entries 
-         * after each insertion 
+        /* Change expected values, and verify the status of the entries
+         * after each insertion
          */
         expected[u].in_cache = TRUE;
         expected[u].is_dirty = TRUE;
@@ -33896,8 +33896,8 @@ check_notify_cb(void)
         expunge_entry(file_ptr, entry_type, (int32_t)u);
         if ( !pass ) CACHE_ERROR("expunge_entry failed")
 
-        /* Change expected values, and verify the status of the entries 
-         * after each insertion 
+        /* Change expected values, and verify the status of the entries
+         * after each insertion
          */
         expected[u].in_cache = FALSE;
         expected[u].is_dirty = FALSE;
@@ -33924,8 +33924,8 @@ check_notify_cb(void)
         protect_entry(file_ptr, entry_type, (int32_t)u);
         if ( !pass ) CACHE_ERROR("protect_entry failed")
 
-        /* Change expected values, and verify the status of the entries 
-         * after each insertion 
+        /* Change expected values, and verify the status of the entries
+         * after each insertion
          */
         expected[u].in_cache = TRUE;
         expected[u].is_dirty = FALSE;
@@ -33952,8 +33952,8 @@ check_notify_cb(void)
         unprotect_entry(file_ptr, entry_type, (int32_t)u, TRUE, H5C__NO_FLAGS_SET);
         if ( !pass ) CACHE_ERROR("unprotect_entry failed")
 
-        /* Change expected values, and verify the status of the entries 
-         * after each insertion 
+        /* Change expected values, and verify the status of the entries
+         * after each insertion
          */
         expected[u].in_cache = TRUE;
         expected[u].is_dirty = TRUE;
@@ -33979,8 +33979,8 @@ check_notify_cb(void)
         expunge_entry(file_ptr, entry_type, (int32_t)u);
         if ( !pass ) CACHE_ERROR("expunge_entry failed")
 
-        /* Change expected values, and verify the status of the entries 
-         * after each insertion 
+        /* Change expected values, and verify the status of the entries
+         * after each insertion
          */
         expected[u].in_cache = FALSE;
         expected[u].is_dirty = FALSE;
@@ -34003,7 +34003,7 @@ check_notify_cb(void)
     } /* end for */
 
 done:
-    if(file_ptr) 
+    if(file_ptr)
         takedown_cache(file_ptr, FALSE, FALSE);
 
     if ( pass )
@@ -34091,8 +34091,8 @@ main(void)
     nerrs += check_auto_cache_resize_epoch_markers();
     nerrs += check_auto_cache_resize_input_errs();
     nerrs += check_auto_cache_resize_aux_fcns();
-    nerrs += check_metadata_blizzard_absence(TRUE);   
-    nerrs += check_metadata_blizzard_absence(FALSE);  
+    nerrs += check_metadata_blizzard_absence(TRUE);
+    nerrs += check_metadata_blizzard_absence(FALSE);
     nerrs += check_flush_deps();
     nerrs += check_flush_deps_err();
     nerrs += check_flush_deps_order();
diff --git a/test/cache_common.c b/test/cache_common.c
index 335704d..bc82e57 100644
--- a/test/cache_common.c
+++ b/test/cache_common.c
@@ -35,20 +35,20 @@ const char *FILENAME[] = {
     NULL
 };
 
-hid_t saved_fapl_id = H5P_DEFAULT; /* store the fapl id here between 
-				    * cache setup and takedown.  Note 
+hid_t saved_fapl_id = H5P_DEFAULT; /* store the fapl id here between
+				    * cache setup and takedown.  Note
 				    * that if saved_fapl_id == H5P_DEFAULT,
-				    * we assume that there is no fapl to 
+				    * we assume that there is no fapl to
 				    * close.
 				    */
 
-hid_t saved_fid = -1; /* store the file id here between cache setup 
+hid_t saved_fid = -1; /* store the file id here between cache setup
 		       * and takedown.
 		       */
 
-H5C_t * saved_cache = NULL; /* store the pointer to the instance of 
- 			       * of H5C_t created by H5Fcreate() 
-			       * here between test cache setup and 
+H5C_t * saved_cache = NULL; /* store the pointer to the instance of
+ 			       * of H5C_t created by H5Fcreate()
+			       * here between test cache setup and
 			       * shutdown.
 			       */
 
@@ -1626,7 +1626,7 @@ execute_flush_op(H5F_t * file_ptr,
 
 		    /* change the size of some other entry */
 
-		    resize_entry(file_ptr, op_ptr->type, op_ptr->idx, 
+		    resize_entry(file_ptr, op_ptr->type, op_ptr->idx,
                                  op_ptr->size, op_ptr->flag);
 		}
 		break;
@@ -2011,7 +2011,7 @@ resize_pinned_entry(H5C_t * cache_ptr,
 
 		entry_ptr->size = new_size;
 
-	        result = H5C_resize_pinned_entry((void *)entry_ptr, 
+	        result = H5C_resize_pinned_entry((void *)entry_ptr,
 						 new_size);
 
 		if ( result != SUCCEED ) {
@@ -2586,13 +2586,13 @@ setup_cache(size_t max_cache_size,
 	          < 0 ) {
 
 	    core_file_driver_failed = TRUE;
-        
+
             if ( verbose ) {
                 HDfprintf(stdout, "%s: H5Fcreate() with CFD failed.\n", fcn_name);
             }
 
         } else {
-	
+
 	    saved_fapl_id = fapl_id;
 	}
     }
@@ -2601,12 +2601,12 @@ setup_cache(size_t max_cache_size,
         HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
                   fcn_name, mile_stone++, (int)pass);
 
-    /* if we either aren't using the core file driver, or a create 
+    /* if we either aren't using the core file driver, or a create
      * with the core file driver failed, try again with a regular file.
      * If this fails, we are cooked.
      */
     if ( ( pass ) && ( fid < 0 ) ) {
-    
+
         fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl_id);
 
 	saved_fid = fid;
@@ -2615,7 +2615,7 @@ setup_cache(size_t max_cache_size,
 
             pass = FALSE;
             failure_mssg = "H5Fcreate() failed.";
-        
+
             if ( verbose ) {
                 HDfprintf(stdout, "%s: H5Fcreate() failed.\n", fcn_name);
             }
@@ -2636,7 +2636,7 @@ setup_cache(size_t max_cache_size,
 
             pass = FALSE;
             failure_mssg = "H5Fflush() failed.";
-        
+
             if ( verbose ) {
                 HDfprintf(stdout, "%s: H5Fflush() failed.\n", fcn_name);
             }
@@ -2649,7 +2649,7 @@ setup_cache(size_t max_cache_size,
 
                 pass = FALSE;
                 failure_mssg = "Can't get file_ptr.";
-        
+
                 if ( verbose ) {
                     HDfprintf(stdout, "%s: H5Fflush() failed.\n", fcn_name);
                 }
@@ -2679,15 +2679,15 @@ setup_cache(size_t max_cache_size,
 	 * and we have modified many cache routines to use a file
 	 * pointer to look up the target cache.
 	 *
-	 * Thus we now make note of the address of the instance of 
-	 * H5C_t created by the call to H5Fcreate(), set 
+	 * Thus we now make note of the address of the instance of
+	 * H5C_t created by the call to H5Fcreate(), set
 	 * file_ptr->shared->cache to NULL, call H5C_create()
 	 * to allocate a new instance of H5C_t for test purposes,
-	 * and store than new instance's address in 
+	 * and store than new instance's address in
 	 * file_ptr->shared->cache.
 	 *
 	 * On shut down, we call H5C_dest on our instance of H5C_t,
-	 * set file_ptr->shared->cache to point to the original 
+	 * set file_ptr->shared->cache to point to the original
 	 * instance, and then close the file normally.
 	 */
 
@@ -2714,7 +2714,7 @@ setup_cache(size_t max_cache_size,
                   fcn_name, mile_stone++, (int)pass);
 
     if ( pass ) {
-	    
+
 	if ( cache_ptr == NULL ) {
 
             pass = FALSE;
@@ -2741,14 +2741,14 @@ setup_cache(size_t max_cache_size,
 
     if ( pass ) { /* allocate space for test entries */
 
-        actual_base_addr = H5MF_alloc(file_ptr, H5FD_MEM_DEFAULT, H5P_DEFAULT, 
+        actual_base_addr = H5MF_alloc(file_ptr, H5FD_MEM_DEFAULT, H5P_DEFAULT,
 			              (hsize_t)(ADDR_SPACE_SIZE + BASE_ADDR));
 
 	if ( actual_base_addr == HADDR_UNDEF ) {
 
             pass = FALSE;
 	    failure_mssg = "H5MF_alloc() failed.";
-	    
+
 	    if ( verbose ) {
                 HDfprintf(stdout, "%s: H5MF_alloc() failed.\n", fcn_name);
             }
@@ -2763,7 +2763,7 @@ setup_cache(size_t max_cache_size,
 	    failure_mssg = "actual_base_addr > BASE_ADDR";
 
 	    if ( verbose ) {
-                HDfprintf(stdout, "%s: actual_base_addr > BASE_ADDR.\n", 
+                HDfprintf(stdout, "%s: actual_base_addr > BASE_ADDR.\n",
 			  fcn_name);
             }
         }
@@ -2820,7 +2820,7 @@ takedown_cache(H5F_t * file_ptr,
 
             H5C_stats(cache_ptr, "test cache", dump_detailed_stats);
         }
-	
+
         flush_cache(file_ptr, TRUE, FALSE, FALSE);
 
         H5C_dest(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT);
@@ -2846,7 +2846,7 @@ takedown_cache(H5F_t * file_ptr,
             if ( NULL == file_ptr )  {
                 file_ptr = (H5F_t *)H5I_object_verify(saved_fid, H5I_FILE);
                 HDassert ( file_ptr );
-            } 
+            }
 
             H5MF_xfree(file_ptr, H5FD_MEM_DEFAULT, H5P_DEFAULT, saved_actual_base_addr,
                                           (hsize_t)(ADDR_SPACE_SIZE + BASE_ADDR));
@@ -3018,7 +3018,7 @@ flush_cache(H5F_t * file_ptr,
 	        ( cache_ptr->dirty_index_size != 0 ) ) ) {
 
 	if ( verbose ) {
-            HDfprintf(stdout, 
+            HDfprintf(stdout,
 		      "%s: unexpected il/is/cis/dis = %lld/%lld/%lld/%lld.\n",
 		      fcn_name,
 		      (long long)(cache_ptr->index_len),
@@ -3027,7 +3027,7 @@ flush_cache(H5F_t * file_ptr,
 		      (long long)(cache_ptr->dirty_index_size));
 	}
         pass = FALSE;
-        failure_mssg = 
+        failure_mssg =
 	   "non zero index len/sizes after H5C_flush_cache() with invalidate.";
     }
 
@@ -4020,7 +4020,7 @@ unprotect_entry_with_size_change(H5F_t * file_ptr,
             if ( result < 0 )
                 HDfprintf(stdout, "%s: H5C_unprotect() failed.\n", fcn_name);
 
-            if ( entry_ptr->header.is_protected ) 
+            if ( entry_ptr->header.is_protected )
                 HDfprintf(stdout, "%s: entry still protected?!?.\n", fcn_name);
 
             if ( entry_ptr->header.type != &(types[type]) )
@@ -4549,7 +4549,7 @@ row_major_scan_backward(H5F_t * file_ptr,
     if ( pass ) {
 
         cache_ptr = file_ptr->shared->cache;
-        
+
         HDassert( cache_ptr != NULL );
         HDassert( lag >= 10 );
 
@@ -5324,7 +5324,7 @@ hl_col_major_scan_backward(H5F_t * file_ptr,
     if ( pass ) {
 
         cache_ptr = file_ptr->shared->cache;
-     
+
         HDassert( cache_ptr != NULL );
         HDassert( lag > 5 );
         HDassert( max_index >= 500 );
diff --git a/test/cache_common.h b/test/cache_common.h
index 7f2af16..d7b949a 100644
--- a/test/cache_common.h
+++ b/test/cache_common.h
@@ -81,10 +81,10 @@
 
 #define MAX_ENTRIES		(10 * 1024)
 
-/* The choice of the BASE_ADDR below is arbitrary -- it just has to be 
+/* The choice of the BASE_ADDR below is arbitrary -- it just has to be
  * larger than the superblock.
  */
-#define BASE_ADDR		(haddr_t)1024 
+#define BASE_ADDR		(haddr_t)1024
 #define PICO_BASE_ADDR		BASE_ADDR
 #define NANO_BASE_ADDR		(haddr_t)(PICO_BASE_ADDR + \
                                       (PICO_ENTRY_SIZE * NUM_PICO_ENTRIES))
diff --git a/test/dsets.c b/test/dsets.c
index 1041385..9c70875 100644
--- a/test/dsets.c
+++ b/test/dsets.c
@@ -183,7 +183,7 @@ const char *FILENAME[] = {
 #define BYPASS_DIM               1000
 #define BYPASS_CHUNK_DIM         500
 #define BYPASS_FILL_VALUE        7
- 
+
 /* Shared global arrays */
 #define DSET_DIM1       100
 #define DSET_DIM2       200
@@ -813,7 +813,7 @@ error:
         HDfree(wbuf);
     if(rbuf)
         HDfree(rbuf);
-        
+
     H5E_BEGIN_TRY {
         /* Close file */
         H5Sclose(space);
@@ -1051,16 +1051,16 @@ test_tconv(hid_t file)
     return 0;
 
 error:
-    if(out) 
+    if(out)
         HDfree(out);
-    if(in) 
+    if(in)
         HDfree(in);
-    
+
     H5E_BEGIN_TRY {
         H5Dclose(dataset);
         H5Sclose(space);
     } H5E_END_TRY;
-    
+
     return -1;
 }
 
@@ -1730,7 +1730,7 @@ error:
  *
  * Modifications:
  *              Make copy of data file since the test writes to the file.
- *              Larry Knox, October 14, 2009   
+ *              Larry Knox, October 14, 2009
  *
  *-------------------------------------------------------------------------
  */
@@ -1748,12 +1748,12 @@ test_filter_noencoder(const char *dset_name)
     int test_ints[10] = { 12 };
     int read_buf[10];
     int i;
- 
+
     /* Make a local copy of the file since this test writes to the data file
-       from svn. */  
-    if (h5_make_local_copy(NOENCODER_FILENAME, NOENCODER_COPY_FILENAME) < 0) 
+       from svn. */
+    if (h5_make_local_copy(NOENCODER_FILENAME, NOENCODER_COPY_FILENAME) < 0)
         goto error;
-    
+
     /* Open file */
     file_id = H5Fopen(NOENCODER_COPY_FILENAME, H5F_ACC_RDWR, H5P_DEFAULT);
     if(file_id < 0) goto error;
@@ -5561,9 +5561,9 @@ error:
 /*-------------------------------------------------------------------------
  * Function:	test_copy_dcpl
  *
- * Purpose:	Verifies whether the copy of dataset creation property 
+ * Purpose:	Verifies whether the copy of dataset creation property
  *              list works.  It tests the DCPL for chunked layout with
- *              filter and for contiguous layout with external storage. 
+ *              filter and for contiguous layout with external storage.
  *              (Please see #1608 in Bugzilla)
  *
  * Return:	Success:	0
@@ -5599,7 +5599,7 @@ test_copy_dcpl(hid_t file, hid_t fapl)
     if(H5Pset_fletcher32(dcpl) < 0) TEST_ERROR
 
     /* Create first dataset of chunking with filter */
-    if((dsid1 = H5Dcreate2(file, DSET_COPY_DCPL_NAME_1, H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl, 
+    if((dsid1 = H5Dcreate2(file, DSET_COPY_DCPL_NAME_1, H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl,
         H5P_DEFAULT)) < 0) TEST_ERROR
 
     /* Close dataset */
@@ -5624,7 +5624,7 @@ test_copy_dcpl(hid_t file, hid_t fapl)
     if(H5Pset_external(dcpl, COPY_DCPL_EXTFILE_NAME, 0, 500*4096*sizeof(int)) < 0) TEST_ERROR
 
     /* Create second dataset of contiguous layout with external storage */
-    if((dsid2 = H5Dcreate2(file, DSET_COPY_DCPL_NAME_2, H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl, 
+    if((dsid2 = H5Dcreate2(file, DSET_COPY_DCPL_NAME_2, H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl,
         H5P_DEFAULT)) < 0) TEST_ERROR
 
     /* Close dataset */
@@ -5641,7 +5641,7 @@ test_copy_dcpl(hid_t file, hid_t fapl)
     if(H5Dclose (dsid2) < 0) TEST_ERROR
 
     /* Create a second file and create 2 datasets with the copies of the DCPLs in the first
-     * file.  Test whether the copies of DCPLs work. */ 
+     * file.  Test whether the copies of DCPLs work. */
     h5_fixname(FILENAME[11], fapl, filename, sizeof filename);
     if((new_file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0)
         TEST_ERROR
@@ -5657,10 +5657,10 @@ test_copy_dcpl(hid_t file, hid_t fapl)
 
     /* Close datasets */
     if(H5Dclose (new_dsid1) < 0) TEST_ERROR
-    if(H5Dclose (new_dsid2) < 0) TEST_ERROR 
+    if(H5Dclose (new_dsid2) < 0) TEST_ERROR
 
     /* Close the second file */
-    if(H5Fclose (new_file) < 0) TEST_ERROR 
+    if(H5Fclose (new_file) < 0) TEST_ERROR
 
     /* Close dataset creation property lists */
     if(H5Pclose(dcpl) < 0) TEST_ERROR
@@ -6906,7 +6906,7 @@ error:
  *
  * Purpose:     When the chunk size is bigger than the cache size and the
  *              chunk isn't on disk, this test verifies that the library
- *              bypasses the cache. 
+ *              bypasses the cache.
  *
  * Note:        This test is not very conclusive - it doesn't actually check
  *              if the chunks bypass the cache... :-(  -QAK
@@ -6932,7 +6932,7 @@ test_big_chunks_bypass_cache(hid_t fapl)
     size_t      rdcc_nelmts, rdcc_nbytes;
     int         fvalue = BYPASS_FILL_VALUE;
     hsize_t     count, stride, offset, block;
-    static int  wdata[BYPASS_CHUNK_DIM/2], rdata1[BYPASS_DIM], 
+    static int  wdata[BYPASS_CHUNK_DIM/2], rdata1[BYPASS_DIM],
                 rdata2[BYPASS_CHUNK_DIM/2];
     int         i, j;
 
@@ -6976,7 +6976,7 @@ test_big_chunks_bypass_cache(hid_t fapl)
     count = 1;
     stride = 1;
     block = BYPASS_CHUNK_DIM / 2;
-    if(H5Sselect_hyperslab(sid, H5S_SELECT_SET, &offset, &stride, &count, &block) < 0) 
+    if(H5Sselect_hyperslab(sid, H5S_SELECT_SET, &offset, &stride, &count, &block) < 0)
         FAIL_STACK_ERROR
 
     /* Initialize data to write */
@@ -6992,9 +6992,9 @@ test_big_chunks_bypass_cache(hid_t fapl)
     /* Reopen the dataset */
     if((dsid = H5Dopen2(fid, BYPASS_DATASET1, H5P_DEFAULT)) < 0) FAIL_STACK_ERROR
 
-    /* Reads both 2 chunks.  Reading the second chunk should bypass the cache because the 
+    /* Reads both 2 chunks.  Reading the second chunk should bypass the cache because the
      * chunk is bigger than the cache size and it isn't allocated on disk. */
-    if(H5Dread(dsid, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, rdata1) < 0) 
+    if(H5Dread(dsid, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, rdata1) < 0)
         FAIL_STACK_ERROR
 
     for(i = 0; i < BYPASS_CHUNK_DIM / 2; i++)
@@ -7013,9 +7013,9 @@ test_big_chunks_bypass_cache(hid_t fapl)
 
     /* Close the first dataset */
     if(H5Dclose(dsid) < 0) FAIL_STACK_ERROR
-   
+
     /* Create a second dataset without fill value.  This time, both write
-     * and read should bypass the cache because the chunk is bigger than the 
+     * and read should bypass the cache because the chunk is bigger than the
      * cache size and it's not allocated on disk. */
     if(H5Pset_fill_time(dcpl, H5D_FILL_TIME_NEVER) < 0) FAIL_STACK_ERROR
 
@@ -7030,10 +7030,10 @@ test_big_chunks_bypass_cache(hid_t fapl)
     /* Reopen the dataset */
     if((dsid = H5Dopen2(fid, BYPASS_DATASET2, H5P_DEFAULT)) < 0) FAIL_STACK_ERROR
 
-    /* Read back only the part that was written to the file.  Reading the 
+    /* Read back only the part that was written to the file.  Reading the
      * half chunk should bypass the cache because the chunk is bigger than
      * the cache size. */
-    if(H5Dread(dsid, H5T_NATIVE_INT, H5S_ALL, sid, H5P_DEFAULT, rdata2) < 0) 
+    if(H5Dread(dsid, H5T_NATIVE_INT, H5S_ALL, sid, H5P_DEFAULT, rdata2) < 0)
 
     for(i = 0; i < BYPASS_CHUNK_DIM / 2; i++)
         if(rdata2[i] != i) {
@@ -7547,7 +7547,7 @@ main(void)
     printf("All dataset tests passed.\n");
 #ifdef H5_HAVE_FILTER_SZIP
     if (GetTestCleanup())
-        HDremove(NOENCODER_COPY_FILENAME); 
+        HDremove(NOENCODER_COPY_FILENAME);
 #endif /* H5_HAVE_FILTER_SZIP */
     h5_cleanup(FILENAME, fapl);
 
diff --git a/test/dtypes.c b/test/dtypes.c
index f32afe5..8762380 100644
--- a/test/dtypes.c
+++ b/test/dtypes.c
@@ -327,7 +327,7 @@ test_copy(void)
  * Modifications:
  *              Raymond Lu
  *              8 December 2009
- *              I added a field of VL string in the compound type to test 
+ *              I added a field of VL string in the compound type to test
  *              H5Tdetect_class correctly detect it as string type.
  *-------------------------------------------------------------------------
  */
@@ -523,7 +523,7 @@ test_compound_1(void)
     TESTING("compound datatypes");
 
     /* Create the empty type */
-    if ((complex_id = H5Tcreate(H5T_COMPOUND, sizeof(complex_t))) < 0) 
+    if ((complex_id = H5Tcreate(H5T_COMPOUND, sizeof(complex_t))) < 0)
         goto error;
 
     /* Attempt to add the new compound datatype as a field within itself */
@@ -626,7 +626,7 @@ test_compound_1(void)
         FAIL_PUTS_ERROR("Operation not allowed for this type.");
     } /* end if */
 
-    if (H5Tclose (complex_id) < 0) 
+    if (H5Tclose (complex_id) < 0)
         goto error;
 
     PASSED();
@@ -2429,7 +2429,7 @@ test_compound_14(void)
        char         c2;
        char*        str;
     } cmpd_struct_1;
-    
+
     typedef struct cmpd_struct_2 {
        char         c1;
        char         c2;
@@ -2441,7 +2441,7 @@ test_compound_14(void)
     } cmpd_struct_2;
 
     cmpd_struct_1 wdata1 = {'A', 'B', "variable-length string"};
-    
+
     cmpd_struct_1 rdata1;
     cmpd_struct_2 wdata2 = {'C', 'D', "another vlen!", 1, 2, -1, 9001};
     cmpd_struct_2 rdata2;
@@ -4192,9 +4192,9 @@ test_conv_str_3(void)
     ret_value = 0;
 
 error:
-    if(buf) 
+    if(buf)
         HDfree(buf);
-    if(tag) 
+    if(tag)
         HDfree(tag);
     reset_hdf5();
     return ret_value;  /* Number of errors */
@@ -5016,7 +5016,7 @@ test_encode(void)
         printf("Can't copy a string type\n");
         goto error;
     } /* end if */
-    if(H5Tset_size(tid3, H5T_VARIABLE) < 0) { 
+    if(H5Tset_size(tid3, H5T_VARIABLE) < 0) {
         H5_FAILED();
         printf("Can't the string type to be variable-length\n");
         goto error;
diff --git a/test/error_test.c b/test/error_test.c
index 89a81a3..21a3e58 100644
--- a/test/error_test.c
+++ b/test/error_test.c
@@ -586,7 +586,7 @@ main(void)
         /* Delete an error from the top of error stack */
         H5Epop(ERR_STACK, 1);
 
-        /* Make sure we can use other class's major or minor errors. */ 
+        /* Make sure we can use other class's major or minor errors. */
         H5Epush(ERR_STACK, __FILE__, FUNC_main, __LINE__, ERR_CLS2, ERR_MAJ_TEST, ERR_MIN_ERRSTACK,
                 "Error stack test failed");
 
diff --git a/test/external.c b/test/external.c
index b3831ad..68f81e8 100644
--- a/test/external.c
+++ b/test/external.c
@@ -60,14 +60,14 @@ same_contents (const char *name1, const char *name2)
     fd2 = HDopen(name2, O_RDONLY, 0666);
     assert(fd1 >= 0 && fd2 >= 0);
 
-    while(1) { 
+    while(1) {
         /* Asserts will catch negative return values */
         n1 = HDread(fd1, buf1, sizeof(buf1));
         n2 = HDread(fd2, buf2, sizeof(buf2));
         assert(n1 >= 0 && (size_t)n1 <= sizeof(buf1));
         assert(n2 >= 0 && (size_t)n2 <= sizeof(buf2));
         assert(n1 == n2);
-    
+
         if(n1 == 0 && n2 == 0)
             break;
         if(HDmemcmp(buf1, buf2, (size_t)n1)) {
diff --git a/test/farray.c b/test/farray.c
index b949263..60a2200 100644
--- a/test/farray.c
+++ b/test/farray.c
@@ -13,7 +13,7 @@
  * access to either file, you may request a copy from help@hdfgroup.org.     *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
-/* 
+/*
  * This file is modified based on earray.c.
  */
 #include "h5test.h"
@@ -37,7 +37,7 @@
 #define FARRAY_FILENAME_LEN     1024
 
 /* Fixed array creation values */
-#define ELMT_SIZE      	sizeof(uint64_t) 
+#define ELMT_SIZE      	sizeof(uint64_t)
 #define MAX_DBLOCK_PAGE_NELMTS_BITS     10      /* 2^10 = 1024 elements per data block page */
 
 /* Testing # of elements in the Fixed Array */
@@ -130,8 +130,8 @@ init_cparam(H5FA_create_t *cparam, farray_test_param_t *tparam)
 
     cparam->cls = H5FA_CLS_TEST;
     cparam->raw_elmt_size = ELMT_SIZE;
-    cparam->max_dblk_page_nelmts_bits = MAX_DBLOCK_PAGE_NELMTS_BITS;	
-    cparam->nelmts = tparam->nelmts;	
+    cparam->max_dblk_page_nelmts_bits = MAX_DBLOCK_PAGE_NELMTS_BITS;
+    cparam->nelmts = tparam->nelmts;
 
     return(0);
 } /* init_cparam() */
@@ -187,19 +187,19 @@ check_stats(const H5FA_t *fa, const farray_state_t *state)
 
     /* Compare information */
     if(farray_stats.hdr_size != state->hdr_size) {
-        HDfprintf(stdout, "farray_stats.hdr_size = %Hu, state->hdr_size = %Hu\n", 
+        HDfprintf(stdout, "farray_stats.hdr_size = %Hu, state->hdr_size = %Hu\n",
 	    farray_stats.hdr_size, state->hdr_size);
         TEST_ERROR
     } /* end if */
 
     if(farray_stats.dblk_size != state->dblk_size) {
-        HDfprintf(stdout, "farray_stats.dblk_size = %Hu, state->dblk_size = %Hu\n", 
+        HDfprintf(stdout, "farray_stats.dblk_size = %Hu, state->dblk_size = %Hu\n",
 	    farray_stats.dblk_size, state->dblk_size);
         TEST_ERROR
     } /* end if */
 
     if(farray_stats.nelmts != state->nelmts) {
-        HDfprintf(stdout, "farray_stats.nelmts = %Hu, state->nelmts = %Hu\n", 
+        HDfprintf(stdout, "farray_stats.nelmts = %Hu, state->nelmts = %Hu\n",
 	    farray_stats.nelmts, state->nelmts);
         TEST_ERROR
     } /* end if */
@@ -242,9 +242,9 @@ set_fa_state(const H5FA_create_t *cparam, farray_state_t *state)
 	size_t dblk_page_init_size = (npages + 7) / 8;
 	hsize_t checksum_size = npages * 4;
 
-	state->dblk_size = DBLOCK_PREFIX + dblk_page_init_size + checksum_size + 
+	state->dblk_size = DBLOCK_PREFIX + dblk_page_init_size + checksum_size +
 			    state->nelmts * cparam->raw_elmt_size;
-    } else 
+    } else
 	state->dblk_size = DBLOCK_PREFIX + state->nelmts * cparam->raw_elmt_size;
 
     return(0);
@@ -392,7 +392,7 @@ finish(hid_t file, hid_t fapl, H5F_t *f, H5FA_t *fa, haddr_t fa_addr)
     h5_stat_size_t file_size;           /* File size, after deleting array */
 
     /* Close the fixed array */
-    if(H5FA_close(fa, H5P_DATASET_XFER_DEFAULT) < 0) 
+    if(H5FA_close(fa, H5P_DATASET_XFER_DEFAULT) < 0)
         FAIL_STACK_ERROR
 
     /* Delete array */
@@ -1229,7 +1229,7 @@ test_set_elmts(hid_t fapl, H5FA_create_t *cparam, farray_test_param_t *tparam,
     uint64_t    welmt;                  /* Element to write */
     uint64_t    relmt;                  /* Element to read */
     hsize_t     cnt;                    /* Count of array indices */
-    hssize_t    sidx;                   /* Index value of next element in the fixed array */ 
+    hssize_t    sidx;                   /* Index value of next element in the fixed array */
     hsize_t     idx;                    /* Index value of next element in the fixed array */
     hsize_t	fa_nelmts;		/* # of elements in fixed array */
     haddr_t     fa_addr = HADDR_UNDEF;  /* Array address in file */
@@ -1625,7 +1625,7 @@ main(void)
         nerrors += test_skip_elmts(fapl, &cparam, &tparam, (hsize_t)(tparam.nelmts - 1), TRUE, "skipping to last element");
 
 	/* Create Fixed Array of MAX_NELMTS elements */
-	/* 
+	/*
 	 * MAX_NELMTS succeeds on jam and smirom.
 	 * The value was adjusted for linew due to the following:
 	    Linew failed with "H5FD_sec2_truncate(): unable to extend file properly"
diff --git a/test/gen_filespace.c b/test/gen_filespace.c
index e9dee1c..293e3df 100644
--- a/test/gen_filespace.c
+++ b/test/gen_filespace.c
@@ -24,22 +24,22 @@ const char *FILENAMES[] = {
     "filespace_aggr_vfd.h5",	/* H5F_FILE_SPACE_AGGR_VFD */
     "filespace_vfd.h5",		/* H5F_FILE_SPACE_VFD */
     "filespace_threshold.h5"	/* H5F_FILE_SPACE_ALL, non-default threshold */
-}; 
+};
 
 #define DATASET		"dset"
 #define NUM_ELMTS	100
 
 /*
- * Compile and run this program in file-space branch to generate 
+ * Compile and run this program in file-space branch to generate
  * HDF5 files with different kinds of file space strategies
- * Move the HDF5 files to the 1.6 and 1.8 branch for compatibility 
+ * Move the HDF5 files to the 1.6 and 1.8 branch for compatibility
  * testing:test_filespace_compatible() will use the files
  */
 static void gen_file(void)
 {
     hid_t   	fid;
     hid_t   	fcpl;
-    hid_t       dataset, space;  
+    hid_t       dataset, space;
     hsize_t     dim[1];
     int         data[NUM_ELMTS];
     unsigned    i, j;			/* Local index variable */
diff --git a/test/h5test.c b/test/h5test.c
index a5b50d3..b9f3221 100644
--- a/test/h5test.c
+++ b/test/h5test.c
@@ -72,7 +72,7 @@ MPI_Info    h5_io_info_g=MPI_INFO_NULL;/* MPI INFO object for IO */
 #endif
 
 #define FILENAME_BUF_SIZE       1024
-#define READ_BUF_SIZE           4096 
+#define READ_BUF_SIZE           4096
 
 /*
  * These are the letters that are appended to the file name when generating
@@ -872,10 +872,10 @@ h5_get_file_size(const char *filename, hid_t fapl)
                 driver == H5FD_MPIO || driver == H5FD_MPIPOSIX ||
 #endif /* H5_HAVE_PARALLEL */
 #ifdef H5_HAVE_WINDOWS
-                driver == H5FD_WINDOWS || 
+                driver == H5FD_WINDOWS ||
 #endif /* H5_HAVE_WINDOWS */
 #ifdef H5_HAVE_DIRECT
-                driver == H5FD_DIRECT || 
+                driver == H5FD_DIRECT ||
 #endif /* H5_HAVE_DIRECT */
                 driver == H5FD_LOG) {
             /* Get the file's statistics */
@@ -1096,9 +1096,9 @@ getenv_all(MPI_Comm comm, int root, const char* name)
  *
  * Purpose:     Make copy of file.  Some tests write to data files under that
  *              are under version control.  Those tests should make a copy of
- *              the versioned file and write to the copy.  This function 
+ *              the versioned file and write to the copy.  This function
  *              prepends srcdir to the name of the file to be copied and uses
- *              the name of the copy as is. 
+ *              the name of the copy as is.
  *
  * Return:      Success:        0
  *
@@ -1129,7 +1129,7 @@ h5_make_local_copy(char *origfilename, char *local_copy_name)
 
     /* Copy old file into temporary file */
     if((fd_old = HDopen(filename, O_RDONLY, 0666)) < 0) return -1;
-    if((fd_new = HDopen(local_copy_name, O_RDWR|O_CREAT|O_TRUNC, 0666)) 
+    if((fd_new = HDopen(local_copy_name, O_RDWR|O_CREAT|O_TRUNC, 0666))
         < 0) return -1;
 
     /* Copy data */
@@ -1139,7 +1139,7 @@ h5_make_local_copy(char *origfilename, char *local_copy_name)
     /* Close files */
     if(HDclose(fd_old) < 0) return -1;
     if(HDclose(fd_new) < 0) return -1;
-   
-    return 0; 
+
+    return 0;
 }
 
diff --git a/test/h5test.h b/test/h5test.h
index 61e7d95..f984751 100644
--- a/test/h5test.h
+++ b/test/h5test.h
@@ -157,7 +157,7 @@ H5TEST_DLL void h5_reset(void);
 H5TEST_DLL void h5_show_hostname(void);
 H5TEST_DLL h5_stat_size_t h5_get_file_size(const char *filename, hid_t fapl);
 H5TEST_DLL int print_func(const char *format, ...);
-H5TEST_DLL int h5_make_local_copy(char *origfilename, char *local_copy_name); 
+H5TEST_DLL int h5_make_local_copy(char *origfilename, char *local_copy_name);
 
 /* Routines for operating on the list of tests (for the "all in one" tests) */
 H5TEST_DLL void TestUsage(void);
diff --git a/test/links.c b/test/links.c
index deae5ef..bcf430f 100644
--- a/test/links.c
+++ b/test/links.c
@@ -327,7 +327,7 @@ typedef struct {
  *              14 Jan. 2009
  *-------------------------------------------------------------------------
  */
-static void 
+static void
 fix_ext_filename(char *path_name, char *cwd, const char *file_name)
 {
     HDstrcpy(path_name, cwd);
diff --git a/test/mf.c b/test/mf.c
index ca89b79..6bfa44e 100644
--- a/test/mf.c
+++ b/test/mf.c
@@ -19,7 +19,7 @@
  *	test_mf_fs_*() 	  tests for file memory that interact with the free-space manager
  *	test_mf_aggr_*()  tests for file memory that interact with the aggregators
  *	test_mf_align_*() tests for file memory with alignment setting
- *	test_filespace_*() tests for file space management 
+ *	test_filespace_*() tests for file space management
  */
 
 #include "h5test.h"
@@ -3688,7 +3688,7 @@ test_mf_align_eoa(const char *env_h5_drvr, hid_t fapl, hid_t new_fapl)
     /* Skip test when using VFDs that have their own 'alloc' callback, which
      *  don't push mis-aligned space fragments on the file free space list
      */
-    have_alloc_vfd = (hbool_t)(HDstrcmp(env_h5_drvr, "stdio") 
+    have_alloc_vfd = (hbool_t)(HDstrcmp(env_h5_drvr, "stdio")
             && HDstrcmp(env_h5_drvr, "split") && HDstrcmp(env_h5_drvr, "multi"));
     if(have_alloc_vfd) {
         /* Set the filename to use for this test (dependent on fapl) */
@@ -4127,7 +4127,7 @@ test_mf_align_fs(const char *env_h5_drvr, hid_t fapl, hid_t new_fapl)
     /* Skip test when using VFDs that have their own 'alloc' callback, which
      *  don't push mis-aligned space fragments on the file free space list
      */
-    have_alloc_vfd = (hbool_t)(HDstrcmp(env_h5_drvr, "stdio") 
+    have_alloc_vfd = (hbool_t)(HDstrcmp(env_h5_drvr, "stdio")
             && HDstrcmp(env_h5_drvr, "split") && HDstrcmp(env_h5_drvr, "multi"));
     if(have_alloc_vfd) {
         if((file_size = h5_get_file_size(filename, new_fapl)) < 0)
@@ -4335,7 +4335,7 @@ test_mf_align_alloc1(const char *env_h5_drvr, hid_t fapl, hid_t new_fapl)
     /* Skip test when using VFDs that have their own 'alloc' callback, which
      *  don't push mis-aligned space fragments on the file free space list
      */
-    have_alloc_vfd = (hbool_t)(HDstrcmp(env_h5_drvr, "stdio") 
+    have_alloc_vfd = (hbool_t)(HDstrcmp(env_h5_drvr, "stdio")
             && HDstrcmp(env_h5_drvr, "split") && HDstrcmp(env_h5_drvr, "multi"));
     if(have_alloc_vfd) {
         /* Set the filename to use for this test (dependent on fapl) */
@@ -4592,7 +4592,7 @@ test_mf_align_alloc2(const char *env_h5_drvr, hid_t fapl, hid_t new_fapl)
     /* Skip test when using VFDs that have their own 'alloc' callback, which
      *  don't push mis-aligned space fragments on the file free space list
      */
-    have_alloc_vfd = (hbool_t)(HDstrcmp(env_h5_drvr, "stdio") 
+    have_alloc_vfd = (hbool_t)(HDstrcmp(env_h5_drvr, "stdio")
             && HDstrcmp(env_h5_drvr, "split") && HDstrcmp(env_h5_drvr, "multi"));
     if(have_alloc_vfd) {
         /* Set the filename to use for this test (dependent on fapl) */
@@ -4921,7 +4921,7 @@ test_mf_align_alloc3(const char *env_h5_drvr, hid_t fapl, hid_t new_fapl)
     /* Skip test when using VFDs that have their own 'alloc' callback, which
      *  don't push mis-aligned space fragments on the file free space list
      */
-    have_alloc_vfd = (hbool_t)(HDstrcmp(env_h5_drvr, "stdio") 
+    have_alloc_vfd = (hbool_t)(HDstrcmp(env_h5_drvr, "stdio")
             && HDstrcmp(env_h5_drvr, "split") && HDstrcmp(env_h5_drvr, "multi"));
     if(have_alloc_vfd) {
         /* Set the filename to use for this test (dependent on fapl) */
@@ -5217,7 +5217,7 @@ test_mf_align_alloc4(const char *env_h5_drvr, hid_t fapl, hid_t new_fapl)
     /* Skip test when using VFDs that have their own 'alloc' callback, which
      *  don't push mis-aligned space fragments on the file free space list
      */
-    have_alloc_vfd = (hbool_t)(HDstrcmp(env_h5_drvr, "stdio") 
+    have_alloc_vfd = (hbool_t)(HDstrcmp(env_h5_drvr, "stdio")
             && HDstrcmp(env_h5_drvr, "split") && HDstrcmp(env_h5_drvr, "multi"));
     if(have_alloc_vfd) {
         /* Set the filename to use for this test (dependent on fapl) */
@@ -5424,7 +5424,7 @@ test_mf_align_alloc5(const char *env_h5_drvr, hid_t fapl, hid_t new_fapl)
     /* Skip test when using VFDs that have their own 'alloc' callback, which
      *  don't push mis-aligned space fragments on the file free space list
      */
-    have_alloc_vfd = (hbool_t)(HDstrcmp(env_h5_drvr, "stdio") 
+    have_alloc_vfd = (hbool_t)(HDstrcmp(env_h5_drvr, "stdio")
             && HDstrcmp(env_h5_drvr, "split") && HDstrcmp(env_h5_drvr, "multi"));
     if(have_alloc_vfd) {
         /* Set the filename to use for this test (dependent on fapl) */
@@ -5693,7 +5693,7 @@ test_mf_align_alloc6(const char *env_h5_drvr, hid_t fapl, hid_t new_fapl)
     /* Skip test when using VFDs that have their own 'alloc' callback, which
      *  don't push mis-aligned space fragments on the file free space list
      */
-    have_alloc_vfd = (hbool_t)(HDstrcmp(env_h5_drvr, "stdio") 
+    have_alloc_vfd = (hbool_t)(HDstrcmp(env_h5_drvr, "stdio")
             && HDstrcmp(env_h5_drvr, "split") && HDstrcmp(env_h5_drvr, "multi"));
     if(have_alloc_vfd) {
         /* Set the filename to use for this test (dependent on fapl) */
@@ -5993,7 +5993,7 @@ error:
 } /* test_mf_fs_persist() */
 
 /*
- * Verify that the free-space manager goes away 
+ * Verify that the free-space manager goes away
  */
 static unsigned
 test_mf_fs_gone(hid_t fapl_new, hid_t fcpl)
@@ -6365,7 +6365,7 @@ test_mf_fs_multi(hid_t fapl_new, hid_t fcpl)
     hid_t	file = -1;              	/* File ID */
     char	filename[FILENAME_LEN]; 	/* Filename to use */
     H5F_t	*f = NULL;              	/* Internal file object pointer */
-    H5FD_mem_t 	type, stype, btype, gtype;	/* File allocation type */	
+    H5FD_mem_t 	type, stype, btype, gtype;	/* File allocation type */
     H5FS_stat_t fs_stat;             		/* Information for free-space manager */
     haddr_t	addr1, addr2, addr3, addr4;	/* File allocation type */
     haddr_t	saddr1, saddr2, saddr3, saddr4;	/* File address for H5FD_MEM_SUPER */
@@ -6591,7 +6591,7 @@ test_mf_fs_multi(hid_t fapl_new, hid_t fcpl)
 		(hsize_t)TEST_BLOCK_SIZE1, (H5FS_section_info_t **)&node)) < 0)
 	    FAIL_STACK_ERROR
 	if(node_found) TEST_ERROR
-	    
+
 	if((node_found = H5FS_sect_find(f, H5P_DATASET_XFER_DEFAULT, f->shared->fs_man[type],
 		(hsize_t)TEST_BLOCK_SIZE3, (H5FS_section_info_t **)&node)) < 0)
 	    FAIL_STACK_ERROR
@@ -6691,7 +6691,7 @@ test_mf_fs_drivers(hid_t fapl)
     if((fapl2 = H5Pcopy(fapl)) < 0) TEST_ERROR
 
     /* Set the "use the latest version of the format" bounds for creating objects in the file */
-    if(H5Pset_libver_bounds(fapl2, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST) < 0) 
+    if(H5Pset_libver_bounds(fapl2, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST) < 0)
 	TEST_ERROR
 
     /* Test with old and new format */
@@ -6713,7 +6713,7 @@ test_mf_fs_drivers(hid_t fapl)
 	ret += test_mf_fs_gone(fapl_new, fcpl);
 	ret += test_mf_fs_persist(fapl_new, fcpl);
 
-	h5_cleanup(FILENAME, fapl_new);	
+	h5_cleanup(FILENAME, fapl_new);
 
 
 	/* STDIO */
@@ -6727,13 +6727,13 @@ test_mf_fs_drivers(hid_t fapl)
 	ret += test_mf_fs_gone(fapl_new, fcpl);
 	ret += test_mf_fs_persist(fapl_new, fcpl);
 
-	h5_cleanup(FILENAME, fapl_new);	
+	h5_cleanup(FILENAME, fapl_new);
 
 	/* CORE */
 	HDputs("Testing free-space managers with core driver");
 
 	/* create fapl to be a "core" file */
-	if((fapl_new = H5Pcopy(new_format?fapl2:fapl)) < 0) 
+	if((fapl_new = H5Pcopy(new_format?fapl2:fapl)) < 0)
 	    FAIL_STACK_ERROR
 	if(H5Pset_fapl_core(fapl_new, (size_t)CORE_INCREMENT, TRUE) < 0)
 	    FAIL_STACK_ERROR
@@ -6741,7 +6741,7 @@ test_mf_fs_drivers(hid_t fapl)
 	ret += test_mf_fs_gone(fapl_new, fcpl);
 	ret += test_mf_fs_persist(fapl_new, fcpl);
 
-	h5_cleanup(FILENAME, fapl_new);	
+	h5_cleanup(FILENAME, fapl_new);
 
 	/* FAMILY */
 	HDputs("Testing free-space managers with family driver");
@@ -6753,7 +6753,7 @@ test_mf_fs_drivers(hid_t fapl)
 
 	ret += test_mf_fs_persist(fapl_new, fcpl);
 
-	h5_cleanup(FILENAME, fapl_new);	
+	h5_cleanup(FILENAME, fapl_new);
 
 	/* SPLIT */
 	HDputs("Testing free-space managers with split driver");
@@ -6766,27 +6766,27 @@ test_mf_fs_drivers(hid_t fapl)
 	ret += test_mf_fs_persist(fapl_new, fcpl);
 	ret += test_mf_fs_split(fapl_new, fcpl);
 
-	h5_cleanup(FILENAME, fapl_new);	
+	h5_cleanup(FILENAME, fapl_new);
 
 	/* MULTI */
 	HDputs("Testing free-space managers with multi driver");
 
 	MULTI_SETUP(memb_map, memb_fapl, memb_name, memb_addr, sv)
 
-	if((fapl_new = H5Pcopy(new_format?fapl2:fapl)) < 0) 
+	if((fapl_new = H5Pcopy(new_format?fapl2:fapl)) < 0)
 	    FAIL_STACK_ERROR
 	if(H5Pset_fapl_multi(fapl_new, memb_map, memb_fapl, memb_name, memb_addr, TRUE) < 0)
 	    TEST_ERROR;
 
 	ret += test_mf_fs_multi(fapl_new, fcpl);
 
-	h5_cleanup(FILENAME, fapl_new);	
+	h5_cleanup(FILENAME, fapl_new);
 
     } /* end for new_format */
 
-    if (H5Pclose(fcpl) < 0) 
+    if (H5Pclose(fcpl) < 0)
         FAIL_STACK_ERROR
-    if (H5Pclose(fapl2) < 0) 
+    if (H5Pclose(fapl2) < 0)
         FAIL_STACK_ERROR
 
     return(ret);
@@ -6827,7 +6827,7 @@ test_filespace_strategy_threshold(hid_t fapl_new)
 	    /* Create file-creation template */
 	    if((fcpl = H5Pcreate(H5P_FILE_CREATE)) < 0)
 		FAIL_STACK_ERROR
- 
+
 	    /* Set default file space information */
 	    if(H5Pset_file_space(fcpl, fs_type, fs_threshold) < 0)
 		FAIL_STACK_ERROR
@@ -6864,14 +6864,14 @@ test_filespace_strategy_threshold(hid_t fapl_new)
 		FAIL_STACK_ERROR
 
 	    /* Retrieve the total amount of free space and # of free-space sections */
-	    if(f->shared->fs_man[type] && 
+	    if(f->shared->fs_man[type] &&
 		H5FS_sect_stats(f->shared->fs_man[type], &saved_tot_space, &saved_tot_sect_count) < 0)
 		    FAIL_STACK_ERROR
 
 	    /* H5F_FILE_SPACE_AGGR_VFD and H5F_FILE_SPACE_VFD: should not have free-space manager */
 	    if(fs_type > H5F_FILE_SPACE_ALL && f->shared->fs_man[type])
 		TEST_ERROR
-		
+
 	    /* Close the file */
 	    if(H5Fclose(file) < 0)
 		FAIL_STACK_ERROR
@@ -6904,7 +6904,7 @@ test_filespace_strategy_threshold(hid_t fapl_new)
 			    TEST_ERROR
 
 			/* Retrieve block #5 from H5FD_MEM_SUPER free-space manager */
-			if(HADDR_UNDEF == 
+			if(HADDR_UNDEF ==
 			        (tmp_addr = H5MF_alloc(f, type, H5P_DATASET_XFER_DEFAULT, (hsize_t)TEST_BLOCK_SIZE5)))
 			    FAIL_STACK_ERROR
 
@@ -6929,7 +6929,7 @@ test_filespace_strategy_threshold(hid_t fapl_new)
 	    /* Closing */
 	    if(H5Fclose(file) < 0)
 		FAIL_STACK_ERROR
-	    if(H5Pclose(fcpl) < 0) 
+	    if(H5Pclose(fcpl) < 0)
 		FAIL_STACK_ERROR
 
 	} /* end for fs_type */
@@ -6947,7 +6947,7 @@ error:
 } /* test_filespace_strategy_threshold() */
 
 /*
- * Verify section is merged/shrunk away for 
+ * Verify section is merged/shrunk away for
  * H5F_FILE_SPACE_ALL_PERSIST and H5F_FILE_SPACE_ALL strategy.
  */
 static unsigned
@@ -7063,7 +7063,7 @@ test_filespace_gone(hid_t fapl_new)
 	if(H5Fclose(file) < 0)
 	    FAIL_STACK_ERROR
 
-	if(H5Pclose(fcpl) < 0) 
+	if(H5Pclose(fcpl) < 0)
 	    FAIL_STACK_ERROR
 
     } /* end for fs_type */
@@ -7100,7 +7100,7 @@ test_filespace_drivers(hid_t fapl)
     if((fapl2 = H5Pcopy(fapl)) < 0) TEST_ERROR
 
     /* Set the "use the latest version of the format" bounds for creating objects in the file */
-    if(H5Pset_libver_bounds(fapl2, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST) < 0) 
+    if(H5Pset_libver_bounds(fapl2, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST) < 0)
 	TEST_ERROR
 
     /* Test with old and new format */
@@ -7141,7 +7141,7 @@ test_filespace_drivers(hid_t fapl)
 	HDputs("Testing file space management with core driver");
 
 	/* create fapl to be a "core" file */
-	if((fapl_new = H5Pcopy(new_format?fapl2:fapl)) < 0) 
+	if((fapl_new = H5Pcopy(new_format?fapl2:fapl)) < 0)
 	    FAIL_STACK_ERROR
 	if(H5Pset_fapl_core(fapl_new, (size_t)CORE_INCREMENT, TRUE) < 0)
 	    FAIL_STACK_ERROR
@@ -7183,7 +7183,7 @@ test_filespace_drivers(hid_t fapl)
 
 	MULTI_SETUP(memb_map, memb_fapl, memb_name, memb_addr, sv)
 
-	if((fapl_new = H5Pcopy(new_format?fapl2:fapl)) < 0) 
+	if((fapl_new = H5Pcopy(new_format?fapl2:fapl)) < 0)
 	    TEST_ERROR
 	if(H5Pset_fapl_multi(fapl_new, memb_map, memb_fapl, memb_name, memb_addr, TRUE) < 0)
 	    TEST_ERROR;
@@ -7195,7 +7195,7 @@ test_filespace_drivers(hid_t fapl)
 
     } /* end for new_format */
 
-    if (H5Pclose(fapl2) < 0) 
+    if (H5Pclose(fapl2) < 0)
         FAIL_STACK_ERROR
 
     return(ret);
@@ -7294,7 +7294,7 @@ main(void)
     /* tests for file space management */
     nerrors += test_filespace_drivers(fapl);
 
-    if (H5Pclose(new_fapl) < 0) 
+    if (H5Pclose(new_fapl) < 0)
         FAIL_STACK_ERROR
     h5_cleanup(FILENAME, fapl);
 
diff --git a/test/ntypes.c b/test/ntypes.c
index 6efabc6..781dfef 100644
--- a/test/ntypes.c
+++ b/test/ntypes.c
@@ -2401,7 +2401,7 @@ test_refer_dtype2(hid_t file)
     PASSED();
     return 0;
 
-error: 
+error:
     /* Free memory buffers */
     if(dwbuf)
         HDfree(dwbuf);
@@ -2546,7 +2546,7 @@ test_bitfield_dtype(hid_t file)
     if((space = H5Screate_simple(1, &nelmts, NULL)) < 0) TEST_ERROR;
 
     /* Create and write to dataset1 with a unsigned char buffer */
-    if((dset1 = H5Dcreate2(file, DSET1_BITFIELD_NAME, type, space, H5P_DEFAULT, H5P_DEFAULT, 
+    if((dset1 = H5Dcreate2(file, DSET1_BITFIELD_NAME, type, space, H5P_DEFAULT, H5P_DEFAULT,
         H5P_DEFAULT)) < 0) TEST_ERROR;
 
     for(i = 0; i < BITFIELD_ENUMB*sizeof(int); i++)
@@ -2556,7 +2556,7 @@ test_bitfield_dtype(hid_t file)
     if(H5Dclose(dset1) < 0) TEST_ERROR;
 
     /* Create and write to dataset2 with a unsigned int buffer */
-    if((dset2 = H5Dcreate2(file, DSET2_BITFIELD_NAME, type, space, H5P_DEFAULT, H5P_DEFAULT, 
+    if((dset2 = H5Dcreate2(file, DSET2_BITFIELD_NAME, type, space, H5P_DEFAULT, H5P_DEFAULT,
         H5P_DEFAULT)) < 0) TEST_ERROR;
 
     for(i = 0; i < BITFIELD_ENUMB; i++)
@@ -2587,7 +2587,7 @@ test_bitfield_dtype(hid_t file)
             H5_FAILED();
             printf("    Read different values than written.\n");
             printf("    At index %d\n", i);
-            TEST_ERROR;  
+            TEST_ERROR;
         }
         p++;
     }
@@ -2612,14 +2612,14 @@ test_bitfield_dtype(hid_t file)
             H5_FAILED();
             printf("    Read different values than written.\n");
             printf("    At index %d\n", i);
-            TEST_ERROR;  
+            TEST_ERROR;
         }
     }
 
     if(H5Tclose(dtype) < 0) TEST_ERROR;
     if(H5Tclose(native_type) < 0) TEST_ERROR;
     if(H5Dclose(dataset2) < 0) TEST_ERROR;
- 
+
     PASSED();
     return 0;
 
diff --git a/test/objcopy.c b/test/objcopy.c
index 00cc5bf..05da5dd 100755
--- a/test/objcopy.c
+++ b/test/objcopy.c
@@ -7249,7 +7249,7 @@ static int
 test_copy_dataset_contig_cmpd_vl(hid_t fcpl_src, hid_t fcpl_dst, hid_t fapl)
 {
     hid_t fid_src = -1, fid_dst = -1;           /* File IDs */
-    hid_t tid = -1;                             /* Datatype ID */   
+    hid_t tid = -1;                             /* Datatype ID */
     hid_t tid2 = -1;                            /* Datatype ID */
     hid_t sid = -1;                             /* Dataspace ID */
     hid_t did = -1;                             /* Dataset ID */
diff --git a/test/ohdr.c b/test/ohdr.c
index f59dace..c3b8f8b 100644
--- a/test/ohdr.c
+++ b/test/ohdr.c
@@ -48,7 +48,7 @@ const char *FILENAME[] = {
  *	Create an object header with several continuation chunks
  *	Remove a message in the last chunk
  *	The remaining message(s) in the last chunk should be moved forward into the continuation message
- *	The process will repeat when the continuation message is big enough to hold all the 
+ *	The process will repeat when the continuation message is big enough to hold all the
  *		messages in the last chunk.
  *	Result: the number of chunks should be reduced
  */
@@ -57,7 +57,7 @@ test_cont(char *filename, hid_t fapl)
 {
     hid_t	file=-1;
     H5F_t	*f = NULL;
-    H5O_hdr_info_t hdr_info;               
+    H5O_hdr_info_t hdr_info;
     H5O_loc_t	oh_locA, oh_locB;
     time_t	time_new;
     const char	*short_name = "T";
@@ -181,7 +181,7 @@ main(void)
         /* Display info about testing */
         if(b)
             HDputs("Using new file format:");
-        else	
+        else
             HDputs("Using default file format:");
 
         /* Set the format to use for the file */
diff --git a/test/set_extent.c b/test/set_extent.c
index b4e61b4..c65e7d0 100644
--- a/test/set_extent.c
+++ b/test/set_extent.c
@@ -60,18 +60,18 @@ const char *FILENAME[] = {
 static int do_ranks( hid_t fapl );
 static int do_layouts( hid_t fapl );
 
-static int test_rank1( hbool_t do_compress, 
-                       hbool_t do_fill_value, 
+static int test_rank1( hbool_t do_compress,
+                       hbool_t do_fill_value,
                        hbool_t set_istore_k,
                        H5D_fill_time_t fill_time,
                        hid_t fapl);
-static int test_rank2( hbool_t do_compress, 
-                       hbool_t do_fill_value, 
+static int test_rank2( hbool_t do_compress,
+                       hbool_t do_fill_value,
                        hbool_t set_istore_k,
                        H5D_fill_time_t fill_time,
                        hid_t fapl);
-static int test_rank3( hbool_t do_compress, 
-                       hbool_t do_fill_value, 
+static int test_rank3( hbool_t do_compress,
+                       hbool_t do_fill_value,
                        hbool_t set_istore_k,
                        H5D_fill_time_t fill_time,
                        hid_t fapl);
@@ -152,7 +152,7 @@ int main( void )
     if(H5Pclose(fapl2) < 0) TEST_ERROR
 
     h5_cleanup(FILENAME, fapl);
-   
+
     HDremove(EXT_FILE_NAME1);
     HDremove(EXT_FILE_NAME2);
 
@@ -180,8 +180,8 @@ static int do_ranks( hid_t fapl )
     hbool_t do_compress = 0;
     hbool_t do_fillvalue = 0;
     hbool_t set_istore_k = 0;
-      
-      
+
+
     TESTING_2("with fill value, no compression");
 
     do_fillvalue = 1;
@@ -189,28 +189,28 @@ static int do_ranks( hid_t fapl )
     if (test_rank1( do_compress, do_fillvalue, set_istore_k, H5D_FILL_TIME_ALLOC, fapl ) < 0)
     {
         goto error;
-    } 
+    }
     if (test_rank1( do_compress, do_fillvalue, set_istore_k, H5D_FILL_TIME_IFSET, fapl ) < 0)
     {
         goto error;
-    } 
+    }
     if (test_rank2( do_compress, do_fillvalue, set_istore_k, H5D_FILL_TIME_ALLOC, fapl ) < 0)
     {
         goto error;
-    } 
+    }
     if (test_rank2( do_compress, do_fillvalue, set_istore_k, H5D_FILL_TIME_IFSET, fapl ) < 0)
     {
         goto error;
-    } 
+    }
     if (test_rank3( do_compress, do_fillvalue, set_istore_k, H5D_FILL_TIME_ALLOC, fapl ) < 0)
     {
         goto error;
-    } 
+    }
     if (test_rank3( do_compress, do_fillvalue, set_istore_k, H5D_FILL_TIME_IFSET, fapl ) < 0)
     {
         goto error;
-    } 
-   
+    }
+
 
 
     PASSED();
@@ -232,11 +232,11 @@ static int do_ranks( hid_t fapl )
     {
         goto error;
     }
-   
-   
+
+
 
     PASSED();
-    
+
     TESTING_2("with fill value, with compression");
 
 #ifdef H5_HAVE_FILTER_DEFLATE
@@ -268,8 +268,8 @@ static int do_ranks( hid_t fapl )
     {
         goto error;
     }
-  
-     
+
+
     PASSED();
 #else
     SKIPPED();
@@ -293,7 +293,7 @@ static int do_ranks( hid_t fapl )
     {
         goto error;
     }
-     
+
     PASSED();
 #else
     SKIPPED();
@@ -308,14 +308,14 @@ static int do_ranks( hid_t fapl )
     {
         goto error;
     }
-    
+
 
     PASSED();
-   
-    
+
+
     return 0;
-    
-    
+
+
 error:
     return -1;
 }
@@ -327,23 +327,23 @@ error:
 */
 static int do_layouts( hid_t fapl )
 {
-    
+
     TESTING_2("storage layout use");
- 
+
     if (test_layouts( H5D_COMPACT, fapl ) < 0)
     {
         goto error;
-    } 
-    
+    }
+
     if (test_layouts( H5D_CONTIGUOUS, fapl ) < 0)
     {
         goto error;
-    } 
-    
+    }
+
     PASSED();
-    
+
     return 0;
-    
+
 error:
     return -1;
 }
@@ -353,33 +353,33 @@ error:
  *-------------------------------------------------------------------------
  */
 
-static int test_rank1( hbool_t do_compress, 
-                       hbool_t do_fill_value, 
+static int test_rank1( hbool_t do_compress,
+                       hbool_t do_fill_value,
                        hbool_t set_istore_k,
                        H5D_fill_time_t fill_time,
                        hid_t fapl)
 {
 
-    hid_t   fid=-1;          
+    hid_t   fid=-1;
     hid_t   did=-1;
     hid_t   sid=-1;
     hid_t   dcpl=-1;
     hid_t   fcpl;
-    hsize_t dims_o[RANK1] = {DIM0};   /* original dimensions */ 
-    hsize_t dims_s[RANK1] = {DIMS0};  /* shrinking dimensions */ 
-    hsize_t dims_e[RANK1] = {DIME0};  /* extended dimensions */ 
-    hsize_t dims_c[RANK1] = {2};      /* chunk dimensions */ 
-    hsize_t dims_r[RANK1];            /* read dimensions */ 
+    hsize_t dims_o[RANK1] = {DIM0};   /* original dimensions */
+    hsize_t dims_s[RANK1] = {DIMS0};  /* shrinking dimensions */
+    hsize_t dims_e[RANK1] = {DIME0};  /* extended dimensions */
+    hsize_t dims_c[RANK1] = {2};      /* chunk dimensions */
+    hsize_t dims_r[RANK1];            /* read dimensions */
     hsize_t maxdims[RANK1] = {H5S_UNLIMITED};
     int     buf_o[DIM0];
     int     buf_s[DIMS0];
     int     buf_e[DIME0];
     int     buf_r[DIM0];
     int     i;
-    int     fillvalue = 1; 
-    int     comp_value; 
+    int     fillvalue = 1;
+    int     comp_value;
     char    filename[NAME_BUF_SIZE];
-       
+
     if ( do_fill_value )
     {
         comp_value = fillvalue;
@@ -389,47 +389,47 @@ static int test_rank1( hbool_t do_compress,
         comp_value = 0;
     }
 
-        
+
     for( i = 0; i < DIM0; i++ )
     {
-        
+
         buf_o[i] = 2;
     }
 
     /* create a file creation property list */
-    if ((fcpl = H5Pcreate(H5P_FILE_CREATE)) < 0) 
+    if ((fcpl = H5Pcreate(H5P_FILE_CREATE)) < 0)
     {
         goto error;
     }
-    
+
     if  ( set_istore_k )
     {
         /* set non-default indexed storage B-tree internal 'K' value */
-        if (H5Pset_istore_k(fcpl,ISTORE_IK) < 0) 
+        if (H5Pset_istore_k(fcpl,ISTORE_IK) < 0)
         {
             goto error;
         }
-        
+
     }
     /* create a new file */
     h5_fixname(FILENAME[0], fapl, filename, sizeof filename);
-    if ((fid = H5Fcreate(filename, H5F_ACC_TRUNC, fcpl, fapl)) < 0) 
+    if ((fid = H5Fcreate(filename, H5F_ACC_TRUNC, fcpl, fapl)) < 0)
     {
         goto error;
     }
 
     /* close property list */
-    if(H5Pclose(fcpl) < 0) 
+    if(H5Pclose(fcpl) < 0)
     {
         goto error;
     }
-    
+
     /* create the data space with unlimited dimensions. */
-    if ((sid = H5Screate_simple(RANK1, dims_o, maxdims)) < 0) 
+    if ((sid = H5Screate_simple(RANK1, dims_o, maxdims)) < 0)
     {
         goto error;
     }
-    
+
     /* modify dataset creation properties, i.e. enable chunking. */
     if ((dcpl = H5Pcreate (H5P_DATASET_CREATE)) < 0)
     {
@@ -446,176 +446,176 @@ static int test_rank1( hbool_t do_compress,
             goto error;
         }
 
-        if(H5Pset_fill_time(dcpl, fill_time) < 0) 
+        if(H5Pset_fill_time(dcpl, fill_time) < 0)
         {
             goto error;
         }
     }
     else
     {
-        
-        if(H5Pset_fill_time(dcpl, H5D_FILL_TIME_ALLOC) < 0) 
+
+        if(H5Pset_fill_time(dcpl, H5D_FILL_TIME_ALLOC) < 0)
         {
             goto error;
         }
-        
+
     }
     if (do_compress)
     {
-        if(H5Pset_deflate(dcpl, 9) < 0) 
+        if(H5Pset_deflate(dcpl, 9) < 0)
         {
             goto error;
         }
     }
-    
+
     /*-------------------------------------------------------------------------
     * create, write dataset
     *-------------------------------------------------------------------------
     */
-    
+
     /* create a dataset */
-    if ((did = H5Dcreate2(fid , "dset1", H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0) 
+    if ((did = H5Dcreate2(fid , "dset1", H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0)
     {
         goto error;
     }
-    
+
     /* write */
-    if (H5Dwrite(did , H5T_NATIVE_INT, sid, H5S_ALL, H5P_DEFAULT, buf_o) < 0) 
+    if (H5Dwrite(did , H5T_NATIVE_INT, sid, H5S_ALL, H5P_DEFAULT, buf_o) < 0)
     {
         goto error;
     }
-    
-    
+
+
 #if defined (H5_SET_EXTENT_DEBUG)
     printf("\n");
     for (i = 0; i < (int)dims_o[0]; i++ )
     {
-        
+
         printf("%d ", buf_o[i]);
-        
+
     }
     printf("\n");
-#endif  
+#endif
+
 
 
-    
     if (H5Sclose(sid) < 0)
     {
         goto error;
     }
-    
+
     /*-------------------------------------------------------------------------
     * set new dimensions for the array; expand it
     *-------------------------------------------------------------------------
     */
-    
+
     /* set new dimensions for the array. */
     if (H5Dset_extent(did , dims_e) < 0)
     {
         goto error;
     }
-    
+
     /* get the space */
     if ((sid = H5Dget_space(did)) < 0)
     {
         goto error;
     }
-    
+
     /* get dimensions */
-    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0) 
+    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0)
     {
         goto error;
     }
-    
+
     if (H5Sclose(sid) < 0)
     {
         goto error;
     }
-    
-    
+
+
     /* check dimensions */
     for( i = 0; i < RANK1; i++ )
     {
-        if (dims_r[i] != dims_e[i]) 
+        if (dims_r[i] != dims_e[i])
             goto error;
     }
-    
+
     /* read */
-    if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_e) < 0) 
+    if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_e) < 0)
         goto error;
 
-   
-    
+
+
 #if defined (H5_SET_EXTENT_DEBUG)
     printf("\n");
     for (i = 0; i < (int)dims_r[0]; i++ )
     {
-        
+
         printf("%d ", buf_e[i]);
-        
+
     }
     printf("\n");
-#endif  
+#endif
+
+
+
 
-    
-    
-    
     /* compare the read array with the expanded array */
     for (i = 0; i < (int)dims_r[0]; i++ )
     {
-        
-        if ( i >= DIM0  ) 
+
+        if ( i >= DIM0  )
         {
-            if(buf_e[i] != comp_value) 
+            if(buf_e[i] != comp_value)
             {
                 printf("buf_e[%d] = %d\n", i, buf_e[i]);
                 printf("value = %d\n", comp_value);
                 goto error;
-            } 
-        } 
-        else 
+            }
+        }
+        else
         {
-            if(buf_e[i] != buf_o[i]) 
+            if(buf_e[i] != buf_o[i])
                 goto error;
         }
     }
-    
-    
-  
-    
+
+
+
+
     /*-------------------------------------------------------------------------
-    * shrink 
+    * shrink
     *
     *-------------------------------------------------------------------------
     */
-    
+
     /* set new dimensions for the array. */
     if (H5Dset_extent(did , dims_s) < 0)
     {
         goto error;
     }
-    
+
     /* get the space */
     if ((sid = H5Dget_space(did)) < 0)
     {
         goto error;
     }
-    
+
     /* get dimensions */
-    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0) 
+    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0)
     {
         goto error;
     }
-    
+
     if (H5Sclose(sid) < 0)
     {
         goto error;
     }
-    
+
     /* check dimensions */
     for( i = 0; i < RANK1; i++ )
     {
-        if (dims_r[i] != dims_s[i]) 
+        if (dims_r[i] != dims_s[i])
             goto error;
     }
 
@@ -624,8 +624,8 @@ static int test_rank1( hbool_t do_compress,
     /* for this case we close and reopen file */
     if ( set_istore_k )
     {
-        
-        if (H5Dclose(did) < 0) 
+
+        if (H5Dclose(did) < 0)
         {
             goto error;
         }
@@ -634,76 +634,76 @@ static int test_rank1( hbool_t do_compress,
             goto error;
         }
 
-        if ((fid = H5Fopen( filename, H5F_ACC_RDWR, fapl ))<0) 
+        if ((fid = H5Fopen( filename, H5F_ACC_RDWR, fapl ))<0)
         {
             goto error;
         }
-        
-        if ((did = H5Dopen2( fid , "dset1", H5P_DEFAULT ))<0) 
+
+        if ((did = H5Dopen2( fid , "dset1", H5P_DEFAULT ))<0)
         {
             goto error;
         }
-        
-        
-        
+
+
+
     }
-    
-    
+
+
     /*-------------------------------------------------------------------------
     * read
     *-------------------------------------------------------------------------
     */
-    
+
     /* read */
-    if (H5Dread( did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_s ) < 0) 
+    if (H5Dread( did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_s ) < 0)
     {
         goto error;
     }
-    
+
 #if defined (H5_SET_EXTENT_DEBUG)
     printf("\n");
     for (i = 0; i < (int)dims_r[0]; i++ )
     {
-        
+
         printf("%d ", buf_s[i]);
     }
     printf("\n");
 
-#endif  
+#endif
+
+
 
 
-    
-    
     /* compare the read array with the shrinked array */
     for( i = 0; i < (int)dims_r[0]; i++ )
     {
-        
-        if (  buf_s[i] != buf_o[i] ) 
+
+        if (  buf_s[i] != buf_o[i] )
         {
             printf("buf_s[%d] = %d\n", i, buf_s[i]);
             printf("buf_o[%d] = %d\n", i, buf_o[i]);
             goto error;
-        } 
+        }
     }
-    
-    
+
+
     /*-------------------------------------------------------------------------
     * expand it back to original size
     *-------------------------------------------------------------------------
     */
-    
+
     /* set new dimensions for the array */
     if (H5Dset_extent(did, dims_o) < 0)
     {
         goto error;
     }
-    
+
     /* get the space */
-    if ((sid = H5Dget_space(did)) < 0) 
+    if ((sid = H5Dget_space(did)) < 0)
     {
         goto error;
     }
-    
+
     /* get dimensions. */
     if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0)
     {
@@ -714,53 +714,53 @@ static int test_rank1( hbool_t do_compress,
     {
         goto error;
     }
-    
-    
+
+
     /* check dimensions */
     for( i = 0; i < RANK1; i++ )
     {
-        if (dims_r[i] != dims_o[i]) 
+        if (dims_r[i] != dims_o[i])
             goto error;
     }
-    
-       
+
+
     /* read */
-    if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_r) < 0) 
+    if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_r) < 0)
         goto error;
-    
+
 #if defined (H5_SET_EXTENT_DEBUG)
     printf("\n");
     for (i = 0; i < (int)dims_r[0]; i++ )
     {
-        
+
         printf("%d ", buf_r[i]);
-        
+
     }
     printf("\n");
-#endif  
+#endif
+
 
 
-    
     /* compare the read array with the original array */
     for (i = 0; i < (int)dims_r[0]; i++ )
     {
-        
-        if (i >= DIMS0 ) 
+
+        if (i >= DIMS0 )
         {
-            if(buf_r[i] != comp_value) 
+            if(buf_r[i] != comp_value)
             {
                 printf("buf_r[%d] = %d\n", i, buf_r[i] );
                 printf("value = %d\n", comp_value);
                 goto error;
-            } 
-        } 
-        else 
+            }
+        }
+        else
         {
-            if(buf_r[i] != buf_o[i]) 
+            if(buf_r[i] != buf_o[i])
                 goto error;
         }
     }
-    
+
 
     /*-------------------------------------------------------------------------
     * shrink to 0
@@ -769,75 +769,75 @@ static int test_rank1( hbool_t do_compress,
     */
 
     dims_s[0] = 0;
-    
+
     /* set new dimensions for the array. */
     if (H5Dset_extent(did , dims_s) < 0)
     {
         goto error;
     }
-    
+
     /* get the space */
     if ((sid = H5Dget_space(did)) < 0)
     {
         goto error;
     }
-    
+
     /* get dimensions */
-    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0) 
+    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0)
     {
         goto error;
     }
-    
+
     if (H5Sclose(sid) < 0)
     {
         goto error;
     }
-    
+
     /* check dimensions */
     for( i = 0; i < RANK1; i++ )
     {
-        if (dims_r[i] != dims_s[i]) 
+        if (dims_r[i] != dims_s[i])
             goto error;
-    }    
-    
+    }
+
     /*-------------------------------------------------------------------------
     * close dataset
     *-------------------------------------------------------------------------
     */
-    
-    if (H5Dclose(did) < 0) 
+
+    if (H5Dclose(did) < 0)
     {
         goto error;
     }
-   
-    
-   
-    
-    
+
+
+
+
+
      /*-------------------------------------------------------------------------
     * test a dataset with non initialized chunks
     *-------------------------------------------------------------------------
     */
-    
-      
-    if ((sid = H5Screate_simple(RANK1, dims_o, maxdims)) < 0) 
+
+
+    if ((sid = H5Screate_simple(RANK1, dims_o, maxdims)) < 0)
     {
         goto error;
     }
-    if ((did = H5Dcreate2(fid , "dset3", H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0) 
+    if ((did = H5Dcreate2(fid , "dset3", H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0)
     {
         goto error;
     }
     /* set new dimensions for the array */
     dims_o[ 0 ] = 0;
-    if (H5Dset_extent( did , dims_o ) < 0) 
+    if (H5Dset_extent( did , dims_o ) < 0)
     {
         goto error;
     }
 
 
 
-    if (H5Dclose(did) < 0) 
+    if (H5Dclose(did) < 0)
     {
         goto error;
     }
@@ -846,16 +846,16 @@ static int test_rank1( hbool_t do_compress,
         goto error;
     }
 
-    
-    
-    
+
+
+
     /*-------------------------------------------------------------------------
     * close property list
     *-------------------------------------------------------------------------
     */
-    
-    
-    if (H5Pclose(dcpl) < 0) 
+
+
+    if (H5Pclose(dcpl) < 0)
     {
         goto error;
     }
@@ -867,12 +867,12 @@ static int test_rank1( hbool_t do_compress,
 
 
     return 0;
-    
-    
-    
+
+
+
 error:
-    
-    H5E_BEGIN_TRY 
+
+    H5E_BEGIN_TRY
     {
         H5Dclose( did );
         H5Sclose( sid );
@@ -881,7 +881,7 @@ error:
         H5Fclose( fid );
     } H5E_END_TRY;
     return -1;
-    
+
 }
 
 /*-------------------------------------------------------------------------
@@ -889,33 +889,33 @@ error:
  *-------------------------------------------------------------------------
  */
 
-static int test_rank2( hbool_t do_compress, 
-                       hbool_t do_fill_value, 
+static int test_rank2( hbool_t do_compress,
+                       hbool_t do_fill_value,
                        hbool_t set_istore_k,
                        H5D_fill_time_t fill_time,
                        hid_t fapl)
 {
 
-    hid_t   fid=-1;          
+    hid_t   fid=-1;
     hid_t   did=-1;
     hid_t   sid=-1;
     hid_t   dcpl=-1;
     hid_t   fcpl;
-    hsize_t dims_o[RANK2] = {DIM0,DIM1};    /* original dimensions */ 
-    hsize_t dims_s[RANK2] = {DIMS0,DIMS1};  /* shrinking dimensions */ 
-    hsize_t dims_e[RANK2] = {DIME0,DIME1};  /* extended dimensions */ 
-    hsize_t dims_c[RANK2] = {2,2};          /* chunk dimensions */ 
-    hsize_t dims_r[RANK2];                  /* read dimensions */ 
+    hsize_t dims_o[RANK2] = {DIM0,DIM1};    /* original dimensions */
+    hsize_t dims_s[RANK2] = {DIMS0,DIMS1};  /* shrinking dimensions */
+    hsize_t dims_e[RANK2] = {DIME0,DIME1};  /* extended dimensions */
+    hsize_t dims_c[RANK2] = {2,2};          /* chunk dimensions */
+    hsize_t dims_r[RANK2];                  /* read dimensions */
     hsize_t maxdims[RANK2] = {H5S_UNLIMITED,H5S_UNLIMITED};
     int     buf_o[DIM0][DIM1];
     int     buf_s[DIMS0][DIMS1];
     int     buf_e[DIME0][DIME1];
     int     buf_r[DIM0][DIM1];
     int     i, j;
-    int     fillvalue = 1; 
-    int     comp_value; 
+    int     fillvalue = 1;
+    int     comp_value;
     char    filename[NAME_BUF_SIZE];
-       
+
     if ( do_fill_value )
     {
         comp_value = fillvalue;
@@ -925,7 +925,7 @@ static int test_rank2( hbool_t do_compress,
         comp_value = 0;
     }
 
-        
+
     for( i = 0; i < DIM0; i++ )
     {
         for( j = 0; j < DIM1; j++ )
@@ -935,36 +935,36 @@ static int test_rank2( hbool_t do_compress,
     }
 
     /* create a file creation property list */
-    if ((fcpl = H5Pcreate(H5P_FILE_CREATE)) < 0) 
+    if ((fcpl = H5Pcreate(H5P_FILE_CREATE)) < 0)
     {
         goto error;
     }
-    
+
     if  ( set_istore_k )
     {
         /* set non-default indexed storage B-tree internal 'K' value */
-        if (H5Pset_istore_k(fcpl,ISTORE_IK) < 0) 
+        if (H5Pset_istore_k(fcpl,ISTORE_IK) < 0)
         {
             goto error;
         }
-        
+
     }
-    
+
     /* create a new file */
     h5_fixname(FILENAME[1], fapl, filename, sizeof filename);
-    if ((fid = H5Fcreate(filename, H5F_ACC_TRUNC, fcpl, fapl)) < 0) 
+    if ((fid = H5Fcreate(filename, H5F_ACC_TRUNC, fcpl, fapl)) < 0)
     {
         goto error;
     }
 
-   
-    
+
+
     /* create the data space with unlimited dimensions. */
-    if ((sid = H5Screate_simple(RANK2, dims_o, maxdims)) < 0) 
+    if ((sid = H5Screate_simple(RANK2, dims_o, maxdims)) < 0)
     {
         goto error;
     }
-    
+
     /* modify dataset creation properties, i.e. enable chunking. */
     if ((dcpl = H5Pcreate (H5P_DATASET_CREATE)) < 0)
     {
@@ -981,33 +981,33 @@ static int test_rank2( hbool_t do_compress,
             goto error;
         }
 
-        if(H5Pset_fill_time(dcpl, fill_time) < 0) 
+        if(H5Pset_fill_time(dcpl, fill_time) < 0)
         {
             goto error;
         }
     }
     else
     {
-        
-        if(H5Pset_fill_time(dcpl, H5D_FILL_TIME_ALLOC) < 0) 
+
+        if(H5Pset_fill_time(dcpl, H5D_FILL_TIME_ALLOC) < 0)
         {
             goto error;
         }
-        
+
     }
     if (do_compress)
     {
-        if(H5Pset_deflate(dcpl, 9) < 0) 
+        if(H5Pset_deflate(dcpl, 9) < 0)
         {
             goto error;
         }
     }
-    
+
     /*-------------------------------------------------------------------------
     * Procedure 1
     * a.	Write an array AxB. These are the dimensions for creating the dataset
     * b.	Define a greater array CxD where C > A and D > B
-    * c.	Read data back 
+    * c.	Read data back
     * d.	Verify if new dimensions are C and D
     * e.	Verify if data from A to C and B to D is what it is to be expected
     *
@@ -1020,20 +1020,20 @@ static int test_rank2( hbool_t do_compress,
     *
     *-------------------------------------------------------------------------
     */
-    
+
     /* create a dataset */
-    if ((did = H5Dcreate2(fid , "dset1", H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0) 
+    if ((did = H5Dcreate2(fid , "dset1", H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0)
     {
         goto error;
     }
-    
+
     /* write */
-    if (H5Dwrite(did , H5T_NATIVE_INT, sid, H5S_ALL, H5P_DEFAULT, buf_o) < 0) 
+    if (H5Dwrite(did , H5T_NATIVE_INT, sid, H5S_ALL, H5P_DEFAULT, buf_o) < 0)
     {
         goto error;
     }
-    
-    
+
+
 #if defined (H5_SET_EXTENT_DEBUG2)
     printf("\n");
     for (i = 0; i < (int)dims_o[0]; i++ )
@@ -1044,15 +1044,15 @@ static int test_rank2( hbool_t do_compress,
         }
         printf("\n");
     }
-#endif  
+#endif
+
 
 
-    
     if (H5Sclose(sid) < 0)
     {
         goto error;
     }
-    
+
     /*-------------------------------------------------------------------------
     * set new dimensions for the array; expand it
     * data is now, extended space was initialized with fill value or default value
@@ -1067,44 +1067,44 @@ static int test_rank2( hbool_t do_compress,
     *
     *-------------------------------------------------------------------------
     */
-    
+
     /* set new dimensions for the array. */
     if (H5Dset_extent(did , dims_e) < 0)
     {
         goto error;
     }
-    
+
     /* get the space */
     if ((sid = H5Dget_space(did)) < 0)
     {
         goto error;
     }
-    
+
     /* get dimensions */
-    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0) 
+    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0)
     {
         goto error;
     }
-    
+
     if (H5Sclose(sid) < 0)
     {
         goto error;
     }
-    
-    
+
+
     /* check dimensions */
     for( i = 0; i < RANK2; i++ )
     {
-        if (dims_r[i] != dims_e[i]) 
+        if (dims_r[i] != dims_e[i])
             goto error;
     }
-    
+
     /* read */
-    if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_e) < 0) 
+    if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_e) < 0)
         goto error;
 
-   
-    
+
+
 #if defined (H5_SET_EXTENT_DEBUG2)
     printf("\n");
     for (i = 0; i < (int)dims_r[0]; i++ )
@@ -1115,41 +1115,41 @@ static int test_rank2( hbool_t do_compress,
         }
         printf("\n");
     }
-#endif  
+#endif
+
+
+
 
-    
-    
-    
     /* compare the read array with the expanded array */
     for (i = 0; i < (int)dims_r[0]; i++ )
     {
         for (j = 0; j < (int)dims_r[1]; j++ )
         {
-            if ( i >= DIM0 || j >= DIM1 ) 
+            if ( i >= DIM0 || j >= DIM1 )
             {
-                if(buf_e[i][j] != comp_value) 
+                if(buf_e[i][j] != comp_value)
                 {
                     printf("buf_e[%d][%d] = %d\n", i, j, buf_e[i][j]);
                     printf("value = %d\n", comp_value);
                     goto error;
-                } 
-            } 
-            else 
+                }
+            }
+            else
             {
-                if(buf_e[i][j] != buf_o[i][j]) 
+                if(buf_e[i][j] != buf_o[i][j])
                     goto error;
             }
         }
     }
-    
-    
-  
-    
+
+
+
+
     /*-------------------------------------------------------------------------
     *
     * Procedure 2
     * a.	Define a smaller array ExF where E < A and F < B
-    * b.	Read data back 
+    * b.	Read data back
     * c.	Verify if new dimensions are E and F
     * d.	Verify if data up until E and F is what to be expected
     *
@@ -1160,34 +1160,34 @@ static int test_rank2( hbool_t do_compress,
     *
     *-------------------------------------------------------------------------
     */
-    
+
     /* set new dimensions for the array. */
     if (H5Dset_extent(did , dims_s) < 0)
     {
         goto error;
     }
-    
+
     /* get the space */
     if ((sid = H5Dget_space(did)) < 0)
     {
         goto error;
     }
-    
+
     /* get dimensions */
-    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0) 
+    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0)
     {
         goto error;
     }
-    
+
     if (H5Sclose(sid) < 0)
     {
         goto error;
     }
-    
+
     /* check dimensions */
     for( i = 0; i < RANK2; i++ )
     {
-        if (dims_r[i] != dims_s[i]) 
+        if (dims_r[i] != dims_s[i])
             goto error;
     }
 
@@ -1196,8 +1196,8 @@ static int test_rank2( hbool_t do_compress,
     /* for this case we close and reopen file */
     if ( set_istore_k )
     {
-        
-        if (H5Dclose(did) < 0) 
+
+        if (H5Dclose(did) < 0)
         {
             goto error;
         }
@@ -1206,32 +1206,32 @@ static int test_rank2( hbool_t do_compress,
             goto error;
         }
 
-        if ((fid = H5Fopen( filename, H5F_ACC_RDWR, fapl ))<0) 
+        if ((fid = H5Fopen( filename, H5F_ACC_RDWR, fapl ))<0)
         {
             goto error;
         }
-        
-        if ((did = H5Dopen2( fid , "dset1", H5P_DEFAULT ))<0) 
+
+        if ((did = H5Dopen2( fid , "dset1", H5P_DEFAULT ))<0)
         {
             goto error;
         }
-        
-        
-        
+
+
+
     }
-    
-    
+
+
     /*-------------------------------------------------------------------------
     * read
     *-------------------------------------------------------------------------
     */
-    
+
     /* read */
-    if (H5Dread( did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_s ) < 0) 
+    if (H5Dread( did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_s ) < 0)
     {
         goto error;
     }
-    
+
 #if defined (H5_SET_EXTENT_DEBUG2)
     printf("\n");
     for (i = 0; i < (int)dims_r[0]; i++ )
@@ -1242,26 +1242,26 @@ static int test_rank2( hbool_t do_compress,
         }
         printf("\n");
     }
-#endif  
+#endif
+
+
 
 
-    
-    
     /* compare the read array with the shrinked array */
     for( i = 0; i < (int)dims_r[0]; i++ )
     {
         for( j = 0; j < (int)dims_r[1]; j++ )
         {
-            if (  buf_s[i][j] != buf_o[i][j] ) 
+            if (  buf_s[i][j] != buf_o[i][j] )
             {
                 printf("buf_s[%d][%d] = %d\n", i, j, buf_s[i][j]);
                 printf("buf_o[%d][%d] = %d\n", i, j, buf_o[i][j]);
                 goto error;
-            } 
+            }
         }
     }
-    
-    
+
+
     /*-------------------------------------------------------------------------
     * set new dimensions for the array; expand it back to original size
     * data is now, extended space was initialized with fill value or default value
@@ -1273,19 +1273,19 @@ static int test_rank2( hbool_t do_compress,
     *
     *-------------------------------------------------------------------------
     */
-    
+
     /* set new dimensions for the array */
     if (H5Dset_extent(did, dims_o) < 0)
     {
         goto error;
     }
-    
+
     /* get the space */
-    if ((sid = H5Dget_space(did)) < 0) 
+    if ((sid = H5Dget_space(did)) < 0)
     {
         goto error;
     }
-    
+
     /* get dimensions. */
     if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0)
     {
@@ -1296,24 +1296,24 @@ static int test_rank2( hbool_t do_compress,
     {
         goto error;
     }
-    
+
     /* check dimensions */
     for( i = 0; i < RANK2; i++ )
     {
-        if (dims_r[i] != dims_o[i]) 
+        if (dims_r[i] != dims_o[i])
             goto error;
     }
-    
-    
+
+
     /*-------------------------------------------------------------------------
     * read
     *-------------------------------------------------------------------------
     */
-    
+
     /* read */
-    if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_r) < 0) 
+    if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_r) < 0)
         goto error;
-    
+
 #if defined (H5_SET_EXTENT_DEBUG2)
     printf("\n");
     for (i = 0; i < (int)dims_r[0]; i++ )
@@ -1324,27 +1324,27 @@ static int test_rank2( hbool_t do_compress,
         }
         printf("\n");
     }
-#endif  
+#endif
+
 
 
-    
     /* compare the read array with the original array */
     for (i = 0; i < (int)dims_r[0]; i++ )
     {
         for (j = 0; j < (int)dims_r[1]; j++ )
         {
-            if (i >= DIMS0 || j >= DIMS1) 
+            if (i >= DIMS0 || j >= DIMS1)
             {
-                if(buf_r[i][j] != comp_value) 
+                if(buf_r[i][j] != comp_value)
                 {
                     printf("buf_r[%d][%d] = %d\n", i, j, buf_r[i][j]);
                     printf("value = %d\n", comp_value);
                     goto error;
-                } 
-            } 
-            else 
+                }
+            }
+            else
             {
-                if(buf_r[i][j] != buf_o[i][j]) 
+                if(buf_r[i][j] != buf_o[i][j])
                     goto error;
             }
         }
@@ -1358,74 +1358,74 @@ static int test_rank2( hbool_t do_compress,
 
     dims_s[0] = 0;
     dims_s[1] = 0;
-    
+
     /* set new dimensions for the array. */
     if (H5Dset_extent(did , dims_s) < 0)
     {
         goto error;
     }
-    
+
     /* get the space */
     if ((sid = H5Dget_space(did)) < 0)
     {
         goto error;
     }
-    
+
     /* get dimensions */
-    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0) 
+    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0)
     {
         goto error;
     }
-    
+
     if (H5Sclose(sid) < 0)
     {
         goto error;
     }
-    
+
     /* check dimensions */
     for( i = 0; i < RANK2; i++ )
     {
-        if (dims_r[i] != dims_s[i]) 
+        if (dims_r[i] != dims_s[i])
             goto error;
-    }    
-    
-    
+    }
+
+
     /*-------------------------------------------------------------------------
-    * close dataset 
+    * close dataset
     *-------------------------------------------------------------------------
     */
-    
-    if (H5Dclose(did) < 0) 
+
+    if (H5Dclose(did) < 0)
     {
         goto error;
     }
-       
-    
+
+
      /*-------------------------------------------------------------------------
     * test a dataset with non initialized chunks
     *-------------------------------------------------------------------------
     */
-    
-      
-    if ((sid = H5Screate_simple(RANK2, dims_o, maxdims)) < 0) 
+
+
+    if ((sid = H5Screate_simple(RANK2, dims_o, maxdims)) < 0)
     {
         goto error;
     }
-    if ((did = H5Dcreate2(fid , "dset3", H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0) 
+    if ((did = H5Dcreate2(fid , "dset3", H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0)
     {
         goto error;
     }
     /* set new dimensions for the array */
     dims_o[ 0 ] = 0;
     dims_o[ 1 ] = 0;
-    if (H5Dset_extent( did , dims_o ) < 0) 
+    if (H5Dset_extent( did , dims_o ) < 0)
     {
         goto error;
     }
 
 
 
-    if (H5Dclose(did) < 0) 
+    if (H5Dclose(did) < 0)
     {
         goto error;
     }
@@ -1434,22 +1434,22 @@ static int test_rank2( hbool_t do_compress,
         goto error;
     }
 
-    
-    
-    
+
+
+
     /*-------------------------------------------------------------------------
     * close property list
     *-------------------------------------------------------------------------
     */
-    
-    
-    if (H5Pclose(dcpl) < 0) 
+
+
+    if (H5Pclose(dcpl) < 0)
     {
         goto error;
     }
 
     /* close file creation property list */
-    if(H5Pclose(fcpl) < 0) 
+    if(H5Pclose(fcpl) < 0)
     {
         goto error;
     }
@@ -1461,12 +1461,12 @@ static int test_rank2( hbool_t do_compress,
 
 
     return 0;
-    
-    
-    
+
+
+
 error:
-    
-    H5E_BEGIN_TRY 
+
+    H5E_BEGIN_TRY
     {
         H5Dclose( did );
         H5Sclose( sid );
@@ -1475,7 +1475,7 @@ error:
         H5Fclose( fid );
     } H5E_END_TRY;
     return -1;
-    
+
 }
 
 
@@ -1486,33 +1486,33 @@ error:
  *-------------------------------------------------------------------------
  */
 
-static int test_rank3( hbool_t do_compress, 
-                       hbool_t do_fill_value, 
+static int test_rank3( hbool_t do_compress,
+                       hbool_t do_fill_value,
                        hbool_t set_istore_k,
                        H5D_fill_time_t fill_time,
                        hid_t fapl)
 {
 
-    hid_t   fid=-1;          
+    hid_t   fid=-1;
     hid_t   did=-1;
     hid_t   sid=-1;
     hid_t   dcpl=-1;
     hid_t   fcpl;
-    hsize_t dims_o[RANK3] = {DIM0,DIM1,DIM2};    /* original dimensions */ 
-    hsize_t dims_s[RANK3] = {DIMS0,DIMS1,DIMS2}; /* shrinking dimensions */ 
-    hsize_t dims_e[RANK3] = {DIME0,DIME1,DIME2}; /* extended dimensions */ 
-    hsize_t dims_c[RANK3] = {2,2,2};             /* chunk dimensions */ 
-    hsize_t dims_r[RANK3];                       /* read dimensions */ 
+    hsize_t dims_o[RANK3] = {DIM0,DIM1,DIM2};    /* original dimensions */
+    hsize_t dims_s[RANK3] = {DIMS0,DIMS1,DIMS2}; /* shrinking dimensions */
+    hsize_t dims_e[RANK3] = {DIME0,DIME1,DIME2}; /* extended dimensions */
+    hsize_t dims_c[RANK3] = {2,2,2};             /* chunk dimensions */
+    hsize_t dims_r[RANK3];                       /* read dimensions */
     hsize_t maxdims[RANK3] = {H5S_UNLIMITED,H5S_UNLIMITED,H5S_UNLIMITED};
     int     buf_o[DIM0][DIM1][DIM2];
     int     buf_s[DIMS0][DIMS1][DIMS2];
     int     buf_e[DIME0][DIME1][DIME2];
     int     buf_r[DIM0][DIM1][DIM2];
     int     i, j, k;
-    int     fillvalue = 1; 
-    int     comp_value; 
+    int     fillvalue = 1;
+    int     comp_value;
     char	filename[NAME_BUF_SIZE];
-       
+
     if ( do_fill_value )
     {
         comp_value = fillvalue;
@@ -1522,7 +1522,7 @@ static int test_rank3( hbool_t do_compress,
         comp_value = 0;
     }
 
-        
+
     for( i = 0; i < DIM0; i++ )
     {
         for( j = 0; j < DIM1; j++ )
@@ -1535,39 +1535,39 @@ static int test_rank3( hbool_t do_compress,
     }
 
     /* create a file creation property list */
-    if ((fcpl = H5Pcreate(H5P_FILE_CREATE)) < 0) 
+    if ((fcpl = H5Pcreate(H5P_FILE_CREATE)) < 0)
     {
         goto error;
     }
-    
+
     if  ( set_istore_k )
     {
         /* set non-default indexed storage B-tree internal 'K' value */
-        if (H5Pset_istore_k(fcpl,ISTORE_IK) < 0) 
+        if (H5Pset_istore_k(fcpl,ISTORE_IK) < 0)
         {
             goto error;
         }
-        
+
     }
     /* create a new file */
     h5_fixname(FILENAME[2], fapl, filename, sizeof filename);
-    if ((fid = H5Fcreate(filename, H5F_ACC_TRUNC, fcpl, fapl)) < 0) 
+    if ((fid = H5Fcreate(filename, H5F_ACC_TRUNC, fcpl, fapl)) < 0)
     {
         goto error;
     }
 
     /* close property list */
-    if(H5Pclose(fcpl) < 0) 
+    if(H5Pclose(fcpl) < 0)
     {
         goto error;
     }
-    
+
     /* create the data space with unlimited dimensions. */
-    if ((sid = H5Screate_simple(RANK3, dims_o, maxdims)) < 0) 
+    if ((sid = H5Screate_simple(RANK3, dims_o, maxdims)) < 0)
     {
         goto error;
     }
-    
+
     /* modify dataset creation properties, i.e. enable chunking. */
     if ((dcpl = H5Pcreate (H5P_DATASET_CREATE)) < 0)
     {
@@ -1584,46 +1584,46 @@ static int test_rank3( hbool_t do_compress,
             goto error;
         }
 
-        if(H5Pset_fill_time(dcpl, fill_time) < 0) 
+        if(H5Pset_fill_time(dcpl, fill_time) < 0)
         {
             goto error;
         }
     }
     else
     {
-        
-        if(H5Pset_fill_time(dcpl, H5D_FILL_TIME_ALLOC) < 0) 
+
+        if(H5Pset_fill_time(dcpl, H5D_FILL_TIME_ALLOC) < 0)
         {
             goto error;
         }
-        
+
     }
     if (do_compress)
     {
-        if(H5Pset_deflate(dcpl, 9) < 0) 
+        if(H5Pset_deflate(dcpl, 9) < 0)
         {
             goto error;
         }
     }
-    
+
     /*-------------------------------------------------------------------------
     * create, write array
     *-------------------------------------------------------------------------
     */
-    
+
     /* create a dataset */
-    if ((did = H5Dcreate2(fid , "dset1", H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0) 
+    if ((did = H5Dcreate2(fid , "dset1", H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0)
     {
         goto error;
     }
-    
+
     /* write */
-    if (H5Dwrite(did , H5T_NATIVE_INT, sid, H5S_ALL, H5P_DEFAULT, buf_o) < 0) 
+    if (H5Dwrite(did , H5T_NATIVE_INT, sid, H5S_ALL, H5P_DEFAULT, buf_o) < 0)
     {
         goto error;
     }
-    
-    
+
+
 #if defined (H5_SET_EXTENT_DEBUG3)
     printf("\n");
     for (i = 0; i < (int)dims_o[0]; i++ )
@@ -1637,61 +1637,61 @@ static int test_rank3( hbool_t do_compress,
             printf("[%d] ", j);
         }
         printf("\n");
-        
+
     }
     printf("\n");
-#endif  
+#endif
+
 
 
-    
     if (H5Sclose(sid) < 0)
     {
         goto error;
     }
-    
+
     /*-------------------------------------------------------------------------
     * set new dimensions for the array; expand it
     *
     *-------------------------------------------------------------------------
     */
-    
+
     /* set new dimensions for the array. */
     if (H5Dset_extent(did , dims_e) < 0)
     {
         goto error;
     }
-    
+
     /* get the space */
     if ((sid = H5Dget_space(did)) < 0)
     {
         goto error;
     }
-    
+
     /* get dimensions */
-    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0) 
+    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0)
     {
         goto error;
     }
-    
+
     if (H5Sclose(sid) < 0)
     {
         goto error;
     }
-    
-    
+
+
     /* check dimensions */
     for( i = 0; i < RANK3; i++ )
     {
-        if (dims_r[i] != dims_e[i]) 
+        if (dims_r[i] != dims_e[i])
             goto error;
     }
-    
+
     /* read */
-    if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_e) < 0) 
+    if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_e) < 0)
         goto error;
 
-   
-    
+
+
 #if defined (H5_SET_EXTENT_DEBUG3)
     printf("\n");
     for (i = 0; i < (int)dims_r[0]; i++ )
@@ -1705,14 +1705,14 @@ static int test_rank3( hbool_t do_compress,
             printf("[%d] ", j);
         }
         printf("\n");
-        
+
     }
     printf("\n");
-#endif  
+#endif
+
+
+
 
-    
-    
-    
     /* compare the read array with the expanded array */
     for (i = 0; i < (int)dims_r[0]; i++ )
     {
@@ -1720,59 +1720,59 @@ static int test_rank3( hbool_t do_compress,
         {
             for( k = 0; k < (int)dims_r[2]; k++ )
             {
-                if ( i >= DIM0 || j >= DIM1 || k >= DIM2 ) 
+                if ( i >= DIM0 || j >= DIM1 || k >= DIM2 )
                 {
-                    if(buf_e[i][j][k] != comp_value) 
+                    if(buf_e[i][j][k] != comp_value)
                     {
                         printf("buf_e[%d][%d][%d] = %d\n", i, j, k, buf_e[i][j][k] );
                         printf("value = %d\n", comp_value);
                         goto error;
-                    } 
-                } 
-                else 
+                    }
+                }
+                else
                 {
-                    if(buf_e[i][j][k] != buf_o[i][j][k] ) 
+                    if(buf_e[i][j][k] != buf_o[i][j][k] )
                         goto error;
                 }
             }
         }
     }
-    
-    
-  
-    
+
+
+
+
     /*-------------------------------------------------------------------------
     * shrink
     *-------------------------------------------------------------------------
     */
-    
+
     /* set new dimensions for the array. */
     if (H5Dset_extent(did , dims_s) < 0)
     {
         goto error;
     }
-    
+
     /* get the space */
     if ((sid = H5Dget_space(did)) < 0)
     {
         goto error;
     }
-    
+
     /* get dimensions */
-    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0) 
+    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0)
     {
         goto error;
     }
-    
+
     if (H5Sclose(sid) < 0)
     {
         goto error;
     }
-    
+
     /* check dimensions */
     for( i = 0; i < RANK3; i++ )
     {
-        if (dims_r[i] != dims_s[i]) 
+        if (dims_r[i] != dims_s[i])
             goto error;
     }
 
@@ -1781,8 +1781,8 @@ static int test_rank3( hbool_t do_compress,
     /* for this case we close and reopen file */
     if ( set_istore_k )
     {
-        
-        if (H5Dclose(did) < 0) 
+
+        if (H5Dclose(did) < 0)
         {
             goto error;
         }
@@ -1791,32 +1791,32 @@ static int test_rank3( hbool_t do_compress,
             goto error;
         }
 
-        if ((fid = H5Fopen( filename, H5F_ACC_RDWR, fapl ))<0) 
+        if ((fid = H5Fopen( filename, H5F_ACC_RDWR, fapl ))<0)
         {
             goto error;
         }
-        
-        if ((did = H5Dopen2( fid , "dset1", H5P_DEFAULT ))<0) 
+
+        if ((did = H5Dopen2( fid , "dset1", H5P_DEFAULT ))<0)
         {
             goto error;
         }
-        
-        
-        
+
+
+
     }
-    
-    
+
+
     /*-------------------------------------------------------------------------
     * read
     *-------------------------------------------------------------------------
     */
-    
+
     /* read */
-    if (H5Dread( did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_s ) < 0) 
+    if (H5Dread( did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_s ) < 0)
     {
         goto error;
     }
-    
+
 #if defined (H5_SET_EXTENT_DEBUG3)
     printf("\n");
     for (i = 0; i < (int)dims_r[0]; i++ )
@@ -1830,14 +1830,14 @@ static int test_rank3( hbool_t do_compress,
              printf("[%d] ", j);
         }
         printf("\n");
-        
+
     }
     printf("\n");
-#endif  
+#endif
+
+
 
 
-    
-    
     /* compare the read array with the shrinked array */
     for( i = 0; i < (int)dims_r[0]; i++ )
     {
@@ -1845,34 +1845,34 @@ static int test_rank3( hbool_t do_compress,
         {
             for( k = 0; k < (int)dims_r[2]; k++ )
             {
-                if (  buf_s[i][j][k] != buf_o[i][j][k] ) 
+                if (  buf_s[i][j][k] != buf_o[i][j][k] )
                 {
                     printf("buf_s[%d][%d][%d] = %d\n", i, j, k, buf_s[i][j][k] );
                     printf("buf_o[%d][%d][%d] = %d\n", i, j, k, buf_o[i][j][k] );
                     goto error;
-                } 
+                }
             }
         }
     }
-    
-    
+
+
     /*-------------------------------------------------------------------------
     * set new dimensions for the array; expand it back to original size
     *-------------------------------------------------------------------------
     */
-    
+
     /* set new dimensions for the array */
     if (H5Dset_extent(did, dims_o) < 0)
     {
         goto error;
     }
-    
+
     /* get the space */
-    if ((sid = H5Dget_space(did)) < 0) 
+    if ((sid = H5Dget_space(did)) < 0)
     {
         goto error;
     }
-    
+
     /* get dimensions. */
     if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0)
     {
@@ -1883,18 +1883,18 @@ static int test_rank3( hbool_t do_compress,
     {
         goto error;
     }
-    
+
     /* check dimensions */
     for( i = 0; i < RANK3; i++ )
     {
-        if (dims_r[i] != dims_o[i]) 
+        if (dims_r[i] != dims_o[i])
             goto error;
     }
-    
+
     /* read */
-    if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_r) < 0) 
+    if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_r) < 0)
         goto error;
-    
+
 #if defined (H5_SET_EXTENT_DEBUG3)
     printf("\n");
     for (i = 0; i < (int)dims_r[0]; i++ )
@@ -1903,19 +1903,19 @@ static int test_rank3( hbool_t do_compress,
         {
             for( k = 0; k < (int)dims_r[2]; k++ )
             {
-                
+
                 printf("%d ", buf_r[i][j][k]);
             }
              printf("[%d] ", j);
         }
         printf("\n");
-        
+
     }
     printf("\n");
-#endif  
+#endif
+
 
 
-    
     /* compare the read array with the original array */
     for (i = 0; i < (int)dims_r[0]; i++ )
     {
@@ -1923,24 +1923,24 @@ static int test_rank3( hbool_t do_compress,
         {
             for( k = 0; k < (int)dims_r[2]; k++ )
             {
-                if (i >= DIMS0 || j >= DIMS1 || k >= DIMS2 ) 
+                if (i >= DIMS0 || j >= DIMS1 || k >= DIMS2 )
                 {
-                    if( buf_r[i][j][k] != comp_value ) 
+                    if( buf_r[i][j][k] != comp_value )
                     {
                         printf("buf_r[%d][%d][%d] = %d\n", i, j, k, buf_r[i][j][k] );
                         printf("value = %d\n", comp_value);
                         goto error;
-                    } 
-                } 
-                else 
+                    }
+                }
+                else
                 {
-                    if(buf_r[i][j][k] != buf_o[i][j][k]) 
+                    if(buf_r[i][j][k] != buf_o[i][j][k])
                         goto error;
                 }
             }
         }
     }
-    
+
 
     /*-------------------------------------------------------------------------
     * shrink to 0
@@ -1951,61 +1951,61 @@ static int test_rank3( hbool_t do_compress,
     dims_s[0] = 0;
     dims_s[1] = 0;
     dims_s[2] = 0;
-    
+
     /* set new dimensions for the array. */
     if (H5Dset_extent(did , dims_s) < 0)
     {
         goto error;
     }
-    
+
     /* get the space */
     if ((sid = H5Dget_space(did)) < 0)
     {
         goto error;
     }
-    
+
     /* get dimensions */
-    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0) 
+    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0)
     {
         goto error;
     }
-    
+
     if (H5Sclose(sid) < 0)
     {
         goto error;
     }
-    
+
     /* check dimensions */
     for( i = 0; i < RANK3; i++ )
     {
-        if (dims_r[i] != dims_s[i]) 
+        if (dims_r[i] != dims_s[i])
             goto error;
-    }    
-    
-    
-    
+    }
+
+
+
     /*-------------------------------------------------------------------------
-    * close dataset 
+    * close dataset
     *-------------------------------------------------------------------------
     */
-    
-    if (H5Dclose(did) < 0) 
+
+    if (H5Dclose(did) < 0)
     {
         goto error;
     }
-       
-    
+
+
     /*-------------------------------------------------------------------------
     * test a dataset with non initialized chunks
     *-------------------------------------------------------------------------
     */
-    
-      
-    if ((sid = H5Screate_simple(RANK3, dims_o, maxdims)) < 0) 
+
+
+    if ((sid = H5Screate_simple(RANK3, dims_o, maxdims)) < 0)
     {
         goto error;
     }
-    if ((did = H5Dcreate2(fid , "dset3", H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0) 
+    if ((did = H5Dcreate2(fid , "dset3", H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0)
     {
         goto error;
     }
@@ -2013,14 +2013,14 @@ static int test_rank3( hbool_t do_compress,
     dims_o[ 0 ] = 0;
     dims_o[ 1 ] = 0;
     dims_o[ 2 ] = 0;
-    if (H5Dset_extent( did , dims_o ) < 0) 
+    if (H5Dset_extent( did , dims_o ) < 0)
     {
         goto error;
     }
 
 
 
-    if (H5Dclose(did) < 0) 
+    if (H5Dclose(did) < 0)
     {
         goto error;
     }
@@ -2029,16 +2029,16 @@ static int test_rank3( hbool_t do_compress,
         goto error;
     }
 
-    
-    
-    
+
+
+
     /*-------------------------------------------------------------------------
     * close property list
     *-------------------------------------------------------------------------
     */
-    
-    
-    if (H5Pclose(dcpl) < 0) 
+
+
+    if (H5Pclose(dcpl) < 0)
     {
         goto error;
     }
@@ -2050,12 +2050,12 @@ static int test_rank3( hbool_t do_compress,
 
 
     return 0;
-    
-    
-    
+
+
+
 error:
-    
-    H5E_BEGIN_TRY 
+
+    H5E_BEGIN_TRY
     {
         H5Dclose( did );
         H5Sclose( sid );
@@ -2064,7 +2064,7 @@ error:
         H5Fclose( fid );
     } H5E_END_TRY;
     return -1;
-    
+
 }
 
 
@@ -2075,32 +2075,32 @@ error:
 static int test_external( hid_t fapl )
 {
 
-    hid_t   fid=-1;       
+    hid_t   fid=-1;
     hid_t   did=-1;
     hid_t   sid=-1;
     hid_t   dcpl=-1;
-    hsize_t dims_o[RANK2] = {DIM0,DIM1};    /* original dimensions */ 
-    hsize_t dims_s[RANK2] = {DIMS0,DIMS1};  /* shrinking dimensions */ 
-    hsize_t dims_e[RANK2] = {DIME0,DIM1};   /* extended dimensions, dimension 1 is the original */ 
-    hsize_t dims_r[RANK2];                  /* read dimensions */ 
+    hsize_t dims_o[RANK2] = {DIM0,DIM1};    /* original dimensions */
+    hsize_t dims_s[RANK2] = {DIMS0,DIMS1};  /* shrinking dimensions */
+    hsize_t dims_e[RANK2] = {DIME0,DIM1};   /* extended dimensions, dimension 1 is the original */
+    hsize_t dims_r[RANK2];                  /* read dimensions */
     hsize_t maxdims[RANK2] = {DIME0,DIM1};  /* only the first dimension can be extendible */
-    int     buf_o[DIM0][DIM1];              /* original buffer, for writing */  
-    int     buf_s[DIMS0][DIMS1];            /* shrinked buffer, for reading */  
-    int     buf_e[DIME0][DIM1];             /* extended buffer, for writing, dimension 1 is the original */    
-    int     buf_ro[DIM0][DIM1];             /* original buffer for reading */    
+    int     buf_o[DIM0][DIM1];              /* original buffer, for writing */
+    int     buf_s[DIMS0][DIMS1];            /* shrinked buffer, for reading */
+    int     buf_e[DIME0][DIM1];             /* extended buffer, for writing, dimension 1 is the original */
+    int     buf_ro[DIM0][DIM1];             /* original buffer for reading */
     int     i, j;
     int     comp_value = 0;
     char	filename[NAME_BUF_SIZE];
-   
+
 
     hsize_t size;        /* number of bytes reserved in the file for the data */
-    hsize_t max_size[2];	
-    
+    hsize_t max_size[2];
+
     max_size[0] = dims_e[0];
     max_size[1] = dims_e[1];
     size = max_size[0] * max_size[1] * sizeof(int) / 2;
-    
-      
+
+
     for( i = 0; i < DIM0; i++ )
     {
         for( j = 0; j < DIM1; j++ )
@@ -2110,32 +2110,32 @@ static int test_external( hid_t fapl )
     }
 
     TESTING_2("external file use");
-  
+
     /* create a new file */
     h5_fixname(FILENAME[3], fapl, filename, sizeof filename);
-    if ((fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0) 
+    if ((fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
         FAIL_STACK_ERROR
-  
+
     /* modify dataset creation properties */
     if ((dcpl = H5Pcreate (H5P_DATASET_CREATE)) < 0)
         FAIL_STACK_ERROR
-    
+
     if(H5Pset_external(dcpl, EXT_FILE_NAME1, (off_t)0, size) < 0)
         FAIL_STACK_ERROR
 
     if(H5Pset_external(dcpl, EXT_FILE_NAME2, (off_t)0, size) < 0)
         FAIL_STACK_ERROR
-    
+
     {
-        
+
         char	name[256];		/*external file name		*/
         off_t	file_offset;    /*external file offset		*/
         hsize_t	file_size;		/*sizeof external file segment	*/
-        
+
         if(H5Pget_external(dcpl, 0, sizeof(name), name, &file_offset,
                 &file_size) < 0)
             FAIL_STACK_ERROR
-        
+
     }
 
 
@@ -2155,11 +2155,11 @@ static int test_external( hid_t fapl )
 
 
     /* create the data space with unlimited dimensions. */
-    if ((sid = H5Screate_simple(RANK2, dims_o, maxdims)) < 0) 
+    if ((sid = H5Screate_simple(RANK2, dims_o, maxdims)) < 0)
         FAIL_STACK_ERROR
-    if ((did = H5Dcreate2(fid , "dset1", H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0) 
+    if ((did = H5Dcreate2(fid , "dset1", H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0)
         FAIL_STACK_ERROR
-    if (H5Dwrite(did , H5T_NATIVE_INT, sid, H5S_ALL, H5P_DEFAULT, buf_o) < 0) 
+    if (H5Dwrite(did , H5T_NATIVE_INT, sid, H5S_ALL, H5P_DEFAULT, buf_o) < 0)
         FAIL_STACK_ERROR
     if (H5Sclose(sid) < 0)
         FAIL_STACK_ERROR
@@ -2171,9 +2171,9 @@ static int test_external( hid_t fapl )
     */
 
      /* read */
-    if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_ro) < 0) 
+    if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_ro) < 0)
         FAIL_STACK_ERROR
-    
+
 #if defined (H5_SET_EXTENT_DEBUG)
     printf("\n");
     for (i = 0; i < (int)dims_o[0]; i++ )
@@ -2184,10 +2184,10 @@ static int test_external( hid_t fapl )
         }
         printf("\n");
     }
-#endif  
+#endif
+
 
 
-    
     /*-------------------------------------------------------------------------
     * expand
     *-------------------------------------------------------------------------
@@ -2197,13 +2197,13 @@ static int test_external( hid_t fapl )
     * set new dimensions for the array; expand it
     * data is now, extended space was initialized with default value
     *
-    *  2 2 2 2 
-    *  2 2 2 2 
-    *  2 2 2 2 
-    *  2 2 2 2 
-    *  0 0 0 0 
-    *  0 0 0 0 
-    *  0 0 0 0 
+    *  2 2 2 2
+    *  2 2 2 2
+    *  2 2 2 2
+    *  2 2 2 2
+    *  0 0 0 0
+    *  0 0 0 0
+    *  0 0 0 0
     *
     *-------------------------------------------------------------------------
     */
@@ -2215,28 +2215,28 @@ static int test_external( hid_t fapl )
      /* get the space */
     if ((sid = H5Dget_space(did)) < 0)
         FAIL_STACK_ERROR
-    
+
     /* get dimensions */
-    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0) 
+    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0)
         FAIL_STACK_ERROR
-    
+
     if (H5Sclose(sid) < 0)
         FAIL_STACK_ERROR
-    
-    
+
+
     /* check dimensions */
     for( i = 0; i < RANK2; i++ )
     {
-        if (dims_r[i] != dims_e[i]) 
+        if (dims_r[i] != dims_e[i])
             TEST_ERROR
     }
-    
+
     /* read */
-    if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_e) < 0) 
+    if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_e) < 0)
         FAIL_STACK_ERROR
 
-   
-    
+
+
 #if defined (H5_SET_EXTENT_DEBUG)
     printf("\n");
     for (i = 0; i < (int)dims_r[0]; i++ )
@@ -2247,33 +2247,33 @@ static int test_external( hid_t fapl )
         }
         printf("\n");
     }
-#endif  
+#endif
+
+
+
 
-    
-    
-    
     /* compare the read array with the expanded array */
     for (i = 0; i < (int)dims_r[0]; i++ )
     {
         for (j = 0; j < (int)dims_r[1]; j++ )
         {
-            if ( i >= DIM0 || j >= DIM1 ) 
+            if ( i >= DIM0 || j >= DIM1 )
             {
-                if(buf_e[i][j] != comp_value) 
+                if(buf_e[i][j] != comp_value)
                 {
                     printf("buf_e[%d][%d] = %d\n", i, j, buf_e[i][j]);
                     printf("value = %d\n", comp_value);
                     TEST_ERROR
-                } 
-            } 
-            else 
+                }
+            }
+            else
             {
-                if(buf_e[i][j] != buf_o[i][j]) 
+                if(buf_e[i][j] != buf_o[i][j])
                     TEST_ERROR
             }
         }
     }
-    
+
 
 
      /*-------------------------------------------------------------------------
@@ -2286,41 +2286,41 @@ static int test_external( hid_t fapl )
     *
     *-------------------------------------------------------------------------
     */
-    
+
     /* set new dimensions for the array. */
     if (H5Dset_extent(did , dims_s) < 0)
         FAIL_STACK_ERROR
-    
+
     /* get the space */
     if ((sid = H5Dget_space(did)) < 0)
         FAIL_STACK_ERROR
-    
+
     /* get dimensions */
-    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0) 
+    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0)
         FAIL_STACK_ERROR
-    
+
     if (H5Sclose(sid) < 0)
         FAIL_STACK_ERROR
-    
+
     /* check dimensions */
     for( i = 0; i < RANK2; i++ )
     {
-        if (dims_r[i] != dims_s[i]) 
+        if (dims_r[i] != dims_s[i])
             TEST_ERROR
     }
 
 
-    
-    
+
+
     /*-------------------------------------------------------------------------
     * read
     *-------------------------------------------------------------------------
     */
-    
+
     /* read */
-    if (H5Dread( did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_s ) < 0) 
+    if (H5Dread( did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_s ) < 0)
         FAIL_STACK_ERROR
-    
+
 #if defined (H5_SET_EXTENT_DEBUG)
     printf("\n");
     for (i = 0; i < (int)dims_r[0]; i++ )
@@ -2331,22 +2331,22 @@ static int test_external( hid_t fapl )
         }
         printf("\n");
     }
-#endif  
+#endif
+
+
 
 
-    
-    
     /* compare the read array with the shrinked array */
     for( i = 0; i < (int)dims_r[0]; i++ )
     {
         for( j = 0; j < (int)dims_r[1]; j++ )
         {
-            if (  buf_s[i][j] != buf_o[i][j] ) 
+            if (  buf_s[i][j] != buf_o[i][j] )
             {
                 printf("buf_s[%d][%d] = %d\n", i, j, buf_s[i][j]);
                 printf("buf_o[%d][%d] = %d\n", i, j, buf_o[i][j]);
                 TEST_ERROR
-            } 
+            }
         }
     }
 
@@ -2361,16 +2361,16 @@ static int test_external( hid_t fapl )
     dims_e[1] = DIME1;
 
 
-    H5E_BEGIN_TRY 
+    H5E_BEGIN_TRY
     {
-        
-        
+
+
         /* set new dimensions for the array. */
         if (H5Dset_extent(did , dims_e) == SUCCEED)
         {
             TEST_ERROR
         }
-        
+
     } H5E_END_TRY;
 
 
@@ -2379,9 +2379,9 @@ static int test_external( hid_t fapl )
     * close property list
     *-------------------------------------------------------------------------
     */
-    
-    
-    if (H5Pclose(dcpl) < 0) 
+
+
+    if (H5Pclose(dcpl) < 0)
         FAIL_STACK_ERROR
 
     if (H5Dclose( did ) < 0)
@@ -2393,10 +2393,10 @@ static int test_external( hid_t fapl )
     PASSED();
 
     return 0;
-    
+
 error:
-    
-    H5E_BEGIN_TRY 
+
+    H5E_BEGIN_TRY
     {
         H5Dclose( did );
         H5Sclose( sid );
@@ -2414,19 +2414,19 @@ error:
 static int test_layouts( H5D_layout_t layout, hid_t fapl )
 {
 
-    hid_t   fid=-1;       
+    hid_t   fid=-1;
     hid_t   did=-1;
     hid_t   sid=-1;
     hid_t   dcpl=-1;
-    hsize_t dims_o[RANK2] = {DIM0,DIM1};    /* original dimensions */ 
-    hsize_t dims_s[RANK2] = {DIMS0,DIMS1};  /* shrinking dimensions */ 
-    hsize_t dims_e[RANK2] = {DIME0,DIME1};  /* extended dimensions */ 
-    hsize_t dims_r[RANK2];                  /* read dimensions */ 
+    hsize_t dims_o[RANK2] = {DIM0,DIM1};    /* original dimensions */
+    hsize_t dims_s[RANK2] = {DIMS0,DIMS1};  /* shrinking dimensions */
+    hsize_t dims_e[RANK2] = {DIME0,DIME1};  /* extended dimensions */
+    hsize_t dims_r[RANK2];                  /* read dimensions */
     int     buf_o[DIM0][DIM1];
     int     buf_r[DIM0][DIM1];
-    int     i, j; 
+    int     i, j;
     char	filename[NAME_BUF_SIZE];
-   
+
     for( i = 0; i < DIM0; i++ )
     {
         for( j = 0; j < DIM1; j++ )
@@ -2435,44 +2435,44 @@ static int test_layouts( H5D_layout_t layout, hid_t fapl )
         }
     }
 
-  
+
     /* create a new file */
     h5_fixname(FILENAME[4], fapl, filename, sizeof filename);
-    if ((fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0) 
+    if ((fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
     {
         goto error;
     }
 
     /* create the data space with unlimited dimensions. */
-    if ((sid = H5Screate_simple(RANK2, dims_o, NULL)) < 0) 
+    if ((sid = H5Screate_simple(RANK2, dims_o, NULL)) < 0)
     {
         goto error;
     }
-    
+
     /* modify dataset creation properties */
     if ((dcpl = H5Pcreate (H5P_DATASET_CREATE)) < 0)
     {
         goto error;
     }
-    
+
     if (H5Pset_layout (dcpl, layout) < 0)
     {
         goto error;
     }
-         
+
     /* create a dataset */
-    if ((did = H5Dcreate2(fid , "dset1", H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0) 
+    if ((did = H5Dcreate2(fid , "dset1", H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0)
     {
         goto error;
     }
-    
+
     /* write */
-    if (H5Dwrite(did , H5T_NATIVE_INT, sid, H5S_ALL, H5P_DEFAULT, buf_o) < 0) 
+    if (H5Dwrite(did , H5T_NATIVE_INT, sid, H5S_ALL, H5P_DEFAULT, buf_o) < 0)
     {
         goto error;
     }
-    
-    
+
+
 #if defined (H5_SET_EXTENT_DEBUG4)
     printf("\n");
     for (i = 0; i < (int)dims_o[0]; i++ )
@@ -2483,65 +2483,65 @@ static int test_layouts( H5D_layout_t layout, hid_t fapl )
         }
         printf("\n");
     }
-#endif  
+#endif
+
 
 
-    
     if (H5Sclose(sid) < 0)
     {
         goto error;
     }
-    
+
     /*-------------------------------------------------------------------------
     * negative test
-    * try to extend dimension 
+    * try to extend dimension
     *-------------------------------------------------------------------------
     */
 
-    H5E_BEGIN_TRY 
+    H5E_BEGIN_TRY
     {
-     
+
         if (H5Dset_extent(did , dims_e) == SUCCEED)
         {
             goto error;
         }
-        
+
     } H5E_END_TRY;
 
-    
-  
-    
+
+
+
     /* get the space */
     if ((sid = H5Dget_space(did)) < 0)
     {
         goto error;
     }
-    
+
     /* get dimensions */
-    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0) 
+    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0)
     {
         goto error;
     }
-    
+
     if (H5Sclose(sid) < 0)
     {
         goto error;
     }
-    
-    
+
+
     /* check dimensions */
     for( i = 0; i < RANK2; i++ )
     {
-        if (dims_r[i] != dims_o[i]) 
+        if (dims_r[i] != dims_o[i])
             goto error;
     }
-    
+
     /* read */
-    if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_r) < 0) 
+    if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_r) < 0)
         goto error;
 
-   
-    
+
+
 #if defined (H5_SET_EXTENT_DEBUG4)
     printf("\n");
     for (i = 0; i < (int)dims_r[0]; i++ )
@@ -2552,63 +2552,63 @@ static int test_layouts( H5D_layout_t layout, hid_t fapl )
         }
         printf("\n");
     }
-#endif  
+#endif
+
+
 
-     
-    
     /*-------------------------------------------------------------------------
     * negative test
-    * try to shrink dimension 
+    * try to shrink dimension
     *-------------------------------------------------------------------------
     */
 
-    H5E_BEGIN_TRY 
+    H5E_BEGIN_TRY
     {
-     
+
         if (H5Dset_extent(did , dims_s) == SUCCEED)
         {
             goto error;
         }
-        
+
     } H5E_END_TRY;
 
-    
+
     /* get the space */
     if ((sid = H5Dget_space(did)) < 0)
     {
         goto error;
     }
-    
+
     /* get dimensions */
-    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0) 
+    if (H5Sget_simple_extent_dims(sid, dims_r, NULL) < 0)
     {
         goto error;
     }
-    
+
     if (H5Sclose(sid) < 0)
     {
         goto error;
     }
-    
+
     /* check dimensions */
     for( i = 0; i < RANK2; i++ )
     {
-        if (dims_r[i] != dims_o[i]) 
+        if (dims_r[i] != dims_o[i])
             goto error;
     }
 
-    
+
     /*-------------------------------------------------------------------------
     * read
     *-------------------------------------------------------------------------
     */
-    
+
     /* read */
-    if (H5Dread( did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_r ) < 0) 
+    if (H5Dread( did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_r ) < 0)
     {
         goto error;
     }
-    
+
 #if defined (H5_SET_EXTENT_DEBUG4)
     printf("\n");
     for (i = 0; i < (int)dims_r[0]; i++ )
@@ -2619,21 +2619,21 @@ static int test_layouts( H5D_layout_t layout, hid_t fapl )
         }
         printf("\n");
     }
-#endif  
+#endif
+
 
 
-     
     /*-------------------------------------------------------------------------
-    * close 
+    * close
     *-------------------------------------------------------------------------
     */
-    
-    if (H5Dclose(did) < 0) 
+
+    if (H5Dclose(did) < 0)
     {
         goto error;
     }
-      
-    if (H5Pclose(dcpl) < 0) 
+
+    if (H5Pclose(dcpl) < 0)
     {
         goto error;
     }
@@ -2645,12 +2645,12 @@ static int test_layouts( H5D_layout_t layout, hid_t fapl )
 
 
     return 0;
-    
-    
-    
+
+
+
 error:
-    
-    H5E_BEGIN_TRY 
+
+    H5E_BEGIN_TRY
     {
         H5Dclose( did );
         H5Sclose( sid );
@@ -2658,6 +2658,6 @@ error:
         H5Fclose( fid );
     } H5E_END_TRY;
     return -1;
-    
+
 }
 
diff --git a/test/tattr.c b/test/tattr.c
index dcf13bc..484d83f 100644
--- a/test/tattr.c
+++ b/test/tattr.c
@@ -10347,7 +10347,7 @@ test_attr(void)
                 test_attr_bug3(my_fcpl, my_fapl);               /* Test "self referential" attributes */
                 test_attr_bug4(my_fcpl, my_fapl);               /* Test attributes on named datatypes */
                 test_attr_bug5(my_fcpl, my_fapl);               /* Test opening/closing attributes through different file handles */
-                test_attr_bug6(my_fcpl, my_fapl);               /* Test reading empty attribute */ 
+                test_attr_bug6(my_fcpl, my_fapl);               /* Test reading empty attribute */
             } /* end for */
         } /* end if */
         else {
@@ -10371,7 +10371,7 @@ test_attr(void)
             test_attr_bug3(fcpl, my_fapl);                      /* Test "self referential" attributes */
             test_attr_bug4(fcpl, my_fapl);                      /* Test attributes on named datatypes */
             test_attr_bug5(fcpl, my_fapl);                      /* Test opening/closing attributes through different file handles */
-            test_attr_bug6(fcpl, my_fapl);                      /* Test reading empty attribute */ 
+            test_attr_bug6(fcpl, my_fapl);                      /* Test reading empty attribute */
         } /* end else */
     } /* end for */
 
diff --git a/test/tconfig.c b/test/tconfig.c
index 6b8fd84..f3ac242 100644
--- a/test/tconfig.c
+++ b/test/tconfig.c
@@ -65,7 +65,7 @@ void test_exit_definitions(void);
  *              16 Dec 2009
  *              On Boeing's OpenVMS, the value of EXIT_FAILURE is 268435458.
  *              (The test is in test_exit_definitions.)  Their document says
- *              it's supposed to be 2.  I commented it out for OpenVMS for 
+ *              it's supposed to be 2.  I commented it out for OpenVMS for
  *              further consideration.
  *-------------------------------------------------------------------------
  */
diff --git a/test/tfile.c b/test/tfile.c
index 342230f..2b354b5 100644
--- a/test/tfile.c
+++ b/test/tfile.c
@@ -2095,8 +2095,8 @@ test_cached_stab_info(void)
 /****************************************************************
 **
 **  test_rw_noupdate(): low-level file test routine.
-**      This test checks to ensure that opening and closing a file 
-**      with read/write permissions does not write anything to the 
+**      This test checks to ensure that opening and closing a file
+**      with read/write permissions does not write anything to the
 **      file if the file does not change.
 **
 **  Programmer: Mike McGreevy
@@ -2533,8 +2533,8 @@ test_userblock_alignment(void)
 
 /****************************************************************
 **
-**  test_free_sections(): 
-**      This routine does the actual work of checking information for 
+**  test_free_sections():
+**      This routine does the actual work of checking information for
 **	free space sections available in a file in various situations.
 **
 *****************************************************************/
@@ -2636,7 +2636,7 @@ test_free_sections(hid_t fapl, char *fname)
     /* Verify the correct # of free-space sections */
     nsects = H5Fget_free_sections(file, H5FD_MEM_DEFAULT, (size_t)saved_nsects, saved_sect_info);
     VERIFY(nsects, saved_nsects, "H5Fget_free_sections");
-    
+
     /* Verify the amount of free-space is correct */
     total = 0;
     for(i = 0; i < nsects; i++)
@@ -2703,7 +2703,7 @@ test_free_sections(hid_t fapl, char *fname)
 
 /****************************************************************
 **
-**  test_filespace_sects(): 
+**  test_filespace_sects():
 **      This test checks free space section info for
 **	files created with sec2 and split drivers.
 **
@@ -2815,8 +2815,8 @@ test_filespace_sects(void)
 
 /****************************************************************
 **
-**  test_filespace_info(): 
-**	Verify that the public routines H5Pget/set_file_space() 
+**  test_filespace_info():
+**	Verify that the public routines H5Pget/set_file_space()
 **	retrieve and set the file space strategy and free space
 **	section threshold as specified.
 **
@@ -2939,7 +2939,7 @@ test_filespace_info(void)
 
 /****************************************************************
 **
-**  test_filespace_compatible(): 
+**  test_filespace_compatible():
 **	Verify that the branch with file space management enhancement
 **	can open, read and modify 1.6 HDF5 file and 1.8 HDF5 file.
 **	Also verify the correct file space strategy/threshold in use
@@ -3061,7 +3061,7 @@ test_filespace_compatible(void)
 
 /****************************************************************
 **
-**  test_deprec(): 
+**  test_deprec():
 **	Test deprecated functionality.
 **
 ****************************************************************/
diff --git a/test/tmisc.c b/test/tmisc.c
index 55e4c27..2752f42 100644
--- a/test/tmisc.c
+++ b/test/tmisc.c
@@ -5132,7 +5132,7 @@ test_misc29(void)
     CHECK(ret, -1, "h5_make_local_copy");
 
     /* Open the copied file */
-    fid = H5Fopen(MISC29_COPY_FILE, H5F_ACC_RDWR, H5P_DEFAULT); 
+    fid = H5Fopen(MISC29_COPY_FILE, H5F_ACC_RDWR, H5P_DEFAULT);
     CHECK(fid, FAIL, "H5Fopen");
 
     /* Delete the last dataset */
diff --git a/test/tsohm.c b/test/tsohm.c
index b5b489b..28854e2 100644
--- a/test/tsohm.c
+++ b/test/tsohm.c
@@ -3793,7 +3793,7 @@ test_sohm_extend_dset(void)
  * Function:    test_sohm_external_dtype
  *
  * Purpose:     When a datatype is a SOHM type in one file, test that the
- *              second file using the same datatype actually save it in 
+ *              second file using the same datatype actually save it in
  *              the file, too.
  *
  * Programmer:  Raymond Lu
@@ -3814,9 +3814,9 @@ test_sohm_external_dtype(void)
     hid_t fcpl, file1, file2;
     hid_t dataset1, dataset2;
     hid_t s1_tid, dset1_tid, dset2_tid, space;
-    hsize_t dims[2] = {NX, NY};    
+    hsize_t dims[2] = {NX, NY};
     H5T_class_t dtype_class;
-    size_t dmsg_count; 
+    size_t dmsg_count;
     unsigned x, i;
     herr_t ret;
 
@@ -3843,7 +3843,7 @@ test_sohm_external_dtype(void)
     /* Create a data type for s1_t */
     s1_tid = H5Tcreate(H5T_COMPOUND, sizeof(s1_t));
     CHECK_I(s1_tid, "H5Tcreate");
-    
+
     ret = H5Tinsert(s1_tid, "a", HOFFSET(s1_t,a), H5T_NATIVE_INT);
     CHECK_I(ret, "H5Tinsert");
 
@@ -3860,7 +3860,7 @@ test_sohm_external_dtype(void)
     VERIFY(dmsg_count, 0, "H5F_get_sohm_mesg_count_test");
 
     /* Create data set */
-    dataset1 = H5Dcreate2(file1, "dataset_1", s1_tid, space, H5P_DEFAULT, H5P_DEFAULT, 
+    dataset1 = H5Dcreate2(file1, "dataset_1", s1_tid, space, H5P_DEFAULT, H5P_DEFAULT,
         H5P_DEFAULT);
     CHECK_I(dataset1, "H5Dcreate2");
 
@@ -3880,7 +3880,7 @@ test_sohm_external_dtype(void)
         s_ptr->a = i*3 + 1;
         s_ptr->b = i*3 + 2;
     }
-    
+
     /* Write the data to the dataset1 */
     ret = H5Dwrite(dataset1, s1_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, orig);
     CHECK_I(ret, "H5Dwrite");
@@ -3898,7 +3898,7 @@ test_sohm_external_dtype(void)
     VERIFY(dmsg_count, 0, "H5F_get_sohm_mesg_count_test");
 
     /* Create a data set using the datatype of the dataset in the first file. */
-    dataset2 = H5Dcreate2(file2, "dataset_2", dset1_tid, space, H5P_DEFAULT, H5P_DEFAULT, 
+    dataset2 = H5Dcreate2(file2, "dataset_2", dset1_tid, space, H5P_DEFAULT, H5P_DEFAULT,
         H5P_DEFAULT);
     CHECK_I(dataset2, "H5Dcreate2");
 
@@ -3914,7 +3914,7 @@ test_sohm_external_dtype(void)
     ret = H5Dclose(dataset2);
     CHECK_I(ret, "H5Dclose");
 
-    /* Close file 1 and the dataset's datatype in file 1.  Verify that the datatype in 
+    /* Close file 1 and the dataset's datatype in file 1.  Verify that the datatype in
      * file 2 is still accessible. */
     ret = H5Tclose(dset1_tid);
     CHECK_I(ret, "H5Tclose");
diff --git a/test/vfd.c b/test/vfd.c
index bd642be..12ce04e 100644
--- a/test/vfd.c
+++ b/test/vfd.c
@@ -873,7 +873,7 @@ test_family_compat(void)
 error:
     H5E_BEGIN_TRY {
         H5Fclose(file);
-        H5Pclose(fapl); 
+        H5Pclose(fapl);
     } H5E_END_TRY;
 
     return -1;