Author: rhuijben
Date: Thu Feb 5 18:50:03 2015
New Revision: 1657661
URL: http://svn.apache.org/r1657661
Log:
Make the move-update-bump code properly recursive.
Some of the functions documented that they implemented recursive behavior,
but didn't really work this way as you can't use an Sqlite statement in
multiple places at once. Once the function returns the statement is used
as it was left in the inner function.
This allows integrating the two separate parts of the layer copy code.
* subversion/libsvn_wc/wc-queries.sql
(STMT_SELECT_NO_LONGER_MOVED_RV): New statement.
(STMT_SELECT_MOVED_PAIR3): Update query to only find moves at the intended
op-depth.
* subversion/libsvn_wc/wc_db_update_move.c
(update_moved_away_node): Remove call to delete_move_leaf, that was already
documented to be placed wrong.
(replace_moved_layer): Use standard argument ordering. Implement the delete
part of the layer copying.
(drive_tree_conflict_editor): Update caller.
(bump_moved_layer): Cleanup argument usages. Pass calculated path.
(bump_pair_t): New struct.
(bump_moved_away): Cache query results to allow recursing. Otherwise the
statement is done once the inner function returns. Remove source hash,
as we can no longer get in an endless loop because we use strict op-depth.
(svn_wc__db_bump_moved_away): Update caller.
* subversion/tests/libsvn_wc/op-depth-test.c
(nested_move_update): Extend test.
(move4_update_delself_AAA): Update expected results. Extend test.
Modified:
subversion/trunk/subversion/libsvn_wc/wc-queries.sql
subversion/trunk/subversion/libsvn_wc/wc_db_update_move.c
subversion/trunk/subversion/tests/libsvn_wc/op-depth-test.c
Modified: subversion/trunk/subversion/libsvn_wc/wc-queries.sql
URL:
http://svn.apache.org/viewvc/subversion/trunk/subversion/libsvn_wc/wc-queries.sql?rev=1657661&r1=1657660&r2=1657661&view=diff
==============================================================================
--- subversion/trunk/subversion/libsvn_wc/wc-queries.sql (original)
+++ subversion/trunk/subversion/libsvn_wc/wc-queries.sql Thu Feb 5 18:50:03
2015
@@ -313,6 +313,18 @@ SELECT
FROM nodes
WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth = ?3
+-- STMT_SELECT_NO_LONGER_MOVED_RV
+SELECT d.local_relpath, RELPATH_SKIP_JOIN(?2, ?4, d.local_relpath) srp
+FROM nodes d
+WHERE wc_id = ?1
+ AND IS_STRICT_DESCENDANT_OF(local_relpath, ?2)
+ AND op_depth = ?3
+ AND NOT EXISTS(SELECT * FROM nodes s
+ WHERE s.wc_id = ?1
+ AND s.local_relpath = srp
+ AND s.op_depth = ?5)
+ORDER BY d.local_relpath DESC
+
-- STMT_SELECT_OP_DEPTH_CHILDREN
SELECT local_relpath, kind FROM nodes
WHERE wc_id = ?1
@@ -1599,16 +1611,29 @@ UPDATE nodes SET moved_to = NULL
AND IS_STRICT_DESCENDANT_OF(moved_to, ?2)
-- STMT_SELECT_MOVED_PAIR3
-SELECT local_relpath, moved_to, op_depth, kind FROM nodes
-WHERE wc_id = ?1 AND local_relpath = ?2 AND op_depth > ?3
- AND moved_to IS NOT NULL
+SELECT n.local_relpath, d.moved_to, d.op_depth, n.kind
+FROM nodes n
+JOIN nodes d ON d.wc_id = ?1 AND d.local_relpath = n.local_relpath
+ AND d.op_depth = (SELECT MIN(dd.op_depth)
+ FROM nodes dd
+ WHERE dd.wc_id = ?1
+ AND dd.local_relpath = d.local_relpath
+ AND dd.op_depth > ?3)
+WHERE n.wc_id = ?1 AND n.local_relpath = ?2 AND n.op_depth = ?3
+ AND d.moved_to IS NOT NULL
UNION ALL
-SELECT local_relpath, moved_to, op_depth, kind FROM nodes
-WHERE wc_id = ?1
- AND IS_STRICT_DESCENDANT_OF(local_relpath, ?2)
- AND op_depth > ?3
- AND moved_to IS NOT NULL
-ORDER BY local_relpath, op_depth
+SELECT n.local_relpath, d.moved_to, d.op_depth, n.kind
+FROM nodes n
+JOIN nodes d ON d.wc_id = ?1 AND d.local_relpath = n.local_relpath
+ AND d.op_depth = (SELECT MIN(dd.op_depth)
+ FROM nodes dd
+ WHERE dd.wc_id = ?1
+ AND dd.local_relpath = d.local_relpath
+ AND dd.op_depth > ?3)
+WHERE n.wc_id = ?1 AND IS_STRICT_DESCENDANT_OF(n.local_relpath, ?2)
+ AND n.op_depth = ?3
+ AND d.moved_to IS NOT NULL
+ORDER BY n.local_relpath
-- STMT_SELECT_MOVED_OUTSIDE
SELECT local_relpath, moved_to, op_depth FROM nodes
Modified: subversion/trunk/subversion/libsvn_wc/wc_db_update_move.c
URL:
http://svn.apache.org/viewvc/subversion/trunk/subversion/libsvn_wc/wc_db_update_move.c?rev=1657661&r1=1657660&r2=1657661&view=diff
==============================================================================
--- subversion/trunk/subversion/libsvn_wc/wc_db_update_move.c (original)
+++ subversion/trunk/subversion/libsvn_wc/wc_db_update_move.c Thu Feb 5
18:50:03 2015
@@ -1530,12 +1530,6 @@ update_moved_away_node(update_move_baton
{
SVN_ERR(tc_editor_delete(b, dst_relpath, shadowed,
scratch_pool));
-
- /* And perform some work that in some ways belongs in
- replace_moved_layer() after creating all conflicts */
- SVN_ERR(delete_move_leaf(b->wcroot, dst_relpath,
- relpath_depth(b->move_root_dst_relpath),
- scratch_pool));
}
if (src_kind != svn_node_none && src_kind != dst_kind)
@@ -1659,10 +1653,10 @@ update_moved_away_node(update_move_baton
rooted at DST_RELPATH to make it match the move source subtree
rooted at SRC_RELPATH. */
static svn_error_t *
-replace_moved_layer(const char *src_op_relpath,
- const char *dst_op_relpath,
+replace_moved_layer(svn_wc__db_wcroot_t *wcroot,
+ const char *src_op_relpath,
int src_op_depth,
- svn_wc__db_wcroot_t *wcroot,
+ const char *dst_op_relpath,
apr_pool_t *scratch_pool)
{
svn_sqlite__stmt_t *stmt, *stmt2;
@@ -1760,10 +1754,35 @@ replace_moved_layer(const char *src_op_r
SVN_ERR(svn_sqlite__step(&have_row, stmt));
}
+ SVN_ERR(svn_error_compose_create(err, svn_sqlite__reset(stmt)));
+
+ /* And now remove the records that are no longer needed */
+ SVN_ERR(svn_sqlite__get_statement(&stmt, wcroot->sdb,
+ STMT_SELECT_NO_LONGER_MOVED_RV));
+ SVN_ERR(svn_sqlite__bindf(stmt, "isdsd", wcroot->wc_id,
+ dst_op_relpath, dst_op_depth,
+ src_op_relpath, src_op_depth));
+ SVN_ERR(svn_sqlite__step(&have_row, stmt));
+ while (have_row)
+ {
+ const char *dst_relpath;
+
+ svn_pool_clear(iterpool);
+
+ dst_relpath = svn_sqlite__column_text(stmt, 0, iterpool);
+
+ err = delete_move_leaf(wcroot, dst_relpath, dst_op_depth,
+ iterpool);
+
+ if (err)
+ break;
+
+ SVN_ERR(svn_sqlite__step(&have_row, stmt));
+ }
svn_pool_destroy(iterpool);
- return svn_error_trace(svn_error_compose_create(err,
- svn_sqlite__reset(stmt)));
+ SVN_ERR(svn_error_compose_create(err, svn_sqlite__reset(stmt)));
+ return SVN_NO_ERROR;
}
/* Transfer changes from the move source to the move destination.
@@ -1812,8 +1831,8 @@ drive_tree_conflict_editor(update_move_b
dst_relpath, FALSE /* never shadowed */,
db, scratch_pool));
- SVN_ERR(replace_moved_layer(src_relpath, dst_relpath, src_op_depth,
- wcroot, scratch_pool));
+ SVN_ERR(replace_moved_layer(wcroot, src_relpath, src_op_depth, dst_relpath,
+ scratch_pool));
return SVN_NO_ERROR;
}
@@ -2244,13 +2263,10 @@ bump_moved_layer(svn_boolean_t *recurse,
const char *local_relpath,
int op_depth,
const char *src_relpath,
- int src_op_depth,
- svn_node_kind_t src_kind,
+ int src_del_depth,
svn_depth_t src_depth,
const char *dst_relpath,
- apr_hash_t *src_done,
svn_wc__db_t *db,
- apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
svn_sqlite__stmt_t *stmt;
@@ -2258,8 +2274,6 @@ bump_moved_layer(svn_boolean_t *recurse,
svn_skel_t *conflict;
svn_boolean_t can_bump;
- const char *src_root_relpath = src_relpath;
-
SVN_ERR(verify_write_lock(wcroot, local_relpath, scratch_pool));
*recurse = FALSE;
@@ -2268,7 +2282,7 @@ bump_moved_layer(svn_boolean_t *recurse,
STMT_HAS_LAYER_BETWEEN));
SVN_ERR(svn_sqlite__bindf(stmt, "isdd", wcroot->wc_id, local_relpath,
- op_depth, src_op_depth));
+ op_depth, src_del_depth));
SVN_ERR(svn_sqlite__step(&have_row, stmt));
SVN_ERR(svn_sqlite__reset(stmt));
@@ -2297,34 +2311,33 @@ bump_moved_layer(svn_boolean_t *recurse,
can_bump = FALSE;
}
- if (!can_bump)
- {
- SVN_ERR(bump_mark_tree_conflict(wcroot, src_relpath,
- src_root_relpath, dst_relpath,
- db, scratch_pool));
-
- return SVN_NO_ERROR;
- }
-
- while (relpath_depth(src_root_relpath) > src_op_depth)
- src_root_relpath = svn_relpath_dirname(src_root_relpath, scratch_pool);
-
-
- if (svn_hash_gets(src_done, src_relpath))
- return SVN_NO_ERROR;
-
- svn_hash_sets(src_done, apr_pstrdup(result_pool, src_relpath), "");
-
- SVN_ERR(svn_wc__db_read_conflict_internal(&conflict, wcroot,
- src_root_relpath,
- scratch_pool, scratch_pool));
+ {
+ const char *src_root_relpath = src_relpath;
+ while (relpath_depth(src_root_relpath) > src_del_depth)
+ src_root_relpath = svn_relpath_dirname(src_root_relpath, scratch_pool);
+
+ if (!can_bump)
+ {
+ SVN_ERR(bump_mark_tree_conflict(wcroot, src_relpath,
+ src_root_relpath, dst_relpath,
+ db, scratch_pool));
+
+ return SVN_NO_ERROR;
+ }
+
+ SVN_ERR(svn_wc__db_read_conflict_internal(&conflict, wcroot,
+ src_root_relpath,
+ scratch_pool, scratch_pool));
+ }
/* ### TODO: check this is the right sort of tree-conflict? */
if (!conflict)
{
/* ### TODO: verify moved_here? */
- SVN_ERR(replace_moved_layer(src_relpath, dst_relpath,
- op_depth, wcroot, scratch_pool));
+ SVN_ERR(replace_moved_layer(wcroot,
+ src_relpath, op_depth,
+ dst_relpath,
+ scratch_pool));
*recurse = TRUE;
}
@@ -2332,28 +2345,34 @@ bump_moved_layer(svn_boolean_t *recurse,
return SVN_NO_ERROR;
}
+/* Internal storage for bump_moved_away() */
+struct bump_pair_t
+{
+ const char *src_relpath;
+ const char *dst_relpath;
+ int src_del_op_depth;
+ svn_node_kind_t src_kind;
+};
/* Bump moves of LOCAL_RELPATH and all its descendants that were
originally below LOCAL_RELPATH at op-depth OP_DEPTH.
-
- SRC_DONE is a hash with keys that are 'const char *' relpaths
- that have already been bumped. Any bumped paths are added to
- SRC_DONE. */
+ */
static svn_error_t *
bump_moved_away(svn_wc__db_wcroot_t *wcroot,
const char *local_relpath,
int op_depth,
- apr_hash_t *src_done,
svn_depth_t depth,
svn_wc__db_t *db,
- apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
svn_sqlite__stmt_t *stmt;
svn_boolean_t have_row;
apr_pool_t *iterpool;
- svn_error_t *err = NULL;
+ int i;
+ apr_array_header_t *pairs = apr_array_make(scratch_pool, 32,
+ sizeof(struct bump_pair_t*));
+ /* Build an array, as we can't execute the same Sqlite query recursively */
iterpool = svn_pool_create(scratch_pool);
SVN_ERR(svn_sqlite__get_statement(&stmt, wcroot->sdb,
@@ -2363,51 +2382,52 @@ bump_moved_away(svn_wc__db_wcroot_t *wcr
SVN_ERR(svn_sqlite__step(&have_row, stmt));
while(have_row)
{
- const char *src_relpath, *dst_relpath;
- int src_op_depth;
- svn_node_kind_t src_kind;
- svn_depth_t src_depth;
+ struct bump_pair_t *bp = apr_pcalloc(scratch_pool, sizeof(*bp));
+
+ bp->src_relpath = svn_sqlite__column_text(stmt, 0, scratch_pool);
+ bp->dst_relpath = svn_sqlite__column_text(stmt, 1, scratch_pool);
+ bp->src_del_op_depth = svn_sqlite__column_int(stmt, 2);
+ bp->src_kind = svn_sqlite__column_token(stmt, 3, kind_map);
+
+ APR_ARRAY_PUSH(pairs, struct bump_pair_t *) = bp;
+
+ SVN_ERR(svn_sqlite__step(&have_row, stmt));
+ }
+
+ SVN_ERR(svn_sqlite__reset(stmt));
+
+ for (i = 0; i < pairs->nelts; i++)
+ {
+ struct bump_pair_t *bp = APR_ARRAY_IDX(pairs, i, struct bump_pair_t *);
svn_boolean_t skip;
+ svn_depth_t src_wc_depth;
svn_pool_clear(iterpool);
- src_relpath = svn_sqlite__column_text(stmt, 0, iterpool);
- dst_relpath = svn_sqlite__column_text(stmt, 1, iterpool);
- src_op_depth = svn_sqlite__column_int(stmt, 2);
- src_kind = svn_sqlite__column_token(stmt, 3, kind_map);
-
- err = check_bump_layer(&skip, &src_depth, local_relpath, depth,
- src_relpath, src_kind, iterpool);
- if (err)
- break;
+ SVN_ERR(check_bump_layer(&skip, &src_wc_depth, local_relpath, depth,
+ bp->src_relpath, bp->src_kind, iterpool));
if (!skip)
{
svn_boolean_t recurse;
- err = bump_moved_layer(&recurse, wcroot,
- local_relpath, op_depth,
- src_relpath, src_op_depth, src_kind,
src_depth,
- dst_relpath,
- src_done, db, result_pool, iterpool);
-
- if (!err && recurse)
- err = bump_moved_away(wcroot, dst_relpath,
relpath_depth(dst_relpath),
- src_done, depth, db, result_pool, iterpool);
+ SVN_ERR(bump_moved_layer(&recurse, wcroot,
+ local_relpath, op_depth,
+ bp->src_relpath, bp->src_del_op_depth,
+ src_wc_depth, bp->dst_relpath,
+ db, iterpool));
+
+ if (recurse)
+ SVN_ERR(bump_moved_away(wcroot, bp->dst_relpath,
+ relpath_depth(bp->dst_relpath),
+ depth, db, iterpool));
}
-
- if (err)
- break;
-
- SVN_ERR(svn_sqlite__step(&have_row, stmt));
}
- err = svn_error_compose_create(err, svn_sqlite__reset(stmt));
-
svn_pool_destroy(iterpool);
- return svn_error_trace(err);
+ return SVN_NO_ERROR;
}
svn_error_t *
@@ -2417,8 +2437,6 @@ svn_wc__db_bump_moved_away(svn_wc__db_wc
svn_wc__db_t *db,
apr_pool_t *scratch_pool)
{
- apr_hash_t *src_done;
-
SVN_ERR(svn_sqlite__exec_statements(wcroot->sdb,
STMT_CREATE_UPDATE_MOVE_LIST));
@@ -2463,9 +2481,7 @@ svn_wc__db_bump_moved_away(svn_wc__db_wc
}
}
- src_done = apr_hash_make(scratch_pool);
- SVN_ERR(bump_moved_away(wcroot, local_relpath, 0, src_done, depth, db,
- scratch_pool, scratch_pool));
+ SVN_ERR(bump_moved_away(wcroot, local_relpath, 0, depth, db, scratch_pool));
return SVN_NO_ERROR;
}
Modified: subversion/trunk/subversion/tests/libsvn_wc/op-depth-test.c
URL:
http://svn.apache.org/viewvc/subversion/trunk/subversion/tests/libsvn_wc/op-depth-test.c?rev=1657661&r1=1657660&r2=1657661&view=diff
==============================================================================
--- subversion/trunk/subversion/tests/libsvn_wc/op-depth-test.c (original)
+++ subversion/trunk/subversion/tests/libsvn_wc/op-depth-test.c Thu Feb 5
18:50:03 2015
@@ -5548,6 +5548,30 @@ nested_move_update(const svn_test_opts_t
SVN_ERR(sbox_wc_update(&b, "", 2));
+ {
+ nodes_row_t nodes[] = {
+ {0, "", "normal", 2, ""},
+ {0, "A", "normal", 2, "A"},
+ {0, "A/B", "normal", 2, "A/B"},
+ {0, "A/B/C", "normal", 2, "A/B/C"},
+ {0, "A/B/C/f", "normal", 2, "A/B/C/f"},
+ {1, "A", "base-deleted", NO_COPY_FROM, "A2"},
+ {1, "A/B", "base-deleted", NO_COPY_FROM},
+ {1, "A/B/C", "base-deleted", NO_COPY_FROM},
+ {1, "A/B/C/f", "base-deleted", NO_COPY_FROM},
+ {1, "A2", "normal", 1, "A", MOVED_HERE},
+ {1, "A2/B", "normal", 1, "A/B", MOVED_HERE},
+ {1, "A2/B/C", "normal", 1, "A/B/C", MOVED_HERE},
+ {1, "A2/B/C/f", "normal", 1, "A/B/C/f", MOVED_HERE},
+ {3, "A2/B/C", "base-deleted", NO_COPY_FROM, "A2/B/C2"},
+ {3, "A2/B/C/f", "base-deleted", NO_COPY_FROM},
+ {3, "A2/B/C2", "normal", 1, "A/B/C", MOVED_HERE},
+ {3, "A2/B/C2/f", "normal", 1, "A/B/C/f", MOVED_HERE},
+ {0}
+ };
+ SVN_ERR(check_db_rows(&b, "", nodes));
+ }
+
/* Following the A->A2 move should raise a tree-conflict on A2/B/C,
resolving that may require an explicit resolve. */
SVN_ERR(sbox_wc_resolve(&b, "A", svn_depth_empty,
@@ -9481,13 +9505,44 @@ move4_update_delself_AAA(const svn_test_
{
nodes_row_t nodes[] = {
-
+ {0, "", "normal", 2, ""},
+ {0, "A", "normal", 2, "A"},
+ {0, "A/A", "normal", 2, "A/A"},
+ {0, "B", "normal", 2, "B"},
+ {0, "B/A", "normal", 2, "B/A"},
+ {0, "C", "normal", 2, "C"},
+ {0, "C/A", "normal", 2, "C/A"},
+ {0, "D", "normal", 2, "D"},
+ {0, "D/A", "normal", 2, "D/A"},
+ {1, "A", "normal", 1, "B", FALSE, "A_moved", TRUE},
+ {1, "A/A", "normal", 1, "B/A", MOVED_HERE},
+ {1, "A/A/A", "normal", 1, "B/A/A", MOVED_HERE},
+ {1, "A/A/A/A", "normal", 1, "B/A/A/A", MOVED_HERE},
+ {1, "AAA_1", "normal", 1, "A/A/A"},
+ {1, "AAA_1/A", "normal", 1, "A/A/A/A"},
+ {1, "AAA_2", "normal", 1, "B/A/A", MOVED_HERE},
+ {1, "AAA_2/A", "normal", 1, "B/A/A/A", MOVED_HERE},
+ {1, "AAA_3", "normal", 1, "C/A/A", MOVED_HERE},
+ {1, "AAA_3/A", "normal", 1, "C/A/A/A", MOVED_HERE},
{1, "A_moved", "normal", 2, "A", MOVED_HERE},
{1, "A_moved/A", "normal", 2, "A/A", MOVED_HERE},
+ {1, "B", "base-deleted", NO_COPY_FROM, "A"},
+ {1, "B/A", "base-deleted", NO_COPY_FROM},
+ {1, "BA_moved", "normal", 1, "B/A", MOVED_HERE},
+ {1, "BA_moved/A", "normal", 1, "B/A/A", MOVED_HERE},
+ {1, "BA_moved/A/A", "normal", 1, "B/A/A/A", MOVED_HERE},
+ {2, "A/A", "normal", 1, "C/A", FALSE, "BA_moved",
TRUE},
+ {2, "A/A/A", "normal", 1, "C/A/A", MOVED_HERE},
+ {2, "A/A/A/A", "normal", 1, "C/A/A/A", MOVED_HERE},
+ {2, "BA_moved/A", "base-deleted", NO_COPY_FROM, "AAA_2"},
+ {2, "BA_moved/A/A", "base-deleted", NO_COPY_FROM},
+ {2, "C/A", "base-deleted", NO_COPY_FROM, "A/A"},
+ {3, "A/A/A", "normal", 1, "D/A/A", FALSE, "AAA_3"},
+ {3, "A/A/A/A", "normal", 1, "D/A/A/A"},
{ 0 },
};
- SVN_ERR(check_db_rows(&b, "A_moved", nodes));
+ SVN_ERR(check_db_rows(&b, "", nodes));
}
SVN_ERR(sbox_wc_resolve(&b, "B", svn_depth_empty,
@@ -9503,58 +9558,55 @@ move4_update_delself_AAA(const svn_test_
svn_wc_conflict_choose_merged));
SVN_ERR(sbox_wc_resolve(&b, "A_moved/A/A", svn_depth_empty,
svn_wc_conflict_choose_merged));
- /*SVN_ERR(check_db_conflicts(&b, "", NULL));*/
SVN_ERR(sbox_wc_resolve(&b, "A/A", svn_depth_empty,
svn_wc_conflict_choose_mine_conflict));
SVN_ERR(sbox_wc_resolve(&b, "BA_moved/A", svn_depth_empty,
svn_wc_conflict_choose_merged));
- SVN_ERR(sbox_wc_resolve(&b, "", svn_depth_infinity,
svn_wc_conflict_choose_mine_conflict));
+ SVN_ERR(check_db_conflicts(&b, "", NULL));
/* Go back to start position */
SVN_ERR(sbox_wc_update(&b, "", 1));
{
nodes_row_t nodes[] = {
{0, "", "normal", 1, ""},
{0, "A", "normal", 1, "A"},
- {1, "A", "normal", 2, "B", FALSE, "A_moved", TRUE},
{0, "A/A", "normal", 1, "A/A"},
+ {0, "A/A/A", "normal", 1, "A/A/A"},
+ {0, "A/A/A/A", "normal", 1, "A/A/A/A"},
+ {0, "B", "normal", 1, "B"},
+ {0, "B/A", "normal", 1, "B/A"},
+ {0, "B/A/A", "normal", 1, "B/A/A"},
+ {0, "B/A/A/A", "normal", 1, "B/A/A/A"},
+ {0, "C", "normal", 1, "C"},
+ {0, "C/A", "normal", 1, "C/A"},
+ {0, "C/A/A", "normal", 1, "C/A/A"},
+ {0, "C/A/A/A", "normal", 1, "C/A/A/A"},
+ {0, "D", "normal", 1, "D"},
+ {0, "D/A", "normal", 1, "D/A"},
+ {0, "D/A/A", "normal", 1, "D/A/A"},
+ {0, "D/A/A/A", "normal", 1, "D/A/A/A"},
+ {1, "A", "normal", 2, "B", FALSE, "A_moved", TRUE},
{1, "A/A", "normal", 2, "B/A", MOVED_HERE},
- {2, "A/A", "normal", 2, "C/A", FALSE, "BA_moved",
TRUE},
{1, "A/A/A", "base-deleted", NO_COPY_FROM},
- {0, "A/A/A", "normal", 1, "A/A/A"},
- {3, "A/A/A", "normal", 1, "D/A/A"},
{1, "A/A/A/A", "base-deleted", NO_COPY_FROM},
- {0, "A/A/A/A", "normal", 1, "A/A/A/A"},
- {3, "A/A/A/A", "normal", 1, "D/A/A/A"},
+ {1, "A_moved", "normal", 2, "A", MOVED_HERE},
+ {1, "A_moved/A", "normal", 2, "A/A", MOVED_HERE},
{1, "AAA_1", "normal", 1, "A/A/A"},
{1, "AAA_1/A", "normal", 1, "A/A/A/A"},
{1, "AAA_2", "normal", 1, "B/A/A"},
{1, "AAA_2/A", "normal", 1, "B/A/A/A"},
{1, "AAA_3", "normal", 1, "C/A/A"},
{1, "AAA_3/A", "normal", 1, "C/A/A/A"},
- {1, "A_moved", "normal", 2, "A", MOVED_HERE},
- {1, "A_moved/A", "normal", 2, "A/A", MOVED_HERE},
{1, "B", "base-deleted", NO_COPY_FROM, "A"},
- {0, "B", "normal", 1, "B"},
{1, "B/A", "base-deleted", NO_COPY_FROM},
- {0, "B/A", "normal", 1, "B/A"},
{1, "B/A/A", "base-deleted", NO_COPY_FROM},
- {0, "B/A/A", "normal", 1, "B/A/A"},
{1, "B/A/A/A", "base-deleted", NO_COPY_FROM},
- {0, "B/A/A/A", "normal", 1, "B/A/A/A"},
- {1, "BA_moved", "normal", 1, "A/A", MOVED_HERE},
- {1, "BA_moved/A", "normal", 1, "A/A/A", MOVED_HERE},
- {1, "BA_moved/A/A", "normal", 1, "A/A/A/A", MOVED_HERE},
- {0, "C", "normal", 1, "C"},
+ {1, "BA_moved", "normal", 2, "B/A", MOVED_HERE},
+ {2, "A/A", "normal", 2, "C/A", FALSE, "BA_moved",
TRUE},
{2, "C/A", "base-deleted", NO_COPY_FROM, "A/A"},
- {0, "C/A", "normal", 1, "C/A"},
{2, "C/A/A", "base-deleted", NO_COPY_FROM},
- {0, "C/A/A", "normal", 1, "C/A/A"},
{2, "C/A/A/A", "base-deleted", NO_COPY_FROM},
- {0, "C/A/A/A", "normal", 1, "C/A/A/A"},
- {0, "D", "normal", 1, "D"},
- {0, "D/A", "normal", 1, "D/A"},
- {0, "D/A/A", "normal", 1, "D/A/A"},
- {0, "D/A/A/A", "normal", 1, "D/A/A/A"},
+ {3, "A/A/A", "normal", 1, "D/A/A"},
+ {3, "A/A/A/A", "normal", 1, "D/A/A/A"},
{ 0 },
};
