[svn-r18725] Description:

	Bring r18724 from metadata journaling 'merging' branch to trunk:

	Rename H5[A]C_rename to H5[A]C_move_entry.

Tested on:
        FreeBSD/32 6.3 (duty) in debug mode
        FreeBSD/64 6.3 (liberty) w/C++ & FORTRAN, in debug mode
        Linux/32 2.6 (jam) w/PGI compilers, w/default API=1.8.x,
                w/C++ & FORTRAN, w/threadsafe, in debug mode
        Linux/64-amd64 2.6 (amani) w/Intel compilers, w/default API=1.6.x,
                w/C++ & FORTRAN, in production mode
        Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
                w/szip filter, in production mode
        Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
                in production mode
        Linux/64-amd64 2.6 (abe) w/parallel, w/FORTRAN, in production mode
        Mac OS X/32 10.6.3 (amazon) in debug mode
        Mac OS X/32 10.6.3 (amazon) w/C++ & FORTRAN, w/threadsafe,
                in production mode

3 files changed, 199 insertions, 199 deletions

diff --git a/test/cache.c b/test/cache.c
index 8eb7d37..09cecf2 100644
--- a/test/cache.c
+++ b/test/cache.c
@@ -97,16 +97,16 @@ static unsigned check_flush_protected_err(void);
 static unsigned check_get_entry_status(void);
 static unsigned check_expunge_entry(void);
 static unsigned check_multiple_read_protect(void);
-static unsigned check_rename_entry(void);
-static void check_rename_entry__run_test(H5F_t * file_ptr, int test_num,
-                                      struct rename_entry_test_spec * spec_ptr);
+static unsigned check_move_entry(void);
+static void check_move_entry__run_test(H5F_t * file_ptr, int test_num,
+                                      struct move_entry_test_spec * spec_ptr);
 static unsigned check_pin_protected_entry(void);
 static unsigned check_resize_entry(void);
 static unsigned check_evictions_enabled(void);
 static unsigned check_destroy_pinned_err(void);
 static unsigned check_destroy_protected_err(void);
 static unsigned check_duplicate_insert_err(void);
-static unsigned check_rename_err(void);
+static unsigned check_move_err(void);
 static unsigned check_double_pin_err(void);
 static unsigned check_double_unpin_err(void);
 static unsigned check_pin_entry_errs(void);
@@ -139,7 +139,7 @@ static unsigned check_notify_cb(void);
 /*-------------------------------------------------------------------------
  * Function:	smoke_check_1()
  *
- * Purpose:	A basic functional test, inserts, destroys, and renames in
+ * Purpose:	A basic functional test, inserts, destroys, and moves in
  *              the mix, along with repeated protects and unprotects.
  *		All entries are marked as clean.
  *
@@ -205,8 +205,8 @@ smoke_check_1(void)
                            /* display_detailed_stats */ TRUE,
                            /* do_inserts             */ TRUE,
                            /* dirty_inserts          */ dirty_inserts,
-                           /* do_renames             */ TRUE,
-                           /* rename_to_main_addr    */ FALSE,
+                           /* do_moves             */ TRUE,
+                           /* move_to_main_addr    */ FALSE,
                            /* do_destroys            */ TRUE,
 			   /* do_mult_ro_protects    */ TRUE,
                            /* dirty_destroys         */ dirty_destroys,
@@ -224,8 +224,8 @@ smoke_check_1(void)
                             /* display_detailed_stats */ TRUE,
                             /* do_inserts             */ FALSE,
                             /* dirty_inserts          */ dirty_inserts,
-                            /* do_renames             */ TRUE,
-                            /* rename_to_main_addr    */ TRUE,
+                            /* do_moves             */ TRUE,
+                            /* move_to_main_addr    */ TRUE,
                             /* do_destroys            */ FALSE,
 			    /* do_mult_ro_protects    */ TRUE,
                             /* dirty_destroys         */ dirty_destroys,
@@ -243,8 +243,8 @@ smoke_check_1(void)
                            /* display_detailed_stats */ TRUE,
                            /* do_inserts             */ TRUE,
                            /* dirty_inserts          */ dirty_inserts,
-                           /* do_renames             */ TRUE,
-                           /* rename_to_main_addr    */ FALSE,
+                           /* do_moves             */ TRUE,
+                           /* move_to_main_addr    */ FALSE,
                            /* do_destroys            */ FALSE,
 			   /* do_mult_ro_protects    */ TRUE,
                            /* dirty_destroys         */ dirty_destroys,
@@ -330,7 +330,7 @@ smoke_check_1(void)
  * Function:	smoke_check_2()
  *
  * Purpose:	A basic functional test, with inserts, destroys, and
- *		renames in the mix, along with some repeated protects
+ *		moves in the mix, along with some repeated protects
  *		and unprotects.  About half the entries are marked as
  *		dirty.
  *
@@ -396,8 +396,8 @@ smoke_check_2(void)
                            /* display_detailed_stats */ TRUE,
                            /* do_inserts             */ TRUE,
                            /* dirty_inserts          */ dirty_inserts,
-                           /* do_renames             */ TRUE,
-                           /* rename_to_main_addr    */ FALSE,
+                           /* do_moves             */ TRUE,
+                           /* move_to_main_addr    */ FALSE,
                            /* do_destroys            */ TRUE,
 			   /* do_mult_ro_protects    */ TRUE,
                            /* dirty_destroys         */ dirty_destroys,
@@ -415,8 +415,8 @@ smoke_check_2(void)
                             /* display_detailed_stats */ TRUE,
                             /* do_inserts             */ FALSE,
                             /* dirty_inserts          */ dirty_inserts,
-                            /* do_renames             */ TRUE,
-                            /* rename_to_main_addr    */ TRUE,
+                            /* do_moves             */ TRUE,
+                            /* move_to_main_addr    */ TRUE,
                             /* do_destroys            */ FALSE,
 			    /* do_mult_ro_protects    */ TRUE,
                             /* dirty_destroys         */ dirty_destroys,
@@ -434,8 +434,8 @@ smoke_check_2(void)
                            /* display_detailed_stats */ TRUE,
                            /* do_inserts             */ TRUE,
                            /* dirty_inserts          */ dirty_inserts,
-                           /* do_renames             */ TRUE,
-                           /* rename_to_main_addr    */ FALSE,
+                           /* do_moves             */ TRUE,
+                           /* move_to_main_addr    */ FALSE,
                            /* do_destroys            */ FALSE,
 			   /* do_mult_ro_protects    */ TRUE,
                            /* dirty_destroys         */ dirty_destroys,
@@ -521,7 +521,7 @@ smoke_check_2(void)
  * Function:	smoke_check_3()
  *
  * Purpose:	A basic functional test on a tiny cache, with inserts,
- *		destroys, and renames in the mix, along with repeated
+ *		destroys, and moves in the mix, along with repeated
  *		protects and unprotects.  All entries are marked as clean.
  *
  * Return:	void
@@ -586,8 +586,8 @@ smoke_check_3(void)
                            /* display_detailed_stats */ TRUE,
                            /* do_inserts             */ TRUE,
                            /* dirty_inserts          */ dirty_inserts,
-                           /* do_renames             */ TRUE,
-                           /* rename_to_main_addr    */ FALSE,
+                           /* do_moves             */ TRUE,
+                           /* move_to_main_addr    */ FALSE,
                            /* do_destroys            */ TRUE,
 			   /* do_mult_ro_protects    */ TRUE,
                            /* dirty_destroys         */ dirty_destroys,
@@ -605,8 +605,8 @@ smoke_check_3(void)
                             /* display_detailed_stats */ TRUE,
                             /* do_inserts             */ FALSE,
                             /* dirty_inserts          */ dirty_inserts,
-                            /* do_renames             */ TRUE,
-                            /* rename_to_main_addr    */ TRUE,
+                            /* do_moves             */ TRUE,
+                            /* move_to_main_addr    */ TRUE,
                             /* do_destroys            */ FALSE,
 			    /* do_mult_ro_protects    */ TRUE,
                             /* dirty_destroys         */ dirty_destroys,
@@ -624,8 +624,8 @@ smoke_check_3(void)
                            /* display_detailed_stats */ TRUE,
                            /* do_inserts             */ TRUE,
                            /* dirty_inserts          */ dirty_inserts,
-                           /* do_renames             */ TRUE,
-                           /* rename_to_main_addr    */ FALSE,
+                           /* do_moves             */ TRUE,
+                           /* move_to_main_addr    */ FALSE,
                            /* do_destroys            */ FALSE,
 			   /* do_mult_ro_protects    */ TRUE,
                            /* dirty_destroys         */ dirty_destroys,
@@ -711,7 +711,7 @@ smoke_check_3(void)
  * Function:	smoke_check_4()
  *
  * Purpose:	A basic functional test on a tiny cache, with inserts,
- *	 	destroys, and renames in the mix, along with repeated
+ *	 	destroys, and moves in the mix, along with repeated
  *		protects and unprotects.  About half the entries are
  *		marked as dirty.
  *
@@ -777,8 +777,8 @@ smoke_check_4(void)
                            /* display_detailed_stats */ TRUE,
                            /* do_inserts             */ TRUE,
                            /* dirty_inserts          */ dirty_inserts,
-                           /* do_renames             */ TRUE,
-                           /* rename_to_main_addr    */ FALSE,
+                           /* do_moves             */ TRUE,
+                           /* move_to_main_addr    */ FALSE,
                            /* do_destroys            */ TRUE,
 			   /* do_mult_ro_protects    */ TRUE,
                            /* dirty_destroys         */ dirty_destroys,
@@ -796,8 +796,8 @@ smoke_check_4(void)
                             /* display_detailed_stats */ TRUE,
                             /* do_inserts             */ FALSE,
                             /* dirty_inserts          */ dirty_inserts,
-                            /* do_renames             */ TRUE,
-                            /* rename_to_main_addr    */ TRUE,
+                            /* do_moves             */ TRUE,
+                            /* move_to_main_addr    */ TRUE,
                             /* do_destroys            */ FALSE,
 			    /* do_mult_ro_protects    */ TRUE,
                             /* dirty_destroys         */ dirty_destroys,
@@ -815,8 +815,8 @@ smoke_check_4(void)
                            /* display_detailed_stats */ TRUE,
                            /* do_inserts             */ TRUE,
                            /* dirty_inserts          */ dirty_inserts,
-                           /* do_renames             */ TRUE,
-                           /* rename_to_main_addr    */ FALSE,
+                           /* do_moves             */ TRUE,
+                           /* move_to_main_addr    */ FALSE,
                            /* do_destroys            */ FALSE,
 			   /* do_mult_ro_protects    */ TRUE,
                            /* dirty_destroys         */ dirty_destroys,
@@ -1865,7 +1865,7 @@ smoke_check_8(void)
  * 		part of the time.
  *
  * 		Recall that smoke check 1 is a basic functional test,
- * 		with inserts, destroys, and renames in the mix, along
+ * 		with inserts, destroys, and moves in the mix, along
  * 		with repeated protects and unprotects.  All entries are
  * 		marked as clean.
  *
@@ -1950,8 +1950,8 @@ smoke_check_9(void)
                            /* display_detailed_stats */ display_detailed_stats,
                            /* do_inserts             */ TRUE,
                            /* dirty_inserts          */ dirty_inserts,
-                           /* do_renames             */ TRUE,
-                           /* rename_to_main_addr    */ FALSE,
+                           /* do_moves             */ TRUE,
+                           /* move_to_main_addr    */ FALSE,
                            /* do_destroys            */ TRUE,
 			   /* do_mult_ro_protects    */ TRUE,
                            /* dirty_destroys         */ dirty_destroys,
@@ -1986,8 +1986,8 @@ smoke_check_9(void)
                             /* display_detailed_stats */ display_detailed_stats,
                             /* do_inserts             */ FALSE,
                             /* dirty_inserts          */ dirty_inserts,
-                            /* do_renames             */ TRUE,
-                            /* rename_to_main_addr    */ TRUE,
+                            /* do_moves             */ TRUE,
+                            /* move_to_main_addr    */ TRUE,
                             /* do_destroys            */ FALSE,
 			    /* do_mult_ro_protects    */ TRUE,
                             /* dirty_destroys         */ dirty_destroys,
@@ -2020,8 +2020,8 @@ smoke_check_9(void)
                            /* display_detailed_stats */ display_detailed_stats,
                            /* do_inserts             */ TRUE,
                            /* dirty_inserts          */ dirty_inserts,
-                           /* do_renames             */ TRUE,
-                           /* rename_to_main_addr    */ FALSE,
+                           /* do_moves             */ TRUE,
+                           /* move_to_main_addr    */ FALSE,
                            /* do_destroys            */ FALSE,
 			   /* do_mult_ro_protects    */ TRUE,
                            /* dirty_destroys         */ dirty_destroys,
@@ -2171,7 +2171,7 @@ smoke_check_9(void)
  * 		part of the time.
  *
  * 		Recall that smoke check 2 is a basic functional test,
- * 		with inserts, destroys, and renames in the mix, along
+ * 		with inserts, destroys, and moves in the mix, along
  * 		with some repeated protects and unprotects.  About half
  * 		the entries are marked as dirty.
  *
@@ -2239,8 +2239,8 @@ smoke_check_10(void)
                            /* display_detailed_stats */ display_detailed_stats,
                            /* do_inserts             */ TRUE,
                            /* dirty_inserts          */ dirty_inserts,
-                           /* do_renames             */ TRUE,
-                           /* rename_to_main_addr    */ FALSE,
+                           /* do_moves             */ TRUE,
+                           /* move_to_main_addr    */ FALSE,
                            /* do_destroys            */ TRUE,
 			   /* do_mult_ro_protects    */ TRUE,
                            /* dirty_destroys         */ dirty_destroys,
@@ -2273,8 +2273,8 @@ smoke_check_10(void)
                             /* display_detailed_stats */ display_detailed_stats,
                             /* do_inserts             */ FALSE,
                             /* dirty_inserts          */ dirty_inserts,
-                            /* do_renames             */ TRUE,
-                            /* rename_to_main_addr    */ TRUE,
+                            /* do_moves             */ TRUE,
+                            /* move_to_main_addr    */ TRUE,
                             /* do_destroys            */ FALSE,
 			    /* do_mult_ro_protects    */ TRUE,
                             /* dirty_destroys         */ dirty_destroys,
@@ -2307,8 +2307,8 @@ smoke_check_10(void)
                            /* display_detailed_stats */ display_detailed_stats,
                            /* do_inserts             */ TRUE,
                            /* dirty_inserts          */ dirty_inserts,
-                           /* do_renames             */ TRUE,
-                           /* rename_to_main_addr    */ FALSE,
+                           /* do_moves             */ TRUE,
+                           /* move_to_main_addr    */ FALSE,
                            /* do_destroys            */ FALSE,
 			   /* do_mult_ro_protects    */ TRUE,
                            /* dirty_destroys         */ dirty_destroys,
@@ -2530,8 +2530,8 @@ write_permitted_check(void)
                            /* display_detailed_stats */ TRUE,
                            /* do_inserts             */ TRUE,
                            /* dirty_inserts          */ TRUE,
-                           /* do_renames             */ TRUE,
-                           /* rename_to_main_addr    */ FALSE,
+                           /* do_moves             */ TRUE,
+                           /* move_to_main_addr    */ FALSE,
                            /* do_destroys            */ TRUE,
 			   /* do_mult_ro_protects    */ TRUE,
                            /* dirty_destroys         */ TRUE,
@@ -2551,8 +2551,8 @@ write_permitted_check(void)
                             /* display_detailed_stats */ TRUE,
                             /* do_inserts             */ FALSE,
                             /* dirty_inserts          */ FALSE,
-                            /* do_renames             */ TRUE,
-                            /* rename_to_main_addr    */ TRUE,
+                            /* do_moves             */ TRUE,
+                            /* move_to_main_addr    */ TRUE,
                             /* do_destroys            */ FALSE,
 			    /* do_mult_ro_protects    */ TRUE,
                             /* dirty_destroys         */ FALSE,
@@ -2572,8 +2572,8 @@ write_permitted_check(void)
                            /* display_detailed_stats */ TRUE,
                            /* do_inserts             */ TRUE,
                            /* dirty_inserts          */ TRUE,
-                           /* do_renames             */ TRUE,
-                           /* rename_to_main_addr    */ FALSE,
+                           /* do_moves             */ TRUE,
+                           /* move_to_main_addr    */ FALSE,
                            /* do_destroys            */ FALSE,
 			   /* do_mult_ro_protects    */ TRUE,
                            /* dirty_destroys         */ TRUE,
@@ -5420,7 +5420,7 @@ check_flush_cache__pe_multi_entry_test(H5F_t * file_ptr,
  *
  * 		These are tests that test the cache's ability to handle
  * 		the case in which the flush callback dirties, resizes,
- * 		and/or renames entries.
+ * 		and/or moves entries.
  *
  * 		Do nothing if pass is FALSE on entry.
  *
@@ -5824,7 +5824,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
     if ( pass ) /* test #5 & #6 */
     {
 	/* Single entry test verifying that the cache can handle the case in
-	 * which the call back function renames the entry for which it has
+	 * which the call back function moves the entry for which it has
 	 * been called.
 	 *
 	 * Run this entry twice, as the first run moves the entry to its
@@ -5852,7 +5852,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /* num_flush_ops      = */ 1,
 	    /* flush_ops          = */
 	    /*	op_code:		type:			idx:	flag:	size: order_ptr: */
-	    { { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	0,    NULL },
+	    { { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,			0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,			0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,			0,	FALSE,	0,    NULL },
@@ -5900,11 +5900,11 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 					 check_size,
 					 checks);
 
-	/* this change forces the rename to move the target entry back to its
+	/* this change forces the move to move the target entry back to its
 	 * main address.  The first test moved it to its alternate address.
 	 *
 	 * Note that these two tests are not the same, as in the first test,
-	 * the renamed entry is moved forward in the slist.  In the second
+	 * the moved entry is moved forward in the slist.  In the second
 	 * it is moved backwards.
 	 *
 	 * Since there is only one entry in the cache, this doesn't really
@@ -5936,7 +5936,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	 * second test.
 	 *
 	 * Single entry test verifying that the cache can handle the case in
-	 * which the call back function renames the entry for which it has
+	 * which the call back function moves the entry for which it has
 	 * been called.
 	 *
 	 * Run this entry twice, as the first run moves the entry to its
@@ -5964,7 +5964,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /* num_flush_ops      = */ 1,
 	    /* flush_ops          = */
 	    /*	op_code:		type:			idx:	flag:	size: order_ptr: */
-	    { { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	0,    NULL },
+	    { { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,			0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,			0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,			0,	FALSE,	0,    NULL },
@@ -6012,11 +6012,11 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 					 check_size,
 					 checks);
 
-	/* this change forces the rename to move the target entry back to its
+	/* this change forces the move to move the target entry back to its
 	 * main address.  The first test moved it to its alternate address.
 	 *
 	 * Note that these two tests are not the same, as in the first test,
-	 * the renamed entry is moved forward in the slist.  In the second
+	 * the moved entry is moved forward in the slist.  In the second
 	 * it is moved backwards.
 	 *
 	 * Since there is only one entry in the cache, this doesn't really
@@ -6050,7 +6050,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
     if ( pass ) /* test #9 & #10 */
     {
 	/* Single entry test verifying that the cache can handle the case in
-	 * which the call back function both resizes and renames the entry
+	 * which the call back function both resizes and moves the entry
 	 * for which it has been called.
 	 *
 	 * Again, we run this entry twice, as the first run moves the entry
@@ -6079,7 +6079,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /* flush_ops          = */
 	    /*	op_code:		type:			idx:	flag:	size: order_ptr: */
 	    { { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	VARIABLE_ENTRY_SIZE / 4, NULL },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	0,    NULL },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,			0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,			0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,			0,	FALSE,	0,    NULL },
@@ -6126,11 +6126,11 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 					 check_size,
 					 checks);
 
-	/* this change forces the rename to move the target entry back to its
+	/* this change forces the move to move the target entry back to its
 	 * main address.  The first test moved it to its alternate address.
 	 *
 	 * Note that these two tests are not the same, as in the first test,
-	 * the renamed entry is moved forward in the slist.  In the second
+	 * the moved entry is moved forward in the slist.  In the second
 	 * it is moved backwards.
 	 *
 	 * Since there is only one entry in the cache, this doesn't really
@@ -6162,7 +6162,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	 * second test.
 	 *
 	 * Single entry test verifying that the cache can handle the case in
-	 * which the call back function both resizes and renames the entry
+	 * which the call back function both resizes and moves the entry
 	 * for which it has been called.
 	 *
 	 * Again, we run this entry twice, as the first run moves the entry to its
@@ -6191,7 +6191,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /* flush_ops          = */
 	    /*	op_code:		type:			idx:	flag:	size: order_ptr: */
 	    { { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	VARIABLE_ENTRY_SIZE / 4,    NULL },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	0,    NULL },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,			0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,			0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,			0,	FALSE,	0,    NULL },
@@ -6238,11 +6238,11 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 					 check_size,
 					 checks);
 
-	/* this change forces the rename to move the target entry back to its
+	/* this change forces the move to move the target entry back to its
 	 * main address.  The first test moved it to its alternate address.
 	 *
 	 * Note that these two tests are not the same, as in the first test,
-	 * the renamed entry is moved forward in the slist.  In the second
+	 * the moved entry is moved forward in the slist.  In the second
 	 * it is moved backwards.
 	 *
 	 * Since there is only one entry in the cache, this doesn't really
@@ -6665,7 +6665,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
     {
 	/* Test the ability of the cache to handle the case in which
 	 * the flush function of an entry that is resident in cache
-	 * resizes, dirties, and renames two entries that are not in cache.
+	 * resizes, dirties, and moves two entries that are not in cache.
 	 *
 	 * At present, I am assured that this case will never occur, but
 	 * lets make sure we can handle it regardless.
@@ -6696,10 +6696,10 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /*	op_code:		type:	idx:	flag:	size: order_ptr: */
 	    { { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	VARIABLE_ENTRY_SIZE / 4, NULL },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	0, NULL },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	0, NULL },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	0,	FALSE,	0, NULL },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	2,	FALSE,	0, NULL },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	2,	FALSE,	VARIABLE_ENTRY_SIZE / 2, NULL },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	2,	FALSE,	0, NULL },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	2,	FALSE,	0, NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
@@ -6757,12 +6757,12 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 					 check_size,
 					 checks);
 
-	/* this change forces the renames to move the target entries back to
+	/* this change forces the moves to move the target entries back to
 	 * their main address.  The first test moved them to their alternate
 	 * address.
 	 *
 	 * Note that these two tests are not the same, as in the first test,
-	 * the renamed entries are moved forward in the slist.  In the second
+	 * the moved entries are moved forward in the slist.  In the second
 	 * they are moved backwards.
 	 */
 	if ( pass ) {
@@ -6794,7 +6794,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	 *
 	 * Test the ability of the cache to handle the case in which
 	 * the flush function of an entry that is resident in cache
-	 * resizes, dirties, and renames two entries that are not in cache.
+	 * resizes, dirties, and moves two entries that are not in cache.
 	 *
 	 * At present, I am assured that this case will never occur, but
 	 * lets make sure we can handle it regardless.
@@ -6825,10 +6825,10 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /*	op_code:		type:	idx:	flag:	size: order_ptr: */
 	    { { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	VARIABLE_ENTRY_SIZE / 4, NULL },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	0, NULL },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	0, NULL },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	0,	FALSE,	0, NULL },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	2,	FALSE,	0, NULL },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	2,	FALSE,	VARIABLE_ENTRY_SIZE / 2, NULL },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	2,	FALSE,	0, NULL },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	2,	FALSE,	0, NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
@@ -6886,12 +6886,12 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 					 check_size,
 					 checks);
 
-	/* this change forces the renames to move the target entries back to
+	/* this change forces the moves to move the target entries back to
 	 * their main address.  The first test moved them to their alternate
 	 * address.
 	 *
 	 * Note that these two tests are not the same, as in the first test,
-	 * the renamed entries are moved forward in the slist.  In the second
+	 * the moved entries are moved forward in the slist.  In the second
 	 * they are moved backwards.
 	 */
 	if ( pass ) {
@@ -6929,7 +6929,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	/* Now mix things up a bit.
 	 *
 	 * Load several entries, two of which have flush functions that
-	 * resize, dirty, and rename two entries that are not in the
+	 * resize, dirty, and move two entries that are not in the
 	 * cache.  Mark only one of these entries, and then flush the
 	 * cache with the flush marked entries flag.
 	 *
@@ -6966,10 +6966,10 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /*	op_code:		type:	idx:	flag:	size: order_ptr: */
 	    { { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	VARIABLE_ENTRY_SIZE / 4, NULL },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	0, NULL },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	0, NULL },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	0,	FALSE,	0, NULL },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	2,	FALSE,	0, NULL },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	2,	FALSE,	VARIABLE_ENTRY_SIZE / 2, NULL },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	2,	FALSE,	0, NULL },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	2,	FALSE,	0, NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
@@ -6994,10 +6994,10 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /*	op_code:		type:	idx:	flag:	size: order_ptr: */
 	    { { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	10,	FALSE,	VARIABLE_ENTRY_SIZE / 4, NULL },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	10,	FALSE,	0, NULL },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	10,	FALSE,	0, NULL },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	10,	FALSE,	0, NULL },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	12,	FALSE,	0, NULL },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	12,	FALSE,	VARIABLE_ENTRY_SIZE / 2, NULL },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	12,	FALSE,	0, NULL },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	12,	FALSE,	0, NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
@@ -7148,7 +7148,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	/* Mix things up some more.
 	 *
 	 * Load lots of entries, some of which have flush functions that
-	 * resize, dirty, and rename two entries that are not in the
+	 * resize, dirty, and move two entries that are not in the
 	 * cache.
 	 *
 	 * Also load entries that have flush ops on entries that are in
@@ -7181,10 +7181,10 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /*	op_code:		type:	idx:	flag:	size: order_ptr: */
 	    { { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	VARIABLE_ENTRY_SIZE / 4, NULL },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	0, NULL },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	0, NULL },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	0,	FALSE,	0, NULL },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	2,	FALSE,	0, NULL },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	2,	FALSE,	VARIABLE_ENTRY_SIZE / 2, NULL },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	2,	FALSE,	0, NULL },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	2,	FALSE,	0, NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
@@ -7209,10 +7209,10 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /*	op_code:		type:	idx:	flag:	size: order_ptr: */
 	    { { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	10,	FALSE,	VARIABLE_ENTRY_SIZE / 4, NULL },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	10,	FALSE,	0, NULL },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	10,	FALSE,	0, NULL },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	10,	FALSE,	0, NULL },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	12,	FALSE,	0, NULL },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	12,	FALSE,	VARIABLE_ENTRY_SIZE / 2, NULL },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	12,	FALSE,	0, NULL },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	12,	FALSE,	0, NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
@@ -7421,7 +7421,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	 * Mix things up some more.
 	 *
 	 * Load lots of entries, some of which have flush functions that
-	 * resize, dirty, and rename two entries that are not in the
+	 * resize, dirty, and move two entries that are not in the
 	 * cache.
 	 *
 	 * Also load entries that have flush ops on entries that are in
@@ -7451,10 +7451,10 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /*	op_code:		type:	idx:	flag:	size: order_ptr: */
 	    { { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	VARIABLE_ENTRY_SIZE / 4, NULL },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	0, NULL },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	0, NULL },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	0,	FALSE,	0, NULL },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	2,	FALSE,	0, NULL },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	2,	FALSE,	VARIABLE_ENTRY_SIZE / 2, NULL },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	2,	FALSE,	0, NULL },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	2,	FALSE,	0, NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
@@ -7479,10 +7479,10 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /*	op_code:		type:	idx:	flag:	size: order_ptr: */
 	    { { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	10,	FALSE,	VARIABLE_ENTRY_SIZE / 4, NULL },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	10,	FALSE,	0, NULL },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	10,	FALSE,	0, NULL },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	10,	FALSE,	0, NULL },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	12,	FALSE,	0, NULL },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	12,	FALSE,	VARIABLE_ENTRY_SIZE / 2, NULL },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	12,	FALSE,	0, NULL },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	12,	FALSE,	0, NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
@@ -7990,12 +7990,12 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	 * 		dirties (VET, 100)
 	 * 		resizes (VET, 200)
 	 * 		dirty	(VET, 300) -- dirty first to bring into cache.
-	 * 		renames (VET, 300)
+	 * 		moves (VET, 300)
 	 *
 	 * (VET, 2000)	initially clean, and in cache
 	 * 		dirties (VET, 2100)
 	 * 		resizes (VET, 2200)
-	 * 		renames (VET, 2300)
+	 * 		moves (VET, 2300)
 	 *
 	 * (VET, 350)	initially clean, and in cache
 	 * 		pins	(VET, 1000)
@@ -8007,7 +8007,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	 * (VET, 450)	initially dirty, and in cache
 	 * 		pins	(VET, 1000)
 	 * 		dirties	(VET, 1000)
-	 * 		renames (VET, 450)
+	 * 		moves (VET, 450)
 	 * 		pins	(VET, 2000)
 	 * 		dirties (VET, 2000)
 	 *
@@ -8140,7 +8140,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    { { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	100,	FALSE,	0, NULL },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	200,	FALSE,	VARIABLE_ENTRY_SIZE / 2, NULL },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	300,	FALSE,	0, NULL },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	300,	FALSE,	0, NULL },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	300,	FALSE,	0, NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
@@ -8167,7 +8167,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /*	op_code:		type:	idx:	flag:	size: order_ptr: */
 	    { { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	2100,	FALSE,	0, NULL },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	2200,	FALSE,	VARIABLE_ENTRY_SIZE / 2, NULL },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	2300,	FALSE,	0, NULL },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	2300,	FALSE,	0, NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
@@ -8427,12 +8427,12 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	 * 		dirties (VET, 100)
 	 * 		resizes (VET, 200)
 	 * 		dirty	(VET, 300) -- dirty first to bring into cache.
-	 * 		renames (VET, 300)
+	 * 		moves (VET, 300)
 	 *
 	 * (VET, 2000)	initially clean, and in cache
 	 * 		dirties (VET, 2100)
 	 * 		resizes (VET, 2200)
-	 * 		renames (VET, 2300)
+	 * 		moves (VET, 2300)
 	 *
 	 * (VET, 350)	initially clean, and in cache
 	 * 		pins	(VET, 1000)
@@ -8444,7 +8444,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	 * (VET, 450)	initially dirty, and in cache
 	 * 		pins	(VET, 1000)
 	 * 		dirties	(VET, 1000)
-	 * 		renames (VET, 450)
+	 * 		moves (VET, 450)
 	 * 		pins	(VET, 2000)
 	 * 		dirties (VET, 2000)
 	 *
@@ -8577,7 +8577,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    { { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	100,	FALSE,	0, NULL },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	200,	FALSE,	VARIABLE_ENTRY_SIZE / 2, NULL },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	300,	FALSE,	0, NULL },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	300,	FALSE,	0, NULL },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	300,	FALSE,	0, NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
@@ -8604,7 +8604,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /*	op_code:		type:	idx:	flag:	size: order_ptr: */
 	    { { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	2100,	FALSE,	0, NULL },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	2200,	FALSE,	VARIABLE_ENTRY_SIZE / 2, NULL },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	2300,	FALSE,	0, NULL },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	2300,	FALSE,	0, NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
@@ -8882,7 +8882,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /*	op_code:		type:	idx:	flag:	size: order_ptr: */
 	    { { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	100,	FALSE,	0, NULL },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	200,	FALSE,	VARIABLE_ENTRY_SIZE, NULL },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	200,	FALSE,	0, NULL },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	200,	FALSE,	0, NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
@@ -8910,7 +8910,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /*	op_code:		type:	idx:	flag:	size: order_ptr: */
 	    { { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	400,	FALSE,	0, NULL },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	300,	FALSE,	VARIABLE_ENTRY_SIZE / 2, NULL },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	300,	FALSE,	0, NULL },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	300,	FALSE,	0, NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
@@ -8966,7 +8966,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /*	op_code:		type:	idx:	flag:	size: order_ptr: */
 	    { { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	100,	FALSE,	0, NULL },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	500,	FALSE,	VARIABLE_ENTRY_SIZE / 2, NULL },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	500,	FALSE,	0, NULL },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	500,	FALSE,	0, NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
@@ -9075,7 +9075,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /*	op_code:		type:	idx:	flag:	size: order_ptr: */
 	    { { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	100,	FALSE,	0, NULL },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	200,	FALSE,	VARIABLE_ENTRY_SIZE, NULL },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	200,	FALSE,	0, NULL },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	200,	FALSE,	0, NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
@@ -9103,7 +9103,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /*	op_code:		type:	idx:	flag:	size: order_ptr: */
 	    { { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	400,	FALSE,	0, NULL },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	300,	FALSE,	VARIABLE_ENTRY_SIZE / 2, NULL },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	300,	FALSE,	0, NULL },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	300,	FALSE,	0, NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
@@ -9159,7 +9159,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /*	op_code:		type:	idx:	flag:	size: order_ptr: */
 	    { { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	100,	FALSE,	0, NULL },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	500,	FALSE,	VARIABLE_ENTRY_SIZE / 2, NULL },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	500,	FALSE,	0, NULL },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	500,	FALSE,	0, NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0,    NULL },
@@ -9991,7 +9991,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
 	 *
 	 *          (VET, 2) dirties (VET, 0)
 	 *                   resizes (VET, 0) to VARIABLE_ENTRY_SIZE
-	 *                   renames (VET, 0) to its alternate address
+	 *                   moves (VET, 0) to its alternate address
 	 *
 	 *          (VET, 3) dirties (VET, 0)
 	 *                   resizes itself to VARIABLE_ENTRY_SIZE
@@ -10008,7 +10008,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
                      VARIABLE_ENTRY_TYPE, 0, FALSE, (size_t)0, NULL);
         add_flush_op(VARIABLE_ENTRY_TYPE, 2, FLUSH_OP__RESIZE,
                      VARIABLE_ENTRY_TYPE, 0, FALSE, VARIABLE_ENTRY_SIZE, NULL);
-        add_flush_op(VARIABLE_ENTRY_TYPE, 2, FLUSH_OP__RENAME,
+        add_flush_op(VARIABLE_ENTRY_TYPE, 2, FLUSH_OP__MOVE,
                      VARIABLE_ENTRY_TYPE, 0, FALSE, (size_t)0, NULL);
 
         add_flush_op(VARIABLE_ENTRY_TYPE, 3, FLUSH_OP__DIRTY,
@@ -10035,7 +10035,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
 	 *
 	 * (VET, 2)	Y	10 KB	N	N	0	dirty (VET, 0)
 	 * 							resize (VET, 0) to 10 KB
-	 * 							rename (VET, 0) to its alternate address
+	 * 							move (VET, 0) to its alternate address
 	 *
 	 * (VET, 3)	Y	 5 KB	Y	N	0, 7	dirty (VET, 0)
 	 * 							resize (VET, 3) to 10 KB
@@ -10109,7 +10109,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
 	 *
 	 * (VET, 2)	Y	10 KB	N	N	0	dirty (VET, 0)
 	 * 							resize (VET, 0) to 10 KB
-	 * 							rename (VET, 0) to its alternate address
+	 * 							move (VET, 0) to its alternate address
 	 *
 	 * (VET, 3)	Y	 5 KB	Y	N	0, 7	dirty (VET, 0)
 	 * 							resize (VET, 3) to 10 KB
@@ -10161,7 +10161,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
 
 	/* Now load another large entry.  This should result in the eviction
 	 * of (VET, 2), the increase in the size of (VET, 0) from .75
-	 * VARIABLE_ENTRY_SIZE to 1.0 VARIABLE_ENTRY_SIZE, and the renaming
+	 * VARIABLE_ENTRY_SIZE to 1.0 VARIABLE_ENTRY_SIZE, and the moving
 	 * of (VET, 0) to its alternate address.
 	 *
 	 * The following table shows the expected states of the variable
@@ -10844,9 +10844,9 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
              ( cache_ptr->clears[VARIABLE_ENTRY_TYPE] != 0 ) ||
              ( cache_ptr->flushes[VARIABLE_ENTRY_TYPE] != 14 ) ||
              ( cache_ptr->evictions[VARIABLE_ENTRY_TYPE] != 9 ) ||
-             ( cache_ptr->renames[VARIABLE_ENTRY_TYPE] != 1 ) ||
-             ( cache_ptr->entry_flush_renames[VARIABLE_ENTRY_TYPE] != 0 ) ||
-             ( cache_ptr->cache_flush_renames[VARIABLE_ENTRY_TYPE] != 0 ) ||
+             ( cache_ptr->moves[VARIABLE_ENTRY_TYPE] != 1 ) ||
+             ( cache_ptr->entry_flush_moves[VARIABLE_ENTRY_TYPE] != 0 ) ||
+             ( cache_ptr->cache_flush_moves[VARIABLE_ENTRY_TYPE] != 0 ) ||
              ( cache_ptr->pins[VARIABLE_ENTRY_TYPE] != 2 ) ||
              ( cache_ptr->unpins[VARIABLE_ENTRY_TYPE] != 2 ) ||
              ( cache_ptr->dirty_pins[VARIABLE_ENTRY_TYPE] != 0 ) ||
@@ -10869,9 +10869,9 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
              ( cache_ptr->clears[LARGE_ENTRY_TYPE] != 0 ) ||
              ( cache_ptr->flushes[LARGE_ENTRY_TYPE] != 38 ) ||
              ( cache_ptr->evictions[LARGE_ENTRY_TYPE] != 14 ) ||
-             ( cache_ptr->renames[LARGE_ENTRY_TYPE] != 0 ) ||
-             ( cache_ptr->entry_flush_renames[LARGE_ENTRY_TYPE] != 0 ) ||
-             ( cache_ptr->cache_flush_renames[LARGE_ENTRY_TYPE] != 0 ) ||
+             ( cache_ptr->moves[LARGE_ENTRY_TYPE] != 0 ) ||
+             ( cache_ptr->entry_flush_moves[LARGE_ENTRY_TYPE] != 0 ) ||
+             ( cache_ptr->cache_flush_moves[LARGE_ENTRY_TYPE] != 0 ) ||
              ( cache_ptr->pins[LARGE_ENTRY_TYPE] != 0 ) ||
              ( cache_ptr->unpins[LARGE_ENTRY_TYPE] != 0 ) ||
              ( cache_ptr->dirty_pins[LARGE_ENTRY_TYPE] != 0 ) ||
@@ -10894,9 +10894,9 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
              ( cache_ptr->clears[MONSTER_ENTRY_TYPE] != 0 ) ||
              ( cache_ptr->flushes[MONSTER_ENTRY_TYPE] != 93 ) ||
              ( cache_ptr->evictions[MONSTER_ENTRY_TYPE] != 31 ) ||
-             ( cache_ptr->renames[MONSTER_ENTRY_TYPE] != 0 ) ||
-             ( cache_ptr->entry_flush_renames[MONSTER_ENTRY_TYPE] != 0 ) ||
-             ( cache_ptr->cache_flush_renames[MONSTER_ENTRY_TYPE] != 0 ) ||
+             ( cache_ptr->moves[MONSTER_ENTRY_TYPE] != 0 ) ||
+             ( cache_ptr->entry_flush_moves[MONSTER_ENTRY_TYPE] != 0 ) ||
+             ( cache_ptr->cache_flush_moves[MONSTER_ENTRY_TYPE] != 0 ) ||
              ( cache_ptr->pins[MONSTER_ENTRY_TYPE] != 0 ) ||
              ( cache_ptr->unpins[MONSTER_ENTRY_TYPE] != 0 ) ||
              ( cache_ptr->dirty_pins[MONSTER_ENTRY_TYPE] != 0 ) ||
@@ -14470,9 +14470,9 @@ check_multiple_read_protect(void)
 
 
 /*-------------------------------------------------------------------------
- * Function:	check_rename_entry()
+ * Function:	check_move_entry()
  *
- * Purpose:	Verify that H5C_rename_entry behaves as expected.  In
+ * Purpose:	Verify that H5C_move_entry behaves as expected.  In
  * 		particular, verify that it works correctly with pinned
  * 		entries.
  *
@@ -14487,12 +14487,12 @@ check_multiple_read_protect(void)
  */
 
 static unsigned
-check_rename_entry(void)
+check_move_entry(void)
 {
-    const char * fcn_name = "check_rename_entry";
+    const char * fcn_name = "check_move_entry";
     int          i;
     H5F_t *      file_ptr = NULL;
-    struct rename_entry_test_spec test_specs[4] =
+    struct move_entry_test_spec test_specs[4] =
     {
       {
         /* int     entry_type  = */ PICO_ENTRY_TYPE,
@@ -14520,23 +14520,23 @@ check_rename_entry(void)
       }
     };
 
-    TESTING("H5C_rename_entry() functionality");
+    TESTING("H5C_move_entry() functionality");
 
     pass = TRUE;
 
-    /* allocate a cache, load entries into it, and then rename
+    /* allocate a cache, load entries into it, and then move
      * them.  To the extent possible, verify that the desired
      * actions took place.
      *
      * At present, we should do the following tests:
      *
-     * 1) Rename a clean, unprotected, unpinned entry.
+     * 1) move a clean, unprotected, unpinned entry.
      *
-     * 2) Rename a dirty, unprotected, unpinned entry.
+     * 2) move a dirty, unprotected, unpinned entry.
      *
-     * 3) Rename a clean, unprotected, pinned entry.
+     * 3) move a clean, unprotected, pinned entry.
      *
-     * 4) Rename a dirty, unprotected, pinned entry.
+     * 4) move a dirty, unprotected, pinned entry.
      *
      * In all cases, the entry should have moved to its
      * new location, and have been marked dirty if it wasn't
@@ -14560,7 +14560,7 @@ check_rename_entry(void)
     i = 0;
     while ( ( pass ) && ( i < 4 ) )
     {
-        check_rename_entry__run_test(file_ptr, i, &(test_specs[i]));
+        check_move_entry__run_test(file_ptr, i, &(test_specs[i]));
 	i++;
     }
 
@@ -14579,13 +14579,13 @@ check_rename_entry(void)
 
     return (unsigned)!pass;
 
-} /* check_rename_entry() */
+} /* check_move_entry() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    check_rename_entry__run_test()
+ * Function:    check_move_entry__run_test()
  *
- * Purpose:     Run a rename entry test.
+ * Purpose:     Run a move entry test.
  *
  *		Do nothing if pass is FALSE on entry.
  *
@@ -14602,11 +14602,11 @@ check_rename_entry(void)
  */
 
 static void
-check_rename_entry__run_test(H5F_t * file_ptr,
+check_move_entry__run_test(H5F_t * file_ptr,
                              int test_num,
-                             struct rename_entry_test_spec * spec_ptr)
+                             struct move_entry_test_spec * spec_ptr)
 {
-    /* const char *   fcn_name = "check_rename_entry__run_test"; */
+    /* const char *   fcn_name = "check_move_entry__run_test"; */
     H5C_t *       cache_ptr = file_ptr->shared->cache;
     static char    msg[128];
     unsigned int   flags = H5C__NO_FLAGS_SET;
@@ -14630,7 +14630,7 @@ check_rename_entry__run_test(H5F_t * file_ptr,
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128,
-                       "bad entry_ptr in rename test #%d.",
+                       "bad entry_ptr in move test #%d.",
                        test_num);
             failure_mssg = msg;
 
@@ -14647,15 +14647,15 @@ check_rename_entry__run_test(H5F_t * file_ptr,
         unprotect_entry(file_ptr, spec_ptr->entry_type, spec_ptr->entry_index,
                         (int)(spec_ptr->is_dirty), flags);
 
-        rename_entry(cache_ptr, spec_ptr->entry_type, spec_ptr->entry_index, FALSE);
+        move_entry(cache_ptr, spec_ptr->entry_type, spec_ptr->entry_index, FALSE);
 
     }
 
     if ( pass ) {
 
-        /* verify that the rename took place, and that the cache's internal
+        /* verify that the move took place, and that the cache's internal
          * structures are as expected.  Note that some sanity checking is
-         * done by rename_entry(), so we don't have to repeat it here.
+         * done by move_entry(), so we don't have to repeat it here.
          */
 
         if ( spec_ptr->is_pinned ) {
@@ -14664,7 +14664,7 @@ check_rename_entry__run_test(H5F_t * file_ptr,
 
                 pass = FALSE;
                 HDsnprintf(msg, (size_t)128,
-                           "Pinned entry not pinned after rename in test #%d.",
+                           "Pinned entry not pinned after move in test #%d.",
                            test_num);
                 failure_mssg = msg;
             }
@@ -14683,7 +14683,7 @@ check_rename_entry__run_test(H5F_t * file_ptr,
 
                     pass = FALSE;
                     HDsnprintf(msg, (size_t)128,
-                           "Pinned entry not in pel after rename in test #%d.",
+                           "Pinned entry not in pel after move in test #%d.",
                            test_num);
                     failure_mssg = msg;
                 }
@@ -14697,7 +14697,7 @@ check_rename_entry__run_test(H5F_t * file_ptr,
 
                 pass = FALSE;
                 HDsnprintf(msg, (size_t)128,
-                           "Unpinned entry pinned after rename in test #%d.",
+                           "Unpinned entry pinned after move in test #%d.",
                            test_num);
                 failure_mssg = msg;
             }
@@ -14707,7 +14707,7 @@ check_rename_entry__run_test(H5F_t * file_ptr,
             {
                 pass = FALSE;
                 HDsnprintf(msg, (size_t)128,
-                           "Entry not at head of LRU after rename in test #%d.",
+                           "Entry not at head of LRU after move in test #%d.",
                            test_num);
                 failure_mssg = msg;
             }
@@ -14715,11 +14715,11 @@ check_rename_entry__run_test(H5F_t * file_ptr,
     }
 
     /* put the entry back where it started from */
-    rename_entry(cache_ptr, spec_ptr->entry_type, spec_ptr->entry_index, TRUE);
+    move_entry(cache_ptr, spec_ptr->entry_type, spec_ptr->entry_index, TRUE);
 
     return;
 
-} /* check_rename_entry__run_test() */
+} /* check_move_entry__run_test() */
 
 
 /*-------------------------------------------------------------------------
@@ -16871,9 +16871,9 @@ check_duplicate_insert_err(void)
 
 
 /*-------------------------------------------------------------------------
- * Function:	check_rename_err()
+ * Function:	check_move_err()
  *
- * Purpose:	Verify that an attempt to rename an entry to the address
+ * Purpose:	Verify that an attempt to move an entry to the address
  *		of an existing entry will generate an error.
  *
  * Return:	void
@@ -16887,9 +16887,9 @@ check_duplicate_insert_err(void)
  */
 
 static unsigned
-check_rename_err(void)
+check_move_err(void)
 {
-    const char * fcn_name = "check_rename_err()";
+    const char * fcn_name = "check_move_err()";
     herr_t result;
     H5F_t * file_ptr = NULL;
     H5C_t * cache_ptr = NULL;
@@ -16897,11 +16897,11 @@ check_rename_err(void)
     test_entry_t * entry_0_1_ptr;
     test_entry_t * entry_1_0_ptr;
 
-    TESTING("rename to existing entry errors");
+    TESTING("move to existing entry errors");
 
     pass = TRUE;
 
-    /* allocate a cache, and insert several entries.  Try to rename
+    /* allocate a cache, and insert several entries.  Try to move
      * entries to other entries resident in the cache.  This should
      * fail.  Destroy the cache -- should succeed.
      */
@@ -16925,25 +16925,25 @@ check_rename_err(void)
 
     if ( pass ) {
 
-        result = H5C_rename_entry(cache_ptr, &(types[0]),
+        result = H5C_move_entry(cache_ptr, &(types[0]),
                                   entry_0_0_ptr->addr, entry_0_1_ptr->addr);
 
         if ( result >= 0 ) {
 
             pass = FALSE;
-            failure_mssg = "rename to addr of same type succeeded.\n";
+            failure_mssg = "move to addr of same type succeeded.\n";
         }
     }
 
     if ( pass ) {
 
-        result = H5C_rename_entry(cache_ptr, &(types[0]),
+        result = H5C_move_entry(cache_ptr, &(types[0]),
                                   entry_0_0_ptr->addr, entry_1_0_ptr->addr);
 
         if ( result >= 0 ) {
 
             pass = FALSE;
-            failure_mssg = "rename to addr of different type succeeded.\n";
+            failure_mssg = "move to addr of different type succeeded.\n";
         }
     }
 
@@ -16962,7 +16962,7 @@ check_rename_err(void)
 
     return (unsigned)!pass;
 
-} /* check_rename_err() */
+} /* check_move_err() */
 
 
 /*-------------------------------------------------------------------------
@@ -34164,7 +34164,7 @@ main(void)
     nerrs += check_get_entry_status();
     nerrs += check_expunge_entry();
     nerrs += check_multiple_read_protect();
-    nerrs += check_rename_entry();
+    nerrs += check_move_entry();
     nerrs += check_pin_protected_entry();
     nerrs += check_resize_entry();
     nerrs += check_evictions_enabled();
@@ -34172,7 +34172,7 @@ main(void)
     nerrs += check_destroy_pinned_err();
     nerrs += check_destroy_protected_err();
     nerrs += check_duplicate_insert_err();
-    nerrs += check_rename_err();
+    nerrs += check_move_err();
     nerrs += check_double_pin_err();
     nerrs += check_double_unpin_err();
     nerrs += check_pin_entry_errs();
diff --git a/test/cache_common.c b/test/cache_common.c
index 6290f2a..54b0ecf 100644
--- a/test/cache_common.c
+++ b/test/cache_common.c
@@ -1600,8 +1600,8 @@ execute_flush_op(H5F_t * file_ptr,
 		}
 		break;
 
-	    case FLUSH_OP__RENAME:
-		rename_entry(cache_ptr, op_ptr->type, op_ptr->idx,
+	    case FLUSH_OP__MOVE:
+		move_entry(cache_ptr, op_ptr->type, op_ptr->idx,
 			     op_ptr->flag);
 		break;
 
@@ -3138,9 +3138,9 @@ mark_entry_dirty(int32_t type,
 
 
 /*-------------------------------------------------------------------------
- * Function:	rename_entry()
+ * Function:	move_entry()
  *
- * Purpose:	Rename the entry indicated by the type and index to its
+ * Purpose:	move the entry indicated by the type and index to its
  *		main or alternate address as indicated.  If the entry is
  *		already at the desired entry, do nothing.
  *
@@ -3153,7 +3153,7 @@ mark_entry_dirty(int32_t type,
  */
 
 void
-rename_entry(H5C_t * cache_ptr,
+move_entry(H5C_t * cache_ptr,
              int32_t type,
              int32_t idx,
              hbool_t main_addr)
@@ -3182,7 +3182,7 @@ rename_entry(H5C_t * cache_ptr,
 
     if ( entry_ptr->at_main_addr && !main_addr ) {
 
-        /* rename to alt addr */
+        /* move to alt addr */
 
         HDassert( entry_ptr->addr == entry_ptr->main_addr );
 
@@ -3192,7 +3192,7 @@ rename_entry(H5C_t * cache_ptr,
 
     } else if ( !(entry_ptr->at_main_addr) && main_addr ) {
 
-        /* rename to main addr */
+        /* move to main addr */
 
         HDassert( entry_ptr->addr == entry_ptr->alt_addr );
 
@@ -3205,7 +3205,7 @@ rename_entry(H5C_t * cache_ptr,
 
         entry_ptr->is_dirty = TRUE;
 
-        result = H5C_rename_entry(cache_ptr, &(types[type]),
+        result = H5C_move_entry(cache_ptr, &(types[type]),
                                   old_addr, new_addr);
     }
 
@@ -3216,7 +3216,7 @@ rename_entry(H5C_t * cache_ptr,
 	       ( entry_ptr->header.addr != new_addr ) ) ) {
 
             pass = FALSE;
-            failure_mssg = "error in H5C_rename_entry().";
+            failure_mssg = "error in H5C_move_entry().";
 
         } else {
 
@@ -3232,7 +3232,7 @@ rename_entry(H5C_t * cache_ptr,
 
     return;
 
-} /* rename_entry() */
+} /* move_entry() */
 
 
 /*-------------------------------------------------------------------------
@@ -3833,7 +3833,7 @@ unprotect_entry_with_size_change(H5F_t * file_ptr,
 /*-------------------------------------------------------------------------
  * Function:	row_major_scan_forward()
  *
- * Purpose:	Do a sequence of inserts, protects, unprotects, renames,
+ * Purpose:	Do a sequence of inserts, protects, unprotects, moves,
  *		destroys while scanning through the set of entries.  If
  *		pass is false on entry, do nothing.
  *
@@ -3854,8 +3854,8 @@ row_major_scan_forward(H5F_t * file_ptr,
                        hbool_t display_detailed_stats,
                        hbool_t do_inserts,
                        hbool_t dirty_inserts,
-                       hbool_t do_renames,
-                       hbool_t rename_to_main_addr,
+                       hbool_t do_moves,
+                       hbool_t move_to_main_addr,
                        hbool_t do_destroys,
 		       hbool_t do_mult_ro_protects,
                        int dirty_destroys,
@@ -3929,12 +3929,12 @@ row_major_scan_forward(H5F_t * file_ptr,
             }
 
 
-            if ( ( pass ) && ( do_renames ) && ( (idx + lag - 2) >= 0 ) &&
+            if ( ( pass ) && ( do_moves ) && ( (idx + lag - 2) >= 0 ) &&
                  ( (idx + lag - 2) <= max_indices[type] ) &&
                  ( ( (idx + lag - 2) % 3 ) == 0 ) ) {
 
-                rename_entry(cache_ptr, type, (idx + lag - 2),
-                             rename_to_main_addr);
+                move_entry(cache_ptr, type, (idx + lag - 2),
+                             move_to_main_addr);
             }
 
 
@@ -4253,7 +4253,7 @@ hl_row_major_scan_forward(H5F_t * file_ptr,
 /*-------------------------------------------------------------------------
  * Function:	row_major_scan_backward()
  *
- * Purpose:	Do a sequence of inserts, protects, unprotects, renames,
+ * Purpose:	Do a sequence of inserts, protects, unprotects, moves,
  *		destroys while scanning backwards through the set of
  *		entries.  If pass is false on entry, do nothing.
  *
@@ -4274,8 +4274,8 @@ row_major_scan_backward(H5F_t * file_ptr,
                         hbool_t display_detailed_stats,
                         hbool_t do_inserts,
                         hbool_t dirty_inserts,
-                        hbool_t do_renames,
-                        hbool_t rename_to_main_addr,
+                        hbool_t do_moves,
+                        hbool_t move_to_main_addr,
                         hbool_t do_destroys,
 			hbool_t do_mult_ro_protects,
                         int dirty_destroys,
@@ -4343,12 +4343,12 @@ row_major_scan_backward(H5F_t * file_ptr,
             }
 
 
-            if ( ( pass ) && ( do_renames ) && ( (idx - lag + 2) >= 0 ) &&
+            if ( ( pass ) && ( do_moves ) && ( (idx - lag + 2) >= 0 ) &&
                  ( (idx - lag + 2) <= max_indices[type] ) &&
                  ( ( (idx - lag + 2) % 3 ) == 0 ) ) {
 
-                rename_entry(cache_ptr, type, (idx - lag + 2),
-                             rename_to_main_addr);
+                move_entry(cache_ptr, type, (idx - lag + 2),
+                             move_to_main_addr);
             }
 
 
diff --git a/test/cache_common.h b/test/cache_common.h
index 3bb26ef..ec17774 100644
--- a/test/cache_common.h
+++ b/test/cache_common.h
@@ -141,7 +141,7 @@
 #define FLUSH_OP__NO_OP		0
 #define FLUSH_OP__DIRTY		1
 #define FLUSH_OP__RESIZE	2
-#define FLUSH_OP__RENAME	3
+#define FLUSH_OP__MOVE		3
 #define FLUSH_OP__ORDER		4
 #define FLUSH_OP__MAX_OP	4
 
@@ -159,7 +159,7 @@ typedef struct flush_op
 					 *   FLUSH_OP__NO_OP
 					 *   FLUSH_OP__DIRTY
 					 *   FLUSH_OP__RESIZE
-					 *   FLUSH_OP__RENAME
+					 *   FLUSH_OP__MOVE
 					 *   FLUSH_OP__ORDER
 					 */
     int			type;		/* type code of the cache entry that
@@ -192,12 +192,12 @@ typedef struct flush_op
 					 *   H5C_mark_entry_dirty()
 					 *   call.
 					 *
-					 * FLUSH_OP__RENAME: TRUE iff the
-					 *    target is to be renamed to
+					 * FLUSH_OP__MOVE: TRUE iff the
+					 *    target is to be moved to
 					 *    its main address.
 					 */
     size_t		size;		/* New target size in the
-					 * FLUSH_OP__RENAME operation.
+					 * FLUSH_OP__MOVE operation.
 					 * Unused elsewhere.
 					 */
     unsigned          * order_ptr;      /* Pointer to outside counter for
@@ -229,7 +229,7 @@ typedef struct test_entry_t
     haddr_t		  main_addr;    /* initial location of the entry
                                          */
     haddr_t		  alt_addr;	/* location to which the entry
-					 * can be relocated or "renamed"
+					 * can be relocated or "moved"
                                          */
     size_t		  size;         /* how big the cache thinks this
                                          * entry is
@@ -480,7 +480,7 @@ struct fo_flush_cache_test_spec
     hbool_t			expected_destroyed;
 };
 
-struct rename_entry_test_spec
+struct move_entry_test_spec
 {
     int			entry_type;
     int			entry_index;
@@ -670,7 +670,7 @@ void insert_entry(H5F_t * file_ptr,
 void mark_entry_dirty(int32_t type,
 		              int32_t idx);
 
-void rename_entry(H5C_t * cache_ptr,
+void move_entry(H5C_t * cache_ptr,
                   int32_t type,
                   int32_t idx,
                   hbool_t main_addr);
@@ -719,8 +719,8 @@ void row_major_scan_forward(H5F_t * file_ptr,
                             hbool_t display_detailed_stats,
                             hbool_t do_inserts,
                             hbool_t dirty_inserts,
-                            hbool_t do_renames,
-                            hbool_t rename_to_main_addr,
+                            hbool_t do_moves,
+                            hbool_t move_to_main_addr,
                             hbool_t do_destroys,
                             hbool_t do_mult_ro_protects,
                             int dirty_destroys,
@@ -743,8 +743,8 @@ void row_major_scan_backward(H5F_t * file_ptr,
                              hbool_t display_detailed_stats,
                              hbool_t do_inserts,
                              hbool_t dirty_inserts,
-                             hbool_t do_renames,
-                             hbool_t rename_to_main_addr,
+                             hbool_t do_moves,
+                             hbool_t move_to_main_addr,
                              hbool_t do_destroys,
                              hbool_t do_mult_ro_protects,
                              int dirty_destroys,