Return-Path: X-Original-To: apmail-subversion-commits-archive@minotaur.apache.org Delivered-To: apmail-subversion-commits-archive@minotaur.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id 19817E0AC for ; Sat, 23 Feb 2013 01:27:11 +0000 (UTC) Received: (qmail 8659 invoked by uid 500); 23 Feb 2013 01:27:11 -0000 Delivered-To: apmail-subversion-commits-archive@subversion.apache.org Received: (qmail 8632 invoked by uid 500); 23 Feb 2013 01:27:10 -0000 Mailing-List: contact commits-help@subversion.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@subversion.apache.org Delivered-To: mailing list commits@subversion.apache.org Received: (qmail 8623 invoked by uid 99); 23 Feb 2013 01:27:10 -0000 Received: from athena.apache.org (HELO athena.apache.org) (140.211.11.136) by apache.org (qpsmtpd/0.29) with ESMTP; Sat, 23 Feb 2013 01:27:10 +0000 X-ASF-Spam-Status: No, hits=-2000.0 required=5.0 tests=ALL_TRUSTED X-Spam-Check-By: apache.org Received: from [140.211.11.4] (HELO eris.apache.org) (140.211.11.4) by apache.org (qpsmtpd/0.29) with ESMTP; Sat, 23 Feb 2013 01:27:05 +0000 Received: from eris.apache.org (localhost [127.0.0.1]) by eris.apache.org (Postfix) with ESMTP id 5EAEE2388C6D; Sat, 23 Feb 2013 01:25:58 +0000 (UTC) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r1449262 [24/25] - in /subversion/branches/ev2-export: ./ build/ build/ac-macros/ build/generator/ build/generator/swig/ build/generator/templates/ build/win32/ contrib/server-side/fsfsfixer/fixer/ contrib/server-side/svncutter/ notes/ note... Date: Sat, 23 Feb 2013 01:25:44 -0000 To: commits@subversion.apache.org From: hwright@apache.org X-Mailer: svnmailer-1.0.8-patched Message-Id: <20130223012558.5EAEE2388C6D@eris.apache.org> X-Virus-Checked: Checked by ClamAV on apache.org Modified: subversion/branches/ev2-export/subversion/tests/libsvn_wc/op-depth-test.c URL: http://svn.apache.org/viewvc/subversion/branches/ev2-export/subversion/tests/libsvn_wc/op-depth-test.c?rev=1449262&r1=1449261&r2=1449262&view=diff ============================================================================== --- subversion/branches/ev2-export/subversion/tests/libsvn_wc/op-depth-test.c (original) +++ subversion/branches/ev2-export/subversion/tests/libsvn_wc/op-depth-test.c Sat Feb 23 01:25:38 2013 @@ -2032,12 +2032,10 @@ test_op_revert(const svn_test_opts_t *op before, before, before_actual4, after_actual4)); err = revert(&b, "A/B", svn_depth_empty, before, before, common_actual5, common_actual5); - SVN_TEST_ASSERT(err && err->apr_err == SVN_ERR_WC_INVALID_OPERATION_DEPTH); - svn_error_clear(err); + SVN_TEST_ASSERT_ERROR(err, SVN_ERR_WC_INVALID_OPERATION_DEPTH); err = revert(&b, "A/B/C", svn_depth_empty, before, before, common_actual6, common_actual6); - SVN_TEST_ASSERT(err && err->apr_err == SVN_ERR_WC_INVALID_OPERATION_DEPTH); - svn_error_clear(err); + SVN_TEST_ASSERT_ERROR(err, SVN_ERR_WC_INVALID_OPERATION_DEPTH); } { @@ -2090,30 +2088,24 @@ test_op_revert(const svn_test_opts_t *op err = revert(&b, "A/B", svn_depth_empty, common, common, NULL, NULL); - SVN_TEST_ASSERT(err && err->apr_err == SVN_ERR_WC_INVALID_OPERATION_DEPTH); - svn_error_clear(err); + SVN_TEST_ASSERT_ERROR(err, SVN_ERR_WC_INVALID_OPERATION_DEPTH); err = revert(&b, "A/B", svn_depth_empty, common, common, common_actual, common_actual); - SVN_TEST_ASSERT(err && err->apr_err == SVN_ERR_WC_INVALID_OPERATION_DEPTH); - svn_error_clear(err); + SVN_TEST_ASSERT_ERROR(err, SVN_ERR_WC_INVALID_OPERATION_DEPTH); err = revert(&b, "P", svn_depth_empty, common, common, NULL, NULL); - SVN_TEST_ASSERT(err && err->apr_err == SVN_ERR_WC_INVALID_OPERATION_DEPTH); - svn_error_clear(err); + SVN_TEST_ASSERT_ERROR(err, SVN_ERR_WC_INVALID_OPERATION_DEPTH); err = revert(&b, "P", svn_depth_empty, common, common, common_actual, common_actual); - SVN_TEST_ASSERT(err && err->apr_err == SVN_ERR_WC_INVALID_OPERATION_DEPTH); - svn_error_clear(err); + SVN_TEST_ASSERT_ERROR(err, SVN_ERR_WC_INVALID_OPERATION_DEPTH); err = revert(&b, "X", svn_depth_empty, common, common, NULL, NULL); - SVN_TEST_ASSERT(err && err->apr_err == SVN_ERR_WC_INVALID_OPERATION_DEPTH); - svn_error_clear(err); + SVN_TEST_ASSERT_ERROR(err, SVN_ERR_WC_INVALID_OPERATION_DEPTH); err = revert(&b, "X", svn_depth_empty, common, common, common_actual, common_actual); - SVN_TEST_ASSERT(err && err->apr_err == SVN_ERR_WC_INVALID_OPERATION_DEPTH); - svn_error_clear(err); + SVN_TEST_ASSERT_ERROR(err, SVN_ERR_WC_INVALID_OPERATION_DEPTH); } { @@ -2314,8 +2306,7 @@ test_op_revert(const svn_test_opts_t *op }; err = revert(&b, "A", svn_depth_empty, common, common, NULL, NULL); - SVN_TEST_ASSERT(err && err->apr_err == SVN_ERR_WC_INVALID_OPERATION_DEPTH); - svn_error_clear(err); + SVN_TEST_ASSERT_ERROR(err, SVN_ERR_WC_INVALID_OPERATION_DEPTH); } { @@ -3512,8 +3503,7 @@ copy_wc_wc_server_excluded(const svn_tes SVN_ERR(check_db_rows(&b, "", before)); SVN_ERR(sbox_disk_mkdir(&b, "A")); err = sbox_wc_copy(&b, "A", "X"); - SVN_TEST_ASSERT(err && err->apr_err == SVN_ERR_WC_PATH_UNEXPECTED_STATUS); - svn_error_clear(err); + SVN_TEST_ASSERT_ERROR(err, SVN_ERR_WC_PATH_UNEXPECTED_STATUS); SVN_ERR(check_db_rows(&b, "", after)); return SVN_NO_ERROR; @@ -4083,6 +4073,48 @@ move_to_swap(const svn_test_opts_t *opts SVN_ERR(check_db_rows(&b, "", nodes)); } + /* And move this last bit back and check if the db state is restored */ + SVN_ERR(sbox_wc_move(&b, "A/B", "X/B")); + SVN_ERR(sbox_wc_move(&b, "X/Y", "A/Y")); + + { + /* Exact the same as before the initial moves */ + nodes_row_t nodes[] = { + {0, "", "normal", 1, ""}, + {0, "A", "normal", 1, "A"}, + {0, "A/B", "normal", 1, "A/B"}, + {0, "X", "normal", 1, "X"}, + {0, "X/Y", "normal", 1, "X/Y"}, + {1, "A", "normal", 1, "X", FALSE, "X", TRUE}, + {1, "A/Y", "normal", 1, "X/Y", MOVED_HERE}, + {1, "A/B", "base-deleted", NO_COPY_FROM}, + {1, "X", "normal", 1, "A", FALSE, "A", TRUE}, + {1, "X/B", "normal", 1, "A/B", MOVED_HERE}, + {1, "X/Y", "base-deleted", NO_COPY_FROM}, + {0} + }; + SVN_ERR(check_db_rows(&b, "", nodes)); + } + + /* And try to undo the rest */ + SVN_ERR(sbox_wc_move(&b, "A", "A2")); + SVN_ERR(sbox_wc_move(&b, "X", "A")); + SVN_ERR(sbox_wc_move(&b, "A2", "X")); + + { + nodes_row_t nodes[] = { + {0, "", "normal", 1, ""}, + {0, "A", "normal", 1, "A"}, + {0, "A/B", "normal", 1, "A/B"}, + {0, "X", "normal", 1, "X"}, + {0, "X/Y", "normal", 1, "X/Y"}, + + {0} + }; + + SVN_ERR(check_db_rows(&b, "", nodes)); + } + return SVN_NO_ERROR; } @@ -4139,6 +4171,41 @@ revert_nested_move(const svn_test_opts_t {3, "A2/B2/C2", "normal", 1, "A/B/C", MOVED_HERE}, {0} }; + nodes_row_t nodes_AB_moved_C_copied[] = { + {0, "", "normal", 1, ""}, + {0, "A", "normal", 1, "A"}, + {0, "A/B", "normal", 1, "A/B"}, + {0, "A/B/C", "normal", 1, "A/B/C"}, + {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, "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}, + {2, "A2/B", "base-deleted", NO_COPY_FROM, "A2/B2"}, + {2, "A2/B/C", "base-deleted", NO_COPY_FROM}, + {2, "A2/B2", "normal", 1, "A/B", MOVED_HERE}, + {2, "A2/B2/C", "normal", 1, "A/B/C", MOVED_HERE}, + {3, "A2/B2/C2", "normal", 1, "A/B/C"}, + {0} + }; + nodes_row_t nodes_AC_moved_B_copied[] = { + {0, "", "normal", 1, ""}, + {0, "A", "normal", 1, "A"}, + {0, "A/B", "normal", 1, "A/B"}, + {0, "A/B/C", "normal", 1, "A/B/C"}, + {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, "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}, + {2, "A2/B2", "normal", 1, "A/B"}, + {2, "A2/B2/C", "normal", 1, "A/B/C"}, + {3, "A2/B2/C", "base-deleted", NO_COPY_FROM, "A2/B2/C2"}, + {3, "A2/B2/C2", "normal", 1, "A/B/C", MOVED_HERE}, + {0} + }; SVN_ERR(svn_test__sandbox_create(&b, "revert_nested_move", opts, pool)); @@ -4165,7 +4232,16 @@ revert_nested_move(const svn_test_opts_t SVN_ERR(sbox_wc_move(&b, "A2/B2/C", "A2/B2/C2")); SVN_ERR(check_db_rows(&b, "", nodes_ABC_moved)); + SVN_ERR(sbox_wc_revert(&b, "A2/B2/C", svn_depth_empty)); + SVN_ERR(check_db_rows(&b, "", nodes_AB_moved_C_copied)); + SVN_ERR(sbox_wc_revert(&b, "A2/B2/C2", svn_depth_infinity)); + SVN_ERR(check_db_rows(&b, "", nodes_AB_moved)); + + SVN_ERR(sbox_wc_move(&b, "A2/B2/C", "A2/B2/C2")); + SVN_ERR(check_db_rows(&b, "", nodes_ABC_moved)); + SVN_ERR(sbox_wc_revert(&b, "A2/B2/C", svn_depth_infinity)); + SVN_ERR(check_db_rows(&b, "", nodes_AB_moved_C_copied)); SVN_ERR(sbox_wc_revert(&b, "A2/B2/C2", svn_depth_infinity)); SVN_ERR(check_db_rows(&b, "", nodes_AB_moved)); @@ -4180,6 +4256,9 @@ revert_nested_move(const svn_test_opts_t SVN_ERR(sbox_wc_move(&b, "A", "A2")); SVN_ERR(check_db_rows(&b, "", nodes_ABC_moved)); + SVN_ERR(sbox_wc_revert(&b, "A2/B", svn_depth_infinity)); + SVN_ERR(check_db_rows(&b, "", nodes_AC_moved_B_copied)); + return SVN_NO_ERROR; } @@ -4419,7 +4498,8 @@ move_update(const svn_test_opts_t *opts, } /* Resolve should update the move. */ - SVN_ERR(sbox_wc_resolve(&b, "A", svn_wc_conflict_choose_mine_conflict)); + SVN_ERR(sbox_wc_resolve(&b, "A", svn_depth_empty, + svn_wc_conflict_choose_mine_conflict)); { nodes_row_t nodes[] = { {0, "", "normal", 2, ""}, @@ -4462,7 +4542,8 @@ move_update(const svn_test_opts_t *opts, SVN_ERR(check_db_rows(&b, "", nodes)); } - SVN_ERR(sbox_wc_resolve(&b, "A", svn_wc_conflict_choose_mine_conflict)); + SVN_ERR(sbox_wc_resolve(&b, "A", svn_depth_empty, + svn_wc_conflict_choose_mine_conflict)); { nodes_row_t nodes[] = { {0, "", "normal", 3, ""}, @@ -4508,7 +4589,8 @@ move_update(const svn_test_opts_t *opts, } SVN_ERR(sbox_wc_update(&b, "", 2)); - SVN_ERR(sbox_wc_resolve(&b, "A", svn_wc_conflict_choose_mine_conflict)); + SVN_ERR(sbox_wc_resolve(&b, "A", svn_depth_empty, + svn_wc_conflict_choose_mine_conflict)); { nodes_row_t nodes[] = { {0, "", "normal", 2, ""}, @@ -4563,7 +4645,8 @@ move_update(const svn_test_opts_t *opts, } SVN_ERR(sbox_wc_update(&b, "", 4)); - SVN_ERR(sbox_wc_resolve(&b, "A", svn_wc_conflict_choose_mine_conflict)); + SVN_ERR(sbox_wc_resolve(&b, "A", svn_depth_empty, + svn_wc_conflict_choose_mine_conflict)); { nodes_row_t nodes[] = { {0, "", "normal", 4, ""}, @@ -4593,7 +4676,8 @@ move_update(const svn_test_opts_t *opts, } SVN_ERR(sbox_wc_update(&b, "", 5)); - SVN_ERR(sbox_wc_resolve(&b, "A", svn_wc_conflict_choose_mine_conflict)); + SVN_ERR(sbox_wc_resolve(&b, "A", svn_depth_empty, + svn_wc_conflict_choose_mine_conflict)); { nodes_row_t nodes[] = { {0, "", "normal", 5, ""}, @@ -5124,7 +5208,8 @@ update_prop_mod_into_moved(const svn_tes } /* Resolve should update the move. */ - SVN_ERR(sbox_wc_resolve(&b, "A", svn_wc_conflict_choose_mine_conflict)); + SVN_ERR(sbox_wc_resolve(&b, "A", svn_depth_empty, + svn_wc_conflict_choose_mine_conflict)); { nodes_row_t nodes[] = { {0, "", "normal", 2, ""}, @@ -5203,8 +5288,10 @@ nested_move_update(const svn_test_opts_t /* 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_wc_conflict_choose_mine_conflict)); - SVN_ERR(sbox_wc_resolve(&b, "A2/B/C", svn_wc_conflict_choose_mine_conflict)); + SVN_ERR(sbox_wc_resolve(&b, "A", svn_depth_empty, + svn_wc_conflict_choose_mine_conflict)); + SVN_ERR(sbox_wc_resolve(&b, "A2/B/C", svn_depth_empty, + svn_wc_conflict_choose_mine_conflict)); { nodes_row_t nodes[] = { {0, "", "normal", 2, ""}, @@ -5382,8 +5469,7 @@ nested_move_commit(const svn_test_opts_t {3, "A2/B/C", "base-deleted", NO_COPY_FROM, "C2"}, {3, "A2/B/C/f", "base-deleted", NO_COPY_FROM}, - /* Currently these are recorded as a move but still - have the copy history from ^/A/B/C@1 */ + /* These need to have their copyfrom information updated */ {1, "C2", "normal", 2, "A2/B/C", MOVED_HERE}, {1, "C2/f", "normal", 2, "A2/B/C/f", MOVED_HERE}, {0} @@ -5586,7 +5672,8 @@ move_update_conflicts(const svn_test_opt SVN_ERR(sbox_wc_update(&b, "A", 2)); SVN_ERR(check_tree_conflict_repos_path(&b, "A", "X/A", "X/A")); - SVN_ERR(sbox_wc_resolve(&b, "A", svn_wc_conflict_choose_mine_conflict)); + SVN_ERR(sbox_wc_resolve(&b, "A", svn_depth_empty, + svn_wc_conflict_choose_mine_conflict)); { nodes_row_t nodes[] = { {0, "", "normal", 1, "X"}, @@ -5669,7 +5756,8 @@ move_update_delete_mods(const svn_test_o } SVN_ERR(sbox_wc_update(&b, "A", 2)); - SVN_ERR(sbox_wc_resolve(&b, "A/B", svn_wc_conflict_choose_mine_conflict)); + SVN_ERR(sbox_wc_resolve(&b, "A/B", svn_depth_empty, + svn_wc_conflict_choose_mine_conflict)); { nodes_row_t nodes[] = { {0, "", "normal", 1, ""}, @@ -5704,6 +5792,8 @@ nested_moves2(const svn_test_opts_t *opt SVN_ERR(sbox_wc_mkdir(&b, "A/A/A/A/A")); SVN_ERR(sbox_wc_mkdir(&b, "A/A/A/A/A/A")); SVN_ERR(sbox_wc_commit(&b, "")); + SVN_ERR(sbox_wc_mkdir(&b, "X")); + SVN_ERR(sbox_wc_commit(&b, "")); SVN_ERR(sbox_wc_move(&b, "A/A/A/A/A/A", "C")); SVN_ERR(sbox_wc_move(&b, "A/A/A/A", "D")); @@ -5712,6 +5802,7 @@ nested_moves2(const svn_test_opts_t *opt { nodes_row_t nodes[] = { {0, "", "normal", 0, ""}, + {0, "X", "normal", 2, "X"}, {0, "A", "normal", 1, "A"}, {0, "A/A", "normal", 1, "A/A"}, {0, "A/A/A", "normal", 1, "A/A/A"}, @@ -5740,6 +5831,1239 @@ nested_moves2(const svn_test_opts_t *opt }; SVN_ERR(check_db_rows(&b, "", nodes)); } + + SVN_ERR(sbox_wc_update(&b, "A", 2)); + { + nodes_row_t nodes[] = { + {0, "", "normal", 0, ""}, + {0, "X", "normal", 2, "X"}, + {0, "A", "normal", 2, "A"}, + {0, "A/A", "normal", 2, "A/A"}, + {0, "A/A/A", "normal", 2, "A/A/A"}, + {0, "A/A/A/A", "normal", 2, "A/A/A/A"}, + {0, "A/A/A/A/A", "normal", 2, "A/A/A/A/A"}, + {0, "A/A/A/A/A/A", "normal", 2, "A/A/A/A/A/A"}, + {2, "A/A", "base-deleted", NO_COPY_FROM, "E"}, + {2, "A/A/A", "base-deleted", NO_COPY_FROM}, + {2, "A/A/A/A", "base-deleted", NO_COPY_FROM}, + {2, "A/A/A/A/A", "base-deleted", NO_COPY_FROM}, + {2, "A/A/A/A/A/A", "base-deleted", NO_COPY_FROM}, + {1, "E", "normal", 2, "A/A", MOVED_HERE}, + {1, "E/A", "normal", 2, "A/A/A", MOVED_HERE}, + {1, "E/A/A", "normal", 2, "A/A/A/A", MOVED_HERE}, + {1, "E/A/A/A", "normal", 2, "A/A/A/A/A", MOVED_HERE}, + {1, "E/A/A/A/A", "normal", 2, "A/A/A/A/A/A", MOVED_HERE}, + {3, "E/A/A", "base-deleted", NO_COPY_FROM, "D"}, + {3, "E/A/A/A", "base-deleted", NO_COPY_FROM}, + {3, "E/A/A/A/A", "base-deleted", NO_COPY_FROM}, + {1, "D", "normal", 2, "A/A/A/A", MOVED_HERE}, + {1, "D/A", "normal", 2, "A/A/A/A/A", MOVED_HERE}, + {1, "D/A/A", "normal", 2, "A/A/A/A/A/A", MOVED_HERE}, + {3, "D/A/A", "base-deleted", NO_COPY_FROM, "C"}, + {1, "C", "normal", 2, "A/A/A/A/A/A", MOVED_HERE}, + {0} + }; + SVN_ERR(check_db_rows(&b, "", nodes)); + } + + return SVN_NO_ERROR; +} + +static svn_error_t * +move_in_delete(const svn_test_opts_t *opts, apr_pool_t *pool) +{ + svn_test__sandbox_t b; + + SVN_ERR(svn_test__sandbox_create(&b, "move_in_delete", opts, pool)); + + SVN_ERR(sbox_wc_mkdir(&b, "A")); + SVN_ERR(sbox_wc_mkdir(&b, "A/B")); + SVN_ERR(sbox_wc_mkdir(&b, "A/B/C")); + SVN_ERR(sbox_wc_commit(&b, "")); + SVN_ERR(sbox_wc_mkdir(&b, "A/B/C/D")); + SVN_ERR(sbox_wc_commit(&b, "")); + SVN_ERR(sbox_wc_mkdir(&b, "A/B/C/D/E")); + SVN_ERR(sbox_wc_commit(&b, "")); + SVN_ERR(sbox_wc_mkdir(&b, "X")); + SVN_ERR(sbox_wc_commit(&b, "")); + SVN_ERR(sbox_wc_update(&b, "", 1)); + + SVN_ERR(sbox_wc_move(&b, "A/B/C", "C2")); + SVN_ERR(sbox_wc_delete(&b, "A/B")); + { + nodes_row_t nodes[] = { + {0, "", "normal", 1, ""}, + {0, "A", "normal", 1, "A"}, + {0, "A/B", "normal", 1, "A/B"}, + {0, "A/B/C", "normal", 1, "A/B/C"}, + {2, "A/B", "base-deleted", NO_COPY_FROM}, + {2, "A/B/C", "base-deleted", NO_COPY_FROM, "C2"}, + {1, "C2", "normal", 1, "A/B/C", MOVED_HERE}, + {0} + }; + SVN_ERR(check_db_rows(&b, "", nodes)); + } + + SVN_ERR(sbox_wc_update(&b, "", 2)); + SVN_ERR(sbox_wc_resolve(&b, "A/B", svn_depth_empty, + svn_wc_conflict_choose_merged)); + SVN_ERR(sbox_wc_resolve(&b, "A/B/C", svn_depth_empty, + svn_wc_conflict_choose_mine_conflict)); + { + 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/D", "normal", 2, "A/B/C/D"}, + {2, "A/B", "base-deleted", NO_COPY_FROM}, + {2, "A/B/C", "base-deleted", NO_COPY_FROM, "C2"}, + {2, "A/B/C/D", "base-deleted", NO_COPY_FROM}, + {1, "C2", "normal", 2, "A/B/C", MOVED_HERE}, + {1, "C2/D", "normal", 2, "A/B/C/D", MOVED_HERE}, + {0} + }; + SVN_ERR(check_db_rows(&b, "", nodes)); + } + + SVN_ERR(sbox_wc_update(&b, "", 3)); + SVN_ERR(sbox_wc_revert(&b, "A/B", svn_depth_empty)); + { + nodes_row_t nodes[] = { + {0, "", "normal", 3, ""}, + {0, "A", "normal", 3, "A"}, + {0, "A/B", "normal", 3, "A/B"}, + {0, "A/B/C", "normal", 3, "A/B/C"}, + {0, "A/B/C/D", "normal", 3, "A/B/C/D"}, + {0, "A/B/C/D/E", "normal", 3, "A/B/C/D/E"}, + {3, "A/B/C", "base-deleted", NO_COPY_FROM, "C2"}, + {3, "A/B/C/D", "base-deleted", NO_COPY_FROM}, + {3, "A/B/C/D/E", "base-deleted", NO_COPY_FROM}, + {1, "C2", "normal", 2, "A/B/C", MOVED_HERE}, + {1, "C2/D", "normal", 2, "A/B/C/D", MOVED_HERE}, + {0} + }; + SVN_ERR(check_db_rows(&b, "", nodes)); + } + + /* Revert should have left a tree-conflict (or broken the move). */ + SVN_ERR(sbox_wc_resolve(&b, "A/B/C", svn_depth_empty, + svn_wc_conflict_choose_mine_conflict)); + { + nodes_row_t nodes[] = { + {0, "", "normal", 3, ""}, + {0, "A", "normal", 3, "A"}, + {0, "A/B", "normal", 3, "A/B"}, + {0, "A/B/C", "normal", 3, "A/B/C"}, + {0, "A/B/C/D", "normal", 3, "A/B/C/D"}, + {0, "A/B/C/D/E", "normal", 3, "A/B/C/D/E"}, + {3, "A/B/C", "base-deleted", NO_COPY_FROM, "C2"}, + {3, "A/B/C/D", "base-deleted", NO_COPY_FROM}, + {3, "A/B/C/D/E", "base-deleted", NO_COPY_FROM}, + {1, "C2", "normal", 3, "A/B/C", MOVED_HERE}, + {1, "C2/D", "normal", 3, "A/B/C/D", MOVED_HERE}, + {1, "C2/D/E", "normal", 3, "A/B/C/D/E", MOVED_HERE}, + {0} + }; + SVN_ERR(check_db_rows(&b, "", nodes)); + } + + return SVN_NO_ERROR; +} + +static svn_error_t * +switch_move(const svn_test_opts_t *opts, apr_pool_t *pool) +{ + svn_test__sandbox_t b; + + SVN_ERR(svn_test__sandbox_create(&b, "switch_move", opts, pool)); + + SVN_ERR(sbox_wc_mkdir(&b, "A")); + SVN_ERR(sbox_wc_mkdir(&b, "A/B")); + SVN_ERR(sbox_wc_mkdir(&b, "A/B/C")); + SVN_ERR(sbox_wc_mkdir(&b, "A/B/D")); + SVN_ERR(sbox_wc_mkdir(&b, "A/B/D/E")); + SVN_ERR(sbox_wc_commit(&b, "")); + SVN_ERR(sbox_wc_copy(&b, "A", "X")); + SVN_ERR(sbox_wc_commit(&b, "")); + SVN_ERR(sbox_wc_mkdir(&b, "X/B/D/E/F")); + SVN_ERR(sbox_wc_commit(&b, "")); + SVN_ERR(sbox_wc_switch(&b, "/A")); + SVN_ERR(sbox_wc_update(&b, "", 2)); + + SVN_ERR(sbox_wc_move(&b, "B/C", "C2")); + SVN_ERR(sbox_wc_move(&b, "B/D", "D2")); + SVN_ERR(sbox_wc_move(&b, "D2/E", "D2/E2")); + { + nodes_row_t nodes[] = { + {0, "", "normal", 2, "A"}, + {0, "B", "normal", 2, "A/B"}, + {0, "B/C", "normal", 2, "A/B/C"}, + {0, "B/D", "normal", 2, "A/B/D"}, + {0, "B/D/E", "normal", 2, "A/B/D/E"}, + {2, "B/C", "base-deleted", NO_COPY_FROM, "C2"}, + {2, "B/D", "base-deleted", NO_COPY_FROM, "D2"}, + {2, "B/D/E", "base-deleted", NO_COPY_FROM}, + {1, "C2", "normal", 2, "A/B/C", MOVED_HERE}, + {1, "D2", "normal", 2, "A/B/D", MOVED_HERE}, + {1, "D2/E", "normal", 2, "A/B/D/E", MOVED_HERE}, + {2, "D2/E", "base-deleted", NO_COPY_FROM, "D2/E2"}, + {2, "D2/E2", "normal", 2, "A/B/D/E", MOVED_HERE}, + {0} + }; + SVN_ERR(check_db_rows(&b, "", nodes)); + } + + /* Switch "bumps" revisions and paths and raises conflicts just like + update. */ + SVN_ERR(sbox_wc_switch(&b, "/X")); + { + nodes_row_t nodes[] = { + {0, "", "normal", 3, "X"}, + {0, "B", "normal", 3, "X/B"}, + {0, "B/C", "normal", 3, "X/B/C"}, + {0, "B/D", "normal", 3, "X/B/D"}, + {0, "B/D/E", "normal", 3, "X/B/D/E"}, + {0, "B/D/E/F", "normal", 3, "X/B/D/E/F"}, + {2, "B/C", "base-deleted", NO_COPY_FROM, "C2"}, + {2, "B/D", "base-deleted", NO_COPY_FROM, "D2"}, + {2, "B/D/E", "base-deleted", NO_COPY_FROM}, + {2, "B/D/E/F", "base-deleted", NO_COPY_FROM}, + {1, "C2", "normal", 3, "X/B/C", MOVED_HERE}, + {1, "D2", "normal", 2, "A/B/D", MOVED_HERE}, + {1, "D2/E", "normal", 2, "A/B/D/E", MOVED_HERE}, + {2, "D2/E", "base-deleted", NO_COPY_FROM, "D2/E2"}, + {2, "D2/E2", "normal", 2, "A/B/D/E", MOVED_HERE}, + {0} + }; + SVN_ERR(check_db_rows(&b, "", nodes)); + } + + /* Conflicts from switch are resolved just like those from update. */ + SVN_ERR(sbox_wc_resolve(&b, "B/D", svn_depth_empty, + svn_wc_conflict_choose_mine_conflict)); + { + nodes_row_t nodes[] = { + {0, "", "normal", 3, "X"}, + {0, "B", "normal", 3, "X/B"}, + {0, "B/C", "normal", 3, "X/B/C"}, + {0, "B/D", "normal", 3, "X/B/D"}, + {0, "B/D/E", "normal", 3, "X/B/D/E"}, + {0, "B/D/E/F", "normal", 3, "X/B/D/E/F"}, + {2, "B/C", "base-deleted", NO_COPY_FROM, "C2"}, + {2, "B/D", "base-deleted", NO_COPY_FROM, "D2"}, + {2, "B/D/E", "base-deleted", NO_COPY_FROM}, + {2, "B/D/E/F", "base-deleted", NO_COPY_FROM}, + {1, "C2", "normal", 3, "X/B/C", MOVED_HERE}, + {1, "D2", "normal", 3, "X/B/D", MOVED_HERE}, + {1, "D2/E", "normal", 3, "X/B/D/E", MOVED_HERE}, + {1, "D2/E/F", "normal", 3, "X/B/D/E/F", MOVED_HERE}, + {2, "D2/E", "base-deleted", NO_COPY_FROM, "D2/E2"}, + {2, "D2/E/F", "base-deleted", NO_COPY_FROM}, + {2, "D2/E2", "normal", 2, "A/B/D/E", MOVED_HERE}, + {0} + }; + SVN_ERR(check_db_rows(&b, "", nodes)); + } + + SVN_ERR(sbox_wc_resolve(&b, "D2/E", svn_depth_empty, + svn_wc_conflict_choose_mine_conflict)); + { + nodes_row_t nodes[] = { + {0, "", "normal", 3, "X"}, + {0, "B", "normal", 3, "X/B"}, + {0, "B/C", "normal", 3, "X/B/C"}, + {0, "B/D", "normal", 3, "X/B/D"}, + {0, "B/D/E", "normal", 3, "X/B/D/E"}, + {0, "B/D/E/F", "normal", 3, "X/B/D/E/F"}, + {2, "B/C", "base-deleted", NO_COPY_FROM, "C2"}, + {2, "B/D", "base-deleted", NO_COPY_FROM, "D2"}, + {2, "B/D/E", "base-deleted", NO_COPY_FROM}, + {2, "B/D/E/F", "base-deleted", NO_COPY_FROM}, + {1, "C2", "normal", 3, "X/B/C", MOVED_HERE}, + {1, "D2", "normal", 3, "X/B/D", MOVED_HERE}, + {1, "D2/E", "normal", 3, "X/B/D/E", MOVED_HERE}, + {1, "D2/E/F", "normal", 3, "X/B/D/E/F", MOVED_HERE}, + {2, "D2/E", "base-deleted", NO_COPY_FROM, "D2/E2"}, + {2, "D2/E/F", "base-deleted", NO_COPY_FROM}, + {2, "D2/E2", "normal", 3, "X/B/D/E", MOVED_HERE}, + {2, "D2/E2/F", "normal", 3, "X/B/D/E/F", MOVED_HERE}, + {0} + }; + SVN_ERR(check_db_rows(&b, "", nodes)); + } + + return SVN_NO_ERROR; +} + +static svn_error_t * +move_replace(const svn_test_opts_t *opts, apr_pool_t *pool) +{ + svn_test__sandbox_t b; + + SVN_ERR(svn_test__sandbox_create(&b, "move_replace", opts, pool)); + + SVN_ERR(sbox_wc_mkdir(&b, "A")); + SVN_ERR(sbox_wc_mkdir(&b, "B")); + SVN_ERR(sbox_wc_commit(&b, "")); + SVN_ERR(sbox_wc_mkdir(&b, "B/X")); + SVN_ERR(sbox_wc_commit(&b, "")); + SVN_ERR(sbox_wc_update(&b, "", 1)); + + SVN_ERR(sbox_wc_move(&b, "A", "X")); + SVN_ERR(sbox_wc_move(&b, "B", "A")); + SVN_ERR(sbox_wc_move(&b, "X", "B")); + { + nodes_row_t nodes[] = { + {0, "", "normal", 1, ""}, + {0, "A", "normal", 1, "A"}, + {0, "B", "normal", 1, "B"}, + {1, "A", "normal", 1, "B", FALSE, "B", TRUE}, + {1, "B", "normal", 1, "A", FALSE, "A", TRUE}, + {0} + }; + SVN_ERR(check_db_rows(&b, "", nodes)); + } + + SVN_ERR(sbox_wc_update(&b, "", 2)); + { + nodes_row_t nodes[] = { + {0, "", "normal", 2, ""}, + {0, "A", "normal", 2, "A"}, + {0, "B", "normal", 2, "B"}, + {0, "B/X", "normal", 2, "B/X"}, + {1, "A", "normal", 1, "B", FALSE, "B", TRUE}, + {1, "B", "normal", 2, "A", FALSE, "A", TRUE}, + {1, "B/X", "base-deleted", NO_COPY_FROM}, + {0} + }; + SVN_ERR(check_db_rows(&b, "", nodes)); + } + + SVN_ERR(sbox_wc_resolve(&b, "B", svn_depth_empty, + svn_wc_conflict_choose_mine_conflict)); + { + nodes_row_t nodes[] = { + {0, "", "normal", 2, ""}, + {0, "A", "normal", 2, "A"}, + {0, "B", "normal", 2, "B"}, + {0, "B/X", "normal", 2, "B/X"}, + {1, "A", "normal", 2, "B", FALSE, "B", TRUE}, + {1, "A/X", "normal", 2, "B/X", MOVED_HERE}, + {1, "B", "normal", 2, "A", FALSE, "A", TRUE}, + {1, "B/X", "base-deleted", NO_COPY_FROM}, + {0} + }; + SVN_ERR(check_db_rows(&b, "", nodes)); + } + + return SVN_NO_ERROR; +} + +static svn_error_t * +layered_moved_to(const svn_test_opts_t *opts, apr_pool_t *pool) +{ + svn_test__sandbox_t b; + svn_error_t *err; + + SVN_ERR(svn_test__sandbox_create(&b, "layered_moved_to", opts, pool)); + + SVN_ERR(sbox_wc_mkdir(&b, "A")); + SVN_ERR(sbox_wc_mkdir(&b, "A/B")); + SVN_ERR(sbox_wc_mkdir(&b, "A/B/C")); + SVN_ERR(sbox_wc_mkdir(&b, "A/B/C/D")); + SVN_ERR(sbox_wc_mkdir(&b, "A/B/C/D/E")); + SVN_ERR(sbox_wc_mkdir(&b, "C")); + SVN_ERR(sbox_wc_mkdir(&b, "C/D")); + SVN_ERR(sbox_wc_mkdir(&b, "C/D/E")); + SVN_ERR(sbox_wc_commit(&b, "")); + SVN_ERR(sbox_wc_propset(&b, "property", "value", "A/B/C/D/E")); + SVN_ERR(sbox_wc_commit(&b, "")); + SVN_ERR(sbox_wc_propset(&b, "property", "value", "C/D/E")); + SVN_ERR(sbox_wc_commit(&b, "")); + SVN_ERR(sbox_wc_mkdir(&b, "P")); + SVN_ERR(sbox_wc_commit(&b, "")); + SVN_ERR(sbox_wc_propset(&b, "property2", "value", "A/B/C/D/E")); + SVN_ERR(sbox_wc_propset(&b, "property2", "value", "C/D/E")); + SVN_ERR(sbox_wc_commit(&b, "")); + SVN_ERR(sbox_wc_update(&b, "", 1)); + + SVN_ERR(sbox_wc_move(&b, "A", "X")); + SVN_ERR(sbox_wc_move(&b, "X/B/C/D/E", "E2")); + SVN_ERR(sbox_wc_delete(&b, "X/B/C")); + SVN_ERR(sbox_wc_move(&b, "C", "X/B/C")); + SVN_ERR(sbox_wc_move(&b, "X/B/C/D/E", "E3")); + { + nodes_row_t nodes[] = { + {0, "", "normal", 1, ""}, + {0, "A", "normal", 1, "A"}, + {0, "A/B", "normal", 1, "A/B"}, + {0, "A/B/C", "normal", 1, "A/B/C"}, + {0, "A/B/C/D", "normal", 1, "A/B/C/D"}, + {0, "A/B/C/D/E", "normal", 1, "A/B/C/D/E"}, + {0, "C", "normal", 1, "C"}, + {0, "C/D", "normal", 1, "C/D"}, + {0, "C/D/E", "normal", 1, "C/D/E"}, + {1, "A", "base-deleted", NO_COPY_FROM, "X"}, + {1, "A/B", "base-deleted", NO_COPY_FROM}, + {1, "A/B/C", "base-deleted", NO_COPY_FROM}, + {1, "A/B/C/D", "base-deleted", NO_COPY_FROM}, + {1, "A/B/C/D/E", "base-deleted", NO_COPY_FROM}, + {1, "C", "base-deleted", NO_COPY_FROM, "X/B/C"}, + {1, "C/D", "base-deleted", NO_COPY_FROM}, + {1, "C/D/E", "base-deleted", NO_COPY_FROM}, + {1, "X", "normal", 1, "A", MOVED_HERE}, + {1, "X/B", "normal", 1, "A/B", MOVED_HERE}, + {1, "X/B/C", "normal", 1, "A/B/C", MOVED_HERE}, + {1, "X/B/C/D", "normal", 1, "A/B/C/D", MOVED_HERE}, + {1, "X/B/C/D/E", "normal", 1, "A/B/C/D/E", MOVED_HERE}, + {3, "X/B/C", "normal", 1, "C", MOVED_HERE}, + {3, "X/B/C/D", "normal", 1, "C/D", MOVED_HERE}, + {3, "X/B/C/D/E", "normal", 1, "C/D/E", FALSE, "E2", TRUE}, + {5, "X/B/C/D/E", "base-deleted", NO_COPY_FROM, "E3"}, + {1, "E2", "normal", 1, "A/B/C/D/E", MOVED_HERE}, + {1, "E3", "normal", 1, "C/D/E", MOVED_HERE}, + {0} + }; + SVN_ERR(check_db_rows(&b, "", nodes)); + } + + SVN_ERR(sbox_wc_update(&b, "A", 2)); + SVN_ERR(sbox_wc_resolve(&b, "A", svn_depth_empty, + svn_wc_conflict_choose_mine_conflict)); + SVN_ERR(sbox_wc_resolve(&b, "X/B/C", svn_depth_empty, + svn_wc_conflict_choose_merged)); + SVN_ERR(sbox_wc_resolve(&b, "X/B/C/D/E", svn_depth_empty, + svn_wc_conflict_choose_mine_conflict)); + { + nodes_row_t nodes[] = { + {0, "", "normal", 1, ""}, + {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/D", "normal", 2, "A/B/C/D"}, + {0, "A/B/C/D/E", "normal", 2, "A/B/C/D/E"}, + {0, "C", "normal", 1, "C"}, + {0, "C/D", "normal", 1, "C/D"}, + {0, "C/D/E", "normal", 1, "C/D/E"}, + {1, "A", "base-deleted", NO_COPY_FROM, "X"}, + {1, "A/B", "base-deleted", NO_COPY_FROM}, + {1, "A/B/C", "base-deleted", NO_COPY_FROM}, + {1, "A/B/C/D", "base-deleted", NO_COPY_FROM}, + {1, "A/B/C/D/E", "base-deleted", NO_COPY_FROM}, + {1, "C", "base-deleted", NO_COPY_FROM, "X/B/C"}, + {1, "C/D", "base-deleted", NO_COPY_FROM}, + {1, "C/D/E", "base-deleted", NO_COPY_FROM}, + {1, "X", "normal", 2, "A", MOVED_HERE}, + {1, "X/B", "normal", 2, "A/B", MOVED_HERE}, + {1, "X/B/C", "normal", 2, "A/B/C", MOVED_HERE}, + {1, "X/B/C/D", "normal", 2, "A/B/C/D", MOVED_HERE}, + {1, "X/B/C/D/E", "normal", 2, "A/B/C/D/E", MOVED_HERE}, + {3, "X/B/C", "normal", 1, "C", MOVED_HERE}, + {3, "X/B/C/D", "normal", 1, "C/D", MOVED_HERE}, + {3, "X/B/C/D/E", "normal", 1, "C/D/E", FALSE, "E2", TRUE}, + {5, "X/B/C/D/E", "base-deleted", NO_COPY_FROM, "E3"}, + {1, "E2", "normal", 2, "A/B/C/D/E", MOVED_HERE}, + {1, "E3", "normal", 1, "C/D/E", MOVED_HERE}, + {0} + }; + SVN_ERR(check_db_rows(&b, "", nodes)); + } + + SVN_ERR(sbox_wc_update(&b, "C", 3)); + SVN_ERR(sbox_wc_resolve(&b, "C", svn_depth_empty, + svn_wc_conflict_choose_mine_conflict)); + SVN_ERR(sbox_wc_resolve(&b, "X/B/C/D/E", svn_depth_empty, + svn_wc_conflict_choose_mine_conflict)); + { + nodes_row_t nodes[] = { + {0, "", "normal", 1, ""}, + {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/D", "normal", 2, "A/B/C/D"}, + {0, "A/B/C/D/E", "normal", 2, "A/B/C/D/E"}, + {0, "C", "normal", 3, "C"}, + {0, "C/D", "normal", 3, "C/D"}, + {0, "C/D/E", "normal", 3, "C/D/E"}, + {1, "A", "base-deleted", NO_COPY_FROM, "X"}, + {1, "A/B", "base-deleted", NO_COPY_FROM}, + {1, "A/B/C", "base-deleted", NO_COPY_FROM}, + {1, "A/B/C/D", "base-deleted", NO_COPY_FROM}, + {1, "A/B/C/D/E", "base-deleted", NO_COPY_FROM}, + {1, "C", "base-deleted", NO_COPY_FROM, "X/B/C"}, + {1, "C/D", "base-deleted", NO_COPY_FROM}, + {1, "C/D/E", "base-deleted", NO_COPY_FROM}, + {1, "X", "normal", 2, "A", MOVED_HERE}, + {1, "X/B", "normal", 2, "A/B", MOVED_HERE}, + {1, "X/B/C", "normal", 2, "A/B/C", MOVED_HERE}, + {1, "X/B/C/D", "normal", 2, "A/B/C/D", MOVED_HERE}, + {1, "X/B/C/D/E", "normal", 2, "A/B/C/D/E", MOVED_HERE}, + {3, "X/B/C", "normal", 3, "C", MOVED_HERE}, + {3, "X/B/C/D", "normal", 3, "C/D", MOVED_HERE}, + {3, "X/B/C/D/E", "normal", 3, "C/D/E", FALSE, "E2", TRUE}, + {5, "X/B/C/D/E", "base-deleted", NO_COPY_FROM, "E3"}, + {1, "E2", "normal", 2, "A/B/C/D/E", MOVED_HERE}, + {1, "E3", "normal", 3, "C/D/E", MOVED_HERE}, + {0} + }; + SVN_ERR(check_db_rows(&b, "", nodes)); + } + + /* An update with no text/property/tree changes in A, just a revision bump. */ + SVN_ERR(sbox_wc_update(&b, "A", 4)); + { + nodes_row_t nodes[] = { + {0, "", "normal", 1, ""}, + {0, "A", "normal", 4, "A"}, + {0, "A/B", "normal", 4, "A/B"}, + {0, "A/B/C", "normal", 4, "A/B/C"}, + {0, "A/B/C/D", "normal", 4, "A/B/C/D"}, + {0, "A/B/C/D/E", "normal", 4, "A/B/C/D/E"}, + {0, "C", "normal", 3, "C"}, + {0, "C/D", "normal", 3, "C/D"}, + {0, "C/D/E", "normal", 3, "C/D/E"}, + {1, "A", "base-deleted", NO_COPY_FROM, "X"}, + {1, "A/B", "base-deleted", NO_COPY_FROM}, + {1, "A/B/C", "base-deleted", NO_COPY_FROM}, + {1, "A/B/C/D", "base-deleted", NO_COPY_FROM}, + {1, "A/B/C/D/E", "base-deleted", NO_COPY_FROM}, + {1, "C", "base-deleted", NO_COPY_FROM, "X/B/C"}, + {1, "C/D", "base-deleted", NO_COPY_FROM}, + {1, "C/D/E", "base-deleted", NO_COPY_FROM}, + {1, "X", "normal", 4, "A", MOVED_HERE}, + {1, "X/B", "normal", 4, "A/B", MOVED_HERE}, + {1, "X/B/C", "normal", 4, "A/B/C", MOVED_HERE}, + {1, "X/B/C/D", "normal", 4, "A/B/C/D", MOVED_HERE}, + {1, "X/B/C/D/E", "normal", 4, "A/B/C/D/E", MOVED_HERE}, + {3, "X/B/C", "normal", 3, "C", MOVED_HERE}, + {3, "X/B/C/D", "normal", 3, "C/D", MOVED_HERE}, + {3, "X/B/C/D/E", "normal", 3, "C/D/E", FALSE, "E2", TRUE}, + {5, "X/B/C/D/E", "base-deleted", NO_COPY_FROM, "E3"}, + {1, "E2", "normal", 4, "A/B/C/D/E", MOVED_HERE}, + {1, "E3", "normal", 3, "C/D/E", MOVED_HERE}, + {0} + }; + SVN_ERR(check_db_rows(&b, "", nodes)); + } + + /* Update for conflicts on A and C */ + SVN_ERR(sbox_wc_update(&b, "", 5)); + { + nodes_row_t nodes[] = { + {0, "", "normal", 5, ""}, + {0, "A", "normal", 5, "A"}, + {0, "A/B", "normal", 5, "A/B"}, + {0, "A/B/C", "normal", 5, "A/B/C"}, + {0, "A/B/C/D", "normal", 5, "A/B/C/D"}, + {0, "A/B/C/D/E", "normal", 5, "A/B/C/D/E"}, + {0, "P", "normal", 5, "P"}, + {0, "C", "normal", 5, "C"}, + {0, "C/D", "normal", 5, "C/D"}, + {0, "C/D/E", "normal", 5, "C/D/E"}, + {1, "A", "base-deleted", NO_COPY_FROM, "X"}, + {1, "A/B", "base-deleted", NO_COPY_FROM}, + {1, "A/B/C", "base-deleted", NO_COPY_FROM}, + {1, "A/B/C/D", "base-deleted", NO_COPY_FROM}, + {1, "A/B/C/D/E", "base-deleted", NO_COPY_FROM}, + {1, "C", "base-deleted", NO_COPY_FROM, "X/B/C"}, + {1, "C/D", "base-deleted", NO_COPY_FROM}, + {1, "C/D/E", "base-deleted", NO_COPY_FROM}, + {1, "X", "normal", 4, "A", MOVED_HERE}, + {1, "X/B", "normal", 4, "A/B", MOVED_HERE}, + {1, "X/B/C", "normal", 4, "A/B/C", MOVED_HERE}, + {1, "X/B/C/D", "normal", 4, "A/B/C/D", MOVED_HERE}, + {1, "X/B/C/D/E", "normal", 4, "A/B/C/D/E", MOVED_HERE}, + {3, "X/B/C", "normal", 3, "C", MOVED_HERE}, + {3, "X/B/C/D", "normal", 3, "C/D", MOVED_HERE}, + {3, "X/B/C/D/E", "normal", 3, "C/D/E", FALSE, "E2", TRUE}, + {5, "X/B/C/D/E", "base-deleted", NO_COPY_FROM, "E3"}, + {1, "E2", "normal", 4, "A/B/C/D/E", MOVED_HERE}, + {1, "E3", "normal", 3, "C/D/E", MOVED_HERE}, + {0} + }; + SVN_ERR(check_db_rows(&b, "", nodes)); + } + + /* Partially resolve A */ + SVN_ERR(sbox_wc_resolve(&b, "A", svn_depth_empty, + svn_wc_conflict_choose_mine_conflict)); + SVN_ERR(sbox_wc_resolve(&b, "X/B/C", svn_depth_empty, + svn_wc_conflict_choose_merged)); + + /* Cannot resolve C */ + err = sbox_wc_resolve(&b, "C", svn_depth_empty, + svn_wc_conflict_choose_mine_conflict); + SVN_TEST_ASSERT_ERROR(err, SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE); + + /* Complete resolving A and then resolve C */ + SVN_ERR(sbox_wc_resolve(&b, "X/B/C/D/E", svn_depth_empty, + svn_wc_conflict_choose_mine_conflict)); + SVN_ERR(sbox_wc_resolve(&b, "C", svn_depth_empty, + svn_wc_conflict_choose_mine_conflict)); + + { + nodes_row_t nodes[] = { + {0, "", "normal", 5, ""}, + {0, "A", "normal", 5, "A"}, + {0, "A/B", "normal", 5, "A/B"}, + {0, "A/B/C", "normal", 5, "A/B/C"}, + {0, "A/B/C/D", "normal", 5, "A/B/C/D"}, + {0, "A/B/C/D/E", "normal", 5, "A/B/C/D/E"}, + {0, "P", "normal", 5, "P"}, + {0, "C", "normal", 5, "C"}, + {0, "C/D", "normal", 5, "C/D"}, + {0, "C/D/E", "normal", 5, "C/D/E"}, + {1, "A", "base-deleted", NO_COPY_FROM, "X"}, + {1, "A/B", "base-deleted", NO_COPY_FROM}, + {1, "A/B/C", "base-deleted", NO_COPY_FROM}, + {1, "A/B/C/D", "base-deleted", NO_COPY_FROM}, + {1, "A/B/C/D/E", "base-deleted", NO_COPY_FROM}, + {1, "C", "base-deleted", NO_COPY_FROM, "X/B/C"}, + {1, "C/D", "base-deleted", NO_COPY_FROM}, + {1, "C/D/E", "base-deleted", NO_COPY_FROM}, + {1, "X", "normal", 5, "A", MOVED_HERE}, + {1, "X/B", "normal", 5, "A/B", MOVED_HERE}, + {1, "X/B/C", "normal", 5, "A/B/C", MOVED_HERE}, + {1, "X/B/C/D", "normal", 5, "A/B/C/D", MOVED_HERE}, + {1, "X/B/C/D/E", "normal", 5, "A/B/C/D/E", MOVED_HERE}, + {3, "X/B/C", "normal", 5, "C", MOVED_HERE}, + {3, "X/B/C/D", "normal", 5, "C/D", MOVED_HERE}, + {3, "X/B/C/D/E", "normal", 5, "C/D/E", FALSE, "E2", TRUE}, + {5, "X/B/C/D/E", "base-deleted", NO_COPY_FROM, "E3"}, + {1, "E2", "normal", 5, "A/B/C/D/E", MOVED_HERE}, + {1, "E3", "normal", 3, "C/D/E", MOVED_HERE}, + {0} + }; + SVN_ERR(check_db_rows(&b, "", nodes)); + } + + return SVN_NO_ERROR; +} + +static svn_error_t * +update_within_move(const svn_test_opts_t *opts, apr_pool_t *pool) +{ + svn_test__sandbox_t b; + svn_error_t *err; + + SVN_ERR(svn_test__sandbox_create(&b, "update_within_move", opts, pool)); + + SVN_ERR(sbox_wc_mkdir(&b, "A")); + SVN_ERR(sbox_wc_mkdir(&b, "A/B")); + SVN_ERR(sbox_wc_mkdir(&b, "A/B/C")); + SVN_ERR(sbox_wc_commit(&b, "")); + SVN_ERR(sbox_wc_mkdir(&b, "A/B/C/D")); + SVN_ERR(sbox_wc_commit(&b, "")); + SVN_ERR(sbox_wc_update(&b, "", 1)); + + SVN_ERR(sbox_wc_move(&b, "A", "X")); + SVN_ERR(sbox_wc_update(&b, "A/B/C", 2)); + { + nodes_row_t nodes[] = { + {0, "", "normal", 1, ""}, + {0, "A", "normal", 1, "A"}, + {0, "A/B", "normal", 1, "A/B"}, + {0, "A/B/C", "normal", 2, "A/B/C"}, + {0, "A/B/C/D", "normal", 2, "A/B/C/D"}, + {1, "A", "base-deleted", NO_COPY_FROM, "X"}, + {1, "A/B", "base-deleted", NO_COPY_FROM}, + {1, "A/B/C", "base-deleted", NO_COPY_FROM}, + {1, "A/B/C/D", "base-deleted", NO_COPY_FROM}, + {1, "X", "normal", 1, "A", MOVED_HERE}, + {1, "X/B", "normal", 1, "A/B", MOVED_HERE}, + {1, "X/B/C", "normal", 1, "A/B/C", MOVED_HERE}, + {0} + }; + SVN_ERR(check_db_rows(&b, "", nodes)); + } + + /* Can't resolve mixed-revision source to mine-conflict. */ + err = sbox_wc_resolve(&b, "A", svn_depth_empty, + svn_wc_conflict_choose_mine_conflict); + SVN_TEST_ASSERT_ERROR(err, SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE); + + SVN_ERR(sbox_wc_resolve(&b, "A", svn_depth_empty, + svn_wc_conflict_choose_merged)); + { + nodes_row_t nodes[] = { + {0, "", "normal", 1, ""}, + {0, "A", "normal", 1, "A"}, + {0, "A/B", "normal", 1, "A/B"}, + {0, "A/B/C", "normal", 2, "A/B/C"}, + {0, "A/B/C/D", "normal", 2, "A/B/C/D"}, + {1, "A", "base-deleted", NO_COPY_FROM}, + {1, "A/B", "base-deleted", NO_COPY_FROM}, + {1, "A/B/C", "base-deleted", NO_COPY_FROM}, + {1, "A/B/C/D", "base-deleted", NO_COPY_FROM}, + {1, "X", "normal", 1, "A"}, + {1, "X/B", "normal", 1, "A/B"}, + {1, "X/B/C", "normal", 1, "A/B/C"}, + {0} + }; + SVN_ERR(check_db_rows(&b, "", nodes)); + } + + + return SVN_NO_ERROR; +} + +static svn_error_t * +commit_moved_descendant(const svn_test_opts_t *opts, apr_pool_t *pool) +{ + svn_test__sandbox_t b; + SVN_ERR(svn_test__sandbox_create(&b, "commit_moved_descendant", opts, pool)); + + SVN_ERR(sbox_wc_mkdir(&b, "A")); + SVN_ERR(sbox_wc_mkdir(&b, "A/A")); + SVN_ERR(sbox_wc_mkdir(&b, "A/A/A")); + SVN_ERR(sbox_wc_mkdir(&b, "A/A/A/A")); + SVN_ERR(sbox_wc_mkdir(&b, "A/A/A/A/A")); + SVN_ERR(sbox_wc_mkdir(&b, "A/A/A/A/A/A")); + SVN_ERR(sbox_wc_commit(&b, "")); + SVN_ERR(sbox_wc_copy(&b, "A", "A_copied")); + SVN_ERR(sbox_wc_move(&b, "A/A/A", "AAA_moved")); + SVN_ERR(sbox_wc_delete(&b, "A/A")); + SVN_ERR(sbox_wc_copy(&b, "A_copied/A", "A/A")); + + /* And now I want to commit AAA_moved (the entire move), but not + the replacement of A/A */ + + /* For now, just start committing directly */ + /* ### This fails, because A/A/A is not collected by the commit + harvester (it doesn't need committing, but our move filter + blocks on it) */ + SVN_ERR(sbox_wc_commit(&b, "")); + + /* It would be nicer if we could just do a: */ + /* SVN_ERR(sbox_wc_commit(&b, "AAA_moved")); */ + /* Which then includes the delete half of the move, when it is + shadowed, like in this case. The commit processing doesn't + support this yet though*/ + + return SVN_NO_ERROR; +} + +static svn_error_t * +commit_moved_away_descendant(const svn_test_opts_t *opts, apr_pool_t *pool) +{ + svn_test__sandbox_t b; + SVN_ERR(svn_test__sandbox_create(&b, "commit_moved_away_descendant", + opts, pool)); + + SVN_ERR(sbox_wc_mkdir(&b, "A")); + SVN_ERR(sbox_wc_mkdir(&b, "A/A")); + SVN_ERR(sbox_wc_mkdir(&b, "A/A/A")); + SVN_ERR(sbox_wc_mkdir(&b, "A/A/A/A")); + SVN_ERR(sbox_wc_mkdir(&b, "A/A/A/A/A")); + SVN_ERR(sbox_wc_mkdir(&b, "A/A/A/A/A/A")); + SVN_ERR(sbox_wc_commit(&b, "")); + SVN_ERR(sbox_wc_copy(&b, "A", "A_copied")); + SVN_ERR(sbox_wc_move(&b, "A/A/A", "AAA_moved")); + SVN_ERR(sbox_wc_delete(&b, "A/A")); + SVN_ERR(sbox_wc_copy(&b, "A_copied/A", "A/A")); + + /* And now I want to make sure that I can't commit A, without also + committing AAA_moved, as that would break the move*/ + SVN_ERR(sbox_wc_commit(&b, "A")); + + return svn_error_create(SVN_ERR_TEST_FAILED, NULL, + "The commit should have failed"); + + /*return SVN_NO_ERROR;*/ +} + +static svn_error_t * +finite_move_update_bump(const svn_test_opts_t *opts, apr_pool_t *pool) +{ + svn_test__sandbox_t b; + svn_error_t *err; + SVN_ERR(svn_test__sandbox_create(&b, "finite_move_update_bump", + opts, pool)); + + SVN_ERR(sbox_wc_mkdir(&b, "A")); + SVN_ERR(sbox_wc_mkdir(&b, "A/B")); + SVN_ERR(sbox_wc_mkdir(&b, "A/B/C")); + SVN_ERR(sbox_wc_mkdir(&b, "P")); + SVN_ERR(sbox_wc_mkdir(&b, "P/Q")); + sbox_file_write(&b, "P/Q/f", "r1 content\n"); + SVN_ERR(sbox_wc_add(&b, "P/Q/f")); + SVN_ERR(sbox_wc_commit(&b, "")); + SVN_ERR(sbox_wc_mkdir(&b, "X")); + SVN_ERR(sbox_wc_commit(&b, "")); + SVN_ERR(sbox_wc_update(&b, "", 1)); + + SVN_ERR(sbox_wc_move(&b, "A/B", "B2")); + SVN_ERR(sbox_wc_update(&b, "A/B/C", 2)); + SVN_ERR(check_tree_conflict_repos_path(&b, "A/B", NULL, NULL)); + err = sbox_wc_resolve(&b, "A/B", svn_depth_empty, + svn_wc_conflict_choose_mine_conflict); + SVN_TEST_ASSERT_ERROR(err, SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE); + { + nodes_row_t nodes[] = { + {0, "", "normal", 1, ""}, + {0, "A", "normal", 1, "A"}, + {0, "A/B", "normal", 1, "A/B"}, + {0, "A/B/C", "normal", 2, "A/B/C"}, + {0, "P", "normal", 1, "P"}, + {0, "P/Q", "normal", 1, "P/Q"}, + {0, "P/Q/f", "normal", 1, "P/Q/f"}, + {2, "A/B", "base-deleted", NO_COPY_FROM, "B2"}, + {2, "A/B/C", "base-deleted", NO_COPY_FROM}, + {1, "B2", "normal", 1, "A/B", MOVED_HERE}, + {1, "B2/C", "normal", 1, "A/B/C", MOVED_HERE}, + {0} + }; + SVN_ERR(check_db_rows(&b, "", nodes)); + } + + SVN_ERR(sbox_wc_revert(&b, "", svn_depth_infinity)); + SVN_ERR(sbox_wc_update(&b, "", 1)); + SVN_ERR(sbox_wc_move(&b, "A/B", "B2")); + SVN_ERR(sbox_wc_move(&b, "P/Q", "Q2")); + SVN_ERR(sbox_wc_update_depth(&b, "A/B", 2, svn_depth_files)); + SVN_ERR(sbox_wc_update_depth(&b, "P/Q", 2, svn_depth_files)); + SVN_ERR(check_tree_conflict_repos_path(&b, "A/B", NULL, NULL)); + err = sbox_wc_resolve(&b, "A/B", svn_depth_empty, + svn_wc_conflict_choose_mine_conflict); + SVN_TEST_ASSERT_ERROR(err, SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE); + { + nodes_row_t nodes[] = { + {0, "", "normal", 1, ""}, + {0, "A", "normal", 1, "A"}, + {0, "A/B", "normal", 2, "A/B"}, + {0, "A/B/C", "normal", 1, "A/B/C"}, + {0, "P", "normal", 1, "P"}, + {0, "P/Q", "normal", 2, "P/Q"}, + {0, "P/Q/f", "normal", 2, "P/Q/f"}, + {2, "A/B", "base-deleted", NO_COPY_FROM, "B2"}, + {2, "A/B/C", "base-deleted", NO_COPY_FROM}, + {2, "P/Q", "base-deleted", NO_COPY_FROM, "Q2"}, + {2, "P/Q/f", "base-deleted", NO_COPY_FROM}, + {1, "B2", "normal", 1, "A/B", MOVED_HERE}, + {1, "B2/C", "normal", 1, "A/B/C", MOVED_HERE}, + {1, "Q2", "normal", 2, "P/Q", MOVED_HERE}, + {1, "Q2/f", "normal", 2, "P/Q/f", MOVED_HERE}, + {0} + }; + SVN_ERR(check_db_rows(&b, "", nodes)); + } + + SVN_ERR(sbox_wc_revert(&b, "", svn_depth_infinity)); + SVN_ERR(sbox_wc_update(&b, "", 1)); + SVN_ERR(sbox_wc_move(&b, "A/B", "B2")); + SVN_ERR(sbox_wc_move(&b, "P", "P2")); + SVN_ERR(sbox_wc_update_depth(&b, "A/B", 2, svn_depth_immediates)); + SVN_ERR(sbox_wc_update_depth(&b, "P", 2, svn_depth_immediates)); + SVN_ERR(check_tree_conflict_repos_path(&b, "P", NULL, NULL)); + err = sbox_wc_resolve(&b, "P", svn_depth_empty, + svn_wc_conflict_choose_mine_conflict); + SVN_TEST_ASSERT_ERROR(err, SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE); + { + nodes_row_t nodes[] = { + {0, "", "normal", 1, ""}, + {0, "A", "normal", 1, "A"}, + {0, "A/B", "normal", 2, "A/B"}, + {0, "A/B/C", "normal", 2, "A/B/C"}, + {0, "P", "normal", 2, "P"}, + {0, "P/Q", "normal", 2, "P/Q"}, + {0, "P/Q/f", "normal", 1, "P/Q/f"}, + {2, "A/B", "base-deleted", NO_COPY_FROM, "B2"}, + {2, "A/B/C", "base-deleted", NO_COPY_FROM}, + {1, "P", "base-deleted", NO_COPY_FROM, "P2"}, + {1, "P/Q", "base-deleted", NO_COPY_FROM}, + {1, "P/Q/f", "base-deleted", NO_COPY_FROM}, + {1, "B2", "normal", 2, "A/B", MOVED_HERE}, + {1, "B2/C", "normal", 2, "A/B/C", MOVED_HERE}, + {1, "P2", "normal", 1, "P", MOVED_HERE}, + {1, "P2/Q", "normal", 1, "P/Q", MOVED_HERE}, + {1, "P2/Q/f", "normal", 1, "P/Q/f", MOVED_HERE}, + {0} + }; + SVN_ERR(check_db_rows(&b, "", nodes)); + } + + SVN_ERR(sbox_wc_revert(&b, "", svn_depth_infinity)); + SVN_ERR(sbox_wc_update(&b, "", 1)); + SVN_ERR(sbox_wc_move(&b, "A/B/C", "C2")); + SVN_ERR(sbox_wc_move(&b, "P/Q", "Q2")); + SVN_ERR(sbox_wc_update_depth(&b, "A/B/C", 2, svn_depth_empty)); + SVN_ERR(sbox_wc_update_depth(&b, "P/Q", 2, svn_depth_empty)); + SVN_ERR(check_tree_conflict_repos_path(&b, "P/Q", NULL, NULL)); + err = sbox_wc_resolve(&b, "P/Q", svn_depth_empty, + svn_wc_conflict_choose_mine_conflict); + SVN_TEST_ASSERT_ERROR(err, SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE); + { + nodes_row_t nodes[] = { + {0, "", "normal", 1, ""}, + {0, "A", "normal", 1, "A"}, + {0, "A/B", "normal", 1, "A/B"}, + {0, "A/B/C", "normal", 2, "A/B/C"}, + {0, "P", "normal", 1, "P"}, + {0, "P/Q", "normal", 2, "P/Q"}, + {0, "P/Q/f", "normal", 1, "P/Q/f"}, + {3, "A/B/C", "base-deleted", NO_COPY_FROM, "C2"}, + {2, "P/Q", "base-deleted", NO_COPY_FROM, "Q2"}, + {2, "P/Q/f", "base-deleted", NO_COPY_FROM}, + {1, "C2", "normal", 2, "A/B/C", MOVED_HERE}, + {1, "Q2", "normal", 1, "P/Q", MOVED_HERE}, + {1, "Q2/f", "normal", 1, "P/Q/f", MOVED_HERE}, + {0} + }; + SVN_ERR(check_db_rows(&b, "", nodes)); + } + + return SVN_NO_ERROR; +} + +static svn_error_t * +move_away_delete_update(const svn_test_opts_t *opts, apr_pool_t *pool) +{ + svn_test__sandbox_t b; + SVN_ERR(svn_test__sandbox_create(&b, "move_away_delete_update", + opts, pool)); + + SVN_ERR(sbox_wc_mkdir(&b, "A")); + SVN_ERR(sbox_wc_mkdir(&b, "A/B")); + SVN_ERR(sbox_wc_mkdir(&b, "A/B/C")); + SVN_ERR(sbox_wc_mkdir(&b, "P")); + SVN_ERR(sbox_wc_mkdir(&b, "P/Q")); + SVN_ERR(sbox_wc_commit(&b, "")); + SVN_ERR(sbox_wc_delete(&b, "A/B")); + SVN_ERR(sbox_wc_delete(&b, "P/Q")); + SVN_ERR(sbox_wc_commit(&b, "")); + + SVN_ERR(sbox_wc_update(&b, "", 1)); + SVN_ERR(sbox_wc_move(&b, "A/B/C", "C2")); + SVN_ERR(sbox_wc_move(&b, "P/Q", "Q2")); + SVN_ERR(sbox_wc_update(&b, "", 2)); + SVN_ERR(sbox_wc_resolve(&b, "A/B", svn_depth_empty, + svn_wc_conflict_choose_merged)); + SVN_ERR(sbox_wc_resolve(&b, "P/Q", svn_depth_empty, + svn_wc_conflict_choose_merged)); + /* Either update or resolve should clear the moved-here flags */ + { + nodes_row_t nodes[] = { + {0, "", "normal", 2, ""}, + {0, "A", "normal", 2, "A"}, + {0, "P", "normal", 2, "P"}, + {1, "C2", "normal", 1, "A/B/C"}, + {1, "Q2", "normal", 1, "P/Q"}, + {0} + }; + SVN_ERR(check_db_rows(&b, "", nodes)); + } + + return SVN_NO_ERROR; +} + +static svn_error_t * +move_not_present_variants(const svn_test_opts_t *opts, apr_pool_t *pool) +{ + svn_test__sandbox_t b; + SVN_ERR(svn_test__sandbox_create(&b, "move_not_present_variants", + opts, pool)); + + SVN_ERR(sbox_wc_mkdir(&b, "A")); + SVN_ERR(sbox_wc_mkdir(&b, "A/B")); + SVN_ERR(sbox_wc_mkdir(&b, "B")); + SVN_ERR(sbox_wc_mkdir(&b, "B/B")); + SVN_ERR(sbox_wc_mkdir(&b, "C")); + SVN_ERR(sbox_wc_mkdir(&b, "C/B")); + SVN_ERR(sbox_wc_mkdir(&b, "D")); + SVN_ERR(sbox_wc_mkdir(&b, "D/B")); + SVN_ERR(sbox_wc_commit(&b, "")); + SVN_ERR(sbox_wc_update(&b, "", 1)); + + SVN_ERR(sbox_wc_delete(&b, "A/B")); + SVN_ERR(sbox_wc_commit(&b, "")); + + SVN_ERR(sbox_wc_delete(&b, "B/B")); + SVN_ERR(sbox_wc_update(&b, "C/B", 0)); + SVN_ERR(sbox_wc_exclude(&b, "D/B")); + + SVN_ERR(sbox_wc_copy(&b, "A", "cA")); + SVN_ERR(sbox_wc_copy(&b, "B", "cB")); + SVN_ERR(sbox_wc_copy(&b, "C", "cC")); + SVN_ERR(sbox_wc_copy(&b, "D", "cD")); + + SVN_ERR(sbox_wc_copy(&b, "cA", "ccA")); + SVN_ERR(sbox_wc_copy(&b, "cB", "ccB")); + SVN_ERR(sbox_wc_copy(&b, "cC", "ccC")); + SVN_ERR(sbox_wc_copy(&b, "cD", "ccD")); + + { + nodes_row_t nodes[] = { + {0, "", "normal", 1, ""}, + + /* Copy of a deleted + committed node */ + {0, "A", "normal", 1, "A"}, + {0, "A/B", "not-present", 2, "A/B"}, + + {1, "cA", "normal", 1, "A"}, + {1, "cA/B", "not-present", 2, "A/B"}, + + {1, "ccA", "normal", 1, "A"}, + {1, "ccA/B", "not-present", 2, "A/B"}, + + /* Copy of a local deleted node */ + {0, "B", "normal", 1, "B"}, + {0, "B/B", "normal", 1, "B/B"}, + {2, "B/B", "base-deleted", NO_COPY_FROM}, + + {1, "cB", "normal", 1, "B",}, + {1, "cB/B", "normal", 1, "B/B"}, + {2, "cB/B", "base-deleted", NO_COPY_FROM}, + + {1, "ccB", "normal", 1, "B"}, + {1, "ccB/B", "normal", 1, "B/B"}, + {2, "ccB/B", "base-deleted", NO_COPY_FROM}, + + /* Copy of a to r0 updated node */ + {0, "C", "normal", 1, "C"}, + {0, "C/B", "not-present", 0, "C/B"}, + + {1, "cC", "normal", 1, "C"}, + {1, "cC/B", "not-present", 0, "C/B"}, + + {1, "ccC", "normal", 1, "C"}, + {1, "ccC/B", "not-present", 0, "C/B"}, + + /* Copy of an excluded node */ + {0, "D", "normal", 1, "D"}, + {0, "D/B", "excluded", 1, "D/B"}, + + {1, "cD", "normal", 1, "D"}, + {1, "cD/B", "excluded", 1, "D/B"}, + + {1, "ccD", "normal", 1, "D"}, + {1, "ccD/B", "excluded", 1, "D/B"}, + + {0} + }; + SVN_ERR(check_db_rows(&b, "", nodes)); + } + + SVN_ERR(sbox_wc_revert(&b, "", svn_depth_infinity)); + SVN_ERR(sbox_wc_delete(&b, "B/B")); + + /* And now do the same thing with moves */ + + SVN_ERR(sbox_wc_move(&b, "A", "mA")); + SVN_ERR(sbox_wc_move(&b, "B", "mB")); + SVN_ERR(sbox_wc_move(&b, "C", "mC")); + SVN_ERR(sbox_wc_move(&b, "D", "mD")); + + SVN_ERR(sbox_wc_move(&b, "mA", "mmA")); + SVN_ERR(sbox_wc_move(&b, "mB", "mmB")); + SVN_ERR(sbox_wc_move(&b, "mC", "mmC")); + SVN_ERR(sbox_wc_move(&b, "mD", "mmD")); + + { + nodes_row_t nodes[] = { + {0, "", "normal", 1, ""}, + + /* Move of a deleted + committed node */ + {0, "A", "normal", 1, "A"}, + {0, "A/B", "not-present", 2, "A/B"}, + {1, "A", "base-deleted", NO_COPY_FROM, "mmA"}, + + {1, "mmA", "normal", 1, "A", MOVED_HERE}, + {1, "mmA/B", "not-present", 2, "A/B", MOVED_HERE}, + + + /* Move of a local deleted node */ + {0, "B", "normal", 1, "B"}, + {0, "B/B", "normal", 1, "B/B"}, + {1, "B", "base-deleted", NO_COPY_FROM, "mmB"}, + {1, "B/B", "base-deleted", NO_COPY_FROM}, + + {1, "mmB", "normal", 1, "B", MOVED_HERE}, + {1, "mmB/B", "normal", 1, "B/B", MOVED_HERE}, + {2, "mmB/B", "base-deleted", NO_COPY_FROM}, + + /* Move of a to r0 updated node */ + {0, "C", "normal", 1, "C"}, + {0, "C/B", "not-present", 0, "C/B"}, + {1, "C", "base-deleted", NO_COPY_FROM, "mmC"}, + + {1, "mmC", "normal", 1, "C", MOVED_HERE}, + {1, "mmC/B", "not-present", 0, "C/B", MOVED_HERE}, + + /* Move of an excluded node */ + {0, "D", "normal", 1, "D",}, + {0, "D/B", "excluded", 1, "D/B", }, + {1, "D", "base-deleted", NO_COPY_FROM, "mmD"}, + + {1, "mmD", "normal", 1, "D", MOVED_HERE}, + {1, "mmD/B", "excluded", 1, "D/B", MOVED_HERE}, + + {0} + }; + SVN_ERR(check_db_rows(&b, "", nodes)); + } + + /* And move everything back */ + SVN_ERR(sbox_wc_move(&b, "mmA", "A")); + SVN_ERR(sbox_wc_move(&b, "mmB", "B")); + SVN_ERR(sbox_wc_move(&b, "mmC", "C")); + SVN_ERR(sbox_wc_move(&b, "mmD", "D")); + + { + nodes_row_t nodes[] = { + {0, "", "normal", 1, ""}, + + /* deleted + committed node */ + {0, "A", "normal", 1, "A"}, + {0, "A/B", "not-present", 2, "A/B"}, + + /* local deleted node */ + {0, "B", "normal", 1, "B"}, + {0, "B/B", "normal", 1, "B/B"}, + {2, "B/B", "base-deleted", NO_COPY_FROM}, + + /* To r0 updated node */ + {0, "C", "normal", 1, "C"}, + {0, "C/B", "not-present", 0, "C/B"}, + + /* Move of an excluded node */ + {0, "D", "normal", 1, "D",}, + {0, "D/B", "excluded", 1, "D/B", }, + + {0} + }; + SVN_ERR(check_db_rows(&b, "", nodes)); + } + + return SVN_NO_ERROR; +} + +static svn_error_t * +update_child_under_add(const svn_test_opts_t *opts, apr_pool_t *pool) +{ + svn_test__sandbox_t b; + svn_error_t *err; + nodes_row_t nodes[] = { + {0, "", "normal", 1, ""}, + {0, "A", "normal", 1, "A"}, + {0, "A/B", "not-present", 0, "A/B"}, + {2, "A/B", "normal", NO_COPY_FROM}, + {3, "A/B/C", "normal", NO_COPY_FROM}, + {4, "A/B/C/D", "normal", NO_COPY_FROM}, + {0} + }; + + SVN_ERR(svn_test__sandbox_create(&b, "update_child_under_add", + opts, pool)); + + SVN_ERR(sbox_wc_mkdir(&b, "A")); + SVN_ERR(sbox_wc_mkdir(&b, "A/B")); + SVN_ERR(sbox_wc_mkdir(&b, "A/B/C")); + SVN_ERR(sbox_wc_mkdir(&b, "A/B/C/D")); + SVN_ERR(sbox_wc_commit(&b, "")); + SVN_ERR(sbox_wc_update(&b, "", 1)); + SVN_ERR(sbox_wc_update(&b, "A/B", 0)); + SVN_ERR(sbox_wc_mkdir(&b, "A/B")); + SVN_ERR(sbox_wc_mkdir(&b, "A/B/C")); + SVN_ERR(sbox_wc_mkdir(&b, "A/B/C/D")); + SVN_ERR(check_db_rows(&b, "", nodes)); + + /* A/B/C/D is skipped as it has no base node parent */ + SVN_ERR(sbox_wc_update(&b, "A/B/C/D", 1)); + SVN_ERR(check_db_rows(&b, "", nodes)); + + /* A/B/C should be skipped as it has a not-present base node parent */ + err = sbox_wc_update(&b, "A/B/C", 1); + svn_error_clear(err); /* Allow any error and always check NODES. */ + SVN_ERR(check_db_rows(&b, "", nodes)); + + return SVN_NO_ERROR; +} + +static svn_error_t * +delete_over_moved_away(const svn_test_opts_t *opts, apr_pool_t *pool) +{ + svn_test__sandbox_t b; + + SVN_ERR(svn_test__sandbox_create(&b, "delete_over_moved_away", + opts, pool)); + + SVN_ERR(sbox_wc_mkdir(&b, "A")); + SVN_ERR(sbox_wc_mkdir(&b, "A/B")); + SVN_ERR(sbox_wc_mkdir(&b, "A/B/C")); + + SVN_ERR(sbox_wc_commit(&b, "")); + SVN_ERR(sbox_wc_update(&b, "", 1)); + + SVN_ERR(sbox_wc_move(&b, "A/B", "B")); + SVN_ERR(sbox_wc_delete(&b, "A")); + + { + nodes_row_t nodes[] = { + {0, "", "normal", 1, ""}, + + {0, "A", "normal", 1, "A"}, + {1, "A", "base-deleted", NO_COPY_FROM}, + {0, "A/B", "normal", 1, "A/B"}, + {1, "A/B", "base-deleted", NO_COPY_FROM, "B"}, + {0, "A/B/C", "normal", 1, "A/B/C"}, + {1, "A/B/C", "base-deleted", NO_COPY_FROM}, + + {1, "B", "normal", 1, "A/B", MOVED_HERE}, + {1, "B/C", "normal", 1, "A/B/C", MOVED_HERE}, + {0} + }; + SVN_ERR(check_db_rows(&b, "", nodes)); + } + + /* Now replace A with a similar tree */ + SVN_ERR(sbox_wc_mkdir(&b, "A")); + SVN_ERR(sbox_wc_mkdir(&b, "A/B")); + SVN_ERR(sbox_wc_mkdir(&b, "A/B/C")); + + { + nodes_row_t nodes[] = { + {0, "", "normal", 1, ""}, + + {0, "A", "normal", 1, "A"}, + {1, "A", "normal", NO_COPY_FROM}, + {0, "A/B", "normal", 1, "A/B"}, + {1, "A/B", "base-deleted", NO_COPY_FROM, "B"}, + {2, "A/B", "normal", NO_COPY_FROM}, + {0, "A/B/C", "normal", 1, "A/B/C"}, + {1, "A/B/C", "base-deleted", NO_COPY_FROM}, + {3, "A/B/C", "normal", NO_COPY_FROM}, + + {1, "B", "normal", 1, "A/B", MOVED_HERE}, + {1, "B/C", "normal", 1, "A/B/C", MOVED_HERE}, + {0} + }; + SVN_ERR(check_db_rows(&b, "", nodes)); + } + + /* And delete the new A */ + SVN_ERR(sbox_wc_delete(&b, "A")); + + { + nodes_row_t nodes[] = { + {0, "", "normal", 1, ""}, + + {0, "A", "normal", 1, "A"}, + {1, "A", "base-deleted", NO_COPY_FROM}, + {0, "A/B", "normal", 1, "A/B"}, + /* And here the moved-to information is lost */ + {1, "A/B", "base-deleted", NO_COPY_FROM, "B"}, + {0, "A/B/C", "normal", 1, "A/B/C"}, + {1, "A/B/C", "base-deleted", NO_COPY_FROM}, + + /* But the moved-here is still there */ + {1, "B", "normal", 1, "A/B", MOVED_HERE}, + {1, "B/C", "normal", 1, "A/B/C", MOVED_HERE}, + {0} + }; + SVN_ERR(check_db_rows(&b, "", nodes)); + } + return SVN_NO_ERROR; } @@ -5838,13 +7162,14 @@ struct svn_test_descriptor_t test_funcs[ "scan_delete"), SVN_TEST_OPTS_PASS(test_follow_moved_to, "follow_moved_to"), - SVN_TEST_OPTS_PASS(mixed_rev_move, - "mixed_rev_move"), + SVN_TEST_OPTS_WIMP(mixed_rev_move, + "mixed_rev_move", + "needs different libsvn_wc entry point"), SVN_TEST_OPTS_PASS(update_prop_mod_into_moved, "update_prop_mod_into_moved"), SVN_TEST_OPTS_PASS(nested_move_update, "nested_move_update"), - SVN_TEST_OPTS_XFAIL(nested_move_commit, + SVN_TEST_OPTS_PASS(nested_move_commit, "nested_move_commit"), SVN_TEST_OPTS_PASS(nested_move_update2, "nested_move_update2"), @@ -5854,5 +7179,29 @@ struct svn_test_descriptor_t test_funcs[ "move_update_delete_mods"), SVN_TEST_OPTS_PASS(nested_moves2, "nested_moves2"), + SVN_TEST_OPTS_PASS(move_in_delete, + "move_in_delete (issue 4303)"), + SVN_TEST_OPTS_PASS(switch_move, + "switch_move"), + SVN_TEST_OPTS_PASS(move_replace, + "move_replace"), + SVN_TEST_OPTS_PASS(layered_moved_to, + "layered_moved_to"), + SVN_TEST_OPTS_PASS(update_within_move, + "update_within_move"), + SVN_TEST_OPTS_XFAIL(commit_moved_descendant, + "commit_moved_descendant"), + SVN_TEST_OPTS_XFAIL(commit_moved_away_descendant, + "commit_moved_away_descendant"), + SVN_TEST_OPTS_PASS(finite_move_update_bump, + "finite_move_update_bump"), + SVN_TEST_OPTS_PASS(move_away_delete_update, + "move_away_delete_update"), + SVN_TEST_OPTS_PASS(move_not_present_variants, + "move_not_present_variants"), + SVN_TEST_OPTS_PASS(update_child_under_add, + "update_child_under_add (issue 4111)"), + SVN_TEST_OPTS_PASS(delete_over_moved_away, + "delete_over_moved_away"), SVN_TEST_NULL }; Modified: subversion/branches/ev2-export/subversion/tests/libsvn_wc/pristine-store-test.c URL: http://svn.apache.org/viewvc/subversion/branches/ev2-export/subversion/tests/libsvn_wc/pristine-store-test.c?rev=1449262&r1=1449261&r2=1449262&view=diff ============================================================================== --- subversion/branches/ev2-export/subversion/tests/libsvn_wc/pristine-store-test.c (original) +++ subversion/branches/ev2-export/subversion/tests/libsvn_wc/pristine-store-test.c Sat Feb 23 01:25:38 2013 @@ -187,8 +187,7 @@ pristine_write_read(const svn_test_opts_ SVN_ERR(svn_wc__db_pristine_remove(db, wc_abspath, data_sha1, pool)); err = svn_wc__db_pristine_read(&data_read_back, NULL, db, wc_abspath, data_sha1, pool, pool); - SVN_TEST_ASSERT(err != NULL); - svn_error_clear(err); + SVN_TEST_ASSERT_ERROR(err, SVN_ERR_WC_PATH_NOT_FOUND); } /* Ensure it's no longer found in the store. */ @@ -308,9 +307,7 @@ reject_mismatching_text(const svn_test_o SVN_ERR(write_and_checksum_temp_file(&path, NULL, NULL, data2, pristine_tmp_dir, pool)); err = svn_wc__db_pristine_install(db, path, data_sha1, data_md5, pool); - SVN_TEST_ASSERT(err != NULL); - SVN_TEST_ASSERT(err->apr_err == SVN_ERR_WC_CORRUPT_TEXT_BASE); - svn_error_clear(err); + SVN_TEST_ASSERT_ERROR(err, SVN_ERR_WC_CORRUPT_TEXT_BASE); } return SVN_NO_ERROR; Modified: subversion/branches/ev2-export/subversion/tests/libsvn_wc/utils.c URL: http://svn.apache.org/viewvc/subversion/branches/ev2-export/subversion/tests/libsvn_wc/utils.c?rev=1449262&r1=1449261&r2=1449262&view=diff ============================================================================== --- subversion/branches/ev2-export/subversion/tests/libsvn_wc/utils.c (original) +++ subversion/branches/ev2-export/subversion/tests/libsvn_wc/utils.c Sat Feb 23 01:25:38 2013 @@ -314,7 +314,10 @@ sbox_wc_commit(svn_test__sandbox_t *b, c } svn_error_t * -sbox_wc_update(svn_test__sandbox_t *b, const char *path, svn_revnum_t revnum) +sbox_wc_update_depth(svn_test__sandbox_t *b, + const char *path, + svn_revnum_t revnum, + svn_depth_t depth) { svn_client_ctx_t *ctx; apr_array_header_t *result_revs; @@ -328,12 +331,19 @@ sbox_wc_update(svn_test__sandbox_t *b, c APR_ARRAY_PUSH(paths, const char *) = sbox_wc_path(b, path); SVN_ERR(svn_client_create_context2(&ctx, NULL, b->pool)); ctx->wc_ctx = b->wc_ctx; - return svn_client_update4(&result_revs, paths, &revision, svn_depth_infinity, - TRUE, FALSE, FALSE, FALSE, FALSE, + return svn_client_update4(&result_revs, paths, &revision, depth, + FALSE, FALSE, FALSE, FALSE, FALSE, ctx, b->pool); } svn_error_t * +sbox_wc_update(svn_test__sandbox_t *b, const char *path, svn_revnum_t revnum) +{ + SVN_ERR(sbox_wc_update_depth(b, path, revnum, svn_depth_infinity)); + return SVN_NO_ERROR; +} + +svn_error_t * sbox_wc_switch(svn_test__sandbox_t *b, const char *url) { svn_client_ctx_t *ctx; @@ -355,15 +365,16 @@ sbox_wc_switch(svn_test__sandbox_t *b, c svn_error_t * sbox_wc_resolved(svn_test__sandbox_t *b, const char *path) { - return sbox_wc_resolve(b, path, svn_wc_conflict_choose_merged); + return sbox_wc_resolve(b, path, svn_depth_infinity, + svn_wc_conflict_choose_merged); } svn_error_t * -sbox_wc_resolve(svn_test__sandbox_t *b, const char *path, +sbox_wc_resolve(svn_test__sandbox_t *b, const char *path, svn_depth_t depth, svn_wc_conflict_choice_t conflict_choice) { SVN_ERR(svn_wc__resolve_conflicts(b->wc_ctx, sbox_wc_path(b, path), - svn_depth_infinity, + depth, TRUE /* resolve_text */, "" /* resolve_prop (ALL props) */, TRUE /* resolve_tree */, Modified: subversion/branches/ev2-export/subversion/tests/libsvn_wc/utils.h URL: http://svn.apache.org/viewvc/subversion/branches/ev2-export/subversion/tests/libsvn_wc/utils.h?rev=1449262&r1=1449261&r2=1449262&view=diff ============================================================================== --- subversion/branches/ev2-export/subversion/tests/libsvn_wc/utils.h (original) +++ subversion/branches/ev2-export/subversion/tests/libsvn_wc/utils.h Sat Feb 23 01:25:38 2013 @@ -131,6 +131,12 @@ svn_error_t * sbox_wc_update(svn_test__sandbox_t *b, const char *path, svn_revnum_t revnum); svn_error_t * +sbox_wc_update_depth(svn_test__sandbox_t *b, + const char *path, + svn_revnum_t revnum, + svn_depth_t depth); + +svn_error_t * sbox_wc_switch(svn_test__sandbox_t *b, const char *url); /* */ @@ -139,7 +145,7 @@ sbox_wc_resolved(svn_test__sandbox_t *b, /* */ svn_error_t * -sbox_wc_resolve(svn_test__sandbox_t *b, const char *path, +sbox_wc_resolve(svn_test__sandbox_t *b, const char *path, svn_depth_t depth, svn_wc_conflict_choice_t conflict_choice); /* */ Modified: subversion/branches/ev2-export/subversion/tests/libsvn_wc/wc-queries-test.c URL: http://svn.apache.org/viewvc/subversion/branches/ev2-export/subversion/tests/libsvn_wc/wc-queries-test.c?rev=1449262&r1=1449261&r2=1449262&view=diff ============================================================================== --- subversion/branches/ev2-export/subversion/tests/libsvn_wc/wc-queries-test.c (original) +++ subversion/branches/ev2-export/subversion/tests/libsvn_wc/wc-queries-test.c Sat Feb 23 01:25:38 2013 @@ -73,6 +73,7 @@ static const int schema_statements[] = STMT_CREATE_TARGET_PROP_CACHE, STMT_CREATE_REVERT_LIST, STMT_CREATE_DELETE_LIST, + STMT_CREATE_UPDATE_MOVE_LIST, -1 /* final marker */ }; @@ -81,8 +82,6 @@ static const int schema_statements[] = static const int slow_statements[] = { /* Operate on the entire WC */ - STMT_HAS_SWITCHED_WCROOT, /* wc scan op_depth 0 */ - STMT_HAS_SWITCHED_WCROOT_REPOS_ROOT, /* wc scan op_depth 0 */ STMT_SELECT_ALL_NODES, /* schema validation code */ /* Is there a record? ### Can we somehow check for LIMIT 1? */ @@ -92,6 +91,7 @@ static const int slow_statements[] = STMT_INSERT_ACTUAL_EMPTIES, STMT_SELECT_REVERT_LIST_RECURSIVE, STMT_SELECT_DELETE_LIST, + STMT_SELECT_UPDATE_MOVE_LIST, /* Designed as slow to avoid penalty on other queries */ STMT_SELECT_UNREFERENCED_PRISTINES, Modified: subversion/branches/ev2-export/subversion/tests/libsvn_wc/wc-test.c URL: http://svn.apache.org/viewvc/subversion/branches/ev2-export/subversion/tests/libsvn_wc/wc-test.c?rev=1449262&r1=1449261&r2=1449262&view=diff ============================================================================== --- subversion/branches/ev2-export/subversion/tests/libsvn_wc/wc-test.c (original) +++ subversion/branches/ev2-export/subversion/tests/libsvn_wc/wc-test.c Sat Feb 23 01:25:38 2013 @@ -135,6 +135,7 @@ test_node_get_base(const svn_test_opts_t SVN_ERR(svn_wc__node_get_base(&revision, &repos_relpath, &repos_root_url, &repos_uuid, + NULL, b->wc_ctx, local_abspath, b->pool, b->pool)); SVN_TEST_ASSERT(revision == subtest->base_rev); Modified: subversion/branches/ev2-export/subversion/tests/svn_test_fs.c URL: http://svn.apache.org/viewvc/subversion/branches/ev2-export/subversion/tests/svn_test_fs.c?rev=1449262&r1=1449261&r2=1449262&view=diff ============================================================================== --- subversion/branches/ev2-export/subversion/tests/svn_test_fs.c (original) +++ subversion/branches/ev2-export/subversion/tests/svn_test_fs.c Sat Feb 23 01:25:38 2013 @@ -213,7 +213,10 @@ svn_test__create_repos(svn_repos_t **rep if (apr_stat(&finfo, name, APR_FINFO_TYPE, pool) == APR_SUCCESS) { if (finfo.filetype == APR_DIR) - SVN_ERR(svn_repos_delete(name, pool)); + SVN_ERR_W(svn_io_remove_dir2(name, TRUE, NULL, NULL, pool), + apr_psprintf(pool, + "cannot create repos '%s' there is already " + "a directory of that name", name)); else return svn_error_createf(SVN_ERR_TEST_FAILED, NULL, "there is already a file named '%s'", name); Modified: subversion/branches/ev2-export/tools/client-side/bash_completion URL: http://svn.apache.org/viewvc/subversion/branches/ev2-export/tools/client-side/bash_completion?rev=1449262&r1=1449261&r2=1449262&view=diff ============================================================================== --- subversion/branches/ev2-export/tools/client-side/bash_completion (original) +++ subversion/branches/ev2-export/tools/client-side/bash_completion Sat Feb 23 01:25:38 2013 @@ -647,14 +647,6 @@ _svn() [[ ${COMPREPLY} ]] && return 0 fi - # force mandatory --accept option for 'resolve' command - if [[ $cmd = 'resolve' && ! $acceptOpt ]] - then - COMPREPLY=( $( compgen -W '--accept' -- $cur ) ) - # force option now! others will be available on later completions - return 0 - fi - # maximum number of additional arguments expected in various forms case $cmd in merge) @@ -789,7 +781,7 @@ _svn() # otherwise build possible options for the command pOpts="--username --password --no-auth-cache --non-interactive \ - --trust-server-cert" + --trust-server-cert --force-interactive" mOpts="-m --message -F --file --encoding --force-log --with-revprop" rOpts="-r --revision" qOpts="-q --quiet" @@ -826,7 +818,8 @@ _svn() ;; commit|ci) cmdOpts="$mOpts $qOpts $nOpts --targets --editor-cmd $pOpts \ - --no-unlock $cOpts --keep-changelists" + --no-unlock $cOpts --keep-changelists \ + --include-externals" ;; copy|cp) cmdOpts="$mOpts $rOpts $qOpts --editor-cmd $pOpts --parents \ @@ -840,7 +833,9 @@ _svn() cmdOpts="$rOpts -x --extensions --diff-cmd --no-diff-deleted \ $nOpts $pOpts --force --old --new --notice-ancestry \ -c --change --summarize $cOpts --xml --git \ - --internal-diff --show-copies-as-adds" + --internal-diff --show-copies-as-adds \ + --ignore-properties --properties-only --no-diff-added \ + --patch-compatible" ;; export) cmdOpts="$rOpts $qOpts $pOpts $nOpts --force --native-eol \ @@ -859,7 +854,7 @@ _svn() ;; list|ls) cmdOpts="$rOpts -v --verbose -R --recursive $pOpts \ - --incremental --xml --depth" + --incremental --xml --depth --include-externals" ;; lock) cmdOpts="-m --message -F --file --encoding --force-log \ @@ -870,13 +865,13 @@ _svn() --incremental --xml $qOpts -l --limit -c --change \ $gOpts --with-all-revprops --with-revprop --depth \ --diff --diff-cmd -x --extensions --internal-diff \ - --with-no-revprops" + --with-no-revprops --search --search-and" ;; merge) cmdOpts="$rOpts $nOpts $qOpts --force --dry-run --diff3-cmd \ $pOpts --ignore-ancestry -c --change -x --extensions \ --record-only --accept --reintegrate \ - --allow-mixed-revisions" + --allow-mixed-revisions -v --verbose" ;; mergeinfo) cmdOpts="$rOpts $pOpts --depth --show-revs -R --recursive" @@ -886,7 +881,7 @@ _svn() ;; move|mv|rename|ren) cmdOpts="$mOpts $rOpts $qOpts --force --editor-cmd $pOpts \ - --parents" + --parents --allow-mixed-revisions" ;; patch) cmdOpts="$qOpts $pOpts --dry-run --ignore-whitespace \ @@ -903,13 +898,13 @@ _svn() cmdOpts="$cmdOpts --revprop $rOpts" ;; propget|pget|pg) - cmdOpts="-v --verbose -R --recursive $rOpts --strict $pOpts $cOpts \ - --depth --xml" + cmdOpts="-v --verbose -R --recursive $rOpts --strict \ + $pOpts $cOpts --depth --xml --show-inherited-props" [[ $isRevProp || ! $prop ]] && cmdOpts="$cmdOpts --revprop" ;; proplist|plist|pl) cmdOpts="-v --verbose -R --recursive $rOpts --revprop $qOpts \ - $pOpts $cOpts --depth --xml" + $pOpts $cOpts --depth --xml --show-inherited-props" ;; propset|pset|ps) cmdOpts="$qOpts --targets -R --recursive \ @@ -1035,9 +1030,9 @@ _svnadmin () cur=${COMP_WORDS[COMP_CWORD]} # Possible expansions, without pure-prefix abbreviations such as "h". - cmds='crashtest create deltify dump help hotcopy list-dblogs \ - list-unused-dblogs load lslocks lstxns pack recover rmlocks \ - rmtxns setlog setrevprop setuuid upgrade verify --version' + cmds='crashtest create deltify dump freeze help hotcopy list-dblogs \ + list-unused-dblogs load lock lslocks lstxns pack recover rmlocks \ + rmtxns setlog setrevprop setuuid unlock upgrade verify --version' if [[ $COMP_CWORD -eq 1 ]] ; then COMPREPLY=( $( compgen -W "$cmds" -- $cur ) ) @@ -1046,7 +1041,8 @@ _svnadmin () # options that require a parameter # note: continued lines must end '|' continuing lines must start '|' - optsParam="-r|--revision|--parent-dir|--fs-type" + optsParam="-r|--revision|--parent-dir|--fs-type|-M|--memory-cache-size" + optsParam="$optsParam|-F|--file" # if not typing an option, or if the previous option required a # parameter, then fallback on ordinary filename expansion @@ -1061,13 +1057,18 @@ _svnadmin () case ${COMP_WORDS[1]} in create) cmdOpts="--bdb-txn-nosync --bdb-log-keep --config-dir \ - --fs-type --pre-1.4-compatible --pre-1.5-compatible" + --fs-type --pre-1.4-compatible --pre-1.5-compatible \ + --pre-1.6-compatible --compatible-version" ;; deltify) cmdOpts="-r --revision -q --quiet" ;; dump) - cmdOpts="-r --revision --incremental -q --quiet --deltas" + cmdOpts="-r --revision --incremental -q --quiet --deltas \ + -M --memory-cache-size" + ;; + freeze) + cmdOpts="-F --file" ;; help|h|\?) cmdOpts="$cmds" @@ -1077,7 +1078,11 @@ _svnadmin () ;; load) cmdOpts="--ignore-uuid --force-uuid --parent-dir -q --quiet \ - --use-pre-commit-hook --use-post-commit-hook" + --use-pre-commit-hook --use-post-commit-hook \ + --bypass-prop-validation -M --memory-cache-size" + ;; + lock|unlock) + cmdOpts="--bypass-hooks" ;; recover) cmdOpts="--wait" @@ -1121,6 +1126,10 @@ _svnadmin () --help) cmdOpts=${cmdOpts/ -h / } ;; -r) cmdOpts=${cmdOpts/ --revision / } ;; --revision) cmdOpts=${cmdOpts/ -r / } ;; + -F) cmdOpts=${cmdOpts/ --file / } ;; + --file) cmdOpts=${cmdOpts/ -F / } ;; + -M) cmdOpts=${cmdOpts/ --memory-cache-size / } ;; + --memory-cache-size) cmdOpts=${cmdOpts/ --M / } ;; esac # skip next option if this one requires a parameter Modified: subversion/branches/ev2-export/tools/dev/gen-py-errors.py URL: http://svn.apache.org/viewvc/subversion/branches/ev2-export/tools/dev/gen-py-errors.py?rev=1449262&r1=1449261&r2=1449262&view=diff ============================================================================== --- subversion/branches/ev2-export/tools/dev/gen-py-errors.py (original) +++ subversion/branches/ev2-export/tools/dev/gen-py-errors.py Sat Feb 23 01:25:38 2013 @@ -33,7 +33,7 @@ import os import re HEADER = '''#!/usr/bin/env python -### This file automatically generated by tools/dev/gen-py-error.py, +### This file automatically generated by tools/dev/gen-py-errors.py, ### which see for more information ### ### It is versioned for convenience. Modified: subversion/branches/ev2-export/tools/dev/unix-build/Makefile.svn URL: http://svn.apache.org/viewvc/subversion/branches/ev2-export/tools/dev/unix-build/Makefile.svn?rev=1449262&r1=1449261&r2=1449262&view=diff ============================================================================== --- subversion/branches/ev2-export/tools/dev/unix-build/Makefile.svn (original) +++ subversion/branches/ev2-export/tools/dev/unix-build/Makefile.svn Sat Feb 23 01:25:38 2013 @@ -71,7 +71,7 @@ GNU_ICONV_VER = 1.14 APR_UTIL_VER = 1.4.1 HTTPD_VER = 2.2.22 NEON_VER = 0.29.6 -SERF_VER = 1.1.0 +SERF_VER = 1.2.0 SERF_OLD_VER = 0.3.1 CYRUS_SASL_VER = 2.1.25 SQLITE_VER = 3071201 Modified: subversion/branches/ev2-export/tools/hook-scripts/mailer/mailer.conf.example URL: http://svn.apache.org/viewvc/subversion/branches/ev2-export/tools/hook-scripts/mailer/mailer.conf.example?rev=1449262&r1=1449261&r2=1449262&view=diff ============================================================================== --- subversion/branches/ev2-export/tools/hook-scripts/mailer/mailer.conf.example (original) +++ subversion/branches/ev2-export/tools/hook-scripts/mailer/mailer.conf.example Sat Feb 23 01:25:38 2013 @@ -146,6 +146,15 @@ # # from_addr = %(author)s@example.com # +# The substitution variable "repos_basename" is provided, and is set to +# the directory name of the repository. This can be useful to set +# a custom subject that can be re-used in multiple repositories: +# +# commit_subject_prefix = [svn-%(repos_basename)s] +# +# For example if the repository is at /path/to/repo/project-x then +# the subject of commit emails will be prefixed with [svn-project-x] +# # # SUMMARY # Modified: subversion/branches/ev2-export/tools/hook-scripts/mailer/mailer.py URL: http://svn.apache.org/viewvc/subversion/branches/ev2-export/tools/hook-scripts/mailer/mailer.py?rev=1449262&r1=1449261&r2=1449262&view=diff ============================================================================== --- subversion/branches/ev2-export/tools/hook-scripts/mailer/mailer.py (original) +++ subversion/branches/ev2-export/tools/hook-scripts/mailer/mailer.py Sat Feb 23 01:25:38 2013 @@ -98,7 +98,10 @@ def main(pool, cmd, config_fname, repos_ if cmd == 'commit': revision = int(cmd_args[0]) repos = Repository(repos_dir, revision, pool) - cfg = Config(config_fname, repos, { 'author' : repos.author }) + cfg = Config(config_fname, repos, + {'author': repos.author, + 'repos_basename': os.path.basename(repos.repos_dir) + }) messenger = Commit(pool, cfg, repos) elif cmd == 'propchange' or cmd == 'propchange2': revision = int(cmd_args[0]) @@ -108,14 +111,20 @@ def main(pool, cmd, config_fname, repos_ repos = Repository(repos_dir, revision, pool) # Override the repos revision author with the author of the propchange repos.author = author - cfg = Config(config_fname, repos, { 'author' : author }) + cfg = Config(config_fname, repos, + {'author': author, + 'repos_basename': os.path.basename(repos.repos_dir) + }) messenger = PropChange(pool, cfg, repos, author, propname, action) elif cmd == 'lock' or cmd == 'unlock': author = cmd_args[0] repos = Repository(repos_dir, 0, pool) ### any old revision will do # Override the repos revision author with the author of the lock/unlock repos.author = author - cfg = Config(config_fname, repos, { 'author' : author }) + cfg = Config(config_fname, repos, + {'author': author, + 'repos_basename': os.path.basename(repos.repos_dir) + }) messenger = Lock(pool, cfg, repos, author, cmd == 'lock') else: raise UnknownSubcommand(cmd) Propchange: subversion/branches/ev2-export/tools/server-side/ ------------------------------------------------------------------------------ --- svn:ignore (original) +++ svn:ignore Sat Feb 23 01:25:38 2013 @@ -1,6 +1,7 @@ .libs svn-populate-node-origins-index svnauthz +svnauthz-validate svn-rep-sharing-stats fsfs-reorg fsfs-stats