Cleanup overuse of include files

1 files changed, 1372 insertions, 1373 deletions

diff --git a/testpar/t_cache.c b/testpar/t_cache.c
index 700e993..5768e35 100644
--- a/testpar/t_cache.c
+++ b/testpar/t_cache.c
@@ -16,12 +16,11 @@
  *
  */
 
-#include "h5test.h"
 #include "testpar.h"
 
-#define H5AC_FRIEND		/*suppress error about including H5ACpkg  */
-#define H5C_FRIEND		/*suppress error about including H5Cpkg   */
-#define H5F_FRIEND		/*suppress error about including H5Fpkg   */
+#define H5AC_FRIEND        /*suppress error about including H5ACpkg  */
+#define H5C_FRIEND        /*suppress error about including H5Cpkg   */
+#define H5F_FRIEND        /*suppress error about including H5Fpkg   */
 
 #include "H5ACpkg.h"
 #include "H5Cpkg.h"
@@ -33,9 +32,9 @@
 #define BASE_ADDR               (haddr_t)1024
 
 
-int     	nerrors = 0;
-int		failures = 0;
-hbool_t		verbose = TRUE; /* used to control error messages */
+int         nerrors = 0;
+int        failures = 0;
+hbool_t        verbose = TRUE; /* used to control error messages */
 
 #define NFILENAME 2
 #define PARATESTFILE filenames[0]
@@ -45,23 +44,23 @@ const char *FILENAME[NFILENAME]={"CacheTestDummy", NULL};
 #endif  /* !PATH_MAX */
 char    filenames[NFILENAME][PATH_MAX];
 hid_t   fapl;                           /* file access property list */
-haddr_t max_addr = 0;			/* used to store the end of
-					 * the address space used by
-					 * the data array (see below).
-					 */
-hbool_t callbacks_verbose = FALSE;	/* flag used to control whether
-					 * the callback functions are in
-					 * verbose mode.
-					 */
+haddr_t max_addr = 0;            /* used to store the end of
+                    * the address space used by
+                    * the data array (see below).
+                    */
+hbool_t callbacks_verbose = FALSE;    /* flag used to control whether
+                    * the callback functions are in
+                    * verbose mode.
+                    */
 
 
-int		world_mpi_size = -1;
-int		world_mpi_rank = -1;
-int		world_server_mpi_rank = -1;
-MPI_Comm	world_mpi_comm = MPI_COMM_NULL;
-int		file_mpi_size = -1;
-int		file_mpi_rank = -1;
-MPI_Comm	file_mpi_comm = MPI_COMM_NULL;
+int        world_mpi_size = -1;
+int        world_mpi_rank = -1;
+int        world_server_mpi_rank = -1;
+MPI_Comm    world_mpi_comm = MPI_COMM_NULL;
+int        file_mpi_size = -1;
+int        file_mpi_rank = -1;
+MPI_Comm    file_mpi_comm = MPI_COMM_NULL;
 
 
 /* the following globals are used to maintain rudementary statistics
@@ -74,67 +73,67 @@ long datum_destroys        = 0;
 long datum_flushes         = 0;
 long datum_pinned_flushes  = 0;
 long datum_loads           = 0;
-long global_pins	   = 0;
-long global_dirty_pins	   = 0;
-long local_pins		   = 0;
+long global_pins       = 0;
+long global_dirty_pins       = 0;
+long local_pins           = 0;
 
 
 /* the following fields are used by the server process only */
-int total_reads		   = 0;
+int total_reads           = 0;
 int total_writes           = 0;
 
 
 /*****************************************************************************
  * struct datum
  *
- *	Instances of struct datum are used to store information on entries
- *	that may be loaded into the cache.  The individual fields are
- *	discussed below:
+ *    Instances of struct datum are used to store information on entries
+ *    that may be loaded into the cache.  The individual fields are
+ *    discussed below:
  *
- *	header:	Instance of H5C_cache_entry_t used by the for its data.
- *		This field is only used on the file processes, not on the
- *		server process.
+ *    header:    Instance of H5C_cache_entry_t used by the for its data.
+ *        This field is only used on the file processes, not on the
+ *        server process.
  *
- *		This field MUST be the first entry in this structure.
+ *        This field MUST be the first entry in this structure.
  *
- *	base_addr: Base address of the entry.
+ *    base_addr: Base address of the entry.
  *
- *	len:	Length of the entry.
+ *    len:    Length of the entry.
  *
- *	local_len:  Length of the entry according to the cache.  This
- *		value must be positive, and may not be larger than len.
+ *    local_len:  Length of the entry according to the cache.  This
+ *        value must be positive, and may not be larger than len.
  *
- *		The field exists to allow us change the sizes of entries
- *		in the cache without upsetting the server.  This value
- *		is only used locally, and is never sent to the server.
+ *        The field exists to allow us change the sizes of entries
+ *        in the cache without upsetting the server.  This value
+ *        is only used locally, and is never sent to the server.
  *
- *	ver:	Version number of the entry.  This number is initialize
- *		to zero, and incremented each time the entry is modified.
+ *    ver:    Version number of the entry.  This number is initialize
+ *        to zero, and incremented each time the entry is modified.
  *
- *	dirty:	Boolean flag indicating whether the entry is dirty.
+ *    dirty:    Boolean flag indicating whether the entry is dirty.
  *
- *		For current purposes, an entry is clean until it is
- *		modified, and dirty until written to the server (cache
- *		on process 0) or until it is marked clean (all other
- *		caches).
+ *        For current purposes, an entry is clean until it is
+ *        modified, and dirty until written to the server (cache
+ *        on process 0) or until it is marked clean (all other
+ *        caches).
  *
- *	valid:	Boolean flag indicating whether the entry contains
- *		valid data.  Attempts to read an entry whose valid
- *		flag is not set should trigger an error.
+ *    valid:    Boolean flag indicating whether the entry contains
+ *        valid data.  Attempts to read an entry whose valid
+ *        flag is not set should trigger an error.
  *
- *	locked:	Boolean flag that is set to true iff the entry is in
- *		the cache and locked.
+ *    locked:    Boolean flag that is set to true iff the entry is in
+ *        the cache and locked.
  *
- *	global_pinned:	Boolean flag that is set to true iff the entry has
- *		been pinned collectively in all caches.  Since writes must
- *		be collective across all processes, only entries pinned
- *		in this fashion may be marked dirty.
+ *    global_pinned:    Boolean flag that is set to true iff the entry has
+ *        been pinned collectively in all caches.  Since writes must
+ *        be collective across all processes, only entries pinned
+ *        in this fashion may be marked dirty.
  *
- *	local_pinned:	Boolean flag that is set to true iff the entry
- *		has been pinned in the local cache, but probably not all
- *		caches.  Such pins will typically not be consistant across
- *		processes, and thus cannot be marked as dirty unless they
- *		happen to overlap some collective operation.
+ *    local_pinned:    Boolean flag that is set to true iff the entry
+ *        has been pinned in the local cache, but probably not all
+ *        caches.  Such pins will typically not be consistant across
+ *        processes, and thus cannot be marked as dirty unless they
+ *        happen to overlap some collective operation.
  *
  *      cleared: Boolean flag that is set to true whenever the entry is
  *              dirty, and is cleared via a call to datum_notify with the
@@ -143,61 +142,61 @@ int total_writes           = 0;
  *      flushed: Boolean flag that is set to true whenever the entry is
  *              dirty, and is flushed by the metadata cache.
  *
- *	reads:  Integer field used to maintain a count of the number of 
- *		times this entry has been read from the server since 
- *		the last time the read and write counts were reset.
+ *    reads:  Integer field used to maintain a count of the number of
+ *        times this entry has been read from the server since
+ *        the last time the read and write counts were reset.
  *
- *	writes: Integer field used to maintain a count of the number of 
- *		times this entry has been written to the server since 
- *		the last time the read and write counts were reset.
+ *    writes: Integer field used to maintain a count of the number of
+ *        times this entry has been written to the server since
+ *        the last time the read and write counts were reset.
  *
- *	index:	Index of this instance of datum in the data_index[] array
- *		discussed below.
+ *    index:    Index of this instance of datum in the data_index[] array
+ *        discussed below.
  *
- *	aux_ptr: Pointer to the instance of H5AC_aux_t associated with the
- *		instance of the metadata cache within which this entry
- *		resides.  This field was added to allow us to pass this 
- *		value to the notify callback from the serialize callback. 
- *		It should be NULL when not in use.
+ *    aux_ptr: Pointer to the instance of H5AC_aux_t associated with the
+ *        instance of the metadata cache within which this entry
+ *        resides.  This field was added to allow us to pass this
+ *        value to the notify callback from the serialize callback.
+ *        It should be NULL when not in use.
  *
  *****************************************************************************/
 
 struct datum
 {
-    H5C_cache_entry_t	header;
-    haddr_t		base_addr;
-    size_t		len;
-    size_t		local_len;
-    int			ver;
-    hbool_t		dirty;
-    hbool_t		valid;
-    hbool_t		locked;
-    hbool_t		global_pinned;
-    hbool_t		local_pinned;
-    hbool_t		cleared;
+    H5C_cache_entry_t    header;
+    haddr_t        base_addr;
+    size_t        len;
+    size_t        local_len;
+    int            ver;
+    hbool_t        dirty;
+    hbool_t        valid;
+    hbool_t        locked;
+    hbool_t        global_pinned;
+    hbool_t        local_pinned;
+    hbool_t        cleared;
     hbool_t             flushed;
-    int			reads;
-    int			writes;
-    int			index;
+    int            reads;
+    int            writes;
+    int            index;
     struct H5AC_aux_t * aux_ptr;
 };
 
 /*****************************************************************************
  * data array
  *
- *	The data array is an array of instances of datum of size
- *	NUM_DATA_ENTRIES that is used to track the particulars of all
- *	the entries that may be loaded into the cache.
+ *    The data array is an array of instances of datum of size
+ *    NUM_DATA_ENTRIES that is used to track the particulars of all
+ *    the entries that may be loaded into the cache.
  *
- *	It exists on all processes, although the master copy is maintained
- *	by the server process.  If the cache is performing correctly, all
- *	versions should be effectively identical.  By that I mean that
- *	the data received from the server should always match that in
- *	the local version of the data array.
+ *    It exists on all processes, although the master copy is maintained
+ *    by the server process.  If the cache is performing correctly, all
+ *    versions should be effectively identical.  By that I mean that
+ *    the data received from the server should always match that in
+ *    the local version of the data array.
  *
  *****************************************************************************/
 
-#define NUM_DATA_ENTRIES	100000
+#define NUM_DATA_ENTRIES    100000
 
 struct datum data[NUM_DATA_ENTRIES];
 
@@ -216,10 +215,10 @@ struct datum data[NUM_DATA_ENTRIES];
  * Further, this value must be consistant across all processes.
  */
 
-#define STD_VIRT_NUM_DATA_ENTRIES	NUM_DATA_ENTRIES
-#define EXPRESS_VIRT_NUM_DATA_ENTRIES	(NUM_DATA_ENTRIES / 10)
+#define STD_VIRT_NUM_DATA_ENTRIES    NUM_DATA_ENTRIES
+#define EXPRESS_VIRT_NUM_DATA_ENTRIES    (NUM_DATA_ENTRIES / 10)
 /* Use a smaller test size to avoid creating huge MPE logfiles. */
-#define MPE_VIRT_NUM_DATA_ENTIES	(NUM_DATA_ENTRIES / 100)
+#define MPE_VIRT_NUM_DATA_ENTIES    (NUM_DATA_ENTRIES / 100)
 
 int virt_num_data_entries = NUM_DATA_ENTRIES;
 
@@ -227,14 +226,14 @@ int virt_num_data_entries = NUM_DATA_ENTRIES;
 /*****************************************************************************
  * data_index array
  *
- *	The data_index array is an array of integer used to maintain a list
- *	of instances of datum in the data array in increasing base_addr order.
+ *    The data_index array is an array of integer used to maintain a list
+ *    of instances of datum in the data array in increasing base_addr order.
  *
- *	This array is necessary, as move operations can swap the values
- *	of the base_addr fields of two instances of datum.  Without this
- *	array, we would no longer be able to use a binary search on a sorted
- *	list to find the indexes of instances of datum given the values of
- *	their base_addr fields.
+ *    This array is necessary, as move operations can swap the values
+ *    of the base_addr fields of two instances of datum.  Without this
+ *    array, we would no longer be able to use a binary search on a sorted
+ *    list to find the indexes of instances of datum given the values of
+ *    their base_addr fields.
  *
  *****************************************************************************/
 
@@ -243,99 +242,99 @@ int data_index[NUM_DATA_ENTRIES];
 
 /*****************************************************************************
  * The following two #defines are used to control code that is in turn used
- * to force "POSIX" semantics on the server process used to simulate metadata 
- * reads and writes.  Without some such mechanism, the test code contains 
+ * to force "POSIX" semantics on the server process used to simulate metadata
+ * reads and writes.  Without some such mechanism, the test code contains
  * race conditions that will frequently cause spurious failures.
  *
  * When set to TRUE, DO_WRITE_REQ_ACK forces the server to send an ack after
- * each write request, and the client to wait until the ack is received 
+ * each write request, and the client to wait until the ack is received
  * before proceeding.  This was my first solution to the problem, and at
  * first glance, it would seem to have a lot of unnecessary overhead.
  *
  * In an attempt to reduce the overhead, I implemented a second solution
- * in which no acks are sent after writes.  Instead, the metadata cache is 
- * provided with a callback function to call after each sequence of writes.  
- * This callback simply causes the client to send the server process a 
+ * in which no acks are sent after writes.  Instead, the metadata cache is
+ * provided with a callback function to call after each sequence of writes.
+ * This callback simply causes the client to send the server process a
  * "sync" message and and await an ack in reply.
  *
- * Strangely, at least on Phoenix, the first solution runs faster by a 
- * rather large margin.  However, I can imagine this changing with 
+ * Strangely, at least on Phoenix, the first solution runs faster by a
+ * rather large margin.  However, I can imagine this changing with
  * different OS's and MPI implementatins.
  *
- * Thus I have left code supporting the second solution in place.  
+ * Thus I have left code supporting the second solution in place.
  *
- * Note that while one of these two #defines must be set to TRUE, there 
- * should never be any need to set both of them to TRUE (although the 
+ * Note that while one of these two #defines must be set to TRUE, there
+ * should never be any need to set both of them to TRUE (although the
  * tests will still function with this setting).
  *****************************************************************************/
 
-#define DO_WRITE_REQ_ACK	TRUE
-#define DO_SYNC_AFTER_WRITE	FALSE
+#define DO_WRITE_REQ_ACK    TRUE
+#define DO_SYNC_AFTER_WRITE    FALSE
 
 
 /*****************************************************************************
  * struct mssg
  *
- *	The mssg structure is used as a generic container for messages to
- *	and from the server.  Not all fields are used in all cases.
+ *    The mssg structure is used as a generic container for messages to
+ *    and from the server.  Not all fields are used in all cases.
  *
- *	req:	Integer field containing the type of the message.
+ *    req:    Integer field containing the type of the message.
  *
- *	src:	World communicator MPI rank of the sending process.
+ *    src:    World communicator MPI rank of the sending process.
  *
- *	dest:	World communicator MPI rank of the destination process.
+ *    dest:    World communicator MPI rank of the destination process.
  *
- *	mssg_num:	Serial number assigned to the message by the sender.
+ *    mssg_num:    Serial number assigned to the message by the sender.
  *
- *	base_addr:	Base address of a datum.  Not used in all mssgs.
+ *    base_addr:    Base address of a datum.  Not used in all mssgs.
  *
- *	len:	Length of a datum (in bytes).  Not used in all mssgs.
+ *    len:    Length of a datum (in bytes).  Not used in all mssgs.
  *
- *	ver:	Version number of a datum.  Not used in all mssgs.
+ *    ver:    Version number of a datum.  Not used in all mssgs.
  *
- *	count:  Reported number of total/entry reads/writes.  Not used
- *		in all mssgs.
+ *    count:  Reported number of total/entry reads/writes.  Not used
+ *        in all mssgs.
  *
- *	magic:	Magic number for error detection.  Must be set to
- *		MSSG_MAGIC.
+ *    magic:    Magic number for error detection.  Must be set to
+ *        MSSG_MAGIC.
  *
  *****************************************************************************/
 
-#define	WRITE_REQ_CODE			 0
-#define	WRITE_REQ_ACK_CODE		 1
-#define READ_REQ_CODE			 2
-#define READ_REQ_REPLY_CODE		 3
-#define SYNC_REQ_CODE			 4
-#define SYNC_ACK_CODE			 5
-#define REQ_TTL_WRITES_CODE		 6
-#define REQ_TTL_WRITES_RPLY_CODE 	 7
-#define REQ_TTL_READS_CODE		 8
-#define REQ_TTL_READS_RPLY_CODE 	 9
-#define REQ_ENTRY_WRITES_CODE		10
-#define REQ_ENTRY_WRITES_RPLY_CODE 	11
-#define REQ_ENTRY_READS_CODE		12
-#define REQ_ENTRY_READS_RPLY_CODE 	13
-#define REQ_RW_COUNT_RESET_CODE		14
-#define REQ_RW_COUNT_RESET_RPLY_CODE	15
-#define DONE_REQ_CODE			16
-#define MAX_REQ_CODE			16
-
-#define MSSG_MAGIC	0x1248
+#define    WRITE_REQ_CODE             0
+#define    WRITE_REQ_ACK_CODE         1
+#define READ_REQ_CODE             2
+#define READ_REQ_REPLY_CODE         3
+#define SYNC_REQ_CODE             4
+#define SYNC_ACK_CODE             5
+#define REQ_TTL_WRITES_CODE         6
+#define REQ_TTL_WRITES_RPLY_CODE      7
+#define REQ_TTL_READS_CODE         8
+#define REQ_TTL_READS_RPLY_CODE      9
+#define REQ_ENTRY_WRITES_CODE        10
+#define REQ_ENTRY_WRITES_RPLY_CODE     11
+#define REQ_ENTRY_READS_CODE        12
+#define REQ_ENTRY_READS_RPLY_CODE     13
+#define REQ_RW_COUNT_RESET_CODE        14
+#define REQ_RW_COUNT_RESET_RPLY_CODE    15
+#define DONE_REQ_CODE            16
+#define MAX_REQ_CODE            16
+
+#define MSSG_MAGIC    0x1248
 
 struct mssg_t
 {
-    int		req;
-    int		src;
-    int		dest;
-    long int	mssg_num;
-    haddr_t	base_addr;
-    unsigned	len;
-    int		ver;
-    unsigned	count;
-    unsigned	magic;
+    int        req;
+    int        src;
+    int        dest;
+    long int    mssg_num;
+    haddr_t    base_addr;
+    unsigned    len;
+    int        ver;
+    unsigned    count;
+    unsigned    magic;
 };
 
-MPI_Datatype mpi_mssg_t;	/* for MPI derived type created from mssg */
+MPI_Datatype mpi_mssg_t;    /* for MPI derived type created from mssg */
 
 
 /*****************************************************************************/
@@ -409,24 +408,24 @@ static herr_t datum_notify(H5C_notify_action_t action, void *thing);
 static herr_t datum_free_icr(void * thing);
 
 /* Masquerade as object header entries to the cache */
-#define DATUM_ENTRY_TYPE	H5AC_OHDR_ID
+#define DATUM_ENTRY_TYPE    H5AC_OHDR_ID
 
-#define NUMBER_OF_ENTRY_TYPES	1
+#define NUMBER_OF_ENTRY_TYPES    1
 
 
 /* Note the use of the H5AC__CLASS_SKIP_READS and H5AC__CLASS_SKIP_WRITES
  * flags.  As a result of these flags, the metadata cache does no file I/O
  * on metadata of the datum type.
  *
- * Instead, this test uses a server process to keep track of who has 
+ * Instead, this test uses a server process to keep track of who has
  * written and read what, and to verify that there are no messages from
  * the past / future.
  *
- * In the callbacks for the version 2 cache, this activity was hidden in 
+ * In the callbacks for the version 2 cache, this activity was hidden in
  * the load and flush callbacks.  However, now we handle this function in
  * notify callbacks for the after load and after flush events.
  *
- *					     JRM -- 1/13/15
+ *                         JRM -- 1/13/15
  */
 const H5C_class_t types[NUMBER_OF_ENTRY_TYPES] =
 {
@@ -474,9 +473,9 @@ static void pin_protected_entry(int32_t idx, hbool_t global);
 static void move_entry(H5F_t * file_ptr, int32_t old_idx, int32_t new_idx);
 static hbool_t reset_server_counts(void);
 static void resize_entry(int32_t idx, size_t  new_size);
-static hbool_t setup_cache_for_test(hid_t * fid_ptr, 
+static hbool_t setup_cache_for_test(hid_t * fid_ptr,
                              H5F_t ** file_ptr_ptr,
-                             H5C_t ** cache_ptr_ptr, 
+                             H5C_t ** cache_ptr_ptr,
                              int metadata_write_strategy);
 static void setup_rand(void);
 static hbool_t take_down_cache(hid_t fid, H5C_t * cache_ptr);
@@ -550,17 +549,17 @@ print_stats(void)
 
 /*****************************************************************************
  *
- * Function:	reset_stats()
+ * Function:    reset_stats()
  *
- * Purpose:	Reset the rudementary stats maintained by t_cache.
+ * Purpose:    Reset the rudementary stats maintained by t_cache.
  *
- * Return:	void
+ * Return:    void
  *
- * Programmer:	JRM -- 4/17/06
+ * Programmer:    JRM -- 4/17/06
  *
  * Modifications:
  *
- *		None.
+ *        None.
  *
  *****************************************************************************/
 
@@ -573,9 +572,9 @@ reset_stats(void)
     datum_flushes         = 0;
     datum_pinned_flushes  = 0;
     datum_loads           = 0;
-    global_pins		  = 0;
-    global_dirty_pins	  = 0;
-    local_pins		  = 0;
+    global_pins          = 0;
+    global_dirty_pins      = 0;
+    local_pins          = 0;
 
     return;
 
@@ -588,20 +587,20 @@ reset_stats(void)
 
 /*****************************************************************************
  *
- * Function:	set_up_file_communicator()
+ * Function:    set_up_file_communicator()
  *
- * Purpose:	Create the MPI communicator used to open a HDF5 file with.
- *		In passing, also initialize the file_mpi... globals.
+ * Purpose:    Create the MPI communicator used to open a HDF5 file with.
+ *        In passing, also initialize the file_mpi... globals.
  *
- * Return:	Success:	TRUE
+ * Return:    Success:    TRUE
  *
- *		Failure:	FALSE
+ *        Failure:    FALSE
  *
- * Programmer:	JRM -- 11/16/05
+ * Programmer:    JRM -- 11/16/05
  *
  * Modifications:
  *
- *		None.
+ *        None.
  *
  *****************************************************************************/
 
@@ -623,7 +622,7 @@ set_up_file_communicator(void)
 
             nerrors++;
             success = FALSE;
-	    if ( verbose ) {
+        if ( verbose ) {
                 fprintf(stdout,
                         "%d:%s: MPI_Comm_group() failed with error %d.\n",
                         world_mpi_rank, FUNC, mpi_result);
@@ -740,16 +739,16 @@ set_up_file_communicator(void)
 
 /*****************************************************************************
  *
- * Function:	addr_to_datum_index()
+ * Function:    addr_to_datum_index()
  *
- * Purpose:	Given the base address of a datum, find and return its index
- *		in the data array.
+ * Purpose:    Given the base address of a datum, find and return its index
+ *        in the data array.
  *
- * Return:	Success:	index of target datum.
+ * Return:    Success:    index of target datum.
  *
- *		Failure:	-1.
+ *        Failure:    -1.
  *
- * Programmer:	JRM -- 12/20/05
+ * Programmer:    JRM -- 12/20/05
  *
  *****************************************************************************/
 static int
@@ -787,16 +786,16 @@ addr_to_datum_index(haddr_t base_addr)
 
 /*****************************************************************************
  *
- * Function:	init_data()
+ * Function:    init_data()
  *
- * Purpose:	Initialize the data array, from which cache entries are
- *		loaded.
+ * Purpose:    Initialize the data array, from which cache entries are
+ *        loaded.
  *
- * Return:	Success:	TRUE
+ * Return:    Success:    TRUE
  *
- *		Failure:	FALSE
+ *        Failure:    FALSE
  *
- * Programmer:	JRM -- 12/20/05
+ * Programmer:    JRM -- 12/20/05
  *
  *****************************************************************************/
 static void
@@ -831,14 +830,14 @@ init_data(void)
         data[i].dirty         = FALSE;
         data[i].valid         = FALSE;
         data[i].locked        = FALSE;
-	data[i].global_pinned = FALSE;
-	data[i].local_pinned  = FALSE;
-	data[i].cleared       = FALSE;
+    data[i].global_pinned = FALSE;
+    data[i].local_pinned  = FALSE;
+    data[i].cleared       = FALSE;
         data[i].flushed       = FALSE;
         data[i].reads         = 0;
         data[i].writes        = 0;
-	data[i].index         = i;
-	data[i].aux_ptr       = NULL;
+    data[i].index         = i;
+    data[i].aux_ptr       = NULL;
 
         data_index[i]         = i;
 
@@ -862,22 +861,22 @@ init_data(void)
 
 /*****************************************************************************
  *
- * Function:	do_express_test()
+ * Function:    do_express_test()
  *
- * Purpose:	Do an MPI_Allreduce to obtain the maximum value returned
- * 		by GetTestExpress() across all processes.  Return this
- * 		value.
+ * Purpose:    Do an MPI_Allreduce to obtain the maximum value returned
+ *         by GetTestExpress() across all processes.  Return this
+ *         value.
  *
- * 		Envirmoment variables can be different across different
- * 		processes.  This function ensures that all processes agree
- * 		on whether to do an express test.
+ *         Envirmoment variables can be different across different
+ *         processes.  This function ensures that all processes agree
+ *         on whether to do an express test.
  *
- * Return:	Success:	Maximum of the values returned by
- * 				GetTestExpress() across	all processes.
+ * Return:    Success:    Maximum of the values returned by
+ *                 GetTestExpress() across    all processes.
  *
- *		Failure:	-1
+ *        Failure:    -1
  *
- * Programmer:	JRM -- 4/25/06
+ * Programmer:    JRM -- 4/25/06
  *
  *****************************************************************************/
 static int
@@ -913,19 +912,19 @@ do_express_test(void)
 
 /*****************************************************************************
  *
- * Function:	do_sync()
+ * Function:    do_sync()
  *
- * Purpose:	Ensure that all messages sent by this process have been
- * 		processed before proceeding.
+ * Purpose:    Ensure that all messages sent by this process have been
+ *         processed before proceeding.
  *
- * 		Do this by exchanging sync req / sync ack messages with
- * 		the server.
+ *         Do this by exchanging sync req / sync ack messages with
+ *         the server.
  *
- * 		Do nothing if nerrors is greater than zero.
+ *         Do nothing if nerrors is greater than zero.
  *
- * Return:	void
+ * Return:    void
  *
- * Programmer:	JRM -- 5/10/06
+ * Programmer:    JRM -- 5/10/06
  *
  *****************************************************************************/
 static void
@@ -937,7 +936,7 @@ do_sync(void)
     if ( nerrors <= 0 ) {
 
         /* compose the message */
-	mssg.req       = SYNC_REQ_CODE;
+    mssg.req       = SYNC_REQ_CODE;
         mssg.src       = world_mpi_rank;
         mssg.dest      = world_server_mpi_rank;
         mssg.mssg_num  = -1; /* set by send function */
@@ -947,10 +946,10 @@ do_sync(void)
         mssg.count     = 0;
         mssg.magic     = MSSG_MAGIC;
 
-	if ( ! send_mssg(&mssg, FALSE) ) {
+    if ( ! send_mssg(&mssg, FALSE) ) {
 
-	    nerrors++;
-	    if ( verbose ) {
+        nerrors++;
+        if ( verbose ) {
                 HDfprintf(stdout, "%d:%s: send_mssg() failed.\n",
                           world_mpi_rank, FUNC);
             }
@@ -959,24 +958,24 @@ do_sync(void)
 
     if ( nerrors <= 0 ) {
 
-	if ( ! recv_mssg(&mssg, SYNC_ACK_CODE) ) {
+    if ( ! recv_mssg(&mssg, SYNC_ACK_CODE) ) {
 
             nerrors++;
             if ( verbose ) {
                 HDfprintf(stdout, "%d:%s: recv_mssg() failed.\n",
                           world_mpi_rank, FUNC);
             }
-	} else if ( ( mssg.req != SYNC_ACK_CODE ) ||
+    } else if ( ( mssg.req != SYNC_ACK_CODE ) ||
                     ( mssg.src != world_server_mpi_rank ) ||
                     ( mssg.dest != world_mpi_rank ) ||
-		    ( mssg.magic != MSSG_MAGIC ) ) {
+            ( mssg.magic != MSSG_MAGIC ) ) {
 
             nerrors++;
-	    if ( verbose ) {
+        if ( verbose ) {
                 HDfprintf(stdout, "%d:%s: Bad data in sync ack.\n",
                           world_mpi_rank, FUNC);
             }
-	}
+    }
     }
 
     return;
@@ -986,17 +985,17 @@ do_sync(void)
 
 /*****************************************************************************
  *
- * Function:	get_max_nerrors()
+ * Function:    get_max_nerrors()
  *
- * Purpose:	Do an MPI_Allreduce to obtain the maximum value of nerrors
- *		across all processes.  Return this value.
+ * Purpose:    Do an MPI_Allreduce to obtain the maximum value of nerrors
+ *        across all processes.  Return this value.
  *
- * Return:	Success:	Maximum of the nerrors global variables across
- *				all processes.
+ * Return:    Success:    Maximum of the nerrors global variables across
+ *                all processes.
  *
- *		Failure:	-1
+ *        Failure:    -1
  *
- * Programmer:	JRM -- 1/3/06
+ * Programmer:    JRM -- 1/3/06
  *
  *****************************************************************************/
 static int
@@ -1033,29 +1032,29 @@ get_max_nerrors(void)
 
 /*****************************************************************************
  *
- * Function:	recv_mssg()
+ * Function:    recv_mssg()
  *
- * Purpose:	Receive a message from any process in the provided instance
- *		of struct mssg.
+ * Purpose:    Receive a message from any process in the provided instance
+ *        of struct mssg.
  *
- * Return:	Success:	TRUE
+ * Return:    Success:    TRUE
  *
- *		Failure:	FALSE
+ *        Failure:    FALSE
  *
- * Programmer:	JRM -- 12/22/05
+ * Programmer:    JRM -- 12/22/05
  *
  * Modifications:
  *
- * 		JRM -- 5/10/06
- *		Added mssg_tag_offset parameter and supporting code.
+ *         JRM -- 5/10/06
+ *        Added mssg_tag_offset parameter and supporting code.
  *
  *****************************************************************************/
 
-#define CACHE_TEST_TAG	99 /* different from any used by the library */
+#define CACHE_TEST_TAG    99 /* different from any used by the library */
 
 static hbool_t
 recv_mssg(struct mssg_t *mssg_ptr,
-	  int mssg_tag_offset)
+    int mssg_tag_offset)
 {
     hbool_t success = TRUE;
     int mssg_tag = CACHE_TEST_TAG;
@@ -1117,28 +1116,28 @@ recv_mssg(struct mssg_t *mssg_ptr,
 
 /*****************************************************************************
  *
- * Function:	send_mssg()
+ * Function:    send_mssg()
  *
- * Purpose:	Send the provided instance of mssg to the indicated target.
+ * Purpose:    Send the provided instance of mssg to the indicated target.
  *
- *		Note that all source and destination ranks are in the
- *		global communicator.
+ *        Note that all source and destination ranks are in the
+ *        global communicator.
  *
- * Return:	Success:	TRUE
+ * Return:    Success:    TRUE
  *
- *		Failure:	FALSE
+ *        Failure:    FALSE
  *
- * Programmer:	JRM -- 12/22/05
+ * Programmer:    JRM -- 12/22/05
  *
  * Modifications:
  *
- * 		JRM -- 5/10/06
- *		Added the add_req_to_tag parameter and supporting code.
+ *         JRM -- 5/10/06
+ *        Added the add_req_to_tag parameter and supporting code.
  *
  *****************************************************************************/
 static hbool_t
 send_mssg(struct mssg_t *mssg_ptr,
-	  hbool_t add_req_to_tag)
+    hbool_t add_req_to_tag)
 {
     hbool_t success = TRUE;
     int mssg_tag = CACHE_TEST_TAG;
@@ -1166,10 +1165,10 @@ send_mssg(struct mssg_t *mssg_ptr,
 
         mssg_ptr->mssg_num = mssg_num++;
 
-	if ( add_req_to_tag ) {
+    if ( add_req_to_tag ) {
 
-	    mssg_tag += mssg_ptr->req;
-	}
+        mssg_tag += mssg_ptr->req;
+    }
 
         result = MPI_Send((void *)mssg_ptr, 1, mpi_mssg_t,
                           mssg_ptr->dest, mssg_tag, world_mpi_comm);
@@ -1189,19 +1188,19 @@ send_mssg(struct mssg_t *mssg_ptr,
 
 } /* send_mssg() */
 
-
+
 /*****************************************************************************
  *
- * Function:	setup_derived_types()
+ * Function:    setup_derived_types()
  *
- * Purpose:	Set up the derived types used by the test bed.  At present,
- *		only the mpi_mssg derived type is needed.
+ * Purpose:    Set up the derived types used by the test bed.  At present,
+ *        only the mpi_mssg derived type is needed.
  *
- * Return:	Success:	TRUE
+ * Return:    Success:    TRUE
  *
- *		Failure:	FALSE
+ *        Failure:    FALSE
  *
- * Programmer:	JRM -- 12/22/05
+ * Programmer:    JRM -- 12/22/05
  *
  *****************************************************************************/
 static hbool_t
@@ -1278,19 +1277,19 @@ setup_derived_types(void)
 
 } /* setup_derived_types */
 
-
+
 /*****************************************************************************
  *
- * Function:	takedown_derived_types()
+ * Function:    takedown_derived_types()
  *
- * Purpose:	take down the derived types used by the test bed.  At present,
- *		only the mpi_mssg derived type is needed.
+ * Purpose:    take down the derived types used by the test bed.  At present,
+ *        only the mpi_mssg derived type is needed.
  *
- * Return:	Success:	TRUE
+ * Return:    Success:    TRUE
  *
- *		Failure:	FALSE
+ *        Failure:    FALSE
  *
- * Programmer:	JRM -- 12/22/05
+ * Programmer:    JRM -- 12/22/05
  *
  *****************************************************************************/
 static hbool_t
@@ -1322,16 +1321,16 @@ takedown_derived_types(void)
 
 /*****************************************************************************
  *
- * Function:	reset_server_counters()
+ * Function:    reset_server_counters()
  *
- * Purpose:	Reset the counters maintained by the server, doing a 
- *		sanity check in passing.
+ * Purpose:    Reset the counters maintained by the server, doing a
+ *        sanity check in passing.
  *
- * Return:	Success:	TRUE
+ * Return:    Success:    TRUE
  *
- *		Failure:	FALSE
+ *        Failure:    FALSE
  *
- * Programmer:	JRM -- 5/5/10
+ * Programmer:    JRM -- 5/5/10
  *
  *****************************************************************************/
 static hbool_t
@@ -1363,7 +1362,7 @@ reset_server_counters(void)
         nerrors++;
         if ( verbose ) {
             HDfprintf(stdout, "%d:%s: actual/total reads mismatch (%ld/%ld).\n",
-                      world_mpi_rank, FUNC, 
+                      world_mpi_rank, FUNC,
                       actual_total_reads, total_reads);
         }
     }
@@ -1374,7 +1373,7 @@ reset_server_counters(void)
         nerrors++;
         if ( verbose ) {
             HDfprintf(stdout, "%d:%s: actual/total writes mismatch (%ld/%ld).\n",
-                      world_mpi_rank, FUNC, 
+                      world_mpi_rank, FUNC,
                       actual_total_writes, total_writes);
         }
     }
@@ -1389,25 +1388,25 @@ reset_server_counters(void)
 
 /*****************************************************************************
  *
- * Function:	server_main()
+ * Function:    server_main()
  *
- * Purpose:	Main function for the server process.  This process exists
- *		to provide an independant view of the data array.
+ * Purpose:    Main function for the server process.  This process exists
+ *        to provide an independant view of the data array.
  *
- *		The function handles request from the other processes in
- *		the test until the count of done messages received equals
- *		the number of client processes.
+ *        The function handles request from the other processes in
+ *        the test until the count of done messages received equals
+ *        the number of client processes.
  *
- * Return:	Success:	TRUE
+ * Return:    Success:    TRUE
  *
- *		Failure:	FALSE
+ *        Failure:    FALSE
  *
- * Programmer:	JRM -- 12/22/05
+ * Programmer:    JRM -- 12/22/05
  *
  * Modifications:
  *
- * 		JRM -- 5/10/06
- *		Updated for sync message.
+ *         JRM -- 5/10/06
+ *        Updated for sync message.
  *
  *****************************************************************************/
 static hbool_t
@@ -1437,98 +1436,98 @@ server_main(void)
 
             switch ( mssg.req )
             {
-		case WRITE_REQ_CODE:
-		    success = serve_write_request(&mssg);
-		    break;
+        case WRITE_REQ_CODE:
+            success = serve_write_request(&mssg);
+            break;
 
-		case WRITE_REQ_ACK_CODE:
+        case WRITE_REQ_ACK_CODE:
                     success = FALSE;
                     if(verbose)
                         HDfprintf(stdout, "%s: Received write ack?!?.\n", FUNC);
-		    break;
+            break;
 
-		case READ_REQ_CODE:
+        case READ_REQ_CODE:
                     success = serve_read_request(&mssg);
-		    break;
+            break;
 
-		case READ_REQ_REPLY_CODE:
+        case READ_REQ_REPLY_CODE:
                     success = FALSE;
                     if(verbose)
                         HDfprintf(stdout, "%s: Received read req reply?!?.\n", FUNC);
-		    break;
+            break;
 
-		case SYNC_REQ_CODE:
+        case SYNC_REQ_CODE:
                     success = serve_sync_request(&mssg);
-		    break;
+            break;
 
-		case SYNC_ACK_CODE:
+        case SYNC_ACK_CODE:
                     success = FALSE;
                     if(verbose)
                         HDfprintf(stdout, "%s: Received sync ack?!?.\n", FUNC);
-		    break;
+            break;
 
-		case REQ_TTL_WRITES_CODE:
-		    success = serve_total_writes_request(&mssg);
-		    break;
+        case REQ_TTL_WRITES_CODE:
+            success = serve_total_writes_request(&mssg);
+            break;
 
-		case REQ_TTL_WRITES_RPLY_CODE:
+        case REQ_TTL_WRITES_RPLY_CODE:
                     success = FALSE;
                     if(verbose)
                         HDfprintf(stdout, "%s: Received total writes reply?!?.\n", FUNC);
-		    break;
+            break;
 
-		case REQ_TTL_READS_CODE:
-		    success = serve_total_reads_request(&mssg);
-		    break;
+        case REQ_TTL_READS_CODE:
+            success = serve_total_reads_request(&mssg);
+            break;
 
-		case REQ_TTL_READS_RPLY_CODE:
+        case REQ_TTL_READS_RPLY_CODE:
                     success = FALSE;
                     if(verbose)
                         HDfprintf(stdout, "%s: Received total reads reply?!?.\n", FUNC);
-		    break;
+            break;
 
-		case REQ_ENTRY_WRITES_CODE:
-		    success = serve_entry_writes_request(&mssg);
-		    break;
+        case REQ_ENTRY_WRITES_CODE:
+            success = serve_entry_writes_request(&mssg);
+            break;
 
-		case REQ_ENTRY_WRITES_RPLY_CODE:
+        case REQ_ENTRY_WRITES_RPLY_CODE:
                     success = FALSE;
                     if(verbose)
                         HDfprintf(stdout, "%s: Received entry writes reply?!?.\n", FUNC);
-		    break;
+            break;
 
-		case REQ_ENTRY_READS_CODE:
-		    success = serve_entry_reads_request(&mssg);
-		    break;
+        case REQ_ENTRY_READS_CODE:
+            success = serve_entry_reads_request(&mssg);
+            break;
 
-		case REQ_ENTRY_READS_RPLY_CODE:
+        case REQ_ENTRY_READS_RPLY_CODE:
                     success = FALSE;
                     if(verbose)
                         HDfprintf(stdout, "%s: Received entry reads reply?!?.\n", FUNC);
-		    break;
+            break;
 
-		case REQ_RW_COUNT_RESET_CODE:
-		    success = serve_rw_count_reset_request(&mssg);
-		    break;
+        case REQ_RW_COUNT_RESET_CODE:
+            success = serve_rw_count_reset_request(&mssg);
+            break;
 
-		case REQ_RW_COUNT_RESET_RPLY_CODE:
+        case REQ_RW_COUNT_RESET_RPLY_CODE:
                     success = FALSE;
                     if(verbose)
                         HDfprintf(stdout, "%s: Received RW count reset reply?!?.\n", FUNC);
-		    break;
+            break;
 
-		case DONE_REQ_CODE:
-		    done_count++;
-		    if(done_count >= file_mpi_size)
-			done = TRUE;
-		    break;
+        case DONE_REQ_CODE:
+            done_count++;
+            if(done_count >= file_mpi_size)
+            done = TRUE;
+            break;
 
-		default:
+        default:
                     nerrors++;
                     success = FALSE;
                     if(verbose)
-		        HDfprintf(stdout, "%d:%s: Unknown request code.\n", world_mpi_rank, FUNC);
-		    break;
+                HDfprintf(stdout, "%d:%s: Unknown request code.\n", world_mpi_rank, FUNC);
+            break;
             }
         }
     }
@@ -1537,23 +1536,23 @@ server_main(void)
 
 } /* server_main() */
 
-
+
 /*****************************************************************************
  *
- * Function:	serve_read_request()
+ * Function:    serve_read_request()
  *
- * Purpose:	Serve a read request.
+ * Purpose:    Serve a read request.
  *
- *		The function accepts a pointer to an instance of struct
- *		mssg_t as input.  If all sanity checks pass, it sends
- *		a copy of the indicated datum from the data array to
- *		the requesting process.
+ *        The function accepts a pointer to an instance of struct
+ *        mssg_t as input.  If all sanity checks pass, it sends
+ *        a copy of the indicated datum from the data array to
+ *        the requesting process.
  *
- * Return:	Success:	TRUE
+ * Return:    Success:    TRUE
  *
- *		Failure:	FALSE
+ *        Failure:    FALSE
  *
- * Programmer:	JRM -- 12/22/05
+ * Programmer:    JRM -- 12/22/05
  *
  *****************************************************************************/
 static hbool_t
@@ -1609,8 +1608,8 @@ serve_read_request(struct mssg_t * mssg_ptr)
                   "%d:%s: proc %d read invalid entry. idx/base_addr = %d/%a.\n",
                          world_mpi_rank, FUNC,
                          mssg_ptr->src,
-			target_index,
-			data[target_index].base_addr);
+            target_index,
+            data[target_index].base_addr);
             }
         } else {
 
@@ -1622,11 +1621,11 @@ serve_read_request(struct mssg_t * mssg_ptr)
             reply.base_addr = data[target_index].base_addr;
             reply.len       = data[target_index].len;
             reply.ver       = data[target_index].ver;
-	    reply.count     = 0;
+        reply.count     = 0;
             reply.magic     = MSSG_MAGIC;
 
-	    /* and update the counters */
-	    total_reads++;
+        /* and update the counters */
+        total_reads++;
             (data[target_index].reads)++;
         }
     }
@@ -1641,7 +1640,7 @@ serve_read_request(struct mssg_t * mssg_ptr)
         if ( success ) {
 
             HDfprintf(stdout, "%d read 0x%llx. len = %d. ver = %d.\n",
-                      (int)(mssg_ptr->src), 
+                      (int)(mssg_ptr->src),
                       (long long)(data[target_index].base_addr),
                       (int)(data[target_index].len),
                       (int)(data[target_index].ver));
@@ -1649,38 +1648,38 @@ serve_read_request(struct mssg_t * mssg_ptr)
         } else {
 
             HDfprintf(stdout, "%d read 0x%llx FAILED. len = %d. ver = %d.\n",
-                      (int)(mssg_ptr->src), 
+                      (int)(mssg_ptr->src),
                       (long long)(data[target_index].base_addr),
                       (int)(data[target_index].len),
                       (int)(data[target_index].ver));
 
         }
-    } 
+    }
 
     return(success);
 
 } /* serve_read_request() */
 
-
+
 /*****************************************************************************
  *
- * Function:	serve_sync_request()
+ * Function:    serve_sync_request()
  *
- * Purpose:	Serve a sync request.
+ * Purpose:    Serve a sync request.
  *
- *		The function accepts a pointer to an instance of struct
- *		mssg_t as input.  If all sanity checks pass, it sends a
- *		sync ack to the requesting process.
+ *        The function accepts a pointer to an instance of struct
+ *        mssg_t as input.  If all sanity checks pass, it sends a
+ *        sync ack to the requesting process.
  *
- *		This service exist to allow the sending process to ensure
- *		that all previous messages have been processed before
- *		proceeding.
+ *        This service exist to allow the sending process to ensure
+ *        that all previous messages have been processed before
+ *        proceeding.
  *
- * Return:	Success:	TRUE
+ * Return:    Success:    TRUE
  *
- *		Failure:	FALSE
+ *        Failure:    FALSE
  *
- * Programmer:	JRM -- 5/10/06
+ * Programmer:    JRM -- 5/10/06
  *
  *****************************************************************************/
 static hbool_t
@@ -1712,7 +1711,7 @@ serve_sync_request(struct mssg_t * mssg_ptr)
         reply.base_addr = 0;
         reply.len       = 0;
         reply.ver       = 0;
-	reply.count     = 0;
+    reply.count     = 0;
         reply.magic     = MSSG_MAGIC;
     }
 
@@ -1732,29 +1731,29 @@ serve_sync_request(struct mssg_t * mssg_ptr)
             HDfprintf(stdout, "%d sync FAILED.\n", (int)(mssg_ptr->src));
 
         }
-    } 
+    }
 
     return(success);
 
 } /* serve_sync_request() */
 
-
+
 /*****************************************************************************
  *
- * Function:	serve_write_request()
+ * Function:    serve_write_request()
  *
- * Purpose:	Serve a write request.
+ * Purpose:    Serve a write request.
  *
- *		The function accepts a pointer to an instance of struct
- *		mssg_t as input.  If all sanity checks pass, it updates
- *		the version number of the target data array entry as
- *		specified in the message.
+ *        The function accepts a pointer to an instance of struct
+ *        mssg_t as input.  If all sanity checks pass, it updates
+ *        the version number of the target data array entry as
+ *        specified in the message.
  *
- * Return:	Success:	TRUE
+ * Return:    Success:    TRUE
  *
- *		Failure:	FALSE
+ *        Failure:    FALSE
  *
- * Programmer:	JRM -- 12/21/05
+ * Programmer:    JRM -- 12/21/05
  *
  *****************************************************************************/
 static hbool_t
@@ -1812,7 +1811,7 @@ serve_write_request(struct mssg_t * mssg_ptr)
         new_ver_num = mssg_ptr->ver;
 
         /* this check should catch duplicate writes */
-	if ( new_ver_num <= data[target_index].ver ) {
+    if ( new_ver_num <= data[target_index].ver ) {
 
             nerrors++;
             success = FALSE;
@@ -1826,12 +1825,12 @@ serve_write_request(struct mssg_t * mssg_ptr)
 
     if ( success ) {
 
-	/* process the write */
+    /* process the write */
         data[target_index].ver = new_ver_num;
         data[target_index].valid = TRUE;
 
         /* and update the counters */
-	total_writes++;
+    total_writes++;
         (data[target_index].writes)++;
 
 #if DO_WRITE_REQ_ACK
@@ -1847,7 +1846,7 @@ serve_write_request(struct mssg_t * mssg_ptr)
         reply.count     = 0;
         reply.magic     = MSSG_MAGIC;
 
-	/* and send it */
+    /* and send it */
         success = send_mssg(&reply, TRUE);
 
 #endif /* DO_WRITE_REQ_ACK */
@@ -1859,7 +1858,7 @@ serve_write_request(struct mssg_t * mssg_ptr)
         if ( success ) {
 
             HDfprintf(stdout, "%d write 0x%llx. len = %d. ver = %d.\n",
-                      (int)(mssg_ptr->src), 
+                      (int)(mssg_ptr->src),
                       (long long)(data[target_index].base_addr),
                       (int)(data[target_index].len),
                       (int)(data[target_index].ver));
@@ -1867,36 +1866,36 @@ serve_write_request(struct mssg_t * mssg_ptr)
         } else {
 
             HDfprintf(stdout, "%d write 0x%llx FAILED. len = %d. ver = %d.\n",
-                      (int)(mssg_ptr->src), 
+                      (int)(mssg_ptr->src),
                       (long long)(data[target_index].base_addr),
                       (int)(data[target_index].len),
                       (int)(data[target_index].ver));
 
         }
-    } 
+    }
 
     return(success);
 
 } /* serve_write_request() */
 
-
+
 /*****************************************************************************
  *
- * Function:	serve_total_writes_request()
+ * Function:    serve_total_writes_request()
  *
- * Purpose:	Serve a request for the total number of writes recorded since
- *		the last reset.
+ * Purpose:    Serve a request for the total number of writes recorded since
+ *        the last reset.
  *
- *		The function accepts a pointer to an instance of struct
- *		mssg_t as input.  If all sanity checks pass, it sends
- *		the current value of the total_writes global variable to 
- *		the requesting process.
+ *        The function accepts a pointer to an instance of struct
+ *        mssg_t as input.  If all sanity checks pass, it sends
+ *        the current value of the total_writes global variable to
+ *        the requesting process.
  *
- * Return:	Success:	TRUE
+ * Return:    Success:    TRUE
  *
- *		Failure:	FALSE
+ *        Failure:    FALSE
  *
- * Programmer:	JRM -- 5/5/10
+ * Programmer:    JRM -- 5/5/10
  *
  *****************************************************************************/
 static hbool_t
@@ -1942,40 +1941,40 @@ serve_total_writes_request(struct mssg_t * mssg_ptr)
         if ( success ) {
 
             HDfprintf(stdout, "%d request total writes %ld.\n",
-                      (int)(mssg_ptr->src), 
+                      (int)(mssg_ptr->src),
                       total_writes);
 
         } else {
 
             HDfprintf(stdout, "%d request total writes %ld -- FAILED.\n",
-                      (int)(mssg_ptr->src), 
+                      (int)(mssg_ptr->src),
                       total_writes);
 
         }
-    } 
+    }
 
     return(success);
 
 } /* serve_total_writes_request() */
 
-
+
 /*****************************************************************************
  *
- * Function:	serve_total_reads_request()
+ * Function:    serve_total_reads_request()
  *
- * Purpose:	Serve a request for the total number of reads recorded since
- *		the last reset.
+ * Purpose:    Serve a request for the total number of reads recorded since
+ *        the last reset.
  *
- *		The function accepts a pointer to an instance of struct
- *		mssg_t as input.  If all sanity checks pass, it sends
- *		the current value of the total_reads global variable to 
- *		the requesting process.
+ *        The function accepts a pointer to an instance of struct
+ *        mssg_t as input.  If all sanity checks pass, it sends
+ *        the current value of the total_reads global variable to
+ *        the requesting process.
  *
- * Return:	Success:	TRUE
+ * Return:    Success:    TRUE
  *
- *		Failure:	FALSE
+ *        Failure:    FALSE
  *
- * Programmer:	JRM -- 5/5/10
+ * Programmer:    JRM -- 5/5/10
  *
  *****************************************************************************/
 static hbool_t
@@ -2021,40 +2020,40 @@ serve_total_reads_request(struct mssg_t * mssg_ptr)
         if ( success ) {
 
             HDfprintf(stdout, "%d request total reads %ld.\n",
-                      (int)(mssg_ptr->src), 
+                      (int)(mssg_ptr->src),
                       total_reads);
 
         } else {
 
             HDfprintf(stdout, "%d request total reads %ld -- FAILED.\n",
-                      (int)(mssg_ptr->src), 
+                      (int)(mssg_ptr->src),
                       total_reads);
 
         }
-    } 
+    }
 
     return(success);
 
 } /* serve_total_reads_request() */
 
-
+
 /*****************************************************************************
  *
- * Function:	serve_entry_writes_request()
+ * Function:    serve_entry_writes_request()
  *
- * Purpose:	Serve an entry writes request.
+ * Purpose:    Serve an entry writes request.
  *
- *		The function accepts a pointer to an instance of struct
- *		mssg_t as input.  If all sanity checks pass, it sends
- *		the number of times that the indicated datum has been 
- *		written since the last counter reset to the requesting 
- *		process.
+ *        The function accepts a pointer to an instance of struct
+ *        mssg_t as input.  If all sanity checks pass, it sends
+ *        the number of times that the indicated datum has been
+ *        written since the last counter reset to the requesting
+ *        process.
  *
- * Return:	Success:	TRUE
+ * Return:    Success:    TRUE
  *
- *		Failure:	FALSE
+ *        Failure:    FALSE
  *
- * Programmer:	JRM -- 5/5/10
+ * Programmer:    JRM -- 5/5/10
  *
  *****************************************************************************/
 static hbool_t
@@ -2101,7 +2100,7 @@ serve_entry_writes_request(struct mssg_t * mssg_ptr)
             reply.base_addr = target_addr;
             reply.len       = 0;
             reply.ver       = 0;
-	    reply.count     = data[target_index].writes;
+        reply.count     = data[target_index].writes;
             reply.magic     = MSSG_MAGIC;
         }
     }
@@ -2116,42 +2115,42 @@ serve_entry_writes_request(struct mssg_t * mssg_ptr)
         if ( success ) {
 
             HDfprintf(stdout, "%d request entry 0x%llx writes = %ld.\n",
-                      (int)(mssg_ptr->src), 
+                      (int)(mssg_ptr->src),
                       (long long)(data[target_index].base_addr),
                       (long)(data[target_index].writes));
 
         } else {
 
             HDfprintf(stdout, "%d request entry 0x%llx writes = %ld FAILED.\n",
-                      (int)(mssg_ptr->src), 
+                      (int)(mssg_ptr->src),
                       (long long)(data[target_index].base_addr),
                       (long)(data[target_index].writes));
 
         }
-    } 
+    }
 
     return(success);
 
 } /* serve_entry_writes_request() */
 
-
+
 /*****************************************************************************
  *
- * Function:	serve_entry_reads_request()
+ * Function:    serve_entry_reads_request()
  *
- * Purpose:	Serve an entry reads request.
+ * Purpose:    Serve an entry reads request.
  *
- *		The function accepts a pointer to an instance of struct
- *		mssg_t as input.  If all sanity checks pass, it sends
- *		the number of times that the indicated datum has been 
- *		read since the last counter reset to the requesting 
- *		process.
+ *        The function accepts a pointer to an instance of struct
+ *        mssg_t as input.  If all sanity checks pass, it sends
+ *        the number of times that the indicated datum has been
+ *        read since the last counter reset to the requesting
+ *        process.
  *
- * Return:	Success:	TRUE
+ * Return:    Success:    TRUE
  *
- *		Failure:	FALSE
+ *        Failure:    FALSE
  *
- * Programmer:	JRM -- 5/5/10
+ * Programmer:    JRM -- 5/5/10
  *
  *****************************************************************************/
 static hbool_t
@@ -2198,7 +2197,7 @@ serve_entry_reads_request(struct mssg_t * mssg_ptr)
             reply.base_addr = target_addr;
             reply.len       = 0;
             reply.ver       = 0;
-	    reply.count     = (long)(data[target_index].reads);
+        reply.count     = (long)(data[target_index].reads);
             reply.magic     = MSSG_MAGIC;
         }
     }
@@ -2213,41 +2212,41 @@ serve_entry_reads_request(struct mssg_t * mssg_ptr)
         if ( success ) {
 
             HDfprintf(stdout, "%d request entry 0x%llx reads = %ld.\n",
-                      (int)(mssg_ptr->src), 
+                      (int)(mssg_ptr->src),
                       (long long)(data[target_index].base_addr),
                       (long)(data[target_index].reads));
 
         } else {
 
             HDfprintf(stdout, "%d request entry 0x%llx reads = %ld FAILED.\n",
-                      (int)(mssg_ptr->src), 
+                      (int)(mssg_ptr->src),
                       (long long)(data[target_index].base_addr),
                       (long)(data[target_index].reads));
 
         }
-    } 
+    }
 
     return(success);
 
 } /* serve_entry_reads_request() */
 
-
+
 /*****************************************************************************
  *
- * Function:	serve_rw_count_reset_request()
+ * Function:    serve_rw_count_reset_request()
  *
- * Purpose:	Serve read/write count reset request.
+ * Purpose:    Serve read/write count reset request.
  *
- *		The function accepts a pointer to an instance of struct
- *		mssg_t as input.  If all sanity checks pass, it resets the
- *		read/write counters, and sends a confirmation message to 
- *		the calling process.
+ *        The function accepts a pointer to an instance of struct
+ *        mssg_t as input.  If all sanity checks pass, it resets the
+ *        read/write counters, and sends a confirmation message to
+ *        the calling process.
  *
- * Return:	Success:	TRUE
+ * Return:    Success:    TRUE
  *
- *		Failure:	FALSE
+ *        Failure:    FALSE
  *
- * Programmer:	JRM -- 5/5/10
+ * Programmer:    JRM -- 5/5/10
  *
  *****************************************************************************/
 static hbool_t
@@ -2272,7 +2271,7 @@ serve_rw_count_reset_request(struct mssg_t * mssg_ptr)
     if ( success ) {
 
         success = reset_server_counters();
-    } 
+    }
 
     if ( success ) {
 
@@ -2306,7 +2305,7 @@ serve_rw_count_reset_request(struct mssg_t * mssg_ptr)
                       (int)(mssg_ptr->src));
 
         }
-    } 
+    }
 
     return(success);
 
@@ -2317,15 +2316,15 @@ serve_rw_count_reset_request(struct mssg_t * mssg_ptr)
 /**************************** Call back functions ****************************/
 /*****************************************************************************/
 
-
+
 /*-------------------------------------------------------------------------
- * Function:	datum_get_initial_load_size
+ * Function:    datum_get_initial_load_size
  *
- * Purpose:	Query the image size for an entry before deserializing it
+ * Purpose:    Query the image size for an entry before deserializing it
  *
- * Return:	SUCCEED
+ * Return:    SUCCEED
  *
- * Programmer:	Quincey Koziol
+ * Programmer:    Quincey Koziol
  *              5/18/10
  *
  *-------------------------------------------------------------------------
@@ -2355,9 +2354,9 @@ datum_get_initial_load_size(void *udata_ptr, size_t *image_len_ptr)
     if ( callbacks_verbose ) {
 
         HDfprintf(stdout,
-	  "%d: get_initial_load_size() idx = %d, addr = %ld, len = %d.\n",
+    "%d: get_initial_load_size() idx = %d, addr = %ld, len = %d.\n",
               world_mpi_rank, idx, (long)addr, (int)entry_ptr->local_len);
-	fflush(stdout);
+    fflush(stdout);
     }
 
     /* Set image length size */
@@ -2366,15 +2365,15 @@ datum_get_initial_load_size(void *udata_ptr, size_t *image_len_ptr)
     return(SUCCEED);
 } /* get_initial_load_size() */
 
-
+
 /*-------------------------------------------------------------------------
- * Function:	datum_deserialize
+ * Function:    datum_deserialize
  *
- * Purpose:	deserialize the entry.
+ * Purpose:    deserialize the entry.
  *
- * Return:	void * (pointer to the in core representation of the entry)
+ * Return:    void * (pointer to the in core representation of the entry)
  *
- * Programmer:	John Mainzer
+ * Programmer:    John Mainzer
  *              9/20/07
  *
  *-------------------------------------------------------------------------
@@ -2409,10 +2408,10 @@ datum_deserialize(const void * image_ptr,
     if ( callbacks_verbose ) {
 
         HDfprintf(stdout,
-	  "%d: deserialize() idx = %d, addr = %ld, len = %d, is_dirty = %d.\n",
-	  world_mpi_rank, idx, (long)addr, (int)len,
-	  (int)(entry_ptr->header.is_dirty));
-	fflush(stdout);
+    "%d: deserialize() idx = %d, addr = %ld, len = %d, is_dirty = %d.\n",
+    world_mpi_rank, idx, (long)addr, (int)len,
+    (int)(entry_ptr->header.is_dirty));
+    fflush(stdout);
     }
 
     *dirty_ptr = FALSE;
@@ -2427,18 +2426,18 @@ datum_deserialize(const void * image_ptr,
 
 } /* deserialize() */
 
-
+
 /*-------------------------------------------------------------------------
- * Function:	datum_image_len
+ * Function:    datum_image_len
  *
- * Purpose:	Return the real (and possibly reduced) length of the image.
- * 		The helper functions verify that the correct version of
- * 		deserialize is being called, and then call deserialize
- * 		proper.
+ * Purpose:    Return the real (and possibly reduced) length of the image.
+ *         The helper functions verify that the correct version of
+ *         deserialize is being called, and then call deserialize
+ *         proper.
  *
- * Return:	SUCCEED
+ * Return:    SUCCEED
  *
- * Programmer:	John Mainzer
+ * Programmer:    John Mainzer
  *              9/19/07
  *
  *-------------------------------------------------------------------------
@@ -2465,10 +2464,10 @@ datum_image_len(const void *thing, size_t *image_len)
 
     if(callbacks_verbose) {
         HDfprintf(stdout,
-		  "%d: image_len() idx = %d, addr = %ld, len = %d.\n",
-		  world_mpi_rank, idx, (long)(entry_ptr->base_addr),
-		  (int)(entry_ptr->local_len));
-	fflush(stdout);
+        "%d: image_len() idx = %d, addr = %ld, len = %d.\n",
+        world_mpi_rank, idx, (long)(entry_ptr->base_addr),
+        (int)(entry_ptr->local_len));
+    fflush(stdout);
     }
 
     HDassert( entry_ptr->header.addr == entry_ptr->base_addr );
@@ -2478,15 +2477,15 @@ datum_image_len(const void *thing, size_t *image_len)
     return(SUCCEED);
 } /* datum_image_len() */
 
-
+
 /*-------------------------------------------------------------------------
- * Function:	datum_serialize
+ * Function:    datum_serialize
  *
- * Purpose:	Serialize the supplied entry.
+ * Purpose:    Serialize the supplied entry.
  *
- * Return:	SUCCEED if successful, FAIL otherwise.
+ * Return:    SUCCEED if successful, FAIL otherwise.
  *
- * Programmer:	John Mainzer
+ * Programmer:    John Mainzer
  *              10/30/07
  *
  *-------------------------------------------------------------------------
@@ -2511,11 +2510,11 @@ datum_serialize(const H5F_t *f,
     HDassert( f );
     HDassert( f->shared );
     HDassert( f->shared->cache );
-  
+
     cache_ptr = f->shared->cache;
 
     HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
-    HDassert( cache_ptr->aux_ptr ); 
+    HDassert( cache_ptr->aux_ptr );
 
     aux_ptr = (H5AC_aux_t *)(f->shared->cache->aux_ptr);
 
@@ -2534,9 +2533,9 @@ datum_serialize(const H5F_t *f,
     if ( callbacks_verbose ) {
 
         HDfprintf(stdout,
-		  "%d: serialize() idx = %d, addr = %ld, len = %d.\n",
-		  world_mpi_rank, idx, (long)entry_ptr->header.addr, (int)len);
-	fflush(stdout);
+        "%d: serialize() idx = %d, addr = %ld, len = %d.\n",
+        world_mpi_rank, idx, (long)entry_ptr->header.addr, (int)len);
+    fflush(stdout);
     }
 
     HDassert( entry_ptr->header.addr == entry_ptr->base_addr );
@@ -2557,16 +2556,16 @@ datum_serialize(const H5F_t *f,
 
 } /* datum_serialize() */
 
-
+
 /*-------------------------------------------------------------------------
- * Function:	datum_notify
+ * Function:    datum_notify
  *
- * Purpose:	Do the communication with the server we used to do in the 
- *		flush and load callbacks in the version 2 cache.
+ * Purpose:    Do the communication with the server we used to do in the
+ *        flush and load callbacks in the version 2 cache.
  *
- * Return:	SUCCEED
+ * Return:    SUCCEED
  *
- * Programmer:	John Mainzer
+ * Programmer:    John Mainzer
  *              1/12/15
  *
  *-------------------------------------------------------------------------
@@ -2596,7 +2595,7 @@ datum_notify(H5C_notify_action_t action, void *thing)
 
         HDfprintf(stdout,
                   "%d: notify() action = %d, idx = %d, addr = %ld.\n",
-                  world_mpi_rank, (int) action, idx, 
+                  world_mpi_rank, (int) action, idx,
                   (long)entry_ptr->header.addr);
         fflush(stdout);
     }
@@ -2685,62 +2684,62 @@ datum_notify(H5C_notify_action_t action, void *thing)
                     }
 
 #if 0 /* This has been useful debugging code -- keep it for now. */
-	            if ( mssg.req != READ_REQ_REPLY_CODE ) {
+                if ( mssg.req != READ_REQ_REPLY_CODE ) {
 
-		        HDfprintf(stdout, 
+                HDfprintf(stdout,
                                   "%d:%s: mssg.req != READ_REQ_REPLY_CODE.\n",
-			          world_mpi_rank, FUNC);
-		        HDfprintf(stdout, "%d:%s: mssg.req = %d.\n",
-			           world_mpi_rank, FUNC, (int)(mssg.req));
-	            }
+                    world_mpi_rank, FUNC);
+                HDfprintf(stdout, "%d:%s: mssg.req = %d.\n",
+                    world_mpi_rank, FUNC, (int)(mssg.req));
+                }
 
-	            if ( mssg.src != world_server_mpi_rank ) {
+                if ( mssg.src != world_server_mpi_rank ) {
 
-		        HDfprintf(stdout, 
+                HDfprintf(stdout,
                                  "%d:%s: mssg.src != world_server_mpi_rank.\n",
-			         world_mpi_rank, FUNC);
-	            }
+                    world_mpi_rank, FUNC);
+                }
 
-	            if ( mssg.dest != world_mpi_rank ) {
+                if ( mssg.dest != world_mpi_rank ) {
 
-		        HDfprintf(stdout, 
+                HDfprintf(stdout,
                                   "%d:%s: mssg.dest != world_mpi_rank.\n",
-			          world_mpi_rank, FUNC);
+                    world_mpi_rank, FUNC);
                     }
 
-	            if ( mssg.base_addr != entry_ptr->base_addr ) {
+                if ( mssg.base_addr != entry_ptr->base_addr ) {
 
-		        HDfprintf(stdout,
-		 	    "%d:%s: mssg.base_addr != entry_ptr->base_addr.\n",
-			    world_mpi_rank, FUNC);
-		        HDfprintf(stdout, "%d:%s: mssg.base_addr = %a.\n",
-			          world_mpi_rank, FUNC, mssg.base_addr);
-		        HDfprintf(stdout, 
+                HDfprintf(stdout,
+                "%d:%s: mssg.base_addr != entry_ptr->base_addr.\n",
+                world_mpi_rank, FUNC);
+                HDfprintf(stdout, "%d:%s: mssg.base_addr = %a.\n",
+                    world_mpi_rank, FUNC, mssg.base_addr);
+                HDfprintf(stdout,
                                   "%d:%s: entry_ptr->base_addr = %a.\n",
-			           world_mpi_rank, FUNC, 
+                    world_mpi_rank, FUNC,
                                    entry_ptr->base_addr);
                     }
 
-	            if ( mssg.len != entry_ptr->len ) {
+                if ( mssg.len != entry_ptr->len ) {
 
-		        HDfprintf(stdout, 
+                HDfprintf(stdout,
                                   "%d:%s: mssg.len != entry_ptr->len.\n",
-			          world_mpi_rank, FUNC);
-		        HDfprintf(stdout, "%d:%s: mssg.len = %a.\n",
-			          world_mpi_rank, FUNC, mssg.len);
+                    world_mpi_rank, FUNC);
+                HDfprintf(stdout, "%d:%s: mssg.len = %a.\n",
+                    world_mpi_rank, FUNC, mssg.len);
                     }
 
-	            if ( mssg.ver < entry_ptr->ver ) {
+                if ( mssg.ver < entry_ptr->ver ) {
 
-		        HDfprintf(stdout, 
+                HDfprintf(stdout,
                                   "%d:%s: mssg.ver < entry_ptr->ver.\n",
-			          world_mpi_rank, FUNC);
+                    world_mpi_rank, FUNC);
                     }
 
-	            if ( mssg.magic != MSSG_MAGIC ) {
+                if ( mssg.magic != MSSG_MAGIC ) {
 
-		        HDfprintf(stdout, "%d:%s: mssg.magic != MSSG_MAGIC.\n",
-			          world_mpi_rank, FUNC);
+                HDfprintf(stdout, "%d:%s: mssg.magic != MSSG_MAGIC.\n",
+                    world_mpi_rank, FUNC);
                      }
 #endif /* JRM */
 
@@ -2753,7 +2752,7 @@ datum_notify(H5C_notify_action_t action, void *thing)
             }
             break;
 
-	case H5C_NOTIFY_ACTION_AFTER_FLUSH:
+    case H5C_NOTIFY_ACTION_AFTER_FLUSH:
             if ( callbacks_verbose ) {
 
                 HDfprintf(stdout,
@@ -2767,11 +2766,11 @@ datum_notify(H5C_notify_action_t action, void *thing)
             aux_ptr = entry_ptr->aux_ptr;
             entry_ptr->aux_ptr = NULL;
 
-	    HDassert(entry_ptr->header.is_dirty); /* JRM */
+        HDassert(entry_ptr->header.is_dirty); /* JRM */
 
-            if ( ( file_mpi_rank != 0 ) && 
+            if ( ( file_mpi_rank != 0 ) &&
                  ( entry_ptr->dirty ) &&
-                 ( aux_ptr->metadata_write_strategy == 
+                 ( aux_ptr->metadata_write_strategy ==
                    H5AC_METADATA_WRITE_STRATEGY__PROCESS_0_ONLY ) ) {
 
                 ret_value = FAIL;
@@ -2784,8 +2783,8 @@ datum_notify(H5C_notify_action_t action, void *thing)
 
                 if ( entry_ptr->header.is_dirty ) {
 
-	            was_dirty = TRUE; /* so we will receive the ack 
-                                       * if requested 
+                was_dirty = TRUE; /* so we will receive the ack
+                                       * if requested
                                        */
 
                     /* compose the message */
@@ -2811,7 +2810,7 @@ datum_notify(H5C_notify_action_t action, void *thing)
                     else
                     {
                         entry_ptr->dirty = FALSE;
-			entry_ptr->flushed = TRUE;
+            entry_ptr->flushed = TRUE;
                     }
                 }
             }
@@ -2839,7 +2838,7 @@ datum_notify(H5C_notify_action_t action, void *thing)
                     nerrors++;
                     ret_value = FAIL;
                     if ( verbose ) {
-                        HDfprintf(stdout, 
+                        HDfprintf(stdout,
                                   "%d:%s: Bad data in write req ack.\n",
                                   world_mpi_rank, FUNC);
                     }
@@ -2855,7 +2854,7 @@ datum_notify(H5C_notify_action_t action, void *thing)
                 datum_pinned_flushes++;
                 HDassert(entry_ptr->global_pinned || entry_ptr->local_pinned);
             }
-	    break;
+        break;
 
         case H5AC_NOTIFY_ACTION_BEFORE_EVICT:
             if ( callbacks_verbose ) {
@@ -2950,33 +2949,33 @@ datum_notify(H5C_notify_action_t action, void *thing)
             /* do nothing */
             break;
 
-	default:
+    default:
             nerrors++;
             ret_value = FAIL;
             if ( verbose ) {
                 HDfprintf(stdout, "%d:%s: Unknown notify action.\n",
                           world_mpi_rank, FUNC);
             }
-	    break;
+        break;
     }
 
     return(ret_value);
 
 } /* datum_notify() */
 
-
+
 /*-------------------------------------------------------------------------
- * Function:	datum_free_icr
+ * Function:    datum_free_icr
  *
- * Purpose:	Nominally, this callback is supposed to free the
- * 		in core representation of the entry.
+ * Purpose:    Nominally, this callback is supposed to free the
+ *         in core representation of the entry.
  *
- * 		In the context of this test bed, we use it to do
- * 		do all the processing we used to do on a destroy.
+ *         In the context of this test bed, we use it to do
+ *         do all the processing we used to do on a destroy.
  *
- * Return:	SUCCEED
+ * Return:    SUCCEED
  *
- * Programmer:	John Mainzer
+ * Programmer:    John Mainzer
  *              9/19/07
  *
  *-------------------------------------------------------------------------
@@ -3001,9 +3000,9 @@ datum_free_icr(void * thing)
     if ( callbacks_verbose ) {
 
         HDfprintf(stdout,
-	  "%d: free_icr() idx = %d, dirty = %d.\n",
-		  world_mpi_rank, idx, (int)(entry_ptr->dirty));
-	fflush(stdout);
+    "%d: free_icr() idx = %d, dirty = %d.\n",
+        world_mpi_rank, idx, (int)(entry_ptr->dirty));
+    fflush(stdout);
     }
 
     HDassert( entry_ptr->header.addr == entry_ptr->base_addr );
@@ -3020,7 +3019,7 @@ datum_free_icr(void * thing)
     return(SUCCEED);
 } /* datum_free_icr() */
 
-
+
 /*****************************************************************************/
 /************************** test utility functions ***************************/
 /*****************************************************************************/
@@ -3029,9 +3028,9 @@ datum_free_icr(void * thing)
  * Function:    expunge_entry()
  *
  * Purpose:     Expunge the entry indicated by the type and index, mark it
- *		as clean, and don't increment its version number.
+ *        as clean, and don't increment its version number.
  *
- *		Do nothing if nerrors is non-zero on entry.
+ *        Do nothing if nerrors is non-zero on entry.
  *
  * Return:      void
  *
@@ -3062,36 +3061,36 @@ expunge_entry(H5F_t * file_ptr,
     if ( nerrors == 0 ) {
 
         result = H5AC_expunge_entry(file_ptr, (hid_t)-1, &(types[0]),
-			            entry_ptr->header.addr, H5AC__NO_FLAGS_SET);
+                        entry_ptr->header.addr, H5AC__NO_FLAGS_SET);
 
         if ( result < 0 ) {
 
             nerrors++;
             if ( verbose ) {
-	        HDfprintf(stdout, "%d:%s: Error in H5AC_expunge_entry().\n",
-	                  world_mpi_rank, FUNC);
+            HDfprintf(stdout, "%d:%s: Error in H5AC_expunge_entry().\n",
+                    world_mpi_rank, FUNC);
             }
         }
 
         HDassert( ((entry_ptr->header).type)->id == DATUM_ENTRY_TYPE );
-	HDassert( ! ((entry_ptr->header).is_dirty) );
+    HDassert( ! ((entry_ptr->header).is_dirty) );
 
-	result = H5C_get_entry_status(file_ptr, entry_ptr->base_addr,
-				      NULL, &in_cache, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+    result = H5C_get_entry_status(file_ptr, entry_ptr->base_addr,
+                    NULL, &in_cache, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 
-	if ( result < 0 ) {
+    if ( result < 0 ) {
 
             nerrors++;
             if ( verbose ) {
-	        HDfprintf(stdout, "%d:%s: Error in H5C_get_entry_status().\n",
-	                  world_mpi_rank, FUNC);
+            HDfprintf(stdout, "%d:%s: Error in H5C_get_entry_status().\n",
+                    world_mpi_rank, FUNC);
             }
         } else if ( in_cache ) {
 
             nerrors++;
             if ( verbose ) {
-	        HDfprintf(stdout, "%d:%s: Expunged entry still in cache?!?\n",
-	                  world_mpi_rank, FUNC);
+            HDfprintf(stdout, "%d:%s: Expunged entry still in cache?!?\n",
+                    world_mpi_rank, FUNC);
             }
         }
     }
@@ -3100,14 +3099,14 @@ expunge_entry(H5F_t * file_ptr,
 
 } /* expunge_entry() */
 
-
+
 /*****************************************************************************
  * Function:    insert_entry()
  *
  * Purpose:     Insert the entry indicated by the type and index, mark it
- *		as dirty, and increment its version number.
+ *        as dirty, and increment its version number.
  *
- *		Do nothing if nerrors is non-zero on entry.
+ *        Do nothing if nerrors is non-zero on entry.
  *
  * Return:      void
  *
@@ -3158,33 +3157,33 @@ insert_entry(H5C_t * cache_ptr,
 
             nerrors++;
             if ( verbose ) {
-	        HDfprintf(stdout, "%d:%s: Error in H5AC_insert_entry().\n",
-	                  world_mpi_rank, FUNC);
+            HDfprintf(stdout, "%d:%s: Error in H5AC_insert_entry().\n",
+                    world_mpi_rank, FUNC);
             }
         }
 
         if ( ! (entry_ptr->header.is_dirty) ) {
 
-	    /* it is possible that we just exceeded the dirty bytes
-	     * threshold, triggering a write of the newly inserted
-	     * entry.  Test for this, and only flag an error if this
-	     * is not the case.
-	     */
+        /* it is possible that we just exceeded the dirty bytes
+        * threshold, triggering a write of the newly inserted
+        * entry.  Test for this, and only flag an error if this
+        * is not the case.
+        */
 
-	    struct H5AC_aux_t * aux_ptr;
+        struct H5AC_aux_t * aux_ptr;
 
-	    aux_ptr = ((H5AC_aux_t *)(cache_ptr->aux_ptr));
+        aux_ptr = ((H5AC_aux_t *)(cache_ptr->aux_ptr));
 
-	    if ( ! ( ( aux_ptr != NULL ) &&
-		     ( aux_ptr->magic == H5AC__H5AC_AUX_T_MAGIC ) &&
-		     ( aux_ptr->dirty_bytes == 0 ) ) ) {
+        if ( ! ( ( aux_ptr != NULL ) &&
+            ( aux_ptr->magic == H5AC__H5AC_AUX_T_MAGIC ) &&
+            ( aux_ptr->dirty_bytes == 0 ) ) ) {
 
                 nerrors++;
                 if ( verbose ) {
-	            HDfprintf(stdout, "%d:%s: data[%d].header.is_dirty = %d.\n",
-	                      world_mpi_rank, FUNC, idx,
+                HDfprintf(stdout, "%d:%s: data[%d].header.is_dirty = %d.\n",
+                        world_mpi_rank, FUNC, idx,
                               (int)(data[idx].header.is_dirty));
-		}
+        }
             }
         }
 
@@ -3192,7 +3191,7 @@ insert_entry(H5C_t * cache_ptr,
 
             HDassert( entry_ptr->header.is_pinned );
             entry_ptr->global_pinned = TRUE;
-	    global_pins++;
+        global_pins++;
 
         } else {
 
@@ -3209,7 +3208,7 @@ insert_entry(H5C_t * cache_ptr,
 
 } /* insert_entry() */
 
-
+
 /*****************************************************************************
  * Function:    local_pin_and_unpin_random_entries()
  *
@@ -3228,8 +3227,8 @@ static void
 local_pin_and_unpin_random_entries(H5F_t * file_ptr,
                                    int min_idx,
                                    int max_idx,
-				   int min_count,
-				   int max_count)
+                int min_count,
+                int max_count)
 {
 
     if ( nerrors == 0 ) {
@@ -3244,40 +3243,40 @@ local_pin_and_unpin_random_entries(H5F_t * file_ptr,
         HDassert( min_idx < max_idx );
         HDassert( max_idx < NUM_DATA_ENTRIES );
         HDassert( max_idx < virt_num_data_entries );
-	HDassert( 0 <= min_count );
-	HDassert( min_count < max_count );
+    HDassert( 0 <= min_count );
+    HDassert( min_count < max_count );
 
-	count = (HDrand() % (max_count - min_count)) + min_count;
+    count = (HDrand() % (max_count - min_count)) + min_count;
 
-	HDassert( min_count <= count );
-	HDassert( count <= max_count );
+    HDassert( min_count <= count );
+    HDassert( count <= max_count );
 
-	for ( i = 0; i < count; i++ )
-	{
+    for ( i = 0; i < count; i++ )
+    {
             local_pin_random_entry(file_ptr, min_idx, max_idx);
-	}
+    }
 
-	count = (HDrand() % (max_count - min_count)) + min_count;
+    count = (HDrand() % (max_count - min_count)) + min_count;
 
-	HDassert( min_count <= count );
-	HDassert( count <= max_count );
+    HDassert( min_count <= count );
+    HDassert( count <= max_count );
 
         i = 0;
-	idx = 0;
+    idx = 0;
 
-	while ( ( i < count ) && ( idx >= 0 ) )
-	{
-	    via_unprotect = ( (((unsigned)i) & 0x0001) == 0 );
-	    idx = local_unpin_next_pinned_entry(file_ptr, idx, via_unprotect);
-	    i++;
-	}
+    while ( ( i < count ) && ( idx >= 0 ) )
+    {
+        via_unprotect = ( (((unsigned)i) & 0x0001) == 0 );
+        idx = local_unpin_next_pinned_entry(file_ptr, idx, via_unprotect);
+        i++;
+    }
     }
 
     return;
 
 } /* local_pin_and_unpin_random_entries() */
 
-
+
 /*****************************************************************************
  * Function:    local_pin_random_entry()
  *
@@ -3309,13 +3308,13 @@ local_pin_random_entry(H5F_t * file_ptr,
         HDassert( max_idx < NUM_DATA_ENTRIES );
         HDassert( max_idx < virt_num_data_entries );
 
-	do
-	{
-       	    idx = (HDrand() % (max_idx - min_idx)) + min_idx;
+    do
+    {
+            idx = (HDrand() % (max_idx - min_idx)) + min_idx;
             HDassert( min_idx <= idx );
             HDassert( idx <= max_idx );
-	}
-	while ( data[idx].global_pinned || data[idx].local_pinned );
+    }
+    while ( data[idx].global_pinned || data[idx].local_pinned );
 
         pin_entry(file_ptr, idx, FALSE, FALSE);
     }
@@ -3324,7 +3323,7 @@ local_pin_random_entry(H5F_t * file_ptr,
 
 } /* local_pin_random_entry() */
 
-
+
 /*****************************************************************************
  * Function:    local_unpin_all_entries()
  *
@@ -3340,7 +3339,7 @@ local_pin_random_entry(H5F_t * file_ptr,
  *****************************************************************************/
 static void
 local_unpin_all_entries(H5F_t * file_ptr,
-			hbool_t via_unprotect)
+            hbool_t via_unprotect)
 {
 
     if ( nerrors == 0 ) {
@@ -3349,25 +3348,25 @@ local_unpin_all_entries(H5F_t * file_ptr,
 
         HDassert( file_ptr );
 
-	idx = 0;
+    idx = 0;
 
-	while ( idx >= 0 )
-	{
-	    idx = local_unpin_next_pinned_entry(file_ptr,
-			                        idx, via_unprotect);
-	}
+    while ( idx >= 0 )
+    {
+        idx = local_unpin_next_pinned_entry(file_ptr,
+                                    idx, via_unprotect);
+    }
     }
 
     return;
 
 } /* local_unpin_all_entries() */
 
-
+
 /*****************************************************************************
  * Function:    local_unpin_next_pinned_entry()
  *
  * Purpose:     Find the next locally pinned entry after the specified
- * 		starting point, and unpin it.
+ *         starting point, and unpin it.
  *
  *              Do nothing if nerrors is non-zero on entry.
  *
@@ -3382,7 +3381,7 @@ local_unpin_all_entries(H5F_t * file_ptr,
 static int
 local_unpin_next_pinned_entry(H5F_t * file_ptr,
                               int start_idx,
-			      hbool_t via_unprotect)
+                hbool_t via_unprotect)
 {
     int i = 0;
     int idx = -1;
@@ -3394,39 +3393,39 @@ local_unpin_next_pinned_entry(H5F_t * file_ptr,
         HDassert( start_idx < NUM_DATA_ENTRIES );
         HDassert( start_idx < virt_num_data_entries );
 
-	idx = start_idx;
+    idx = start_idx;
 
-	while ( ( i < virt_num_data_entries ) &&
-		( ! ( data[idx].local_pinned ) ) )
-	{
-	    i++;
-	    idx++;
-	    if ( idx >= virt_num_data_entries ) {
-		idx = 0;
-	    }
-	}
+    while ( ( i < virt_num_data_entries ) &&
+        ( ! ( data[idx].local_pinned ) ) )
+    {
+        i++;
+        idx++;
+        if ( idx >= virt_num_data_entries ) {
+        idx = 0;
+        }
+    }
 
-	if ( data[idx].local_pinned ) {
+    if ( data[idx].local_pinned ) {
 
-	    unpin_entry(file_ptr, idx, FALSE, FALSE, via_unprotect);
+        unpin_entry(file_ptr, idx, FALSE, FALSE, via_unprotect);
 
-	} else {
+    } else {
 
-	    idx = -1;
-	}
+        idx = -1;
+    }
     }
 
     return(idx);
 
 } /* local_unpin_next_pinned_entry() */
 
-
+
 /*****************************************************************************
  * Function:    lock_and_unlock_random_entries()
  *
  * Purpose:     Obtain a random number in the closed interval [min_count,
- *		max_count].  Then protect and unprotect that number of
- *		random entries.
+ *        max_count].  Then protect and unprotect that number of
+ *        random entries.
  *
  *              Do nothing if nerrors is non-zero on entry.
  *
@@ -3467,12 +3466,12 @@ lock_and_unlock_random_entries(H5F_t * file_ptr,
 
 } /* lock_and_unlock_random_entries() */
 
-
+
 /*****************************************************************************
  * Function:    lock_and_unlock_random_entry()
  *
  * Purpose:     Protect and then unprotect a random entry with index in
- *		the data[] array in the close interval [min_idx, max_idx].
+ *        the data[] array in the close interval [min_idx, max_idx].
  *
  *              Do nothing if nerrors is non-zero on entry.
  *
@@ -3502,15 +3501,15 @@ lock_and_unlock_random_entry(H5F_t * file_ptr,
         HDassert( min_idx <= idx );
         HDassert( idx <= max_idx );
 
-	lock_entry(file_ptr, idx);
-	unlock_entry(file_ptr, idx, H5AC__NO_FLAGS_SET);
+    lock_entry(file_ptr, idx);
+    unlock_entry(file_ptr, idx, H5AC__NO_FLAGS_SET);
     }
 
     return;
 
 } /* lock_and_unlock_random_entry() */
 
-
+
 /*****************************************************************************
  * Function:    lock_entry()
  *
@@ -3525,9 +3524,9 @@ lock_and_unlock_random_entry(H5F_t * file_ptr,
  *
  * Modifications:
  *
- * 		JRM -- 7/11/06
- * 		Modified asserts to handle the new local_len field in
- * 		datum.
+ *         JRM -- 7/11/06
+ *         Modified asserts to handle the new local_len field in
+ *         datum.
  *
  *****************************************************************************/
 static void
@@ -3544,30 +3543,30 @@ lock_entry(H5F_t * file_ptr,
 
         entry_ptr = &(data[idx]);
 
-	HDassert( ! (entry_ptr->locked) );
+    HDassert( ! (entry_ptr->locked) );
 
-        cache_entry_ptr = (H5C_cache_entry_t *)H5AC_protect(file_ptr, 
+        cache_entry_ptr = (H5C_cache_entry_t *)H5AC_protect(file_ptr,
                                         H5AC_ind_read_dxpl_id,
                                         &(types[0]), entry_ptr->base_addr,
-                                        &entry_ptr->base_addr, 
+                                        &entry_ptr->base_addr,
                                         H5AC__NO_FLAGS_SET);
 
         if ( ( cache_entry_ptr != (void *)(&(entry_ptr->header)) ) ||
              ( entry_ptr->header.type != &(types[0]) ) ||
              ( ( entry_ptr->len != entry_ptr->header.size ) &&
-	       ( entry_ptr->local_len != entry_ptr->header.size ) ) ||
+        ( entry_ptr->local_len != entry_ptr->header.size ) ) ||
              ( entry_ptr->base_addr != entry_ptr->header.addr ) ) {
 
             nerrors++;
             if ( verbose ) {
-		HDfprintf(stdout, "%d:%s: error in H5AC_protect().\n",
-	                  world_mpi_rank, FUNC);
+        HDfprintf(stdout, "%d:%s: error in H5AC_protect().\n",
+                    world_mpi_rank, FUNC);
             }
         } else {
 
-	    entry_ptr->locked = TRUE;
+        entry_ptr->locked = TRUE;
 
-	}
+    }
 
         HDassert( ((entry_ptr->header).type)->id == DATUM_ENTRY_TYPE );
     }
@@ -3604,33 +3603,33 @@ mark_entry_dirty(int32_t idx)
         entry_ptr = &(data[idx]);
 
         HDassert ( entry_ptr->locked || entry_ptr->global_pinned );
-	HDassert ( ! (entry_ptr->local_pinned) );
+    HDassert ( ! (entry_ptr->local_pinned) );
 
         (entry_ptr->ver)++;
         entry_ptr->dirty = TRUE;
 
-	result = H5AC_mark_entry_dirty( (void *)entry_ptr);
+    result = H5AC_mark_entry_dirty( (void *)entry_ptr);
 
         if ( result < 0 ) {
 
             nerrors++;
             if ( verbose ) {
-	        HDfprintf(stdout,
+            HDfprintf(stdout,
                           "%d:%s: error in H5AC_mark_entry_dirty().\n",
                           world_mpi_rank, FUNC);
             }
         }
-	else if ( ! ( entry_ptr->locked ) )
-	{
-	    global_dirty_pins++;
-	}
+    else if ( ! ( entry_ptr->locked ) )
+    {
+        global_dirty_pins++;
+    }
     }
 
     return;
 
 } /* mark_entry_dirty() */
 
-
+
 /*****************************************************************************
  * Function:    pin_entry()
  *
@@ -3647,8 +3646,8 @@ mark_entry_dirty(int32_t idx)
 static void
 pin_entry(H5F_t * file_ptr,
           int32_t idx,
-	  hbool_t global,
-	  hbool_t dirty)
+    hbool_t global,
+    hbool_t dirty)
 {
     unsigned int flags = H5AC__PIN_ENTRY_FLAG;
     struct datum * entry_ptr;
@@ -3661,35 +3660,35 @@ pin_entry(H5F_t * file_ptr,
 
         entry_ptr = &(data[idx]);
 
-	HDassert ( ! (entry_ptr->global_pinned) );
-	HDassert ( ! (entry_ptr->local_pinned) );
-	HDassert ( ! ( dirty && ( ! global ) ) );
+    HDassert ( ! (entry_ptr->global_pinned) );
+    HDassert ( ! (entry_ptr->local_pinned) );
+    HDassert ( ! ( dirty && ( ! global ) ) );
 
-	lock_entry(file_ptr, idx);
+    lock_entry(file_ptr, idx);
 
-	if ( dirty ) {
+    if ( dirty ) {
 
-	    flags |= H5AC__DIRTIED_FLAG;
-	}
+        flags |= H5AC__DIRTIED_FLAG;
+    }
 
-	unlock_entry(file_ptr, idx, flags);
+    unlock_entry(file_ptr, idx, flags);
 
         HDassert( (entry_ptr->header).is_pinned );
-	HDassert( ( ! dirty ) || ( (entry_ptr->header).is_dirty ) );
+    HDassert( ( ! dirty ) || ( (entry_ptr->header).is_dirty ) );
 
-	if ( global ) {
+    if ( global ) {
 
-	    entry_ptr->global_pinned = TRUE;
+        entry_ptr->global_pinned = TRUE;
 
-	    global_pins++;
+        global_pins++;
 
-	} else {
+    } else {
 
-	    entry_ptr->local_pinned = TRUE;
+        entry_ptr->local_pinned = TRUE;
 
-	    local_pins++;
+        local_pins++;
 
-	}
+    }
     }
 
     return;
@@ -3697,14 +3696,14 @@ pin_entry(H5F_t * file_ptr,
 } /* pin_entry() */
 
 #ifdef H5_METADATA_TRACE_FILE
-
+
 /*****************************************************************************
  * Function:    pin_protected_entry()
  *
  * Purpose:     Insert the entry indicated by the type and index, mark it
- *		as dirty, and increment its version number.
+ *        as dirty, and increment its version number.
  *
- *		Do nothing if nerrors is non-zero on entry.
+ *        Do nothing if nerrors is non-zero on entry.
  *
  * Return:      void
  *
@@ -3714,7 +3713,7 @@ pin_entry(H5F_t * file_ptr,
  *****************************************************************************/
 static void
 pin_protected_entry(int32_t idx,
-		    hbool_t global)
+            hbool_t global)
 {
     herr_t result;
     struct datum * entry_ptr;
@@ -3728,36 +3727,36 @@ pin_protected_entry(int32_t idx,
 
     if ( nerrors == 0 ) {
 
-	result = H5AC_pin_protected_entry((void *)entry_ptr);
+    result = H5AC_pin_protected_entry((void *)entry_ptr);
 
         if ( ( result < 0 ) ||
              ( entry_ptr->header.type != &(types[0]) ) ||
              ( ( entry_ptr->len != entry_ptr->header.size ) &&
-	       ( entry_ptr->local_len != entry_ptr->header.size ) )||
+        ( entry_ptr->local_len != entry_ptr->header.size ) )||
              ( entry_ptr->base_addr != entry_ptr->header.addr ) ||
-	     ( ! ( (entry_ptr->header).is_pinned ) ) ) {
+        ( ! ( (entry_ptr->header).is_pinned ) ) ) {
 
             nerrors++;
             if ( verbose ) {
-	        HDfprintf(stdout,
-			  "%d:%s: Error in H5AC_pin_protected entry().\n",
-	                  world_mpi_rank, FUNC);
+            HDfprintf(stdout,
+            "%d:%s: Error in H5AC_pin_protected entry().\n",
+                    world_mpi_rank, FUNC);
             }
         }
 
         if ( global ) {
 
-	    entry_ptr->global_pinned = TRUE;
+        entry_ptr->global_pinned = TRUE;
 
-	    global_pins++;
+        global_pins++;
 
-	} else {
+    } else {
 
-	    entry_ptr->local_pinned = TRUE;
+        entry_ptr->local_pinned = TRUE;
 
-	    local_pins++;
+        local_pins++;
 
-	}
+    }
 
         HDassert( ((entry_ptr->header).type)->id == DATUM_ENTRY_TYPE );
     }
@@ -3767,16 +3766,16 @@ pin_protected_entry(int32_t idx,
 } /* pin_protected_entry() */
 #endif /* H5_METADATA_TRACE_FILE */
 
-
+
 /*****************************************************************************
  * Function:    move_entry()
  *
  * Purpose:     Move the entry indicated old_idx to the entry indicated
- *		by new_idex.  Touch up the data array so that flush will
- *		not choke.
+ *        by new_idex.  Touch up the data array so that flush will
+ *        not choke.
  *
- *		Do nothing if nerrors isn't zero, or if old_idx equals
- *		new_idx.
+ *        Do nothing if nerrors isn't zero, or if old_idx equals
+ *        new_idx.
  *
  * Return:      void
  *
@@ -3790,8 +3789,8 @@ move_entry(H5F_t * file_ptr,
            int32_t new_idx)
 {
     herr_t         result;
-    int		   tmp;
-    size_t	   tmp_len;
+    int           tmp;
+    size_t       tmp_len;
     haddr_t        old_addr = HADDR_UNDEF;
     haddr_t        new_addr = HADDR_UNDEF;
     struct datum * old_entry_ptr;
@@ -3819,12 +3818,12 @@ move_entry(H5F_t * file_ptr,
         /* Moving will mark the entry dirty if it is not already */
         old_entry_ptr->dirty = TRUE;
 
-        /* touch up versions, base_addrs, and data_index.  Do this 
-         * now as it is possible that the rename will trigger a 
+        /* touch up versions, base_addrs, and data_index.  Do this
+         * now as it is possible that the rename will trigger a
          * sync point.
          */
         if(old_entry_ptr->ver < new_entry_ptr->ver)
-	    old_entry_ptr->ver = new_entry_ptr->ver;
+        old_entry_ptr->ver = new_entry_ptr->ver;
         else
             (old_entry_ptr->ver)++;
 
@@ -3838,11 +3837,11 @@ move_entry(H5F_t * file_ptr,
         old_entry_ptr->index = new_entry_ptr->index;
         new_entry_ptr->index = tmp;
 
-	if(old_entry_ptr->local_len != new_entry_ptr->local_len) {
-	    tmp_len                  = old_entry_ptr->local_len;
-	    old_entry_ptr->local_len = new_entry_ptr->local_len;
-	    new_entry_ptr->local_len = tmp_len;
-	} /* end if */
+    if(old_entry_ptr->local_len != new_entry_ptr->local_len) {
+        tmp_len                  = old_entry_ptr->local_len;
+        old_entry_ptr->local_len = new_entry_ptr->local_len;
+        new_entry_ptr->local_len = tmp_len;
+    } /* end if */
 
         result = H5AC_move_entry(file_ptr, &(types[0]), old_addr, new_addr, H5AC_ind_read_dxpl_id);
 
@@ -3850,8 +3849,8 @@ move_entry(H5F_t * file_ptr,
 
             nerrors++;
             if ( verbose ) {
-		HDfprintf(stdout, "%d:%s: H5AC_move_entry() failed.\n",
-	                  world_mpi_rank, FUNC);
+        HDfprintf(stdout, "%d:%s: H5AC_move_entry() failed.\n",
+                    world_mpi_rank, FUNC);
             }
 
         } else {
@@ -3860,27 +3859,27 @@ move_entry(H5F_t * file_ptr,
 
             if ( ! (old_entry_ptr->header.is_dirty) ) {
 
-	        /* it is possible that we just exceeded the dirty bytes
-	         * threshold, triggering a write of the newly inserted
-	         * entry.  Test for this, and only flag an error if this
-	         * is not the case.
-	         */
+            /* it is possible that we just exceeded the dirty bytes
+            * threshold, triggering a write of the newly inserted
+            * entry.  Test for this, and only flag an error if this
+            * is not the case.
+            */
 
-	        struct H5AC_aux_t * aux_ptr;
+            struct H5AC_aux_t * aux_ptr;
 
-	        aux_ptr = ((H5AC_aux_t *)(file_ptr->shared->cache->aux_ptr));
+            aux_ptr = ((H5AC_aux_t *)(file_ptr->shared->cache->aux_ptr));
 
-	        if ( ! ( ( aux_ptr != NULL ) &&
-		         ( aux_ptr->magic == H5AC__H5AC_AUX_T_MAGIC ) &&
-		         ( aux_ptr->dirty_bytes == 0 ) ) ) {
+            if ( ! ( ( aux_ptr != NULL ) &&
+                ( aux_ptr->magic == H5AC__H5AC_AUX_T_MAGIC ) &&
+                ( aux_ptr->dirty_bytes == 0 ) ) ) {
 
                     nerrors++;
                     if ( verbose ) {
-	                HDfprintf(stdout, 
+                    HDfprintf(stdout,
                                   "%d:%s: data[%d].header.is_dirty = %d.\n",
-	                          world_mpi_rank, FUNC, new_idx,
+                            world_mpi_rank, FUNC, new_idx,
                                   (int)(data[new_idx].header.is_dirty));
-		    }
+            }
                 }
             } else {
 
@@ -3891,19 +3890,19 @@ move_entry(H5F_t * file_ptr,
 
 } /* move_entry() */
 
-
+
 /*****************************************************************************
  *
- * Function:	reset_server_counts()
+ * Function:    reset_server_counts()
  *
- * Purpose:	Send a message to the server process requesting it to reset
- *		its counters.  Await confirmation message.
+ * Purpose:    Send a message to the server process requesting it to reset
+ *        its counters.  Await confirmation message.
  *
- * Return:	Success:	TRUE
+ * Return:    Success:    TRUE
  *
- *		Failure:	FALSE
+ *        Failure:    FALSE
  *
- * Programmer:	JRM -- 5/6/10
+ * Programmer:    JRM -- 5/6/10
  *
  *****************************************************************************/
 static hbool_t
@@ -3958,7 +3957,7 @@ reset_server_counts(void)
             nerrors++;
             success = FALSE;
             if ( verbose ) {
-                HDfprintf(stdout, 
+                HDfprintf(stdout,
                           "%d:%s: Bad data in req r/w counter reset reply.\n",
                           world_mpi_rank, FUNC);
             }
@@ -3969,15 +3968,15 @@ reset_server_counts(void)
 
 } /* reset_server_counts() */
 
-
+
 /*****************************************************************************
  * Function:    resize_entry()
  *
  * Purpose:     Resize the pinned entry indicated by idx to the new_size.
- * 		Note that new_size must be greater than 0, and must be
- * 		less than or equal to the original size of the entry.
+ *         Note that new_size must be greater than 0, and must be
+ *         less than or equal to the original size of the entry.
  *
- *		Do nothing if nerrors isn't zero.
+ *        Do nothing if nerrors isn't zero.
  *
  * Return:      void
  *
@@ -3987,7 +3986,7 @@ reset_server_counts(void)
  *****************************************************************************/
 static void
 resize_entry(int32_t idx,
-	     size_t  new_size)
+        size_t  new_size)
 {
     herr_t         result;
     struct datum * entry_ptr;
@@ -4001,21 +4000,21 @@ resize_entry(int32_t idx,
 
         HDassert( ((entry_ptr->header).type)->id == DATUM_ENTRY_TYPE );
         HDassert( !(entry_ptr->locked) );
-	HDassert( ( entry_ptr->global_pinned ) &&
-		  ( ! entry_ptr->local_pinned ) );
-	HDassert( ( entry_ptr->header.size == entry_ptr->len ) ||
-	          ( entry_ptr->header.size == entry_ptr->local_len ) );
-	HDassert( new_size > 0 );
-	HDassert( new_size <= entry_ptr->len );
+    HDassert( ( entry_ptr->global_pinned ) &&
+        ( ! entry_ptr->local_pinned ) );
+    HDassert( ( entry_ptr->header.size == entry_ptr->len ) ||
+            ( entry_ptr->header.size == entry_ptr->local_len ) );
+    HDassert( new_size > 0 );
+    HDassert( new_size <= entry_ptr->len );
 
-	result = H5AC_resize_entry((void *)entry_ptr, new_size);
+    result = H5AC_resize_entry((void *)entry_ptr, new_size);
 
         if ( result < 0 ) {
 
             nerrors++;
             if ( verbose ) {
-		HDfprintf(stdout, "%d:%s: H5AC_resize_entry() failed.\n",
-	                  world_mpi_rank, FUNC);
+        HDfprintf(stdout, "%d:%s: H5AC_resize_entry() failed.\n",
+                    world_mpi_rank, FUNC);
             }
 
         } else {
@@ -4025,7 +4024,7 @@ resize_entry(int32_t idx,
             HDassert( entry_ptr->header.size == new_size );
 
             entry_ptr->dirty = TRUE;
-	    entry_ptr->local_len = new_size;
+        entry_ptr->local_len = new_size;
 
             /* touch up version. */
 
@@ -4037,24 +4036,24 @@ resize_entry(int32_t idx,
 
 } /* resize_entry() */
 
-
+
 /*****************************************************************************
  *
- * Function:	setup_cache_for_test()
+ * Function:    setup_cache_for_test()
  *
- * Purpose:	Setup the parallel cache for a test, and return the file id
- *		and a pointer to the cache's internal data structures.
+ * Purpose:    Setup the parallel cache for a test, and return the file id
+ *        and a pointer to the cache's internal data structures.
  *
- *		To do this, we must create a file, flush it (so that we
- *		don't have to worry about entries in the metadata cache),
- *		look up the address of the metadata cache, and then instruct
- *		the cache to omit sanity checks on dxpl IDs.
+ *        To do this, we must create a file, flush it (so that we
+ *        don't have to worry about entries in the metadata cache),
+ *        look up the address of the metadata cache, and then instruct
+ *        the cache to omit sanity checks on dxpl IDs.
  *
- * Return:	Success:	TRUE
+ * Return:    Success:    TRUE
  *
- *		Failure:	FALSE
+ *        Failure:    FALSE
  *
- * Programmer:	JRM -- 1/4/06
+ * Programmer:    JRM -- 1/4/06
  *
  *****************************************************************************/
 static hbool_t
@@ -4081,13 +4080,13 @@ setup_cache_for_test(hid_t * fid_ptr,
     if ( fid < 0 ) {
         nerrors++;
         if ( verbose ) {
-	    HDfprintf(stdout, "%d:%s: H5Fcreate() failed.\n",
+        HDfprintf(stdout, "%d:%s: H5Fcreate() failed.\n",
                       world_mpi_rank, FUNC);
         }
     } else if ( H5Fflush(fid, H5F_SCOPE_GLOBAL) < 0 ) {
         nerrors++;
         if ( verbose ) {
-	    HDfprintf(stdout, "%d:%s: H5Fflush() failed.\n",
+        HDfprintf(stdout, "%d:%s: H5Fflush() failed.\n",
                       world_mpi_rank, FUNC);
         }
     } else {
@@ -4097,7 +4096,7 @@ setup_cache_for_test(hid_t * fid_ptr,
     if ( file_ptr == NULL ) {
         nerrors++;
         if ( verbose ) {
-	    HDfprintf(stdout, "%d:%s: Can't get file_ptr.\n",
+        HDfprintf(stdout, "%d:%s: Can't get file_ptr.\n",
                       world_mpi_rank, FUNC);
         }
     } else {
@@ -4107,13 +4106,13 @@ setup_cache_for_test(hid_t * fid_ptr,
     if ( cache_ptr == NULL ) {
         nerrors++;
         if ( verbose ) {
-	    HDfprintf(stdout, "%d:%s: Can't get cache_ptr.\n",
+        HDfprintf(stdout, "%d:%s: Can't get cache_ptr.\n",
                       world_mpi_rank, FUNC);
         }
     } else if ( cache_ptr->magic != H5C__H5C_T_MAGIC ) {
         nerrors++;
         if ( verbose ) {
-	    HDfprintf(stdout, "%d:%s: Bad cache_ptr magic.\n",
+        HDfprintf(stdout, "%d:%s: Bad cache_ptr magic.\n",
                       world_mpi_rank, FUNC);
         }
     } else {
@@ -4132,7 +4131,7 @@ setup_cache_for_test(hid_t * fid_ptr,
         if ( H5AC_get_cache_auto_resize_config(cache_ptr, &config)
              != SUCCEED ) {
 
-	    HDfprintf(stdout,
+        HDfprintf(stdout,
                       "%d:%s: H5AC_get_cache_auto_resize_config(1) failed.\n",
                       world_mpi_rank, FUNC);
 
@@ -4142,9 +4141,9 @@ setup_cache_for_test(hid_t * fid_ptr,
             config.metadata_write_strategy = metadata_write_strategy;
 
             if ( H5AC_set_cache_auto_resize_config(cache_ptr, &config)
-		 != SUCCEED ) {
+        != SUCCEED ) {
 
-	        HDfprintf(stdout,
+            HDfprintf(stdout,
                          "%d:%s: H5AC_set_cache_auto_resize_config() failed.\n",
                           world_mpi_rank, FUNC);
 
@@ -4167,15 +4166,15 @@ setup_cache_for_test(hid_t * fid_ptr,
 
             nerrors++;
             if ( verbose ) {
-	        HDfprintf(stdout, "%d:%s: cache_ptr->aux_ptr == NULL.\n",
+            HDfprintf(stdout, "%d:%s: cache_ptr->aux_ptr == NULL.\n",
                           world_mpi_rank, FUNC);
             }
-        } else if ( ((H5AC_aux_t *)(cache_ptr->aux_ptr))->magic != 
+        } else if ( ((H5AC_aux_t *)(cache_ptr->aux_ptr))->magic !=
                     H5AC__H5AC_AUX_T_MAGIC ) {
 
             nerrors++;
             if ( verbose ) {
-	        HDfprintf(stdout, 
+            HDfprintf(stdout,
                 "%d:%s: cache_ptr->aux_ptr->magic != H5AC__H5AC_AUX_T_MAGIC.\n",
                 world_mpi_rank, FUNC);
             }
@@ -4184,14 +4183,14 @@ setup_cache_for_test(hid_t * fid_ptr,
 
             nerrors++;
             if ( verbose ) {
-	        HDfprintf(stdout, 
+            HDfprintf(stdout,
                     "%d:%s: bad cache_ptr->aux_ptr->metadata_write_strategy\n",
                     world_mpi_rank, FUNC);
             }
         }
     }
 
-    /* also verify that the expected metadata write strategy is reported 
+    /* also verify that the expected metadata write strategy is reported
      * when we get the current configuration.
      */
 
@@ -4202,25 +4201,25 @@ setup_cache_for_test(hid_t * fid_ptr,
         if ( H5AC_get_cache_auto_resize_config(cache_ptr, &test_config)
              != SUCCEED ) {
 
-	    HDfprintf(stdout,
+        HDfprintf(stdout,
                       "%d:%s: H5AC_get_cache_auto_resize_config(2) failed.\n",
                       world_mpi_rank, FUNC);
 
-        } else if ( test_config.metadata_write_strategy != 
+        } else if ( test_config.metadata_write_strategy !=
                     metadata_write_strategy ) {
 
             nerrors++;
 
             if ( verbose ) {
 
-                HDfprintf(stdout, 
+                HDfprintf(stdout,
                           "%d:%s: unexpected metadata_write_strategy.\n",
                           world_mpi_rank, FUNC);
             }
         }
     }
 
-    /* allocate space for test entries -- do this before we set the 
+    /* allocate space for test entries -- do this before we set the
      * sync point done callback as it will dirty the superblock, requiring
      * another flush.  If the sync point done callback is set, this will
      * cause a spurious failure.
@@ -4233,10 +4232,10 @@ setup_cache_for_test(hid_t * fid_ptr,
         if ( actual_base_addr == HADDR_UNDEF ) {
 
             success = FALSE;
-	    nerrors++;
+        nerrors++;
 
             if ( verbose ) {
-	        HDfprintf(stdout, "%d:%s: H5MF_alloc() failed.\n",
+            HDfprintf(stdout, "%d:%s: H5MF_alloc() failed.\n",
                           world_mpi_rank, FUNC);
             }
 
@@ -4247,10 +4246,10 @@ setup_cache_for_test(hid_t * fid_ptr,
              * if the size of the superblock is increase.
              */
             success = FALSE;
-	    nerrors++;
+        nerrors++;
 
             if ( verbose ) {
-	        HDfprintf(stdout, "%d:%s: actual_base_addr > BASE_ADDR.\n",
+            HDfprintf(stdout, "%d:%s: actual_base_addr > BASE_ADDR.\n",
                           world_mpi_rank, FUNC);
             }
         }
@@ -4263,7 +4262,7 @@ setup_cache_for_test(hid_t * fid_ptr,
         if ( H5Fflush(fid, H5F_SCOPE_GLOBAL) < 0 ) {
             nerrors++;
             if ( verbose ) {
-	        HDfprintf(stdout, "%d:%s: second H5Fflush() failed.\n",
+            HDfprintf(stdout, "%d:%s: second H5Fflush() failed.\n",
                           world_mpi_rank, FUNC);
             }
         }
@@ -4273,62 +4272,62 @@ setup_cache_for_test(hid_t * fid_ptr,
 
     if ( success ) {
 
-	if ( H5AC__set_write_done_callback(cache_ptr, do_sync) != SUCCEED ) {
+    if ( H5AC__set_write_done_callback(cache_ptr, do_sync) != SUCCEED ) {
 
             nerrors++;
             if ( verbose ) {
-	        HDfprintf(stdout,
-			  "%d:%s: H5C_set_write_done_callback failed.\n",
+            HDfprintf(stdout,
+            "%d:%s: H5C_set_write_done_callback failed.\n",
                           world_mpi_rank, FUNC);
             }
-	}
+    }
     }
 
 #endif /* DO_SYNC_AFTER_WRITE */
 
     if ( success ) {
 
-	if ( H5AC__set_sync_point_done_callback(cache_ptr, verify_writes) != SUCCEED ) {
+    if ( H5AC__set_sync_point_done_callback(cache_ptr, verify_writes) != SUCCEED ) {
 
             nerrors++;
             if ( verbose ) {
-	        HDfprintf(stdout,
-			  "%d:%s: H5AC__set_sync_point_done_callback failed.\n",
+            HDfprintf(stdout,
+            "%d:%s: H5AC__set_sync_point_done_callback failed.\n",
                           world_mpi_rank, FUNC);
             }
-	}
+    }
     }
 
     return(success);
 
 } /* setup_cache_for_test() */
 
-
+
 /*****************************************************************************
  *
- * Function:	verify_writes()
+ * Function:    verify_writes()
  *
- * Purpose:	Verify that the indicated entries have been written exactly
- *		once each, and that the indicated total number of writes
- *		has been processed by the server process.  Flag an error if 
- *		discrepency is noted.  Finally reset the counters maintained
- *		by the server process.
+ * Purpose:    Verify that the indicated entries have been written exactly
+ *        once each, and that the indicated total number of writes
+ *        has been processed by the server process.  Flag an error if
+ *        discrepency is noted.  Finally reset the counters maintained
+ *        by the server process.
  *
- *		This function should only be called by the metadata cache 
- *		as the "sync point done" function, as it must do some 
- *		synchronization to avoid false positives.
+ *        This function should only be called by the metadata cache
+ *        as the "sync point done" function, as it must do some
+ *        synchronization to avoid false positives.
  *
- *		Note that at present, this function does not allow for the 
- *		case in which one or more of the indicated entries should 
- *		have been written more than once since the last time the 
- *		server process's counters were reset.  That is fine for now,
- *		as with the current metadata write strategies, no entry
- *		should be written more than once per sync point.  If this
- *		changes this limitation will have to be revisited.
+ *        Note that at present, this function does not allow for the
+ *        case in which one or more of the indicated entries should
+ *        have been written more than once since the last time the
+ *        server process's counters were reset.  That is fine for now,
+ *        as with the current metadata write strategies, no entry
+ *        should be written more than once per sync point.  If this
+ *        changes this limitation will have to be revisited.
  *
- * Return:	void.
+ * Return:    void.
  *
- * Programmer:	JRM -- 5/9/10
+ * Programmer:    JRM -- 5/9/10
  *
  *****************************************************************************/
 static void
@@ -4404,7 +4403,7 @@ verify_writes(unsigned num_writes, haddr_t *written_entries_tbl)
     }
 
     /* final barrier to ensure that all processes think that the server
-     * counters have been reset before we leave the sync point.  This 
+     * counters have been reset before we leave the sync point.  This
      * barrier is probaby not necessary at this point in time (5/9/10),
      * but I can think of at least one likely change to the metadata write
      * strategies that will require it -- hence its insertion now.
@@ -4426,24 +4425,24 @@ verify_writes(unsigned num_writes, haddr_t *written_entries_tbl)
 
 } /* verify_writes() */
 
-
+
 /*****************************************************************************
  *
- * Function:	setup_rand()
+ * Function:    setup_rand()
  *
- * Purpose:	Use gettimeofday() to obtain a seed for rand(), print the
- *		seed to stdout, and then pass it to srand().
+ * Purpose:    Use gettimeofday() to obtain a seed for rand(), print the
+ *        seed to stdout, and then pass it to srand().
  *
- *		Increment nerrors if any errors are detected.
+ *        Increment nerrors if any errors are detected.
  *
- * Return:	void.
+ * Return:    void.
  *
- * Programmer:	JRM -- 1/12/06
+ * Programmer:    JRM -- 1/12/06
  *
  * Modifications:
  *
- *		JRM -- 5/9/06
- *		Modified function to facilitate setting predefined seeds.
+ *        JRM -- 5/9/06
+ *        Modified function to facilitate setting predefined seeds.
  *
  *****************************************************************************/
 static void
@@ -4458,13 +4457,13 @@ setup_rand(void)
     if ( ( use_predefined_seeds ) &&
          ( world_mpi_size == num_predefined_seeds ) ) {
 
-	    HDassert( world_mpi_rank >= 0 );
-	    HDassert( world_mpi_rank < world_mpi_size );
+        HDassert( world_mpi_rank >= 0 );
+        HDassert( world_mpi_rank < world_mpi_size );
 
             seed = predefined_seeds[world_mpi_rank];
-	    HDfprintf(stdout, "%d:%s: predefined_seed = %d.\n",
+        HDfprintf(stdout, "%d:%s: predefined_seed = %d.\n",
                       world_mpi_rank, FUNC, seed);
-	    fflush(stdout);
+        fflush(stdout);
             HDsrand(seed);
 
     } else {
@@ -4473,7 +4472,7 @@ setup_rand(void)
 
             nerrors++;
             if ( verbose ) {
-	        HDfprintf(stdout, "%d:%s: gettimeofday() failed.\n",
+            HDfprintf(stdout, "%d:%s: gettimeofday() failed.\n",
                           world_mpi_rank, FUNC);
             }
         } else {
@@ -4491,21 +4490,21 @@ setup_rand(void)
 
 } /* setup_rand() */
 
-
+
 /*****************************************************************************
  *
- * Function:	take_down_cache()
+ * Function:    take_down_cache()
  *
- * Purpose:	Take down the parallel cache after a test.
+ * Purpose:    Take down the parallel cache after a test.
  *
- *		To do this, we must close the file, and delete if if
- *		possible.
+ *        To do this, we must close the file, and delete if if
+ *        possible.
  *
- * Return:	Success:	TRUE
+ * Return:    Success:    TRUE
  *
- *		Failure:	FALSE
+ *        Failure:    FALSE
  *
- * Programmer:	JRM -- 1/4/06
+ * Programmer:    JRM -- 1/4/06
  *
  *****************************************************************************/
 static hbool_t
@@ -4513,7 +4512,7 @@ take_down_cache(hid_t fid, H5C_t * cache_ptr)
 {
     hbool_t success = TRUE; /* will set to FALSE if appropriate. */
 
-    /* flush the file -- this should write out any remaining test 
+    /* flush the file -- this should write out any remaining test
      * entries in the cache.
      */
     if ( ( success ) && ( H5Fflush(fid, H5F_SCOPE_GLOBAL) < 0 ) ) {
@@ -4526,7 +4525,7 @@ take_down_cache(hid_t fid, H5C_t * cache_ptr)
         }
     }
 
-    /* Now reset the sync point done callback.  Must do this as with 
+    /* Now reset the sync point done callback.  Must do this as with
      * the SWMR mods, the cache will do additional I/O on file close
      * un-related to the test entries, and thereby corrupt our counts
      * of entry writes.
@@ -4557,7 +4556,7 @@ take_down_cache(hid_t fid, H5C_t * cache_ptr)
                       world_mpi_rank, FUNC);
         }
 
-    } 
+    }
 
     if ( success ) {
 
@@ -4574,11 +4573,11 @@ take_down_cache(hid_t fid, H5C_t * cache_ptr)
             }
         } else {
 
-	    /* verify that there have been no further writes of test 
+        /* verify that there have been no further writes of test
              * entries during the close
              */
             success = verify_total_writes(0);
- 
+
         }
     }
 
@@ -4586,19 +4585,19 @@ take_down_cache(hid_t fid, H5C_t * cache_ptr)
 
 } /* take_down_cache() */
 
-
+
 /*****************************************************************************
  * Function:    verify_entry_reads
  *
- * Purpose:     Query the server to determine the number of times the 
- *		indicated entry has been read since the last time the 
- *		server counters were reset.
+ * Purpose:     Query the server to determine the number of times the
+ *        indicated entry has been read since the last time the
+ *        server counters were reset.
  *
- *		Return TRUE if successful, and if the supplied expected
- *		number of reads matches the number of reads reported by
- *		the server process.
+ *        Return TRUE if successful, and if the supplied expected
+ *        number of reads matches the number of reads reported by
+ *        the server process.
  *
- *		Return FALSE and flag an error otherwise.
+ *        Return FALSE and flag an error otherwise.
  *
  * Return:      TRUE if successful, FALSE otherwise.
  *
@@ -4681,31 +4680,31 @@ verify_entry_reads(haddr_t addr,
             nerrors++;
             success = FALSE;
             if ( verbose ) {
-                HDfprintf(stdout, 
+                HDfprintf(stdout,
                     "%d:%s: rep/exp entry 0x%llx reads mismatch (%ld/%ld).\n",
                     world_mpi_rank, FUNC, (long long)addr,
                     reported_entry_reads, expected_entry_reads);
             }
-        } 
+        }
     }
 
     return(success);
 
 } /* verify_entry_reads() */
 
-
+
 /*****************************************************************************
  * Function:    verify_entry_writes
  *
- * Purpose:     Query the server to determine the number of times the 
- *		indicated entry has been written since the last time the 
- *		server counters were reset.
+ * Purpose:     Query the server to determine the number of times the
+ *        indicated entry has been written since the last time the
+ *        server counters were reset.
  *
- *		Return TRUE if successful, and if the supplied expected
- *		number of reads matches the number of reads reported by
- *		the server process.
+ *        Return TRUE if successful, and if the supplied expected
+ *        number of reads matches the number of reads reported by
+ *        the server process.
  *
- *		Return FALSE and flag an error otherwise.
+ *        Return FALSE and flag an error otherwise.
  *
  * Return:      TRUE if successful, FALSE otherwise.
  *
@@ -4788,36 +4787,36 @@ verify_entry_writes(haddr_t addr,
             nerrors++;
             success = FALSE;
             if ( verbose ) {
-                HDfprintf(stdout, 
+                HDfprintf(stdout,
                     "%d:%s: rep/exp entry 0x%llx writes mismatch (%ld/%ld).\n",
                     world_mpi_rank, FUNC, (long long)addr,
                     reported_entry_writes, expected_entry_writes);
             }
-        } 
+        }
     }
 
     return(success);
 
 } /* verify_entry_writes() */
 
-
+
 /*****************************************************************************
  *
- * Function:	verify_total_reads()
+ * Function:    verify_total_reads()
  *
- * Purpose:	Query the server to obtain the total reads since the last 
- *		server counter reset, and compare this value with the supplied
- *		expected value.
+ * Purpose:    Query the server to obtain the total reads since the last
+ *        server counter reset, and compare this value with the supplied
+ *        expected value.
  *
- *		If the values match, return TRUE.
+ *        If the values match, return TRUE.
  *
- *		If the values don't match, flag an error and return FALSE.
+ *        If the values don't match, flag an error and return FALSE.
  *
- * Return:	Success:	TRUE
+ * Return:    Success:    TRUE
  *
- *		Failure:	FALSE
+ *        Failure:    FALSE
  *
- * Programmer:	JRM -- 5/6/10
+ * Programmer:    JRM -- 5/6/10
  *
  *****************************************************************************/
 static hbool_t
@@ -4888,9 +4887,9 @@ verify_total_reads(int expected_total_reads)
             nerrors++;
             success = FALSE;
             if ( verbose ) {
-                HDfprintf(stdout, 
+                HDfprintf(stdout,
                     "%d:%s: reported/expected total reads mismatch (%ld/%ld).\n",
-                    world_mpi_rank, FUNC, 
+                    world_mpi_rank, FUNC,
                     reported_total_reads, expected_total_reads);
 
             }
@@ -4901,24 +4900,24 @@ verify_total_reads(int expected_total_reads)
 
 } /* verify_total_reads() */
 
-
+
 /*****************************************************************************
  *
- * Function:	verify_total_writes()
+ * Function:    verify_total_writes()
  *
- * Purpose:	Query the server to obtain the total writes since the last 
- *		server counter reset, and compare this value with the supplied
- *		expected value.
+ * Purpose:    Query the server to obtain the total writes since the last
+ *        server counter reset, and compare this value with the supplied
+ *        expected value.
  *
- *		If the values match, return TRUE.
+ *        If the values match, return TRUE.
  *
- *		If the values don't match, flag an error and return FALSE.
+ *        If the values don't match, flag an error and return FALSE.
  *
- * Return:	Success:	TRUE
+ * Return:    Success:    TRUE
  *
- *		Failure:	FALSE
+ *        Failure:    FALSE
  *
- * Programmer:	JRM -- 5/6/10
+ * Programmer:    JRM -- 5/6/10
  *
  *****************************************************************************/
 static hbool_t
@@ -4989,9 +4988,9 @@ verify_total_writes(unsigned expected_total_writes)
             nerrors++;
             success = FALSE;
             if ( verbose ) {
-                HDfprintf(stdout, 
+                HDfprintf(stdout,
                    "%d:%s: reported/expected total writes mismatch (%u/%u).\n",
-                   world_mpi_rank, FUNC, 
+                   world_mpi_rank, FUNC,
                    reported_total_writes, expected_total_writes);
             }
         }
@@ -5001,7 +5000,7 @@ verify_total_writes(unsigned expected_total_writes)
 
 } /* verify_total_writes() */
 
-
+
 /*****************************************************************************
  * Function:    unlock_entry()
  *
@@ -5016,8 +5015,8 @@ verify_total_writes(unsigned expected_total_writes)
  *
  * Modifications:
  *
- * 		7/11/06
- * 		Updated for the new local_len field in datum.
+ *         7/11/06
+ *         Updated for the new local_len field in datum.
  *
  *****************************************************************************/
 static void
@@ -5037,7 +5036,7 @@ unlock_entry(H5F_t * file_ptr,
 
         entry_ptr = &(data[idx]);
 
-	HDassert( entry_ptr->locked );
+    HDassert( entry_ptr->locked );
 
         dirtied = ((flags & H5AC__DIRTIED_FLAG) == H5AC__DIRTIED_FLAG );
 
@@ -5053,7 +5052,7 @@ unlock_entry(H5F_t * file_ptr,
         if ( ( result < 0 ) ||
              ( entry_ptr->header.type != &(types[0]) ) ||
              ( ( entry_ptr->len != entry_ptr->header.size ) &&
-	       ( entry_ptr->local_len != entry_ptr->header.size ) ) ||
+        ( entry_ptr->local_len != entry_ptr->header.size ) ) ||
              ( entry_ptr->base_addr != entry_ptr->header.addr ) ) {
 
             nerrors++;
@@ -5065,7 +5064,7 @@ unlock_entry(H5F_t * file_ptr,
 
             entry_ptr->locked = FALSE;
 
-	}
+    }
 
         HDassert( ((entry_ptr->header).type)->id == DATUM_ENTRY_TYPE );
 
@@ -5086,7 +5085,7 @@ unlock_entry(H5F_t * file_ptr,
 
 } /* unlock_entry() */
 
-
+
 /*****************************************************************************
  * Function:    unpin_entry()
  *
@@ -5101,8 +5100,8 @@ unlock_entry(H5F_t * file_ptr,
  *
  * Modifications:
  *
- * 		JRM -- 8/15/06
- * 		Added assertion that entry is pinned on entry.
+ *         JRM -- 8/15/06
+ *         Added assertion that entry is pinned on entry.
  *
  *****************************************************************************/
 static void
@@ -5124,54 +5123,54 @@ unpin_entry(H5F_t * file_ptr,
 
         entry_ptr = &(data[idx]);
 
-	HDassert( (entry_ptr->header).is_pinned );
-	HDassert ( ! ( entry_ptr->global_pinned && entry_ptr->local_pinned) );
-	HDassert ( ( global && entry_ptr->global_pinned ) ||
-		   ( ! global && entry_ptr->local_pinned ) );
-	HDassert ( ! ( dirty && ( ! global ) ) );
+    HDassert( (entry_ptr->header).is_pinned );
+    HDassert ( ! ( entry_ptr->global_pinned && entry_ptr->local_pinned) );
+    HDassert ( ( global && entry_ptr->global_pinned ) ||
+        ( ! global && entry_ptr->local_pinned ) );
+    HDassert ( ! ( dirty && ( ! global ) ) );
 
-	if ( via_unprotect ) {
+    if ( via_unprotect ) {
 
-	    lock_entry(file_ptr, idx);
+        lock_entry(file_ptr, idx);
 
-	    if ( dirty ) {
+        if ( dirty ) {
 
-	        flags |= H5AC__DIRTIED_FLAG;
-	    }
+            flags |= H5AC__DIRTIED_FLAG;
+        }
 
-	    unlock_entry(file_ptr, idx, flags);
+        unlock_entry(file_ptr, idx, flags);
 
-	} else {
+    } else {
 
-	    if ( dirty ) {
+        if ( dirty ) {
 
-		mark_entry_dirty(idx);
+        mark_entry_dirty(idx);
 
-	    }
+        }
 
-	    result = H5AC_unpin_entry(entry_ptr);
+        result = H5AC_unpin_entry(entry_ptr);
 
-	    if ( result < 0 ) {
+        if ( result < 0 ) {
 
                 nerrors++;
                 if ( verbose ) {
                     HDfprintf(stdout, "%d:%s: error in H5AC_unpin_entry().\n",
-	                      world_mpi_rank, FUNC);
+                        world_mpi_rank, FUNC);
                 }
-	    }
-	}
+        }
+    }
 
         HDassert( ! ((entry_ptr->header).is_pinned) );
 
-	if ( global ) {
+    if ( global ) {
 
-	    entry_ptr->global_pinned = FALSE;
+        entry_ptr->global_pinned = FALSE;
 
-	} else {
+    } else {
 
-	    entry_ptr->local_pinned = FALSE;
+        entry_ptr->local_pinned = FALSE;
 
-	}
+    }
     }
 
     return;
@@ -5183,18 +5182,18 @@ unpin_entry(H5F_t * file_ptr,
 /****************************** test functions *******************************/
 /*****************************************************************************/
 
-
+
 /*****************************************************************************
  *
- * Function:	server_smoke_check()
+ * Function:    server_smoke_check()
  *
- * Purpose:	Quick smoke check for the server process.
+ * Purpose:    Quick smoke check for the server process.
  *
- * Return:	Success:	TRUE
+ * Return:    Success:    TRUE
  *
- *		Failure:	FALSE
+ *        Failure:    FALSE
  *
- * Programmer:	JRM -- 12/21/05
+ * Programmer:    JRM -- 12/21/05
  *
  *****************************************************************************/
 static hbool_t
@@ -5215,12 +5214,12 @@ server_smoke_check(void)
 
     if ( world_mpi_rank == world_server_mpi_rank ) {
 
-	if ( ! server_main() ) {
+    if ( ! server_main() ) {
 
             /* some error occured in the server -- report failure */
             nerrors++;
             if ( verbose ) {
-		HDfprintf(stdout, "%d:%s: server_main() failed.\n",
+        HDfprintf(stdout, "%d:%s: server_main() failed.\n",
                           world_mpi_rank, FUNC);
             }
         }
@@ -5286,9 +5285,9 @@ server_smoke_check(void)
 
 #endif /* DO_WRITE_REQ_ACK */
 
-	do_sync();
+    do_sync();
 
-	/* barrier to allow all writes to complete */
+    /* barrier to allow all writes to complete */
         if ( MPI_SUCCESS != MPI_Barrier(file_mpi_comm) ) {
 
             success = FALSE;
@@ -5303,12 +5302,12 @@ server_smoke_check(void)
         if ( success ) {
 
             success = verify_entry_writes(data[world_mpi_rank].base_addr, 1);
-        } 
+        }
 
         if ( success ) {
 
             success = verify_entry_reads(data[world_mpi_rank].base_addr, 0);
-        } 
+        }
 
         if ( success ) {
 
@@ -5320,7 +5319,7 @@ server_smoke_check(void)
             success = verify_total_reads(0);
         }
 
-	/* barrier to allow all writes to complete */
+    /* barrier to allow all writes to complete */
         if ( MPI_SUCCESS != MPI_Barrier(file_mpi_comm) ) {
 
             success = FALSE;
@@ -5392,7 +5391,7 @@ server_smoke_check(void)
             }
         }
 
-	/* barrier to allow all writes to complete */
+    /* barrier to allow all writes to complete */
         if ( MPI_SUCCESS != MPI_Barrier(file_mpi_comm) ) {
 
             success = FALSE;
@@ -5407,12 +5406,12 @@ server_smoke_check(void)
         if ( success ) {
 
             success = verify_entry_writes(data[world_mpi_rank].base_addr, 1);
-        } 
+        }
 
         if ( success ) {
 
             success = verify_entry_reads(data[world_mpi_rank].base_addr, 1);
-        } 
+        }
 
         if ( success ) {
 
@@ -5456,12 +5455,12 @@ server_smoke_check(void)
         if ( success ) {
 
             success = verify_entry_writes(data[world_mpi_rank].base_addr, 0);
-        } 
+        }
 
         if ( success ) {
 
             success = verify_entry_reads(data[world_mpi_rank].base_addr, 0);
-        } 
+        }
 
         if ( success ) {
 
@@ -5514,9 +5513,9 @@ server_smoke_check(void)
 
     if ( world_mpi_rank == 0 ) {
 
-	if ( max_nerrors == 0 ) {
+    if ( max_nerrors == 0 ) {
 
-	    PASSED();
+        PASSED();
 
         } else {
 
@@ -5531,18 +5530,18 @@ server_smoke_check(void)
 
 } /* server_smoke_check() */
 
-
+
 /*****************************************************************************
  *
- * Function:	smoke_check_1()
+ * Function:    smoke_check_1()
  *
- * Purpose:	First smoke check for the parallel cache.
+ * Purpose:    First smoke check for the parallel cache.
  *
- * Return:	Success:	TRUE
+ * Return:    Success:    TRUE
  *
- *		Failure:	FALSE
+ *        Failure:    FALSE
  *
- * Programmer:	JRM -- 1/4/06
+ * Programmer:    JRM -- 1/4/06
  *
  *****************************************************************************/
 static hbool_t
@@ -5558,23 +5557,23 @@ smoke_check_1(int metadata_write_strategy)
 
     switch ( metadata_write_strategy ) {
 
-	case H5AC_METADATA_WRITE_STRATEGY__PROCESS_0_ONLY:
+    case H5AC_METADATA_WRITE_STRATEGY__PROCESS_0_ONLY:
             if ( world_mpi_rank == 0 ) {
-        	TESTING("smoke check #1 -- process 0 only md write strategy");
+            TESTING("smoke check #1 -- process 0 only md write strategy");
             }
-	    break;
+        break;
 
-	case H5AC_METADATA_WRITE_STRATEGY__DISTRIBUTED:
+    case H5AC_METADATA_WRITE_STRATEGY__DISTRIBUTED:
             if ( world_mpi_rank == 0 ) {
-        	TESTING("smoke check #1 -- distributed md write strategy");
+            TESTING("smoke check #1 -- distributed md write strategy");
             }
-	    break;
+        break;
 
         default:
             if ( world_mpi_rank == 0 ) {
-        	TESTING("smoke check #1 -- unknown md write strategy");
+            TESTING("smoke check #1 -- unknown md write strategy");
             }
-	    break;
+        break;
     }
 
     nerrors = 0;
@@ -5583,12 +5582,12 @@ smoke_check_1(int metadata_write_strategy)
 
     if ( world_mpi_rank == world_server_mpi_rank ) {
 
-	if ( ! server_main() ) {
+    if ( ! server_main() ) {
 
             /* some error occured in the server -- report failure */
             nerrors++;
             if ( verbose ) {
-		HDfprintf(stdout, "%d:%s: server_main() failed.\n",
+        HDfprintf(stdout, "%d:%s: server_main() failed.\n",
                           world_mpi_rank, FUNC);
             }
         }
@@ -5602,7 +5601,7 @@ smoke_check_1(int metadata_write_strategy)
             fid = -1;
             cache_ptr = NULL;
             if ( verbose ) {
-		HDfprintf(stdout, "%d:%s: setup_cache_for_test() failed.\n",
+        HDfprintf(stdout, "%d:%s: setup_cache_for_test() failed.\n",
                           world_mpi_rank, FUNC);
             }
         }
@@ -5614,24 +5613,24 @@ smoke_check_1(int metadata_write_strategy)
 
         for ( i = (virt_num_data_entries / 2) - 1; i >= 0; i-- )
         {
-	    lock_entry(file_ptr, i);
-	    unlock_entry(file_ptr, i, H5AC__NO_FLAGS_SET);
+        lock_entry(file_ptr, i);
+        unlock_entry(file_ptr, i, H5AC__NO_FLAGS_SET);
         }
 
         /* Move the first half of the entries... */
         for ( i = 0; i < (virt_num_data_entries / 2); i++ )
         {
-	    lock_entry(file_ptr, i);
-	    unlock_entry(file_ptr, i, H5AC__NO_FLAGS_SET);
-	    move_entry(file_ptr, i, (i + (virt_num_data_entries / 2)));
+        lock_entry(file_ptr, i);
+        unlock_entry(file_ptr, i, H5AC__NO_FLAGS_SET);
+        move_entry(file_ptr, i, (i + (virt_num_data_entries / 2)));
         }
 
         /* ...and then move them back. */
         for ( i = (virt_num_data_entries / 2) - 1; i >= 0; i-- )
         {
-	    lock_entry(file_ptr, i);
-	    unlock_entry(file_ptr, i, H5AC__NO_FLAGS_SET);
-	    move_entry(file_ptr, i, (i + (virt_num_data_entries / 2)));
+        lock_entry(file_ptr, i);
+        unlock_entry(file_ptr, i, H5AC__NO_FLAGS_SET);
+        move_entry(file_ptr, i, (i + (virt_num_data_entries / 2)));
         }
 
         if ( fid >= 0 ) {
@@ -5640,7 +5639,7 @@ smoke_check_1(int metadata_write_strategy)
 
                 nerrors++;
                 if ( verbose ) {
-		    HDfprintf(stdout, "%d:%s: take_down_cache() failed.\n",
+            HDfprintf(stdout, "%d:%s: take_down_cache() failed.\n",
                               world_mpi_rank, FUNC);
                 }
             }
@@ -5686,9 +5685,9 @@ smoke_check_1(int metadata_write_strategy)
 
     if ( world_mpi_rank == 0 ) {
 
-	if ( max_nerrors == 0 ) {
+    if ( max_nerrors == 0 ) {
 
-	    PASSED();
+        PASSED();
 
         } else {
 
@@ -5703,21 +5702,21 @@ smoke_check_1(int metadata_write_strategy)
 
 } /* smoke_check_1() */
 
-
+
 /*****************************************************************************
  *
- * Function:	smoke_check_2()
+ * Function:    smoke_check_2()
  *
- * Purpose:	Second smoke check for the parallel cache.
+ * Purpose:    Second smoke check for the parallel cache.
  *
- *		Introduce random reads, but keep all processes with roughly
- *		the same work load.
+ *        Introduce random reads, but keep all processes with roughly
+ *        the same work load.
  *
- * Return:	Success:	TRUE
+ * Return:    Success:    TRUE
  *
- *		Failure:	FALSE
+ *        Failure:    FALSE
  *
- * Programmer:	JRM -- 1/12/06
+ * Programmer:    JRM -- 1/12/06
  *
  *****************************************************************************/
 static hbool_t
@@ -5733,23 +5732,23 @@ smoke_check_2(int metadata_write_strategy)
 
     switch ( metadata_write_strategy ) {
 
-	case H5AC_METADATA_WRITE_STRATEGY__PROCESS_0_ONLY:
+    case H5AC_METADATA_WRITE_STRATEGY__PROCESS_0_ONLY:
             if ( world_mpi_rank == 0 ) {
-        	TESTING("smoke check #2 -- process 0 only md write strategy");
+            TESTING("smoke check #2 -- process 0 only md write strategy");
             }
-	    break;
+        break;
 
-	case H5AC_METADATA_WRITE_STRATEGY__DISTRIBUTED:
+    case H5AC_METADATA_WRITE_STRATEGY__DISTRIBUTED:
             if ( world_mpi_rank == 0 ) {
-        	TESTING("smoke check #2 -- distributed md write strategy");
+            TESTING("smoke check #2 -- distributed md write strategy");
             }
-	    break;
+        break;
 
         default:
             if ( world_mpi_rank == 0 ) {
-        	TESTING("smoke check #2 -- unknown md write strategy");
+            TESTING("smoke check #2 -- unknown md write strategy");
             }
-	    break;
+        break;
     }
 
     nerrors = 0;
@@ -5758,12 +5757,12 @@ smoke_check_2(int metadata_write_strategy)
 
     if ( world_mpi_rank == world_server_mpi_rank ) {
 
-	if ( ! server_main() ) {
+    if ( ! server_main() ) {
 
             /* some error occured in the server -- report failure */
             nerrors++;
             if ( verbose ) {
-		HDfprintf(stdout, "%d:%s: server_main() failed.\n",
+        HDfprintf(stdout, "%d:%s: server_main() failed.\n",
                           world_mpi_rank, FUNC);
             }
         }
@@ -5777,7 +5776,7 @@ smoke_check_2(int metadata_write_strategy)
             fid = -1;
             cache_ptr = NULL;
             if ( verbose ) {
-		HDfprintf(stdout, "%d:%s: setup_cache_for_test() failed.\n",
+        HDfprintf(stdout, "%d:%s: setup_cache_for_test() failed.\n",
                           world_mpi_rank, FUNC);
             }
         }
@@ -5788,73 +5787,73 @@ smoke_check_2(int metadata_write_strategy)
 
             if ( i > 100 ) {
 
-		lock_and_unlock_random_entries(file_ptr, (i - 100), i, 0, 10);
+        lock_and_unlock_random_entries(file_ptr, (i - 100), i, 0, 10);
             }
         }
 
-	for ( i = 0; i < (virt_num_data_entries / 2); i+=61 )
-	{
-	    /* Make sure we don't step on any locally pinned entries */
-	    if ( data[i].local_pinned ) {
-		unpin_entry(file_ptr, i, FALSE, FALSE, FALSE);
-	    }
+    for ( i = 0; i < (virt_num_data_entries / 2); i+=61 )
+    {
+        /* Make sure we don't step on any locally pinned entries */
+        if ( data[i].local_pinned ) {
+        unpin_entry(file_ptr, i, FALSE, FALSE, FALSE);
+        }
 
-	    pin_entry(file_ptr, i, TRUE, FALSE);
-	}
+        pin_entry(file_ptr, i, TRUE, FALSE);
+    }
 
         for ( i = (virt_num_data_entries / 2) - 1; i >= 0; i-=2 )
         {
-	    lock_entry(file_ptr, i);
-	    unlock_entry(file_ptr, i, H5AC__NO_FLAGS_SET);
-	    lock_and_unlock_random_entries(file_ptr, 0,
-			                   (virt_num_data_entries / 20),
-					   0, 100);
-	    local_pin_and_unpin_random_entries(file_ptr, 0,
-			                       (virt_num_data_entries / 4),
-					       0, 3);
+        lock_entry(file_ptr, i);
+        unlock_entry(file_ptr, i, H5AC__NO_FLAGS_SET);
+        lock_and_unlock_random_entries(file_ptr, 0,
+                            (virt_num_data_entries / 20),
+                    0, 100);
+        local_pin_and_unpin_random_entries(file_ptr, 0,
+                                (virt_num_data_entries / 4),
+                        0, 3);
         }
 
         for ( i = 0; i < (virt_num_data_entries / 2); i+=2 )
         {
-	    lock_entry(file_ptr, i);
-	    unlock_entry(file_ptr, i, H5AC__DIRTIED_FLAG);
-	    lock_and_unlock_random_entries(file_ptr, 0,
-			                   (virt_num_data_entries / 10),
-					   0, 100);
+        lock_entry(file_ptr, i);
+        unlock_entry(file_ptr, i, H5AC__DIRTIED_FLAG);
+        lock_and_unlock_random_entries(file_ptr, 0,
+                            (virt_num_data_entries / 10),
+                    0, 100);
         }
 
-	/* we can't move pinned entries, so release any local pins now. */
-	local_unpin_all_entries(file_ptr, FALSE);
+    /* we can't move pinned entries, so release any local pins now. */
+    local_unpin_all_entries(file_ptr, FALSE);
 
         /* Move the first half of the entries... */
         for ( i = 0; i < (virt_num_data_entries / 2); i++ )
         {
-	    lock_entry(file_ptr, i);
-	    unlock_entry(file_ptr, i, H5AC__NO_FLAGS_SET);
-	    move_entry(file_ptr, i, (i + (virt_num_data_entries / 2)));
-	    lock_and_unlock_random_entries(file_ptr, 0,
-			                   ((virt_num_data_entries / 50) - 1),
+        lock_entry(file_ptr, i);
+        unlock_entry(file_ptr, i, H5AC__NO_FLAGS_SET);
+        move_entry(file_ptr, i, (i + (virt_num_data_entries / 2)));
+        lock_and_unlock_random_entries(file_ptr, 0,
+                            ((virt_num_data_entries / 50) - 1),
                                            0, 100);
         }
 
         /* ...and then move them back. */
         for ( i = (virt_num_data_entries / 2) - 1; i >= 0; i-- )
         {
-	    lock_entry(file_ptr, i);
-	    unlock_entry(file_ptr, i, H5AC__DIRTIED_FLAG);
-	    move_entry(file_ptr, i, (i + (virt_num_data_entries / 2)));
-	    lock_and_unlock_random_entries(file_ptr, 0,
-			                   (virt_num_data_entries / 100),
-					   0, 100);
+        lock_entry(file_ptr, i);
+        unlock_entry(file_ptr, i, H5AC__DIRTIED_FLAG);
+        move_entry(file_ptr, i, (i + (virt_num_data_entries / 2)));
+        lock_and_unlock_random_entries(file_ptr, 0,
+                            (virt_num_data_entries / 100),
+                    0, 100);
         }
 
-	for ( i = 0; i < (virt_num_data_entries / 2); i+=61 )
-	{
-	    hbool_t via_unprotect = ( (((unsigned)i) & 0x01) == 0 );
-	    hbool_t dirty = ( (((unsigned)i) & 0x02) == 0 );
+    for ( i = 0; i < (virt_num_data_entries / 2); i+=61 )
+    {
+        hbool_t via_unprotect = ( (((unsigned)i) & 0x01) == 0 );
+        hbool_t dirty = ( (((unsigned)i) & 0x02) == 0 );
 
-	    unpin_entry(file_ptr, i, TRUE, dirty, via_unprotect);
-	}
+        unpin_entry(file_ptr, i, TRUE, dirty, via_unprotect);
+    }
 
         if ( fid >= 0 ) {
 
@@ -5862,7 +5861,7 @@ smoke_check_2(int metadata_write_strategy)
 
                 nerrors++;
                 if ( verbose ) {
-		    HDfprintf(stdout, "%d:%s: take_down_cache() failed.\n",
+            HDfprintf(stdout, "%d:%s: take_down_cache() failed.\n",
                               world_mpi_rank, FUNC);
                 }
             }
@@ -5908,9 +5907,9 @@ smoke_check_2(int metadata_write_strategy)
 
     if ( world_mpi_rank == 0 ) {
 
-	if ( max_nerrors == 0 ) {
+    if ( max_nerrors == 0 ) {
 
-	    PASSED();
+        PASSED();
 
         } else {
 
@@ -5925,24 +5924,24 @@ smoke_check_2(int metadata_write_strategy)
 
 } /* smoke_check_2() */
 
-
+
 /*****************************************************************************
  *
- * Function:	smoke_check_3()
+ * Function:    smoke_check_3()
  *
- * Purpose:	Third smoke check for the parallel cache.
+ * Purpose:    Third smoke check for the parallel cache.
  *
- *		Use random reads to vary the loads on the diffferent
- *		processors.  Also force different cache size adjustments.
+ *        Use random reads to vary the loads on the diffferent
+ *        processors.  Also force different cache size adjustments.
  *
- *		In this test, load process 0 heavily, and the other
- *		processes lightly.
+ *        In this test, load process 0 heavily, and the other
+ *        processes lightly.
  *
- * Return:	Success:	TRUE
+ * Return:    Success:    TRUE
  *
- *		Failure:	FALSE
+ *        Failure:    FALSE
  *
- * Programmer:	JRM -- 1/13/06
+ * Programmer:    JRM -- 1/13/06
  *
  *****************************************************************************/
 static hbool_t
@@ -5962,23 +5961,23 @@ smoke_check_3(int metadata_write_strategy)
 
     switch ( metadata_write_strategy ) {
 
-	case H5AC_METADATA_WRITE_STRATEGY__PROCESS_0_ONLY:
+    case H5AC_METADATA_WRITE_STRATEGY__PROCESS_0_ONLY:
             if ( world_mpi_rank == 0 ) {
-        	TESTING("smoke check #3 -- process 0 only md write strategy");
+            TESTING("smoke check #3 -- process 0 only md write strategy");
             }
-	    break;
+        break;
 
-	case H5AC_METADATA_WRITE_STRATEGY__DISTRIBUTED:
+    case H5AC_METADATA_WRITE_STRATEGY__DISTRIBUTED:
             if ( world_mpi_rank == 0 ) {
-        	TESTING("smoke check #3 -- distributed md write strategy");
+            TESTING("smoke check #3 -- distributed md write strategy");
             }
-	    break;
+        break;
 
         default:
             if ( world_mpi_rank == 0 ) {
-        	TESTING("smoke check #3 -- unknown md write strategy");
+            TESTING("smoke check #3 -- unknown md write strategy");
             }
-	    break;
+        break;
     }
 
     nerrors = 0;
@@ -5987,12 +5986,12 @@ smoke_check_3(int metadata_write_strategy)
 
     if ( world_mpi_rank == world_server_mpi_rank ) {
 
-	if ( ! server_main() ) {
+    if ( ! server_main() ) {
 
             /* some error occured in the server -- report failure */
             nerrors++;
             if ( verbose ) {
-		HDfprintf(stdout, "%d:%s: server_main() failed.\n",
+        HDfprintf(stdout, "%d:%s: server_main() failed.\n",
                           world_mpi_rank, FUNC);
             }
         }
@@ -6006,7 +6005,7 @@ smoke_check_3(int metadata_write_strategy)
             fid = -1;
             cache_ptr = NULL;
             if ( verbose ) {
-		HDfprintf(stdout, "%d:%s: setup_cache_for_test() failed.\n",
+        HDfprintf(stdout, "%d:%s: setup_cache_for_test() failed.\n",
                           world_mpi_rank, FUNC);
             }
         }
@@ -6020,7 +6019,7 @@ smoke_check_3(int metadata_write_strategy)
 
             if ( i > 100 ) {
 
-		lock_and_unlock_random_entries(file_ptr, (i - 100), i,
+        lock_and_unlock_random_entries(file_ptr, (i - 100), i,
                                                min_count, max_count);
             }
         }
@@ -6030,48 +6029,48 @@ smoke_check_3(int metadata_write_strategy)
         max_count = min_count + 50;
 
         for ( i = (virt_num_data_entries / 4);
-	      i < (virt_num_data_entries / 2);
-	      i++ )
+        i < (virt_num_data_entries / 2);
+        i++ )
         {
 
             insert_entry(cache_ptr, file_ptr, i, H5AC__NO_FLAGS_SET);
 
-	    if ( i % 59 == 0 ) {
+        if ( i % 59 == 0 ) {
 
-		hbool_t dirty = ( (i % 2) == 0);
+        hbool_t dirty = ( (i % 2) == 0);
 
-		if ( data[i].local_pinned ) {
-		    unpin_entry(file_ptr, i, FALSE, FALSE, FALSE);
-		}
+        if ( data[i].local_pinned ) {
+            unpin_entry(file_ptr, i, FALSE, FALSE, FALSE);
+        }
 
-		pin_entry(file_ptr, i, TRUE, dirty);
+        pin_entry(file_ptr, i, TRUE, dirty);
 
-	        HDassert( !dirty || data[i].header.is_dirty );
-	        HDassert( data[i].header.is_pinned );
-	        HDassert( data[i].global_pinned );
-	        HDassert( ! data[i].local_pinned );
-	    }
+            HDassert( !dirty || data[i].header.is_dirty );
+            HDassert( data[i].header.is_pinned );
+            HDassert( data[i].global_pinned );
+            HDassert( ! data[i].local_pinned );
+        }
 
             if ( i > 100 ) {
 
-		lock_and_unlock_random_entries(file_ptr, (i - 100), i,
+        lock_and_unlock_random_entries(file_ptr, (i - 100), i,
                                                min_count, max_count);
             }
 
-	    local_pin_and_unpin_random_entries(file_ptr, 0,
+        local_pin_and_unpin_random_entries(file_ptr, 0,
                                                virt_num_data_entries / 4,
-					       0, (file_mpi_rank + 2));
+                        0, (file_mpi_rank + 2));
 
-	}
+    }
 
 
-	/* flush the file to be sure that we have no problems flushing
-	 * pinned entries
-	 */
+    /* flush the file to be sure that we have no problems flushing
+    * pinned entries
+    */
         if ( H5Fflush(fid, H5F_SCOPE_GLOBAL) < 0 ) {
             nerrors++;
             if ( verbose ) {
-	        HDfprintf(stdout, "%d:%s: H5Fflush() failed.\n",
+            HDfprintf(stdout, "%d:%s: H5Fflush() failed.\n",
                           world_mpi_rank, FUNC);
             }
         }
@@ -6087,27 +6086,27 @@ smoke_check_3(int metadata_write_strategy)
 
         for ( i = (virt_num_data_entries / 2) - 1; i >= 0; i-- )
         {
-	    if ( ( i >= (virt_num_data_entries / 4) ) && ( i % 59 == 0 ) ) {
+        if ( ( i >= (virt_num_data_entries / 4) ) && ( i % 59 == 0 ) ) {
 
                 hbool_t via_unprotect = ( (((unsigned)i) & 0x02) == 0 );
-	        hbool_t dirty = ( (((unsigned)i) & 0x04) == 0 );
-
-		HDassert( data[i].global_pinned );
-		HDassert( ! data[i].local_pinned );
-
-		unpin_entry(file_ptr, i, TRUE, dirty,
-			    via_unprotect);
-	    }
-	    if ( i % 2 == 0 ) {
-
-	        lock_entry(file_ptr, i);
-	        unlock_entry(file_ptr, i, H5AC__NO_FLAGS_SET);
-	        local_pin_and_unpin_random_entries(file_ptr, 0,
-				                   virt_num_data_entries / 2,
-						   0, 2);
-	        lock_and_unlock_random_entries(file_ptr,
+            hbool_t dirty = ( (((unsigned)i) & 0x04) == 0 );
+
+        HDassert( data[i].global_pinned );
+        HDassert( ! data[i].local_pinned );
+
+        unpin_entry(file_ptr, i, TRUE, dirty,
+                via_unprotect);
+        }
+        if ( i % 2 == 0 ) {
+
+            lock_entry(file_ptr, i);
+            unlock_entry(file_ptr, i, H5AC__NO_FLAGS_SET);
+            local_pin_and_unpin_random_entries(file_ptr, 0,
+                                virt_num_data_entries / 2,
+                        0, 2);
+            lock_and_unlock_random_entries(file_ptr,
                                                min_idx, max_idx, 0, 100);
-	    }
+        }
         }
 
         min_idx = 0;
@@ -6120,9 +6119,9 @@ smoke_check_3(int metadata_write_strategy)
 
         for ( i = 0; i < (virt_num_data_entries / 2); i+=2 )
         {
-	    lock_entry(file_ptr, i);
-	    unlock_entry(file_ptr, i, H5AC__DIRTIED_FLAG);
-	    lock_and_unlock_random_entries(file_ptr,
+        lock_entry(file_ptr, i);
+        unlock_entry(file_ptr, i, H5AC__DIRTIED_FLAG);
+        lock_and_unlock_random_entries(file_ptr,
                                            min_idx, max_idx, 0, 100);
         }
 
@@ -6135,22 +6134,22 @@ smoke_check_3(int metadata_write_strategy)
         /* move the first half of the entries... */
         for ( i = 0; i < (virt_num_data_entries / 2); i++ )
         {
-	    lock_entry(file_ptr, i);
-	    unlock_entry(file_ptr, i, H5AC__NO_FLAGS_SET);
-	    move_entry(file_ptr, i, (i + (virt_num_data_entries / 2)));
-	    lock_and_unlock_random_entries(file_ptr, 0,
-			                   (virt_num_data_entries / 20),
+        lock_entry(file_ptr, i);
+        unlock_entry(file_ptr, i, H5AC__NO_FLAGS_SET);
+        move_entry(file_ptr, i, (i + (virt_num_data_entries / 2)));
+        lock_and_unlock_random_entries(file_ptr, 0,
+                            (virt_num_data_entries / 20),
                                            min_count, max_count);
         }
 
         /* ...and then move them back. */
         for ( i = (virt_num_data_entries / 2) - 1; i >= 0; i-- )
         {
-	    lock_entry(file_ptr, i);
-	    unlock_entry(file_ptr, i, H5AC__DIRTIED_FLAG);
-	    move_entry(file_ptr, i, (i + (virt_num_data_entries / 2)));
-	    lock_and_unlock_random_entries(file_ptr, 0,
-			                   (virt_num_data_entries / 40),
+        lock_entry(file_ptr, i);
+        unlock_entry(file_ptr, i, H5AC__DIRTIED_FLAG);
+        move_entry(file_ptr, i, (i + (virt_num_data_entries / 2)));
+        lock_and_unlock_random_entries(file_ptr, 0,
+                            (virt_num_data_entries / 40),
                                            min_count, max_count);
         }
 
@@ -6162,16 +6161,16 @@ smoke_check_3(int metadata_write_strategy)
 
         for ( i = 0; i < (virt_num_data_entries / 2); i+=2 )
         {
-	    local_pin_and_unpin_random_entries(file_ptr, 0,
-			                       (virt_num_data_entries / 2),
-					       0, 5);
+        local_pin_and_unpin_random_entries(file_ptr, 0,
+                                (virt_num_data_entries / 2),
+                        0, 5);
 
-	    lock_entry(file_ptr, i);
-	    unlock_entry(file_ptr, i, H5AC__DIRTIED_FLAG);
+        lock_entry(file_ptr, i);
+        unlock_entry(file_ptr, i, H5AC__DIRTIED_FLAG);
 
             if ( i > 100 ) {
 
-		lock_and_unlock_random_entries(file_ptr, (i - 100), i,
+        lock_and_unlock_random_entries(file_ptr, (i - 100), i,
                                                min_count, max_count);
             }
         }
@@ -6185,7 +6184,7 @@ smoke_check_3(int metadata_write_strategy)
 
                 nerrors++;
                 if ( verbose ) {
-		    HDfprintf(stdout, "%d:%s: take_down_cache() failed.\n",
+            HDfprintf(stdout, "%d:%s: take_down_cache() failed.\n",
                               world_mpi_rank, FUNC);
                 }
             }
@@ -6232,9 +6231,9 @@ smoke_check_3(int metadata_write_strategy)
 
     if ( world_mpi_rank == 0 ) {
 
-	if ( max_nerrors == 0 ) {
+    if ( max_nerrors == 0 ) {
 
-	    PASSED();
+        PASSED();
 
         } else {
 
@@ -6249,24 +6248,24 @@ smoke_check_3(int metadata_write_strategy)
 
 } /* smoke_check_3() */
 
-
+
 /*****************************************************************************
  *
- * Function:	smoke_check_4()
+ * Function:    smoke_check_4()
  *
- * Purpose:	Fourth smoke check for the parallel cache.
+ * Purpose:    Fourth smoke check for the parallel cache.
  *
- *		Use random reads to vary the loads on the diffferent
- *		processors.  Also force different cache size adjustments.
+ *        Use random reads to vary the loads on the diffferent
+ *        processors.  Also force different cache size adjustments.
  *
- *		In this test, load process 0 lightly, and the other
- *		processes heavily.
+ *        In this test, load process 0 lightly, and the other
+ *        processes heavily.
  *
- * Return:	Success:	TRUE
+ * Return:    Success:    TRUE
  *
- *		Failure:	FALSE
+ *        Failure:    FALSE
  *
- * Programmer:	JRM -- 1/13/06
+ * Programmer:    JRM -- 1/13/06
  *
  *****************************************************************************/
 static hbool_t
@@ -6286,23 +6285,23 @@ smoke_check_4(int metadata_write_strategy)
 
     switch ( metadata_write_strategy ) {
 
-	case H5AC_METADATA_WRITE_STRATEGY__PROCESS_0_ONLY:
+    case H5AC_METADATA_WRITE_STRATEGY__PROCESS_0_ONLY:
             if ( world_mpi_rank == 0 ) {
-        	TESTING("smoke check #4 -- process 0 only md write strategy");
+            TESTING("smoke check #4 -- process 0 only md write strategy");
             }
-	    break;
+        break;
 
-	case H5AC_METADATA_WRITE_STRATEGY__DISTRIBUTED:
+    case H5AC_METADATA_WRITE_STRATEGY__DISTRIBUTED:
             if ( world_mpi_rank == 0 ) {
-        	TESTING("smoke check #4 -- distributed md write strategy");
+            TESTING("smoke check #4 -- distributed md write strategy");
             }
-	    break;
+        break;
 
         default:
             if ( world_mpi_rank == 0 ) {
-        	TESTING("smoke check #4 -- unknown md write strategy");
+            TESTING("smoke check #4 -- unknown md write strategy");
             }
-	    break;
+        break;
     }
 
     nerrors = 0;
@@ -6311,12 +6310,12 @@ smoke_check_4(int metadata_write_strategy)
 
     if ( world_mpi_rank == world_server_mpi_rank ) {
 
-	if ( ! server_main() ) {
+    if ( ! server_main() ) {
 
             /* some error occured in the server -- report failure */
             nerrors++;
             if ( verbose ) {
-		HDfprintf(stdout, "%d:%s: server_main() failed.\n",
+        HDfprintf(stdout, "%d:%s: server_main() failed.\n",
                           world_mpi_rank, FUNC);
             }
         }
@@ -6330,7 +6329,7 @@ smoke_check_4(int metadata_write_strategy)
             fid = -1;
             cache_ptr = NULL;
             if ( verbose ) {
-		HDfprintf(stdout, "%d:%s: setup_cache_for_test() failed.\n",
+        HDfprintf(stdout, "%d:%s: setup_cache_for_test() failed.\n",
                           world_mpi_rank, FUNC);
             }
         }
@@ -6345,7 +6344,7 @@ smoke_check_4(int metadata_write_strategy)
 
             if ( i > 100 ) {
 
-		lock_and_unlock_random_entries(file_ptr, (i - 100), i,
+        lock_and_unlock_random_entries(file_ptr, (i - 100), i,
                                                min_count, max_count);
             }
         }
@@ -6354,23 +6353,23 @@ smoke_check_4(int metadata_write_strategy)
         max_count = min_count + 100;
 
         for ( i = (virt_num_data_entries / 4);
-	      i < (virt_num_data_entries / 2);
-	      i++ )
+        i < (virt_num_data_entries / 2);
+        i++ )
         {
-	    if ( i % 2 == 0 ) {
+        if ( i % 2 == 0 ) {
 
                 insert_entry(cache_ptr, file_ptr, i, H5AC__NO_FLAGS_SET);
 
-	    } else {
+        } else {
 
-		/* Insert some entries pinned, and then unpin them
-		 * immediately.  We have tested pinned entries elsewhere,
-		 * so it should be sufficient to verify that the
-		 * entries are in fact pinned (which unpin_entry() should do).
-		 */
+        /* Insert some entries pinned, and then unpin them
+        * immediately.  We have tested pinned entries elsewhere,
+        * so it should be sufficient to verify that the
+        * entries are in fact pinned (which unpin_entry() should do).
+        */
                 insert_entry(cache_ptr, file_ptr, i, H5C__PIN_ENTRY_FLAG);
                 unpin_entry(file_ptr, i, TRUE, FALSE, FALSE);
-	    }
+        }
 
             if ( i % 59 == 0 ) {
 
@@ -6390,19 +6389,19 @@ smoke_check_4(int metadata_write_strategy)
 
             if ( i > 100 ) {
 
-		lock_and_unlock_random_entries(file_ptr, (i - 100), i,
+        lock_and_unlock_random_entries(file_ptr, (i - 100), i,
                                                min_count, max_count);
             }
 
             local_pin_and_unpin_random_entries(file_ptr, 0,
-			                       (virt_num_data_entries / 4),
+                                (virt_num_data_entries / 4),
                                                0, (file_mpi_rank + 2));
         }
 
 
         /* flush the file to be sure that we have no problems flushing
-	 * pinned entries
-	 */
+    * pinned entries
+    */
         if ( H5Fflush(fid, H5F_SCOPE_GLOBAL) < 0 ) {
             nerrors++;
             if ( verbose ) {
@@ -6429,13 +6428,13 @@ smoke_check_4(int metadata_write_strategy)
                 unpin_entry(file_ptr, i, TRUE, dirty, via_unprotect);
             }
 
-	    if ( i % 2 == 0 ) {
+        if ( i % 2 == 0 ) {
 
-	        lock_entry(file_ptr, i);
-	        unlock_entry(file_ptr, i, H5AC__NO_FLAGS_SET);
-	        lock_and_unlock_random_entries(file_ptr,
+            lock_entry(file_ptr, i);
+            unlock_entry(file_ptr, i, H5AC__NO_FLAGS_SET);
+            lock_and_unlock_random_entries(file_ptr,
                                                min_idx, max_idx, 0, 100);
-	    }
+        }
         }
 
         min_idx = 0;
@@ -6444,14 +6443,14 @@ smoke_check_4(int metadata_write_strategy)
 
         for ( i = 0; i < (virt_num_data_entries / 2); i+=2 )
         {
-	    lock_entry(file_ptr, i);
-	    unlock_entry(file_ptr, i, H5AC__DIRTIED_FLAG);
-	    lock_and_unlock_random_entries(file_ptr,
+        lock_entry(file_ptr, i);
+        unlock_entry(file_ptr, i, H5AC__DIRTIED_FLAG);
+        lock_and_unlock_random_entries(file_ptr,
                                            min_idx, max_idx, 0, 100);
         }
 
-	/* we can't move pinned entries, so release any local pins now. */
-	local_unpin_all_entries(file_ptr, FALSE);
+    /* we can't move pinned entries, so release any local pins now. */
+    local_unpin_all_entries(file_ptr, FALSE);
 
         min_count = 10 * (file_mpi_rank % 4);
         max_count = min_count + 100;
@@ -6459,22 +6458,22 @@ smoke_check_4(int metadata_write_strategy)
         /* move the first half of the entries... */
         for ( i = 0; i < (virt_num_data_entries / 2); i++ )
         {
-	    lock_entry(file_ptr, i);
-	    unlock_entry(file_ptr, i, H5AC__NO_FLAGS_SET);
-	    move_entry(file_ptr, i, (i + (virt_num_data_entries / 2)));
-	    lock_and_unlock_random_entries(file_ptr, 0,
-			                   (virt_num_data_entries / 20),
+        lock_entry(file_ptr, i);
+        unlock_entry(file_ptr, i, H5AC__NO_FLAGS_SET);
+        move_entry(file_ptr, i, (i + (virt_num_data_entries / 2)));
+        lock_and_unlock_random_entries(file_ptr, 0,
+                            (virt_num_data_entries / 20),
                                            min_count, max_count);
         }
 
         /* ...and then move them back. */
         for ( i = (virt_num_data_entries / 2) - 1; i >= 0; i-- )
         {
-	    lock_entry(file_ptr, i);
-	    unlock_entry(file_ptr, i, H5AC__DIRTIED_FLAG);
-	    move_entry(file_ptr, i, (i + (virt_num_data_entries / 2)));
-	    lock_and_unlock_random_entries(file_ptr, 0,
-			                   (virt_num_data_entries / 40),
+        lock_entry(file_ptr, i);
+        unlock_entry(file_ptr, i, H5AC__DIRTIED_FLAG);
+        move_entry(file_ptr, i, (i + (virt_num_data_entries / 2)));
+        lock_and_unlock_random_entries(file_ptr, 0,
+                            (virt_num_data_entries / 40),
                                            min_count, max_count);
         }
 
@@ -6486,12 +6485,12 @@ smoke_check_4(int metadata_write_strategy)
 
         for ( i = 0; i < (virt_num_data_entries / 2); i+=2 )
         {
-	    lock_entry(file_ptr, i);
-	    unlock_entry(file_ptr, i, H5AC__DIRTIED_FLAG);
+        lock_entry(file_ptr, i);
+        unlock_entry(file_ptr, i, H5AC__DIRTIED_FLAG);
 
             if ( i > 100 ) {
 
-		lock_and_unlock_random_entries(file_ptr, (i - 100), i,
+        lock_and_unlock_random_entries(file_ptr, (i - 100), i,
                                                min_count, max_count);
             }
         }
@@ -6502,7 +6501,7 @@ smoke_check_4(int metadata_write_strategy)
 
                 nerrors++;
                 if ( verbose ) {
-		    HDfprintf(stdout, "%d:%s: take_down_cache() failed.\n",
+            HDfprintf(stdout, "%d:%s: take_down_cache() failed.\n",
                               world_mpi_rank, FUNC);
                 }
             }
@@ -6549,9 +6548,9 @@ smoke_check_4(int metadata_write_strategy)
 
     if ( world_mpi_rank == 0 ) {
 
-	if ( max_nerrors == 0 ) {
+    if ( max_nerrors == 0 ) {
 
-	    PASSED();
+        PASSED();
 
         } else {
 
@@ -6566,19 +6565,19 @@ smoke_check_4(int metadata_write_strategy)
 
 } /* smoke_check_4() */
 
-
+
 /*****************************************************************************
  *
- * Function:	smoke_check_5()
+ * Function:    smoke_check_5()
  *
- * Purpose:	Similar to smoke check 1, but modified to verify that
- * 		H5AC_mark_entry_dirty() works in the parallel case.
+ * Purpose:    Similar to smoke check 1, but modified to verify that
+ *         H5AC_mark_entry_dirty() works in the parallel case.
  *
- * Return:	Success:	TRUE
+ * Return:    Success:    TRUE
  *
- *		Failure:	FALSE
+ *        Failure:    FALSE
  *
- * Programmer:	JRM -- 5/18/06
+ * Programmer:    JRM -- 5/18/06
  *
  *****************************************************************************/
 static hbool_t
@@ -6594,23 +6593,23 @@ smoke_check_5(int metadata_write_strategy)
 
     switch ( metadata_write_strategy ) {
 
-	case H5AC_METADATA_WRITE_STRATEGY__PROCESS_0_ONLY:
+    case H5AC_METADATA_WRITE_STRATEGY__PROCESS_0_ONLY:
             if ( world_mpi_rank == 0 ) {
-        	TESTING("smoke check #5 -- process 0 only md write strategy");
+            TESTING("smoke check #5 -- process 0 only md write strategy");
             }
-	    break;
+        break;
 
-	case H5AC_METADATA_WRITE_STRATEGY__DISTRIBUTED:
+    case H5AC_METADATA_WRITE_STRATEGY__DISTRIBUTED:
             if ( world_mpi_rank == 0 ) {
-        	TESTING("smoke check #5 -- distributed md write strategy");
+            TESTING("smoke check #5 -- distributed md write strategy");
             }
-	    break;
+        break;
 
         default:
             if ( world_mpi_rank == 0 ) {
-        	TESTING("smoke check #5 -- unknown md write strategy");
+            TESTING("smoke check #5 -- unknown md write strategy");
             }
-	    break;
+        break;
     }
 
 
@@ -6620,12 +6619,12 @@ smoke_check_5(int metadata_write_strategy)
 
     if ( world_mpi_rank == world_server_mpi_rank ) {
 
-	if ( ! server_main() ) {
+    if ( ! server_main() ) {
 
             /* some error occured in the server -- report failure */
             nerrors++;
             if ( verbose ) {
-		HDfprintf(stdout, "%d:%s: server_main() failed.\n",
+        HDfprintf(stdout, "%d:%s: server_main() failed.\n",
                           world_mpi_rank, FUNC);
             }
         }
@@ -6640,7 +6639,7 @@ smoke_check_5(int metadata_write_strategy)
             fid = -1;
             cache_ptr = NULL;
             if ( verbose ) {
-		HDfprintf(stdout, "%d:%s: setup_cache_for_test() failed.\n",
+        HDfprintf(stdout, "%d:%s: setup_cache_for_test() failed.\n",
                           world_mpi_rank, FUNC);
             }
         }
@@ -6650,60 +6649,60 @@ smoke_check_5(int metadata_write_strategy)
             insert_entry(cache_ptr, file_ptr, i, H5AC__NO_FLAGS_SET);
         }
 
-	/* flush the file so we can lock known clean entries. */
+    /* flush the file so we can lock known clean entries. */
         if ( H5Fflush(fid, H5F_SCOPE_GLOBAL) < 0 ) {
             nerrors++;
             if ( verbose ) {
-	        HDfprintf(stdout, "%d:%s: H5Fflush() failed.\n",
+            HDfprintf(stdout, "%d:%s: H5Fflush() failed.\n",
                           world_mpi_rank, FUNC);
             }
         }
 
         for ( i = 0; i < (virt_num_data_entries / 4); i++ )
         {
-	    lock_entry(file_ptr, i);
+        lock_entry(file_ptr, i);
 
-	    if ( i % 2 == 0 )
-	    {
-		mark_entry_dirty(i);
-	    }
+        if ( i % 2 == 0 )
+        {
+        mark_entry_dirty(i);
+        }
 
-	    unlock_entry(file_ptr, i, H5AC__NO_FLAGS_SET);
+        unlock_entry(file_ptr, i, H5AC__NO_FLAGS_SET);
 
-	    if ( i % 2 == 1 )
-	    {
-		if ( i % 4 == 1 ) {
+        if ( i % 2 == 1 )
+        {
+        if ( i % 4 == 1 ) {
 
-	            lock_entry(file_ptr, i);
-	            unlock_entry(file_ptr, i, H5AC__DIRTIED_FLAG);
-		}
+                lock_entry(file_ptr, i);
+                unlock_entry(file_ptr, i, H5AC__DIRTIED_FLAG);
+        }
 
-	        expunge_entry(file_ptr, i);
-	    }
+            expunge_entry(file_ptr, i);
+        }
         }
 
         for ( i = (virt_num_data_entries / 2) - 1;
               i >= (virt_num_data_entries / 4);
-	      i-- )
+        i-- )
         {
-	    pin_entry(file_ptr, i, TRUE, FALSE);
+        pin_entry(file_ptr, i, TRUE, FALSE);
 
-	    if ( i % 2 == 0 )
-	    {
-		if ( i % 8 <= 4 ) {
+        if ( i % 2 == 0 )
+        {
+        if ( i % 8 <= 4 ) {
 
-		    resize_entry(i, data[i].len / 2);
-		}
+            resize_entry(i, data[i].len / 2);
+        }
 
                 mark_entry_dirty(i);
 
-		if ( i % 8 <= 4 ) {
+        if ( i % 8 <= 4 ) {
 
-		    resize_entry(i, data[i].len);
-		}
-	    }
+            resize_entry(i, data[i].len);
+        }
+        }
 
-	    unpin_entry(file_ptr, i, TRUE, FALSE, FALSE);
+        unpin_entry(file_ptr, i, TRUE, FALSE, FALSE);
         }
 
         if ( fid >= 0 ) {
@@ -6712,7 +6711,7 @@ smoke_check_5(int metadata_write_strategy)
 
                 nerrors++;
                 if ( verbose ) {
-		    HDfprintf(stdout, "%d:%s: take_down_cache() failed.\n",
+            HDfprintf(stdout, "%d:%s: take_down_cache() failed.\n",
                               world_mpi_rank, FUNC);
                 }
             }
@@ -6758,9 +6757,9 @@ smoke_check_5(int metadata_write_strategy)
 
     if ( world_mpi_rank == 0 ) {
 
-	if ( max_nerrors == 0 ) {
+    if ( max_nerrors == 0 ) {
 
-	    PASSED();
+        PASSED();
 
         } else {
 
@@ -6775,10 +6774,10 @@ smoke_check_5(int metadata_write_strategy)
 
 } /* smoke_check_5() */
 
-
+
 /*****************************************************************************
  *
- * Function:	trace_file_check()
+ * Function:    trace_file_check()
  *
  * Purpose:     A basic test of the trace file capability.  In essence,
  *              we invoke all operations that generate trace file output,
@@ -6808,11 +6807,11 @@ smoke_check_5(int metadata_write_strategy)
  *
  *              This test is skipped if H5_METADATA_TRACE_FILE is undefined.
  *
- * Return:	Success:	TRUE
+ * Return:    Success:    TRUE
  *
- *		Failure:	FALSE
+ *        Failure:    FALSE
  *
- * Programmer:	JRM -- 6/13/06
+ * Programmer:    JRM -- 6/13/06
  *
  *****************************************************************************/
 static hbool_t
@@ -6897,25 +6896,25 @@ trace_file_check(int metadata_write_strategy)
 
     switch ( metadata_write_strategy ) {
 
-	case H5AC_METADATA_WRITE_STRATEGY__PROCESS_0_ONLY:
+    case H5AC_METADATA_WRITE_STRATEGY__PROCESS_0_ONLY:
 #ifdef H5_METADATA_TRACE_FILE
             expected_output = &expected_output_0;
 #endif /* H5_METADATA_TRACE_FILE */
             if ( world_mpi_rank == 0 ) {
-        	TESTING(
-		    "trace file collection -- process 0 only md write strategy");
+            TESTING(
+            "trace file collection -- process 0 only md write strategy");
             }
-	    break;
+        break;
 
-	case H5AC_METADATA_WRITE_STRATEGY__DISTRIBUTED:
+    case H5AC_METADATA_WRITE_STRATEGY__DISTRIBUTED:
 #ifdef H5_METADATA_TRACE_FILE
             expected_output = &expected_output_1;
 #endif /* H5_METADATA_TRACE_FILE */
             if ( world_mpi_rank == 0 ) {
-        	TESTING(
-		    "trace file collection -- distributed md write strategy");
+            TESTING(
+            "trace file collection -- distributed md write strategy");
             }
-	    break;
+        break;
 
         default:
 #ifdef H5_METADATA_TRACE_FILE
@@ -6925,9 +6924,9 @@ trace_file_check(int metadata_write_strategy)
             expected_output = &expected_output_0;
 #endif /* H5_METADATA_TRACE_FILE */
             if ( world_mpi_rank == 0 ) {
-        	TESTING("trace file collection -- unknown md write strategy");
+            TESTING("trace file collection -- unknown md write strategy");
             }
-	    break;
+        break;
     }
 
 #ifdef H5_METADATA_TRACE_FILE
@@ -6938,12 +6937,12 @@ trace_file_check(int metadata_write_strategy)
 
     if ( world_mpi_rank == world_server_mpi_rank ) {
 
-	if ( ! server_main() ) {
+    if ( ! server_main() ) {
 
             /* some error occured in the server -- report failure */
             nerrors++;
             if ( verbose ) {
-		HDfprintf(stdout, "%d:%s: server_main() failed.\n",
+        HDfprintf(stdout, "%d:%s: server_main() failed.\n",
                           world_mpi_rank, FUNC);
             }
         }
@@ -6958,7 +6957,7 @@ trace_file_check(int metadata_write_strategy)
             fid = -1;
             cache_ptr = NULL;
             if ( verbose ) {
-		HDfprintf(stdout, "%d:%s: setup_cache_for_test() failed.\n",
+        HDfprintf(stdout, "%d:%s: setup_cache_for_test() failed.\n",
                           world_mpi_rank, FUNC);
             }
         }
@@ -6970,58 +6969,58 @@ trace_file_check(int metadata_write_strategy)
             if ( H5AC_get_cache_auto_resize_config(cache_ptr, &config)
                  != SUCCEED ) {
 
-		nerrors++;
-	        HDfprintf(stdout,
+        nerrors++;
+            HDfprintf(stdout,
                         "%d:%s: H5AC_get_cache_auto_resize_config() failed.\n",
                         world_mpi_rank, FUNC);
 
             } else {
 
                 config.open_trace_file = TRUE;
-		strcpy(config.trace_file_name, "t_cache_trace.txt");
+        strcpy(config.trace_file_name, "t_cache_trace.txt");
 
                 if ( H5AC_set_cache_auto_resize_config(cache_ptr, &config)
-			!= SUCCEED ) {
+            != SUCCEED ) {
 
-		    nerrors++;
-	            HDfprintf(stdout,
+            nerrors++;
+                HDfprintf(stdout,
                          "%d:%s: H5AC_set_cache_auto_resize_config() failed.\n",
                           world_mpi_rank, FUNC);
                 }
             }
         }
 
-	insert_entry(cache_ptr, file_ptr, 0, H5AC__NO_FLAGS_SET);
-	insert_entry(cache_ptr, file_ptr, 1, H5AC__NO_FLAGS_SET);
-	insert_entry(cache_ptr, file_ptr, 2, H5AC__NO_FLAGS_SET);
-	insert_entry(cache_ptr, file_ptr, 3, H5AC__NO_FLAGS_SET);
+    insert_entry(cache_ptr, file_ptr, 0, H5AC__NO_FLAGS_SET);
+    insert_entry(cache_ptr, file_ptr, 1, H5AC__NO_FLAGS_SET);
+    insert_entry(cache_ptr, file_ptr, 2, H5AC__NO_FLAGS_SET);
+    insert_entry(cache_ptr, file_ptr, 3, H5AC__NO_FLAGS_SET);
 
-	lock_entry(file_ptr, 0);
-	mark_entry_dirty(0);
-	unlock_entry(file_ptr, 0, H5AC__NO_FLAGS_SET);
+    lock_entry(file_ptr, 0);
+    mark_entry_dirty(0);
+    unlock_entry(file_ptr, 0, H5AC__NO_FLAGS_SET);
 
-	lock_entry(file_ptr, 1);
+    lock_entry(file_ptr, 1);
         pin_protected_entry(1, TRUE);
-	unlock_entry(file_ptr, 1, H5AC__NO_FLAGS_SET);
+    unlock_entry(file_ptr, 1, H5AC__NO_FLAGS_SET);
         unpin_entry(file_ptr, 1, TRUE, FALSE, FALSE);
 
         expunge_entry(file_ptr, 1);
 
-	lock_entry(file_ptr, 2);
+    lock_entry(file_ptr, 2);
         pin_protected_entry(2, TRUE);
-	unlock_entry(file_ptr, 2, H5AC__NO_FLAGS_SET);
-	mark_entry_dirty(2);
+    unlock_entry(file_ptr, 2, H5AC__NO_FLAGS_SET);
+    mark_entry_dirty(2);
         resize_entry(2, data[2].len / 2);
         resize_entry(2, data[2].len);
         unpin_entry(file_ptr, 2, TRUE, FALSE, FALSE);
 
-	move_entry(file_ptr, 0, 20);
-	move_entry(file_ptr, 0, 20);
+    move_entry(file_ptr, 0, 20);
+    move_entry(file_ptr, 0, 20);
 
         if ( H5Fflush(fid, H5F_SCOPE_GLOBAL) < 0 ) {
             nerrors++;
             if ( verbose ) {
-	        HDfprintf(stdout, "%d:%s: H5Fflush() failed.\n",
+            HDfprintf(stdout, "%d:%s: H5Fflush() failed.\n",
                           world_mpi_rank, FUNC);
             }
         }
@@ -7033,8 +7032,8 @@ trace_file_check(int metadata_write_strategy)
             if ( H5AC_get_cache_auto_resize_config(cache_ptr, &config)
                  != SUCCEED ) {
 
-		nerrors++;
-	        HDfprintf(stdout,
+        nerrors++;
+            HDfprintf(stdout,
                         "%d:%s: H5AC_get_cache_auto_resize_config() failed.\n",
                         world_mpi_rank, FUNC);
 
@@ -7042,13 +7041,13 @@ trace_file_check(int metadata_write_strategy)
 
                 config.open_trace_file = FALSE;
                 config.close_trace_file = TRUE;
-		config.trace_file_name[0] = '\0';
+        config.trace_file_name[0] = '\0';
 
                 if ( H5AC_set_cache_auto_resize_config(cache_ptr, &config)
-			!= SUCCEED ) {
+            != SUCCEED ) {
 
-		    nerrors++;
-	            HDfprintf(stdout,
+            nerrors++;
+                HDfprintf(stdout,
                         "%d:%s: H5AC_set_cache_auto_resize_config() failed.\n",
                         world_mpi_rank, FUNC);
                 }
@@ -7061,7 +7060,7 @@ trace_file_check(int metadata_write_strategy)
 
                 nerrors++;
                 if ( verbose ) {
-		    HDfprintf(stdout, "%d:%s: take_down_cache() failed.\n",
+            HDfprintf(stdout, "%d:%s: take_down_cache() failed.\n",
                               world_mpi_rank, FUNC);
                 }
             }
@@ -7104,10 +7103,10 @@ trace_file_check(int metadata_write_strategy)
 
         if ( nerrors == 0 ) {
 
-	    sprintf(trace_file_name, "t_cache_trace.txt.%d",
-		    (int)file_mpi_rank);
+        sprintf(trace_file_name, "t_cache_trace.txt.%d",
+            (int)file_mpi_rank);
 
-	    if ( (trace_file_ptr = HDfopen(trace_file_name, "r")) == NULL ) {
+        if ( (trace_file_ptr = HDfopen(trace_file_name, "r")) == NULL ) {
 
                 nerrors++;
                 if ( verbose ) {
@@ -7115,59 +7114,59 @@ trace_file_check(int metadata_write_strategy)
                               world_mpi_rank, FUNC);
                 }
             }
-	}
+    }
 
-	i = 0;
-	while ( ( nerrors == 0 ) && ( ! done ) )
-	{
-	    if ( (*expected_output)[i] == NULL ) {
+    i = 0;
+    while ( ( nerrors == 0 ) && ( ! done ) )
+    {
+        if ( (*expected_output)[i] == NULL ) {
 
-		expected_line_len = 0;
+        expected_line_len = 0;
 
-	    } else {
+        } else {
 
-		expected_line_len = HDstrlen((*expected_output)[i]);
-	    }
+        expected_line_len = HDstrlen((*expected_output)[i]);
+        }
 
-	    if ( HDfgets(buffer, 255, trace_file_ptr) != NULL ) {
+        if ( HDfgets(buffer, 255, trace_file_ptr) != NULL ) {
 
-	        actual_line_len = strlen(buffer);
+            actual_line_len = strlen(buffer);
 
-	    } else {
+        } else {
 
-	        actual_line_len = 0;
-	    }
+            actual_line_len = 0;
+        }
 
-	    if ( ( actual_line_len == 0 ) && ( expected_line_len == 0 ) ) {
+        if ( ( actual_line_len == 0 ) && ( expected_line_len == 0 ) ) {
 
-	        done = TRUE;
+            done = TRUE;
 
-	    } else if ( ( actual_line_len != expected_line_len ) ||
-		        ( HDstrcmp(buffer, (*expected_output)[i]) != 0 ) ) {
+        } else if ( ( actual_line_len != expected_line_len ) ||
+                ( HDstrcmp(buffer, (*expected_output)[i]) != 0 ) ) {
 
-	        nerrors++;
+            nerrors++;
                 if ( verbose ) {
                     HDfprintf(stdout,
-			      "%d:%s: Unexpected data in trace file line %d.\n",
+                "%d:%s: Unexpected data in trace file line %d.\n",
                               world_mpi_rank, FUNC, i);
-		    HDfprintf(stdout, "%d:%s: expected = \"%s\" %d\n",
-			       world_mpi_rank, FUNC, (*expected_output)[i],
-			       expected_line_len);
-		    HDfprintf(stdout, "%d:%s: actual   = \"%s\" %d\n",
-			       world_mpi_rank, FUNC, buffer,
-			       actual_line_len);
+            HDfprintf(stdout, "%d:%s: expected = \"%s\" %d\n",
+                world_mpi_rank, FUNC, (*expected_output)[i],
+                expected_line_len);
+            HDfprintf(stdout, "%d:%s: actual   = \"%s\" %d\n",
+                world_mpi_rank, FUNC, buffer,
+                actual_line_len);
                 }
-	    } else {
-	        i++;
-	    }
-	}
+        } else {
+            i++;
+        }
+    }
 
-	if ( trace_file_ptr != NULL ) {
+    if ( trace_file_ptr != NULL ) {
 
-	    HDfclose(trace_file_ptr);
-	    trace_file_ptr = NULL;
+        HDfclose(trace_file_ptr);
+        trace_file_ptr = NULL;
 #if 1
-	    HDremove(trace_file_name);
+        HDremove(trace_file_name);
 #endif
         }
     }
@@ -7176,9 +7175,9 @@ trace_file_check(int metadata_write_strategy)
 
     if ( world_mpi_rank == 0 ) {
 
-	if ( max_nerrors == 0 ) {
+    if ( max_nerrors == 0 ) {
 
-	    PASSED();
+        PASSED();
 
         } else {
 
@@ -7204,18 +7203,18 @@ trace_file_check(int metadata_write_strategy)
 
 } /* trace_file_check() */
 
-
+
 /*****************************************************************************
  *
- * Function:	smoke_check_6()
+ * Function:    smoke_check_6()
  *
- * Purpose:	Sixth smoke check for the parallel cache.
+ * Purpose:    Sixth smoke check for the parallel cache.
  *
- * Return:	Success:	TRUE
+ * Return:    Success:    TRUE
  *
- *		Failure:	FALSE
+ *        Failure:    FALSE
  *
- * Programmer:	JRM -- 1/13/06
+ * Programmer:    JRM -- 1/13/06
  *
  *****************************************************************************/
 static hbool_t
@@ -7231,23 +7230,23 @@ smoke_check_6(int metadata_write_strategy)
 
     switch ( metadata_write_strategy ) {
 
-	case H5AC_METADATA_WRITE_STRATEGY__PROCESS_0_ONLY:
+    case H5AC_METADATA_WRITE_STRATEGY__PROCESS_0_ONLY:
             if ( world_mpi_rank == 0 ) {
-        	TESTING("smoke check #6 -- process 0 only md write strategy");
+            TESTING("smoke check #6 -- process 0 only md write strategy");
             }
-	    break;
+        break;
 
-	case H5AC_METADATA_WRITE_STRATEGY__DISTRIBUTED:
+    case H5AC_METADATA_WRITE_STRATEGY__DISTRIBUTED:
             if ( world_mpi_rank == 0 ) {
-        	TESTING("smoke check #6 -- distributed md write strategy");
+            TESTING("smoke check #6 -- distributed md write strategy");
             }
-	    break;
+        break;
 
         default:
             if ( world_mpi_rank == 0 ) {
-        	TESTING("smoke check #6 -- unknown md write strategy");
+            TESTING("smoke check #6 -- unknown md write strategy");
             }
-	    break;
+        break;
     }
 
     nerrors = 0;
@@ -7256,12 +7255,12 @@ smoke_check_6(int metadata_write_strategy)
 
     if ( world_mpi_rank == world_server_mpi_rank ) {
 
-	if ( ! server_main() ) {
+    if ( ! server_main() ) {
 
             /* some error occured in the server -- report failure */
             nerrors++;
             if ( verbose ) {
-		HDfprintf(stdout, "%d:%s: server_main() failed.\n",
+        HDfprintf(stdout, "%d:%s: server_main() failed.\n",
                           world_mpi_rank, FUNC);
             }
         }
@@ -7277,7 +7276,7 @@ smoke_check_6(int metadata_write_strategy)
             fid = -1;
             cache_ptr = NULL;
             if ( verbose ) {
-		HDfprintf(stdout, "%d:%s: setup_cache_for_test() failed.\n",
+        HDfprintf(stdout, "%d:%s: setup_cache_for_test() failed.\n",
                           world_mpi_rank, FUNC);
             }
         }
@@ -7327,11 +7326,11 @@ smoke_check_6(int metadata_write_strategy)
             HDassert(cache_ptr->max_cache_size*0.8 > cache_ptr->coll_list_size);
         }
 
-	/* flush the file */
+    /* flush the file */
         if ( H5Fflush(fid, H5F_SCOPE_GLOBAL) < 0 ) {
             nerrors++;
             if ( verbose ) {
-	        HDfprintf(stdout, "%d:%s: H5Fflush() failed.\n",
+            HDfprintf(stdout, "%d:%s: H5Fflush() failed.\n",
                           world_mpi_rank, FUNC);
             }
         }
@@ -7343,7 +7342,7 @@ smoke_check_6(int metadata_write_strategy)
             struct datum * entry_ptr;
             entry_ptr = &(data[i]);
 
-	    lock_entry(file_ptr, i);
+        lock_entry(file_ptr, i);
 
             if(TRUE != entry_ptr->header.coll_access) {
                 nerrors++;
@@ -7364,7 +7363,7 @@ smoke_check_6(int metadata_write_strategy)
             struct datum * entry_ptr;
             entry_ptr = &(data[i]);
 
-	    lock_entry(file_ptr, i);
+        lock_entry(file_ptr, i);
 
             if(FALSE != entry_ptr->header.coll_access) {
                 nerrors++;
@@ -7389,7 +7388,7 @@ smoke_check_6(int metadata_write_strategy)
 
                 nerrors++;
                 if ( verbose ) {
-		    HDfprintf(stdout, "%d:%s: take_down_cache() failed.\n",
+            HDfprintf(stdout, "%d:%s: take_down_cache() failed.\n",
                               world_mpi_rank, FUNC);
                 }
             }
@@ -7437,9 +7436,9 @@ smoke_check_6(int metadata_write_strategy)
 
     if ( world_mpi_rank == 0 ) {
 
-	if ( max_nerrors == 0 ) {
+    if ( max_nerrors == 0 ) {
 
-	    PASSED();
+        PASSED();
 
         } else {
 
@@ -7454,18 +7453,18 @@ smoke_check_6(int metadata_write_strategy)
 
 } /* smoke_check_6() */
 
-
+
 /*****************************************************************************
  *
- * Function:	main()
+ * Function:    main()
  *
- * Purpose:	Main function for the parallel cache test.
+ * Purpose:    Main function for the parallel cache test.
  *
- * Return:	Success:	0
+ * Return:    Success:    0
  *
- *		Failure:	1
+ *        Failure:    1
  *
- * Programmer:	JRM -- 12/23/05
+ * Programmer:    JRM -- 12/23/05
  *
  *****************************************************************************/
 int
@@ -7492,7 +7491,7 @@ main(int argc, char **argv)
      * calls.  By then, MPI calls may not work.
      */
     if (H5dont_atexit() < 0){
-	printf("%d:Failed to turn off atexit processing. Continue.\n", 
+    printf("%d:Failed to turn off atexit processing. Continue.\n",
                mpi_rank);
     };
     H5open();
@@ -7503,32 +7502,32 @@ main(int argc, char **argv)
 #endif /* JRM */
     if ( express_test ) {
 
-	virt_num_data_entries = EXPRESS_VIRT_NUM_DATA_ENTRIES;
+    virt_num_data_entries = EXPRESS_VIRT_NUM_DATA_ENTRIES;
 
     } else {
 
-	virt_num_data_entries = STD_VIRT_NUM_DATA_ENTRIES;
+    virt_num_data_entries = STD_VIRT_NUM_DATA_ENTRIES;
     }
 
 #ifdef H5_HAVE_MPE
-    if ( MAINPROCESS ) { printf("	Tests compiled for MPE.\n"); }
+    if ( MAINPROCESS ) { printf("    Tests compiled for MPE.\n"); }
     virt_num_data_entries = MPE_VIRT_NUM_DATA_ENTIES;
 #endif /* H5_HAVE_MPE */
 
 
     if (MAINPROCESS){
-	printf("===================================\n");
-	printf("Parallel metadata cache tests\n");
-	printf("	mpi_size     = %d\n", mpi_size);
-	printf("	express_test = %d\n", express_test);
-	printf("===================================\n");
+    printf("===================================\n");
+    printf("Parallel metadata cache tests\n");
+    printf("    mpi_size     = %d\n", mpi_size);
+    printf("    express_test = %d\n", express_test);
+    printf("===================================\n");
     }
 
     if ( mpi_size < 3 ) {
 
         if ( MAINPROCESS ) {
 
-            printf("	Need at least 3 processes.  Exiting.\n");
+            printf("    Need at least 3 processes.  Exiting.\n");
         }
         goto finish;
     }
@@ -7547,8 +7546,8 @@ main(int argc, char **argv)
     /* setup file access property list with the world communicator */
     if ( FAIL == (fapl = H5Pcreate(H5P_FILE_ACCESS)) ) {
         nerrors++;
-	if ( verbose ) {
-	    HDfprintf(stdout, "%d:%s: H5Pcreate() failed 1.\n",
+    if ( verbose ) {
+        HDfprintf(stdout, "%d:%s: H5Pcreate() failed 1.\n",
                       world_mpi_rank, FUNC);
         }
     }
@@ -7580,8 +7579,8 @@ main(int argc, char **argv)
     /* close the fapl before we set it up again */
     if ( H5Pclose(fapl) < 0 ) {
         nerrors++;
-	if ( verbose ) {
-	    HDfprintf(stdout, "%d:%s: H5Pclose() failed.\n",
+    if ( verbose ) {
+        HDfprintf(stdout, "%d:%s: H5Pclose() failed.\n",
                       world_mpi_rank, FUNC);
         }
     }
@@ -7591,9 +7590,9 @@ main(int argc, char **argv)
 
         /* setup file access property list */
         if ( FAIL == (fapl = H5Pcreate(H5P_FILE_ACCESS)) ) {
-	    nerrors++;
-	    if ( verbose ) {
-	        HDfprintf(stdout, "%d:%s: H5Pcreate() failed 2.\n",
+        nerrors++;
+        if ( verbose ) {
+            HDfprintf(stdout, "%d:%s: H5Pcreate() failed 2.\n",
                           world_mpi_rank, FUNC);
             }
         }
@@ -7601,8 +7600,8 @@ main(int argc, char **argv)
         if ( H5Pset_fapl_mpio(fapl, file_mpi_comm, MPI_INFO_NULL) < 0 ) {
 
             nerrors++;
-	    if ( verbose ) {
-	        HDfprintf(stdout, "%d:%s: H5Pset_fapl_mpio() failed 2.\n",
+        if ( verbose ) {
+            HDfprintf(stdout, "%d:%s: H5Pset_fapl_mpio() failed 2.\n",
                           world_mpi_rank, FUNC);
             }
         }
@@ -7620,7 +7619,7 @@ main(int argc, char **argv)
 
             HDfprintf(stdout, "Errors in test initialization.  Exiting.\n");
         }
-	goto finish;
+    goto finish;
     }
 
     /* run the tests */
@@ -7673,16 +7672,16 @@ finish:
      * and exit.
      */
     MPI_Barrier(MPI_COMM_WORLD);
-    if (MAINPROCESS){		/* only process 0 reports */
-	printf("===================================\n");
-	if (failures){
-	    printf("***metadata cache tests detected %d failures***\n",
+    if (MAINPROCESS){        /* only process 0 reports */
+    printf("===================================\n");
+    if (failures){
+        printf("***metadata cache tests detected %d failures***\n",
                    failures);
-	}
-	else{
-	    printf("metadata cache tests finished with no failures\n");
-	}
-	printf("===================================\n");
+    }
+    else{
+        printf("metadata cache tests finished with no failures\n");
+    }
+    printf("===================================\n");
     }
 
     takedown_derived_types();