subversion-1.9.7HEADsubversion-1.9.7master

1 files changed, 653 insertions, 200 deletions

diff --git a/subversion/tests/cmdline/lock_tests.py b/subversion/tests/cmdline/lock_tests.py
index aaca991..c27a4f4 100755
--- a/subversion/tests/cmdline/lock_tests.py
+++ b/subversion/tests/cmdline/lock_tests.py
@@ -87,7 +87,7 @@ def lock_file(sbox):
   svntest.main.file_append(file_path, "This represents a binary file\n")
   svntest.main.run_svn(None, 'commit',
                        '-m', '', file_path)
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
+  svntest.actions.run_and_verify_svn(".*locked by user", [], 'lock',
                                      '-m', '', file_path)
 
   # --- Meanwhile, in our other working copy... ---
@@ -135,7 +135,7 @@ def commit_file_keep_lock(sbox):
   wc_dir = sbox.wc_dir
 
   # lock 'A/mu' as wc_author
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
+  svntest.actions.run_and_verify_svn(".*locked by user", [], 'lock',
                                      '-m', 'some lock comment',
                                      sbox.ospath('A/mu'))
 
@@ -158,21 +158,25 @@ def commit_file_unlock(sbox):
   wc_dir = sbox.wc_dir
 
   # lock A/mu and iota as wc_author
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
+  svntest.actions.run_and_verify_svn(".*locked by user", [], 'lock',
                                      '-m', 'some lock comment',
                                      sbox.ospath('A/mu'),
                                      sbox.ospath('iota'))
 
   # make a change and commit it, allowing lock to be released
   sbox.simple_append('A/mu', 'Tweak!\n')
-  sbox.simple_commit()
+
+  expected_output = svntest.wc.State(wc_dir, {
+    'A/mu'              : Item(verb='Sending'),
+  })
 
   expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
   expected_status.tweak('A/mu', wc_rev=2)
-  expected_status.tweak('iota', wc_rev=2)
 
-  # Make sure the file is unlocked
-  svntest.actions.run_and_verify_status(wc_dir, expected_status)
+  # Make sure both iota an mu are unlocked, but only mu is bumped
+  svntest.actions.run_and_verify_commit(wc_dir,
+                                        expected_output,
+                                        expected_status)
 
 #----------------------------------------------------------------------
 def commit_propchange(sbox):
@@ -182,7 +186,7 @@ def commit_propchange(sbox):
   wc_dir = sbox.wc_dir
 
   # lock A/mu as wc_author
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
+  svntest.actions.run_and_verify_svn(".*locked by user", [], 'lock',
                                      '-m', 'some lock comment',
                                      sbox.ospath('A/mu'))
 
@@ -220,7 +224,7 @@ def break_lock(sbox):
   file_path = sbox.ospath('iota')
   file_path_b = sbox.ospath('iota', wc_dir=wc_b)
 
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
+  svntest.actions.run_and_verify_svn(".*locked by user", [], 'lock',
                                      '-m', '', file_path)
 
   # --- Meanwhile, in our other working copy... ---
@@ -230,11 +234,11 @@ def break_lock(sbox):
   # attempt (and fail) to unlock file
 
   # This should give a "iota' is not locked in this working copy" error
-  svntest.actions.run_and_verify_svn(None, None, ".*not locked",
+  svntest.actions.run_and_verify_svn(None, ".*not locked",
                                      'unlock',
                                      file_path_b)
 
-  svntest.actions.run_and_verify_svn(None, ".*unlocked", [],
+  svntest.actions.run_and_verify_svn(".*unlocked", [],
                                      'unlock', '--force',
                                      file_path_b)
 
@@ -262,7 +266,7 @@ def steal_lock(sbox):
   file_path = sbox.ospath('iota')
   file_path_b = sbox.ospath('iota', wc_dir=wc_b)
 
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
+  svntest.actions.run_and_verify_svn(".*locked by user", [], 'lock',
                                      '-m', '', file_path)
 
   # --- Meanwhile, in our other working copy... ---
@@ -271,13 +275,13 @@ def steal_lock(sbox):
 
   # attempt (and fail) to lock file
 
-  # This should give a "iota' is already locked... error, but exits 0.
-  svntest.actions.run_and_verify_svn2(None, None,
-                                      ".*already locked", 0,
-                                      'lock',
-                                      '-m', 'trying to break', file_path_b)
+  # This should give a "iota' is already locked error
+  svntest.actions.run_and_verify_svn(None,
+                                     ".*already locked",
+                                     'lock',
+                                     '-m', 'trying to break', file_path_b)
 
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [],
+  svntest.actions.run_and_verify_svn(".*locked by user", [],
                                      'lock', '--force',
                                      '-m', 'trying to break', file_path_b)
 
@@ -307,7 +311,7 @@ def handle_defunct_lock(sbox):
   expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
 
   # lock the file
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
+  svntest.actions.run_and_verify_svn(".*locked by user", [], 'lock',
                                      '-m', '', sbox.ospath('iota'))
 
   # Make a second copy of the working copy
@@ -318,7 +322,7 @@ def handle_defunct_lock(sbox):
   # --- Meanwhile, in our other working copy... ---
 
   # Try unlocking the file in the second wc.
-  svntest.actions.run_and_verify_svn(None, ".*unlocked", [], 'unlock',
+  svntest.actions.run_and_verify_svn(".*unlocked", [], 'unlock',
                                      file_path_b)
 
 
@@ -370,7 +374,7 @@ def enforce_lock(sbox):
       raise svntest.Failure
 
     # obtain a lock on one of these files...
-    svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
+    svntest.actions.run_and_verify_svn(".*locked by user", [], 'lock',
                                        '-m', '', iota_path)
 
     # ...and verify that the write bit gets set...
@@ -379,7 +383,7 @@ def enforce_lock(sbox):
       raise svntest.Failure
 
     # ...and unlock it...
-    svntest.actions.run_and_verify_svn(None, ".*unlocked", [], 'unlock',
+    svntest.actions.run_and_verify_svn(".*unlocked", [], 'unlock',
                                        iota_path)
 
     # ...and verify that the write bit gets unset
@@ -408,7 +412,7 @@ def update_while_needing_lock(sbox):
   sbox.simple_update()
 
   # Lock, modify, commit, unlock, to create r3.
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
+  svntest.actions.run_and_verify_svn(".*locked by user", [], 'lock',
                                      '-m', '', sbox.ospath('iota'))
   sbox.simple_append('iota', 'This line added in r2.\n')
   sbox.simple_commit('iota') # auto-unlocks
@@ -447,12 +451,12 @@ def defunct_lock(sbox):
   svntest.main.run_svn(None, 'update', wc_b)
 
   # lock iota in wc_b
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
+  svntest.actions.run_and_verify_svn(".*locked by user", [], 'lock',
                                      '-m', '', iota_path_b)
 
 
   # break the lock iota in wc a
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock', '--force',
+  svntest.actions.run_and_verify_svn(".*locked by user", [], 'lock', '--force',
                                      '-m', '', iota_path)
   # update wc_b
   svntest.main.run_svn(None, 'update', wc_b)
@@ -476,16 +480,16 @@ def deleted_path_lock(sbox):
   iota_path = sbox.ospath('iota')
   iota_url = sbox.repo_url + '/iota'
 
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
+  svntest.actions.run_and_verify_svn(".*locked by user", [], 'lock',
                                      '-m', '', iota_path)
 
   sbox.simple_rm('iota')
-  svntest.actions.run_and_verify_svn(None, None, [], 'commit',
+  svntest.actions.run_and_verify_svn(None, [], 'commit',
                                      '--no-unlock',
                                      '-m', '', iota_path)
 
   # Now make sure that we can delete the lock from iota via a URL
-  svntest.actions.run_and_verify_svn(None, ".*unlocked", [], 'unlock',
+  svntest.actions.run_and_verify_svn(".*unlocked", [], 'unlock',
                                      iota_url)
 
 
@@ -505,14 +509,14 @@ def lock_unlock(sbox):
   expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
   expected_status.tweak('A/D/G/pi', 'A/D/G/rho', 'A/D/G/tau', writelocked='K')
 
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
+  svntest.actions.run_and_verify_svn(".*locked by user", [], 'lock',
                                      '-m', '', pi_path, rho_path, tau_path)
 
   svntest.actions.run_and_verify_status(wc_dir, expected_status)
 
   expected_status.tweak('A/D/G/pi', 'A/D/G/rho', 'A/D/G/tau', writelocked=None)
 
-  svntest.actions.run_and_verify_svn(None, ".*unlocked", [], 'unlock',
+  svntest.actions.run_and_verify_svn(".*unlocked", [], 'unlock',
                                      pi_path, rho_path, tau_path)
 
   svntest.actions.run_and_verify_status(wc_dir, expected_status)
@@ -529,11 +533,11 @@ def deleted_dir_lock(sbox):
   rho_path = sbox.ospath('A/D/G/rho')
   tau_path = sbox.ospath('A/D/G/tau')
 
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
+  svntest.actions.run_and_verify_svn(".*locked by user", [], 'lock',
                                      '-m', '', pi_path, rho_path, tau_path)
 
   sbox.simple_rm('A/D/G')  # the parent directory
-  svntest.actions.run_and_verify_svn(None, None, [], 'commit',
+  svntest.actions.run_and_verify_svn(None, [], 'commit',
                                      '--no-unlock',
                                      '-m', '', sbox.ospath('A/D/G'))
 
@@ -699,11 +703,11 @@ def out_of_date(sbox):
                        '-m', '', file_path)
 
   # --- Meanwhile, in our other working copy... ---
-  svntest.actions.run_and_verify_svn2(None, None,
-                                      ".*newer version of '/iota' exists", 0,
-                                      'lock',
-                                      '--username', svntest.main.wc_author2,
-                                      '-m', '', file_path_b)
+  svntest.actions.run_and_verify_svn(None,
+                                     ".*newer version of '/iota' exists",
+                                     'lock',
+                                     '--username', svntest.main.wc_author2,
+                                     '-m', '', file_path_b)
 
 #----------------------------------------------------------------------
 # Tests reverting a svn:needs-lock file
@@ -718,11 +722,11 @@ def revert_lock(sbox):
   mode = stat.S_IWGRP | stat.S_IWOTH | stat.S_IWRITE
 
   # set the prop in wc
-  svntest.actions.run_and_verify_svn(None, None, [], 'propset',
+  svntest.actions.run_and_verify_svn(None, [], 'propset',
                                   'svn:needs-lock', 'foo', iota_path)
 
   # commit r2
-  svntest.actions.run_and_verify_svn(None, None, [], 'commit',
+  svntest.actions.run_and_verify_svn(None, [], 'commit',
                        '-m', '', iota_path)
 
   # make sure that iota got set to read-only
@@ -737,7 +741,7 @@ def revert_lock(sbox):
   svntest.actions.run_and_verify_status(wc_dir, expected_status)
 
   # remove read-only-ness
-  svntest.actions.run_and_verify_svn(None, None, [], 'propdel',
+  svntest.actions.run_and_verify_svn(None, [], 'propdel',
                                   'svn:needs-lock', iota_path)
 
   # make sure that iota got read-only-ness removed
@@ -747,7 +751,7 @@ def revert_lock(sbox):
     raise svntest.Failure
 
   # revert the change
-  svntest.actions.run_and_verify_svn(None, None, [], 'revert', iota_path)
+  svntest.actions.run_and_verify_svn(None, [], 'revert', iota_path)
 
   # make sure that iota got set back to read-only
   if (os.stat(iota_path)[0] & mode):
@@ -760,7 +764,7 @@ def revert_lock(sbox):
   extra_name = 'xx'
 
   # now lock the file
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
+  svntest.actions.run_and_verify_svn(".*locked by user", [], 'lock',
                        '-m', '', iota_path)
 
   # modify it
@@ -772,7 +776,7 @@ def revert_lock(sbox):
   svntest.actions.run_and_verify_status(wc_dir, expected_status)
 
   # revert it
-  svntest.actions.run_and_verify_svn(None, None, [], 'revert', iota_path)
+  svntest.actions.run_and_verify_svn(None, [], 'revert', iota_path)
 
   # make sure it is still writable since we have the lock
   if (os.stat(iota_path)[0] & mode == 0):
@@ -809,7 +813,7 @@ def lock_several_files(sbox):
   lambda_path = os.path.join(sbox.wc_dir, 'A', 'B', 'lambda')
   alpha_path = os.path.join(sbox.wc_dir, 'A', 'B', 'E', 'alpha')
 
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
+  svntest.actions.run_and_verify_svn(".*locked by user", [], 'lock',
                                      '--username', svntest.main.wc_author2,
                                      '-m', 'lock several',
                                      iota_path, lambda_path, alpha_path)
@@ -818,7 +822,7 @@ def lock_several_files(sbox):
   expected_status.tweak('iota', 'A/B/lambda', 'A/B/E/alpha', writelocked='K')
   svntest.actions.run_and_verify_status(wc_dir, expected_status)
 
-  svntest.actions.run_and_verify_svn(None, ".*unlocked", [], 'unlock',
+  svntest.actions.run_and_verify_svn(".*unlocked", [], 'unlock',
                                      '--username', svntest.main.wc_author2,
                                      iota_path, lambda_path, alpha_path)
 
@@ -837,10 +841,10 @@ def lock_switched_files(sbox):
   iota_URL = sbox.repo_url + '/iota'
   alpha_URL = sbox.repo_url + '/A/B/E/alpha'
 
-  svntest.actions.run_and_verify_svn(None, None, [], 'switch',
+  svntest.actions.run_and_verify_svn(None, [], 'switch',
                                      iota_URL, gamma_path,
                                      '--ignore-ancestry')
-  svntest.actions.run_and_verify_svn(None, None, [], 'switch',
+  svntest.actions.run_and_verify_svn(None, [], 'switch',
                                      alpha_URL, lambda_path,
                                      '--ignore-ancestry')
 
@@ -848,7 +852,7 @@ def lock_switched_files(sbox):
   expected_status.tweak('A/D/gamma', 'A/B/lambda', switched='S')
   svntest.actions.run_and_verify_status(wc_dir, expected_status)
 
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
+  svntest.actions.run_and_verify_svn(".*locked by user", [], 'lock',
                                      '-m', 'lock several',
                                      gamma_path, lambda_path)
 
@@ -859,7 +863,7 @@ def lock_switched_files(sbox):
 
   svntest.actions.run_and_verify_status(wc_dir, expected_status)
 
-  svntest.actions.run_and_verify_svn(None, ".*unlocked", [], 'unlock',
+  svntest.actions.run_and_verify_svn(".*unlocked", [], 'unlock',
                                      gamma_path, lambda_path)
 
   expected_status.tweak('A/D/gamma', 'A/B/lambda', writelocked=None)
@@ -877,7 +881,7 @@ def lock_uri_encoded(sbox):
   file_path = sbox.ospath(fname)
 
   svntest.main.file_append(file_path, "This represents a binary file\n")
-  svntest.actions.run_and_verify_svn(None, None, [], "add", file_path)
+  svntest.actions.run_and_verify_svn(None, [], "add", file_path)
 
   expected_output = svntest.wc.State(wc_dir, {
     fname : Item(verb='Adding'),
@@ -890,17 +894,17 @@ def lock_uri_encoded(sbox):
   svntest.actions.run_and_verify_commit(wc_dir,
                                         expected_output,
                                         expected_status,
-                                        None,
+                                        [],
                                         file_path)
 
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
+  svntest.actions.run_and_verify_svn(".*locked by user", [], 'lock',
                                      '-m', '', file_path)
 
   # Make sure that the file was locked.
   expected_status.tweak(fname, writelocked='K')
   svntest.actions.run_and_verify_status(wc_dir, expected_status)
 
-  svntest.actions.run_and_verify_svn(None, ".*unlocked", [], 'unlock',
+  svntest.actions.run_and_verify_svn(".*unlocked", [], 'unlock',
                                      file_path)
 
   # Make sure it was successfully unlocked again.
@@ -909,14 +913,14 @@ def lock_uri_encoded(sbox):
 
   # And now the URL case.
   file_url = sbox.repo_url + '/' + fname
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
+  svntest.actions.run_and_verify_svn(".*locked by user", [], 'lock',
                                      '-m', '', file_url)
 
   # Make sure that the file was locked.
   expected_status.tweak(fname, writelocked='O')
   svntest.actions.run_and_verify_status(wc_dir, expected_status)
 
-  svntest.actions.run_and_verify_svn(None, ".*unlocked", [], 'unlock',
+  svntest.actions.run_and_verify_svn(".*unlocked", [], 'unlock',
                                      file_url)
 
   # Make sure it was successfully unlocked again.
@@ -941,15 +945,15 @@ def lock_and_exebit1(sbox):
   gamma_path = sbox.ospath('A/D/gamma')
 
   expected_err = ".*svn: warning: W125005: To turn off the svn:needs-lock property,.*"
-  svntest.actions.run_and_verify_svn2(None, None, expected_err, 0,
+  svntest.actions.run_and_verify_svn2(None, expected_err, 0,
                                       'ps', 'svn:needs-lock', ' ', gamma_path)
 
   expected_err = ".*svn: warning: W125005: To turn off the svn:executable property,.*"
-  svntest.actions.run_and_verify_svn2(None, None, expected_err, 0,
+  svntest.actions.run_and_verify_svn2(None, expected_err, 0,
                                       'ps', 'svn:executable', ' ', gamma_path)
 
   # commit
-  svntest.actions.run_and_verify_svn(None, None, [], 'commit',
+  svntest.actions.run_and_verify_svn(None, [], 'commit',
                                      '-m', '', gamma_path)
   # mode should be +r, -w, +x
   gamma_stat = os.stat(gamma_path)[0]
@@ -961,7 +965,7 @@ def lock_and_exebit1(sbox):
     raise svntest.Failure
 
   # lock
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
+  svntest.actions.run_and_verify_svn(".*locked by user", [], 'lock',
                                      '-m', '', gamma_path)
   # mode should be +r, +w, +x
   gamma_stat = os.stat(gamma_path)[0]
@@ -976,7 +980,7 @@ def lock_and_exebit1(sbox):
   svntest.main.file_append(gamma_path, "check stat output after mod & unlock")
 
   # unlock
-  svntest.actions.run_and_verify_svn(None, ".*unlocked", [], 'unlock',
+  svntest.actions.run_and_verify_svn(".*unlocked", [], 'unlock',
                                      gamma_path)
 
   # Mode should be +r, -w, +x
@@ -989,7 +993,7 @@ def lock_and_exebit1(sbox):
     raise svntest.Failure
 
   # ci
-  svntest.actions.run_and_verify_svn(None, None, [], 'commit',
+  svntest.actions.run_and_verify_svn(None, [], 'commit',
                                      '-m', '', gamma_path)
 
   # Mode should be still +r, -w, +x
@@ -1018,15 +1022,15 @@ def lock_and_exebit2(sbox):
   gamma_path = sbox.ospath('A/D/gamma')
 
   expected_err = ".*svn: warning: W125005: To turn off the svn:needs-lock property,.*"
-  svntest.actions.run_and_verify_svn2(None, None, expected_err, 0,
+  svntest.actions.run_and_verify_svn2(None, expected_err, 0,
                                       'ps', 'svn:needs-lock', ' ', gamma_path)
 
   expected_err = ".*svn: warning: W125005: To turn off the svn:executable property,.*"
-  svntest.actions.run_and_verify_svn2(None, None, expected_err, 0,
+  svntest.actions.run_and_verify_svn2(None, expected_err, 0,
                                      'ps', 'svn:executable', ' ', gamma_path)
 
   # commit
-  svntest.actions.run_and_verify_svn(None, None, [], 'commit',
+  svntest.actions.run_and_verify_svn(None, [], 'commit',
                                      '-m', '', gamma_path)
   # mode should be +r, -w, +x
   gamma_stat = os.stat(gamma_path)[0]
@@ -1038,7 +1042,7 @@ def lock_and_exebit2(sbox):
     raise svntest.Failure
 
   # lock
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
+  svntest.actions.run_and_verify_svn(".*locked by user", [], 'lock',
                                      '-m', '', gamma_path)
   # mode should be +r, +w, +x
   gamma_stat = os.stat(gamma_path)[0]
@@ -1053,7 +1057,7 @@ def lock_and_exebit2(sbox):
   svntest.main.file_append(gamma_path, "check stat output after mod & unlock")
 
   # commit
-  svntest.actions.run_and_verify_svn(None, None, [], 'commit',
+  svntest.actions.run_and_verify_svn(None, [], 'commit',
                                      '-m', '', gamma_path)
 
   # Mode should be +r, -w, +x
@@ -1079,7 +1083,7 @@ def commit_xml_unsafe_file_unlock(sbox):
                        'commit', '-m', '', file_path)
 
   # lock fname as wc_author
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
+  svntest.actions.run_and_verify_svn(".*locked by user", [], 'lock',
                                      '-m', 'some lock comment', file_path)
 
   # make a change and commit it, allowing lock to be released
@@ -1106,7 +1110,7 @@ def repos_lock_with_info(sbox):
   file_url = sbox.repo_url + '/' + fname
 
   # lock wc file
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
+  svntest.actions.run_and_verify_svn(".*locked by user", [], 'lock',
                                      '--username', svntest.main.wc_author2,
                                      '-m', comment, file_path)
   expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
@@ -1114,7 +1118,7 @@ def repos_lock_with_info(sbox):
   svntest.actions.run_and_verify_status(wc_dir, expected_status)
 
   # Steal lock on wc file
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
+  svntest.actions.run_and_verify_svn(".*locked by user", [], 'lock',
                                      '--username', svntest.main.wc_author2,
                                      '--force',
                                      '-m', comment, file_url)
@@ -1149,7 +1153,7 @@ def unlock_already_unlocked_files(sbox):
   alpha_path = sbox.ospath('A/B/E/alpha')
   gamma_path = sbox.ospath('A/D/gamma')
 
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
+  svntest.actions.run_and_verify_svn(".*locked by user", [], 'lock',
                                      '--username', svntest.main.wc_author2,
                                      '-m', 'lock several',
                                      iota_path, lambda_path, alpha_path)
@@ -1160,14 +1164,14 @@ def unlock_already_unlocked_files(sbox):
 
   error_msg = ".*Path '/A/B/E/alpha' is already locked by user '" + \
               svntest.main.wc_author2 + "'.*"
-  svntest.actions.run_and_verify_svn2(None, None, error_msg, 0,
-                                      'lock',
-                                      '--username', svntest.main.wc_author2,
-                                      alpha_path, gamma_path)
+  svntest.actions.run_and_verify_svn(None, error_msg,
+                                     'lock',
+                                     '--username', svntest.main.wc_author2,
+                                     alpha_path, gamma_path)
   expected_status.tweak('A/D/gamma', writelocked='K')
   svntest.actions.run_and_verify_status(wc_dir, expected_status)
 
-  svntest.actions.run_and_verify_svn(None, ".*unlocked", [], 'unlock',
+  svntest.actions.run_and_verify_svn(".*unlocked", [], 'unlock',
                                      '--username', svntest.main.wc_author2,
                                      lambda_path)
 
@@ -1176,11 +1180,11 @@ def unlock_already_unlocked_files(sbox):
 
   error_msg = "(.*No lock on path '/A/B/lambda'.*)" + \
               "|(.*'A/B/lambda' is not locked.*)"
-  svntest.actions.run_and_verify_svn2(None, None, error_msg, 0,
-                                      'unlock',
-                                      '--username', svntest.main.wc_author2,
-                                      '--force',
-                                      iota_path, lambda_path, alpha_path)
+  svntest.actions.run_and_verify_svn(None, error_msg,
+                                     'unlock',
+                                     '--username', svntest.main.wc_author2,
+                                     '--force',
+                                     iota_path, lambda_path, alpha_path)
 
 
   expected_status.tweak('iota', 'A/B/E/alpha', writelocked=None)
@@ -1196,7 +1200,7 @@ def info_moved_path(sbox):
   fname2 = sbox.ospath("iota2")
 
   # Move iota, creating r2.
-  svntest.actions.run_and_verify_svn(None, None, [],
+  svntest.actions.run_and_verify_svn(None, [],
                                      "mv", fname, fname2)
   expected_output = svntest.wc.State(wc_dir, {
     'iota2' : Item(verb='Adding'),
@@ -1209,13 +1213,11 @@ def info_moved_path(sbox):
   expected_status.remove("iota")
   svntest.actions.run_and_verify_commit(wc_dir,
                                         expected_output,
-                                        expected_status,
-                                        None,
-                                        wc_dir)
+                                        expected_status)
 
   # Create a new, unrelated iota, creating r3.
   svntest.main.file_append(fname, "Another iota")
-  svntest.actions.run_and_verify_svn(None, None, [],
+  svntest.actions.run_and_verify_svn(None, [],
                                      "add", fname)
   expected_output = svntest.wc.State(wc_dir, {
     'iota' : Item(verb='Adding'),
@@ -1225,12 +1227,10 @@ def info_moved_path(sbox):
     })
   svntest.actions.run_and_verify_commit(wc_dir,
                                         expected_output,
-                                        expected_status,
-                                        None,
-                                        wc_dir)
+                                        expected_status)
 
   # Lock the new iota.
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [],
+  svntest.actions.run_and_verify_svn(".*locked by user", [],
                                      "lock", fname)
   expected_status.tweak("iota", writelocked="K")
   svntest.actions.run_and_verify_status(wc_dir, expected_status)
@@ -1252,10 +1252,10 @@ def ls_url_encoded(sbox):
   fname = os.path.join(dirname, "f")
 
   # Create a dir with a space in its name and a file therein.
-  svntest.actions.run_and_verify_svn(None, None, [],
+  svntest.actions.run_and_verify_svn(None, [],
                                      "mkdir", dirname)
   svntest.main.file_append(fname, "someone was here")
-  svntest.actions.run_and_verify_svn(None, None, [],
+  svntest.actions.run_and_verify_svn(None, [],
                                      "add", fname)
   expected_output = svntest.wc.State(wc_dir, {
     'space dir' : Item(verb='Adding'),
@@ -1268,19 +1268,16 @@ def ls_url_encoded(sbox):
     })
   svntest.actions.run_and_verify_commit(wc_dir,
                                         expected_output,
-                                        expected_status,
-                                        None,
-                                        wc_dir)
+                                        expected_status)
 
   # Lock the file.
-  svntest.actions.run_and_verify_svn("Lock space dir/f", ".*locked by user",
+  svntest.actions.run_and_verify_svn(".*locked by user",
                                      [], "lock", fname)
 
   # Make sure ls shows it being locked.
   expected_output = " +2 " + re.escape(svntest.main.wc_author) + " +O .+f|" \
                     " +2 " + re.escape(svntest.main.wc_author) + "    .+\./"
-  svntest.actions.run_and_verify_svn("List space dir",
-                                     expected_output, [],
+  svntest.actions.run_and_verify_svn(expected_output, [],
                                      "list", "-v", dirname)
 
 #----------------------------------------------------------------------
@@ -1297,20 +1294,19 @@ def unlock_wrong_token(sbox):
   file_path = os.path.join(sbox.wc_dir, fname)
   file_url = sbox.repo_url + "/iota"
 
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
+  svntest.actions.run_and_verify_svn(".*locked by user", [], 'lock',
                                      file_path)
 
   # Steal the lock as the same author, but using a URL to keep the old token
   # in the WC.
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
+  svntest.actions.run_and_verify_svn(".*locked by user", [], 'lock',
                                     "--force", file_url)
 
   # Then, unlocking the WC path should fail.
   ### The error message returned is actually this, but let's worry about that
   ### another day...
-  svntest.actions.run_and_verify_svn2(
-    None, None, ".*((No lock on path)|(400 Bad Request))", 0,
-    'unlock', file_path)
+  svntest.actions.run_and_verify_svn(None, ".*(No lock on path)",
+                                     'unlock', file_path)
 
 #----------------------------------------------------------------------
 # Verify that info shows lock info for locked files with URI-unsafe names
@@ -1325,7 +1321,7 @@ def examine_lock_encoded_recurse(sbox):
   file_path = os.path.join(sbox.wc_dir, fname)
 
   svntest.main.file_append(file_path, "This represents a binary file\n")
-  svntest.actions.run_and_verify_svn(None, None, [], "add", file_path)
+  svntest.actions.run_and_verify_svn(None, [], "add", file_path)
 
   expected_output = svntest.wc.State(wc_dir, {
     fname : Item(verb='Adding'),
@@ -1338,7 +1334,7 @@ def examine_lock_encoded_recurse(sbox):
   svntest.actions.run_and_verify_commit(wc_dir,
                                         expected_output,
                                         expected_status,
-                                        None,
+                                        [],
                                         file_path)
 
   # lock the file and validate the contents
@@ -1358,21 +1354,21 @@ def unlocked_lock_of_other_user(sbox):
   expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
   expected_status.tweak('A/D/G/pi', writelocked='K')
 
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
+  svntest.actions.run_and_verify_svn(".*locked by user", [], 'lock',
                                      '-m', '', pi_path)
 
   svntest.actions.run_and_verify_status(wc_dir, expected_status)
 
   # now try to unlock with user jconstant, should fail but exit 0.
   if sbox.repo_url.startswith("http"):
-    expected_err = ".*403 Forbidden.*"
+    expected_err = "svn: warning: W160039: .*[Uu]nlock of .*403 Forbidden.*"
   else:
     expected_err = "svn: warning: W160039: User '%s' is trying to use a lock owned by "\
                    "'%s'.*" % (svntest.main.wc_author2, svntest.main.wc_author)
-  svntest.actions.run_and_verify_svn2(None, [], expected_err, 0,
-                                      'unlock',
-                                      '--username', svntest.main.wc_author2,
-                                      pi_path)
+  svntest.actions.run_and_verify_svn([], expected_err,
+                                     'unlock',
+                                     '--username', svntest.main.wc_author2,
+                                     pi_path)
   svntest.actions.run_and_verify_status(wc_dir, expected_status)
 
 
@@ -1390,7 +1386,7 @@ def lock_funky_comment_chars(sbox):
   svntest.main.file_append(file_path, "This represents a binary file\n")
   svntest.main.run_svn(None, 'commit',
                        '-m', '', file_path)
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
+  svntest.actions.run_and_verify_svn(".*locked by user", [], 'lock',
                                      '-m', 'lock & load', file_path)
 
 #----------------------------------------------------------------------
@@ -1407,26 +1403,26 @@ def lock_twice_in_one_wc(sbox):
 
   # Create a needs-lock file
   svntest.actions.set_prop('svn:needs-lock', '*', mu_path)
-  svntest.actions.run_and_verify_svn(None, None, [],
+  svntest.actions.run_and_verify_svn(None, [],
                                      'commit', wc_dir, '-m', '')
 
   # Mark the file readonly
-  svntest.actions.run_and_verify_svn(None, None, [],
+  svntest.actions.run_and_verify_svn(None, [],
                                      'update', wc_dir)
 
   # Switch a second location for the same file in the same working copy
-  svntest.actions.run_and_verify_svn(None, None, [],
+  svntest.actions.run_and_verify_svn(None, [],
                                      'switch', sbox.repo_url + '/A',
                                      sbox.ospath('A/B'),
                                      '--ignore-ancestry')
 
   # Lock location 1
-  svntest.actions.run_and_verify_svn(None, None, [],
+  svntest.actions.run_and_verify_svn(None, [],
                                      'lock', mu_path, '-m', 'Locked here')
 
-  # Locking in location 2 should fail ### Currently returns exitcode 0
-  svntest.actions.run_and_verify_svn2(None, None, ".*is already locked.*", 0,
-                                      'lock', '-m', '', mu2_path)
+  # Locking in location 2 should fail
+  svntest.actions.run_and_verify_svn(None, ".*is already locked.*",
+                                     'lock', '-m', '', mu2_path)
 
   # Change the file anyway
   os.chmod(mu2_path, 0700)
@@ -1435,7 +1431,7 @@ def lock_twice_in_one_wc(sbox):
   # Commit will just succeed as the DB owns the lock. It's a user decision
   # to commit the other target instead of the one originally locked
 
-  svntest.actions.run_and_verify_svn(None, None, [],
+  svntest.actions.run_and_verify_svn(None, [],
                                      'commit', mu2_path, '-m', '')
 
 #----------------------------------------------------------------------
@@ -1454,14 +1450,13 @@ def lock_path_not_in_head(sbox):
   # Commit deletion of A/D and A/B/lambda as r2, then update the WC
   # back to r1.  Then attempt to lock some paths that no longer exist
   # in HEAD.  These should fail gracefully.
-  svntest.actions.run_and_verify_svn(None, None, [],
+  svntest.actions.run_and_verify_svn(None, [],
                                      'delete', lambda_path, D_path)
-  svntest.actions.run_and_verify_svn(None, None, [], 'commit',
+  svntest.actions.run_and_verify_svn(None, [], 'commit',
                                      '-m', 'Some deletions', wc_dir)
-  svntest.actions.run_and_verify_svn(None, None, [], 'up', '-r1', wc_dir)
+  svntest.actions.run_and_verify_svn(None, [], 'up', '-r1', wc_dir)
   expected_lock_fail_err_re = "svn: warning: W160042: " \
-  "((Path .* doesn't exist in HEAD revision)" \
-  "|(L(ock|OCK) request (on '.*' )?failed: 405 Method Not Allowed))"
+  "(Path .* doesn't exist in HEAD revision)"
   # Issue #3524 These lock attemtps were triggering an assert over ra_serf:
   #
   # working_copies\lock_tests-37>svn lock A\D
@@ -1473,11 +1468,11 @@ def lock_path_not_in_head(sbox):
   # ..\..\..\subversion\libsvn_client\ra.c:275: (apr_err=235000)
   # svn: In file '..\..\..\subversion\libsvn_ra_serf\util.c' line 1120:
   #  assertion failed (ctx->status_code)
-  svntest.actions.run_and_verify_svn2(None, None, expected_lock_fail_err_re,
-                                      0, 'lock', lambda_path)
+  svntest.actions.run_and_verify_svn(None, expected_lock_fail_err_re,
+                                     'lock', lambda_path)
 
   expected_err = 'svn: E155008: The node \'.*D\' is not a file'
-  svntest.actions.run_and_verify_svn(None, None, expected_err,
+  svntest.actions.run_and_verify_svn(None, expected_err,
                                      'lock', D_path)
 
 
@@ -1500,7 +1495,7 @@ def verify_path_escaping(sbox):
 
   svntest.main.run_svn(None, 'add', file1, file2, file3)
 
-  svntest.main.run_svn(None, 'ci', '-m', 'commit', wc_dir)
+  sbox.simple_commit(message='commit')
 
   svntest.main.run_svn(None, 'lock', '-m', 'lock 1', file1)
   svntest.main.run_svn(None, 'lock', '-m', 'lock 2', sbox.repo_url + '/file%20%232')
@@ -1533,37 +1528,37 @@ def replace_and_propset_locked_path(sbox):
   rho_path = sbox.ospath('A/D/G/rho')
 
   # Lock mu and A/D/G/rho.
-  svntest.actions.run_and_verify_svn(None, None, [],
+  svntest.actions.run_and_verify_svn(None, [],
                                      'lock', mu_path, rho_path,
                                      '-m', 'Locked')
 
   # Now replace and propset on mu.
-  svntest.actions.run_and_verify_svn(None, None, [],
+  svntest.actions.run_and_verify_svn(None, [],
                                      'rm', '--keep-local', mu_path)
-  svntest.actions.run_and_verify_svn(None, None, [],
+  svntest.actions.run_and_verify_svn(None, [],
                                      'add', mu_path)
-  svntest.actions.run_and_verify_svn(None, None, [],
+  svntest.actions.run_and_verify_svn(None, [],
                                      'propset', 'foo', 'bar', mu_path)
 
   # Commit mu.
-  svntest.actions.run_and_verify_svn(None, None, [],
+  svntest.actions.run_and_verify_svn(None, [],
                                      'commit', '-m', '', mu_path)
 
   # Let's try this again where directories are involved, shall we?
   # Replace A/D/G and A/D/G/rho, propset on A/D/G/rho.
-  svntest.actions.run_and_verify_svn(None, None, [],
+  svntest.actions.run_and_verify_svn(None, [],
                                      'rm', G_path)
 
-  svntest.actions.run_and_verify_svn(None, None, [],
+  svntest.actions.run_and_verify_svn(None, [],
                                      'mkdir', G_path)
   svntest.main.file_append(rho_path, "This is the new file 'rho'.\n")
-  svntest.actions.run_and_verify_svn(None, None, [],
+  svntest.actions.run_and_verify_svn(None, [],
                                      'add', rho_path)
-  svntest.actions.run_and_verify_svn(None, None, [],
+  svntest.actions.run_and_verify_svn(None, [],
                                      'propset', 'foo', 'bar', rho_path)
 
   # And commit G.
-  svntest.actions.run_and_verify_svn(None, None, [],
+  svntest.actions.run_and_verify_svn(None, [],
                                      'commit', '-m', '', G_path)
 
 
@@ -1676,15 +1671,15 @@ def block_unlock_if_pre_unlock_hook_fails(sbox):
   expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
   expected_status.tweak('A/D/G/pi', writelocked='K')
 
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
+  svntest.actions.run_and_verify_svn(".*locked by user", [], 'lock',
                                      '-m', '', pi_path)
 
   svntest.actions.run_and_verify_status(wc_dir, expected_status)
 
   # Make sure the unlock operation fails as pre-unlock hook blocks it.
-  expected_unlock_fail_err_re = ".*error text|.*500 Internal Server Error"
-  svntest.actions.run_and_verify_svn2(None, None, expected_unlock_fail_err_re,
-                                      1, 'unlock', pi_path)
+  expected_unlock_fail_err_re = ".*error text"
+  svntest.actions.run_and_verify_svn(None, expected_unlock_fail_err_re,
+                                     'unlock', pi_path)
   svntest.actions.run_and_verify_status(wc_dir, expected_status)
 
 #----------------------------------------------------------------------
@@ -1703,10 +1698,10 @@ def lock_invalid_token(sbox):
   fname = 'iota'
   file_path = os.path.join(sbox.wc_dir, fname)
 
-  svntest.actions.run_and_verify_svn2(None, None,
-                                      "svn: warning: W160037: " \
-                                      ".*scheme.*'opaquelocktoken'", 0,
-                                      'lock', '-m', '', file_path)
+  svntest.actions.run_and_verify_svn(None,
+                                     "svn: warning: W160037: " \
+                                     ".*scheme.*'opaquelocktoken'",
+                                     'lock', '-m', '', file_path)
 
 @Issue(3105)
 def lock_multi_wc(sbox):
@@ -1720,19 +1715,19 @@ def lock_multi_wc(sbox):
   wc2_name = os.path.basename(sbox2.wc_dir)
 
   expected_output = svntest.verify.UnorderedOutput([
-    '\'%s\' locked by user \'jrandom\'.\n' % os.path.join(wc_name, 'iota'),
-    '\'%s\' locked by user \'jrandom\'.\n' % os.path.join(wc2_name, 'A', 'mu'),
+    '\'%s\' locked by user \'jrandom\'.\n' % sbox.ospath('iota'),
+    '\'%s\' locked by user \'jrandom\'.\n' % sbox2.ospath('A/mu'),
   ])
 
-  svntest.actions.run_and_verify_svn(None, expected_output, [],
+  svntest.actions.run_and_verify_svn(expected_output, [],
                                      'lock', sbox.ospath('iota'),
                                              sbox2.ospath('A/mu'))
 
   expected_output = svntest.verify.UnorderedOutput([
-    '\'%s\' unlocked.\n' % os.path.join(wc_name, 'iota'),
-    '\'%s\' unlocked.\n' % os.path.join(wc2_name, 'A', 'mu'),
+    '\'%s\' unlocked.\n' % sbox.ospath('iota'),
+    '\'%s\' unlocked.\n' % sbox2.ospath('A/mu'),
   ])
-  svntest.actions.run_and_verify_svn(None, expected_output, [],
+  svntest.actions.run_and_verify_svn(expected_output, [],
                                      'unlock', sbox.ospath('iota'),
                                                sbox2.ospath('A/mu'))
 
@@ -1744,7 +1739,7 @@ def locks_stick_over_switch(sbox):
   wc_dir = sbox.wc_dir
   repo_url = sbox.repo_url
 
-  svntest.actions.run_and_verify_svn(None, None, [],
+  svntest.actions.run_and_verify_svn(None, [],
                                      'cp', sbox.ospath('A'), repo_url + '/AA',
                                      '-m', '')
 
@@ -1753,7 +1748,7 @@ def locks_stick_over_switch(sbox):
     '\'%s\' locked by user \'jrandom\'.\n' % os.path.join('A', 'D', 'H', 'chi'),
     '\'%s\' locked by user \'jrandom\'.\n' % os.path.join('A', 'mu'),
   ])
-  svntest.actions.run_and_verify_svn(None, expected_output, [],
+  svntest.actions.run_and_verify_svn(expected_output, [],
                                      'lock', sbox.ospath('A/D/H/chi'),
                                              sbox.ospath('A/mu'),
                                              sbox.ospath('iota'))
@@ -1793,7 +1788,7 @@ def lock_unlock_deleted(sbox):
 
   sbox.build()
   wc_dir = sbox.wc_dir
-  svntest.actions.run_and_verify_svn(None, None, [],
+  svntest.actions.run_and_verify_svn(None, [],
                                      'rm', sbox.ospath('A/mu'))
 
   expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
@@ -1801,13 +1796,13 @@ def lock_unlock_deleted(sbox):
   svntest.actions.run_and_verify_status(wc_dir, expected_status)
 
   expected_output = '\'mu\' locked by user \'jrandom\'.'
-  svntest.actions.run_and_verify_svn(None, expected_output, [],
+  svntest.actions.run_and_verify_svn(expected_output, [],
                                      'lock', sbox.ospath('A/mu'))
   expected_status.tweak('A/mu', writelocked='K')
   svntest.actions.run_and_verify_status(wc_dir, expected_status)
 
   expected_output = '\'mu\' unlocked.'
-  svntest.actions.run_and_verify_svn(None, expected_output, [],
+  svntest.actions.run_and_verify_svn(expected_output, [],
                                      'unlock', sbox.ospath('A/mu'))
   expected_status.tweak('A/mu', writelocked=None)
   svntest.actions.run_and_verify_status(wc_dir, expected_status)
@@ -1822,8 +1817,8 @@ def commit_stolen_lock(sbox):
   sbox.simple_append('A/mu', 'zig-zag')
   sbox.simple_lock('A/mu')
 
-  expected_output = '\'mu\' locked by user \'jrandom\'.'
-  svntest.actions.run_and_verify_svn(None, expected_output, [],
+  expected_output = '\'.*mu\' locked by user \'jrandom\'.'
+  svntest.actions.run_and_verify_svn(expected_output, [],
                                      'lock', '--force',
                                      sbox.repo_url + '/A/mu')
 
@@ -1834,11 +1829,10 @@ def commit_stolen_lock(sbox):
   svntest.actions.run_and_verify_commit(wc_dir,
                                         [],
                                         expected_status,
-                                        err_re,
-                                        wc_dir)
+                                        err_re)
 
-# When removing directories, the locks of contained files were not 
-# correctly removed from the working copy database, thus they later 
+# When removing directories, the locks of contained files were not
+# correctly removed from the working copy database, thus they later
 # magically reappeared when new files or directories with the same
 # pathes were added.
 @Issue(4364)
@@ -1853,15 +1847,13 @@ def drop_locks_on_parent_deletion(sbox):
   sbox.simple_lock('A/B/E/alpha')
   sbox.simple_lock('A/B/E/beta')
   sbox.simple_rm('A/B')
-  
+
   expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
   expected_status.remove_subtree('A/B')
-  
+
   svntest.actions.run_and_verify_commit(wc_dir,
                                         [],
-                                        expected_status,
-                                        None,
-                                        wc_dir)
+                                        expected_status)
 
   # now re-add entities to the deleted pathes.
   sbox.simple_mkdir('A/B')
@@ -1870,32 +1862,231 @@ def drop_locks_on_parent_deletion(sbox):
   # The bug also resurrected locks on directories when their path
   # matched a former file.
   sbox.simple_mkdir('A/B/E', 'A/B/E/alpha')
-    
+
   expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
   expected_status.tweak('A/B',
-						'A/B/E',
-						'A/B/E/alpha',
-						'A/B/F',
-						'A/B/lambda',
-						wc_rev='3')
+                        'A/B/E',
+                        'A/B/E/alpha',
+                        'A/B/F',
+                        'A/B/lambda',
+                        wc_rev='3')
   expected_status.remove('A/B/E/beta')
-   
+
   svntest.actions.run_and_verify_commit(wc_dir,
                                         [],
-                                        expected_status,
-                                        None,
-                                        wc_dir)
-	
-										
-@SkipUnless(svntest.main.is_ra_type_dav)
+                                        expected_status)
+
+
+def copy_with_lock(sbox):
+  """copy with lock on source"""
+
+  sbox.build()
+  wc_dir = sbox.wc_dir
+  lock_url = sbox.repo_url + '/A/B/E/alpha'
+
+  svntest.actions.run_and_validate_lock(lock_url, svntest.main.wc_author)
+  sbox.simple_copy('A/B/E', 'A/B/E2')
+
+  expected_output = svntest.wc.State(wc_dir, {
+    'A/B/E2' : Item(verb='Adding'),
+    })
+  expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
+  expected_status.tweak('A/B/E/alpha', writelocked='O')
+  expected_status.add({
+    'A/B/E2'       : Item(status='  ', wc_rev=2),
+    'A/B/E2/alpha' : Item(status='  ', wc_rev=2),
+    'A/B/E2/beta'  : Item(status='  ', wc_rev=2),
+    })
+
+  # This is really a regression test for httpd: 2.2.25 and 2.4.6, and
+  # earlier, have a bug that causes mod_dav to check for locks on the
+  # copy source and so the commit fails.
+  svntest.actions.run_and_verify_commit(wc_dir,
+                                        expected_output,
+                                        expected_status)
+
+def lock_hook_messages(sbox):
+  "verify (un)lock message is transferred correctly"
+
+  sbox.build(create_wc = False)
+  repo_dir = sbox.repo_dir
+
+  iota_url = sbox.repo_url + "/iota"
+  mu_url = sbox.repo_url + "/A/mu"
+
+  svntest.actions.run_and_verify_svn(".*locked by user", [], 'lock',
+                                     iota_url)
+
+  error_msg = "Text with <angle brackets> & ampersand"
+  svntest.actions.create_failing_hook(repo_dir, "pre-lock", error_msg)
+  svntest.actions.create_failing_hook(repo_dir, "pre-unlock", error_msg)
+
+  _, _, actual_stderr = svntest.actions.run_and_verify_svn(
+                                     [], svntest.verify.AnyOutput,
+                                     'lock', mu_url)
+  if len(actual_stderr) > 4:
+    actual_stderr = actual_stderr[-4:-2] + actual_stderr[-1:]
+  expected_err = [
+    'svn: warning: W165001: ' + svntest.actions.hook_failure_message('pre-lock'),
+    error_msg + "\n",
+    "svn: E200009: One or more locks could not be obtained\n",
+  ]
+  svntest.verify.compare_and_display_lines(None, 'STDERR',
+                                           expected_err, actual_stderr)
+
+
+  _, _, actual_stderr = svntest.actions.run_and_verify_svn(
+                                     [], svntest.verify.AnyOutput,
+                                     'unlock', iota_url)
+  if len(actual_stderr) > 4:
+    actual_stderr = actual_stderr[-4:-2] + actual_stderr[-1:]
+  expected_err = [
+    'svn: warning: W165001: ' + svntest.actions.hook_failure_message('pre-unlock'),
+    error_msg + "\n",
+    "svn: E200009: One or more locks could not be released\n",
+  ]
+  svntest.verify.compare_and_display_lines(None, 'STDERR',
+                                           expected_err, actual_stderr)
+
+
+def failing_post_hooks(sbox):
+  "locking with failing post-lock and post-unlock"
+
+  sbox.build()
+  wc_dir = sbox.wc_dir
+  repo_dir = sbox.repo_dir
+
+  svntest.actions.create_failing_hook(repo_dir, "post-lock", "error text")
+  svntest.actions.create_failing_hook(repo_dir, "post-unlock", "error text")
+
+  pi_path = sbox.ospath('A/D/G/pi')
+  expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
+  expected_status.tweak('A/D/G/pi', writelocked='K')
+
+  if svntest.main.is_ra_type_dav():
+    expected_lock_err = []
+    expected_unlock_err = '.*svn: E165009: Unlock succeeded.*' #
+  else:
+    expected_unlock_err = expected_lock_err = ".*error text"
+
+  # Failing post-lock doesn't stop lock being created.
+  svntest.actions.run_and_verify_svn("'pi' locked by user",
+                                     expected_lock_err,
+                                     'lock', '-m', '', pi_path)
+  svntest.actions.run_and_verify_status(wc_dir, expected_status)
+
+  expected_status.tweak('A/D/G/pi', writelocked=None)
+
+  # Failing post-unlock doesn't stop lock being removed.
+  svntest.actions.run_and_verify_svn("'pi' unlocked",
+                                     expected_unlock_err,
+                                     'unlock', pi_path)
+  svntest.actions.run_and_verify_status(wc_dir, expected_status)
+
+def break_delete_add(sbox):
+  "break a lock, delete and add the file"
+
+  sbox.build()
+  wc_dir = sbox.wc_dir
+
+  svntest.actions.run_and_verify_svn(".*locked by user", [],
+                                     'lock',
+                                     '-m', 'some lock comment',
+                                     sbox.ospath('A/mu'))
+
+  expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
+  expected_status.tweak('A/mu', writelocked='K')
+  svntest.actions.run_and_verify_status(wc_dir, expected_status)
+
+  svntest.actions.run_and_verify_svn(".*unlocked", [],
+                                     'unlock', '--force',
+                                     sbox.repo_url + '/A/mu')
+
+  svntest.actions.run_and_verify_svn(None, [],
+                                     'rm',
+                                     '-m', 'delete file',
+                                     sbox.repo_url + '/A/mu')
+
+  # Update removes the locked file and should remove the lock token.
+  sbox.simple_update()
+
+  # Lock token not visible on newly added file.
+  sbox.simple_append('A/mu', 'another mu')
+  sbox.simple_add('A/mu')
+  expected_status = svntest.actions.get_virginal_state(wc_dir, 2)
+  expected_status.tweak('A/mu', status='A ', wc_rev='-')
+  svntest.actions.run_and_verify_status(wc_dir, expected_status)
+
+  ### XFAIL Broken lock token now visible in status.
+  sbox.simple_commit()
+  expected_status.tweak('A/mu', status='  ', wc_rev=3)
+  svntest.actions.run_and_verify_status(wc_dir, expected_status)
+
 def dav_lock_timeout(sbox):
   "unlock a lock with timeout"
 
+  # Locks with timeouts are only created by generic DAV clients but a
+  # Subversion client may need to view or unlock one over any RA
+  # layer.
+
+  sbox.build()
+  wc_dir = sbox.wc_dir
+
+  svntest.main.run_lock_helper(sbox.repo_dir, 'iota',  'some_user', 999)
+  # Lock should have an expiration date
+  expiration_date = svntest.actions.run_and_parse_info(sbox.repo_url + '/iota')[0]['Lock Expires']
+
+  # Verify that there is a lock, by trying to obtain one
+  svntest.actions.run_and_verify_svn(None, ".*locked by user",
+                                     'lock', '-m', '', sbox.ospath('iota'))
+  expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
+  expected_status.tweak('iota', writelocked='O')
+  svntest.actions.run_and_verify_status(wc_dir, expected_status)
+
+  # This used to fail over serf with a parse error of the timeout.
+  expected_err = "svn: warning: W160039:"
+  svntest.actions.run_and_verify_svn(None, expected_err,
+                                     'unlock', sbox.repo_url + '/iota')
+
+  # Force unlock via working copy, this also used to fail over serf.
+  svntest.actions.run_and_verify_svn(None, [],
+                                     'unlock', sbox.ospath('iota'), '--force')
+  expected_status.tweak('iota', writelocked=None)
+  svntest.actions.run_and_verify_status(wc_dir, expected_status)
+
+  # Lock again
+  svntest.main.run_lock_helper(sbox.repo_dir, 'iota',  'some_user', 999)
+  expected_status.tweak('iota', writelocked='O')
+  svntest.actions.run_and_verify_status(wc_dir, expected_status)
+
+  # Force unlock via URL, this also used to fail over serf
+  svntest.actions.run_and_verify_svn(None, [],
+                                     'unlock', sbox.repo_url + '/iota',
+                                     '--force')
+  expected_status.tweak('iota', writelocked=None)
+  svntest.actions.run_and_verify_status(wc_dir, expected_status)
+
+  # Lock again
+  svntest.main.run_lock_helper(sbox.repo_dir, 'iota',  'some_user', 999)
+  expected_status.tweak('iota', writelocked='O')
+  svntest.actions.run_and_verify_status(wc_dir, expected_status)
+
+  # Force lock via working copy, this also used to fail over serf.
+  svntest.actions.run_and_verify_svn(None, [],
+                                     'lock', sbox.ospath('iota'), '--force')
+  expected_status.tweak('iota', writelocked='K')
+  svntest.actions.run_and_verify_status(wc_dir, expected_status)
+
+@SkipUnless(svntest.main.is_ra_type_dav)
+def create_dav_lock_timeout(sbox):
+  "create generic DAV lock with timeout"
+
   import httplib
   from urlparse import urlparse
   import base64
 
   sbox.build()
+  wc_dir = sbox.wc_dir
   loc = urlparse(sbox.repo_url)
 
   if loc.scheme == 'http':
@@ -1924,18 +2115,12 @@ def dav_lock_timeout(sbox):
 
   r = h.getresponse()
 
-  # Verify that there is a lock, by trying to obtain one
-  svntest.actions.run_and_verify_svn2(None, None, ".*locked by user", 0,
-                                      'lock', '-m', '', sbox.ospath('iota'))
-
-  # Before this patch this used to fail with a parse error of the timeout
-  svntest.actions.run_and_verify_svn2(None, None, ".*W160039.*Unlock.*403", 0,
-                                     'unlock', sbox.repo_url + '/iota')
-
-  svntest.actions.run_and_verify_svn(None, None, [],
-                                     'unlock', sbox.ospath('iota'), '--force')
-
+  expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
+  expected_status.tweak('iota', writelocked='O')
+  svntest.actions.run_and_verify_status(wc_dir, expected_status)
 
+  # Lock should have an expiration date
+  expiration_date = svntest.actions.run_and_parse_info(sbox.repo_url + '/iota')[0]['Lock Expires']
 
 def non_root_locks(sbox):
   "locks for working copies not at repos root"
@@ -1943,16 +2128,16 @@ def non_root_locks(sbox):
   sbox.build()
   wc_dir = sbox.wc_dir
 
-  svntest.actions.run_and_verify_svn(None, None, [],
+  svntest.actions.run_and_verify_svn(None, [],
                                      'cp', sbox.repo_url, sbox.repo_url + '/X',
                                      '-m', 'copy greek tree')
 
-  sbox.simple_switch(sbox.repo_url + '/X')  
+  sbox.simple_switch(sbox.repo_url + '/X')
   expected_status = svntest.actions.get_virginal_state(wc_dir, 2)
   svntest.actions.run_and_verify_status(wc_dir, expected_status)
 
   # Lock a file
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [],
+  svntest.actions.run_and_verify_svn(".*locked by user", [],
                                      'lock', sbox.ospath('A/D/G/pi'),
                                      '-m', '')
   expected_status.tweak('A/D/G/pi', writelocked='K')
@@ -1965,7 +2150,7 @@ def non_root_locks(sbox):
   svntest.actions.run_and_verify_status(wc_dir, expected_status)
 
   # Break the lock
-  svntest.actions.run_and_verify_svn(None, None, [],
+  svntest.actions.run_and_verify_svn(None, [],
                                      'unlock', sbox.repo_url + '/X/A/D/G/pi')
 
   # Subdir update reports the break
@@ -1974,12 +2159,12 @@ def non_root_locks(sbox):
   svntest.actions.run_and_verify_status(wc_dir, expected_status)
 
   # Relock and break
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [],
+  svntest.actions.run_and_verify_svn(".*locked by user", [],
                                      'lock', sbox.ospath('A/D/G/pi'),
                                      '-m', '')
   expected_status.tweak('A/D/G/pi', writelocked='K')
   svntest.actions.run_and_verify_status(wc_dir, expected_status)
-  svntest.actions.run_and_verify_svn(None, None, [],
+  svntest.actions.run_and_verify_svn(None, [],
                                      'unlock', sbox.repo_url + '/X/A/D/G/pi')
 
   # Root update reports the break
@@ -1987,6 +2172,56 @@ def non_root_locks(sbox):
   expected_status.tweak('A/D/G/pi', writelocked=None)
   svntest.actions.run_and_verify_status(wc_dir, expected_status)
 
+def many_locks_hooks(sbox):
+  "many locks with hooks"
+
+  sbox.build()
+  wc_dir = sbox.wc_dir
+
+  # Prevent locking '/A/D/G/pi'.
+  svntest.main.create_python_hook_script(os.path.join(sbox.repo_dir,
+                                                      'hooks', 'pre-lock'),
+                                         'import sys\n'
+                                         'if sys.argv[2] == "/A/D/G/pi":\n'
+                                         '  sys.exit(1)\n'
+                                         'sys.exit(0)\n')
+
+  # Prevent unlocking '/A/mu'.
+  svntest.main.create_python_hook_script(os.path.join(sbox.repo_dir,
+                                                      'hooks', 'pre-unlock'),
+                                         'import sys\n'
+                                         'if sys.argv[2] == "/A/mu":\n'
+                                         '  sys.exit(1)\n'
+                                         'sys.exit(0)\n')
+
+  svntest.actions.run_and_verify_svn(".* locked",
+                                     "svn: warning: W165001: .*",
+                                     'lock',
+                                     sbox.ospath('iota'),
+                                     sbox.ospath('A/mu'),
+                                     sbox.ospath('A/B/E/alpha'),
+                                     sbox.ospath('A/D/G/pi'),
+                                     sbox.ospath('A/D/G/rho'))
+
+  expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
+  expected_status.tweak('iota', 'A/mu', 'A/B/E/alpha', 'A/D/G/rho',
+                        writelocked='K')
+  svntest.actions.run_and_verify_status(wc_dir, expected_status)
+
+  svntest.actions.run_and_verify_svn(".* unlocked",
+                                     "svn: warning: W165001: .*",
+                                     'unlock',
+                                     sbox.ospath('iota'),
+                                     sbox.ospath('A/mu'),
+                                     sbox.ospath('A/B/E/alpha'),
+                                     sbox.ospath('A/D/G/rho'))
+
+  expected_status.tweak('iota', 'A/B/E/alpha', 'A/D/G/rho',
+                        writelocked=None)
+  svntest.actions.run_and_verify_status(wc_dir, expected_status)
+
+
+
 @Issue(3515)
 @SkipUnless(svntest.main.is_ra_type_dav)
 def dav_lock_refresh(sbox):
@@ -1999,7 +2234,7 @@ def dav_lock_refresh(sbox):
   sbox.build(create_wc = False)
 
   # Acquire lock on 'iota'
-  svntest.actions.run_and_verify_svn(None, ".*locked by user", [], 'lock',
+  svntest.actions.run_and_verify_svn(".*locked by user", [], 'lock',
                                      sbox.repo_url + '/iota')
 
   # Try to refresh lock using 'If' header
@@ -2033,14 +2268,27 @@ def delete_locked_file_with_percent(sbox):
   "lock and delete a file called 'a %( ) .txt'"
 
   sbox.build()
+  wc_dir = sbox.wc_dir
 
   locked_filename = 'a %( ) .txt'
   locked_path = sbox.ospath(locked_filename)
   svntest.main.file_write(locked_path, "content\n")
   sbox.simple_add(locked_filename)
   sbox.simple_commit()
-  
+
   sbox.simple_lock(locked_filename)
+
+  expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
+  expected_status.add({
+      'a %( ) .txt' : Item(status='  ', wc_rev='2', writelocked='K')
+  })
+  expected_infos = [
+      { 'Lock Owner' : 'jrandom' },
+    ]
+  svntest.actions.run_and_verify_info(expected_infos, sbox.path('a %( ) .txt'),
+                                      '-rHEAD')
+  svntest.actions.run_and_verify_status(wc_dir, expected_status)
+
   sbox.simple_rm(locked_filename)
 
   # XFAIL: With a 1.8.x client, this commit fails with:
@@ -2049,6 +2297,200 @@ def delete_locked_file_with_percent(sbox):
   #  Invalid percent encoded URI in tagged If-header [400, #104]
   sbox.simple_commit()
 
+def lock_commit_bump(sbox):
+  "a commit should not bump just locked files"
+
+  sbox.build()
+  wc_dir = sbox.wc_dir
+  sbox.simple_lock('iota')
+
+  changed_file = sbox.ospath('changed')
+  sbox.simple_append('changed', 'Changed!')
+
+  svntest.actions.run_and_verify_svn(None, [], 'unlock', '--force',
+                                     sbox.repo_url + '/iota')
+
+  svntest.actions.run_and_verify_svnmucc(None, [],
+                                         '-U', sbox.repo_url, '-m', 'Q',
+                                         'put', changed_file, 'iota')
+
+  sbox.simple_append('A/mu', 'GOAAAAAAAAL!')
+
+  expected_output = svntest.wc.State(wc_dir, {
+    'A/mu'              : Item(verb='Sending'),
+  })
+  expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
+  expected_status.tweak('A/mu', wc_rev=3)
+
+  svntest.actions.run_and_verify_commit(wc_dir,
+                                        expected_output,
+                                        expected_status)
+
+  # We explicitly check both the Revision and Last Changed Revision.
+  expected_infos = [ {
+    'Revision'           : '1' ,
+    'Last Changed Rev'   : '1' ,
+    'URL'                : '.*',
+    'Lock Token'         : None, }
+  ]
+  svntest.actions.run_and_verify_info(expected_infos,
+                                      sbox.ospath('iota'))
+
+def copy_dir_with_locked_file(sbox):
+  "copy a directory containing a locked file"
+
+  sbox.build()
+  AA_url = sbox.repo_url + '/AA'
+  AA2_url = sbox.repo_url + '/AA2'
+  A_url = sbox.repo_url + '/A'
+  mu_url = A_url + '/mu'
+
+  svntest.main.run_svn(None, 'lock', '-m', 'locked', mu_url)
+
+  svntest.actions.run_and_verify_svn(None, [],
+                                     'cp', A_url, AA_url,
+                                     '-m', '')
+
+  expected_err = "svn: E160037: .*no matching lock-token available"
+  svntest.actions.run_and_verify_svn(None, expected_err,
+                                     'mv', A_url, AA2_url,
+                                     '-m', '')
+
+@Issue(4557)
+def delete_dir_with_lots_of_locked_files(sbox):
+  "delete a directory containing lots of locked files"
+
+  sbox.build()
+  wc_dir = sbox.wc_dir
+
+  # A lot of paths.
+  nfiles = 75 # NOTE: test XPASSES with 50 files!!!
+  locked_paths = []
+  for i in range(nfiles):
+      locked_paths.append(sbox.ospath("A/locked_files/file-%i" % i))
+
+  # Create files at these paths
+  os.mkdir(sbox.ospath("A/locked_files"))
+  for file_path in locked_paths:
+    svntest.main.file_write(file_path, "This is '%s'.\n" % (file_path,))
+  sbox.simple_add("A/locked_files")
+  sbox.simple_commit()
+  sbox.simple_update()
+
+  # lock all the files
+  svntest.actions.run_and_verify_svn(None, [], 'lock',
+                                     '-m', 'All locks',
+                                      *locked_paths)
+  # Locally delete A (regression against earlier versions, which
+  #                   always used a special non-standard request)
+  sbox.simple_rm("A")
+
+  # Commit the deletion
+  # XFAIL: As of 1.8.10, this commit fails with:
+  #  svn: E175002: Unexpected HTTP status 400 'Bad Request' on '<path>'
+  # and the following error in the httpd error log:
+  #  request failed: error reading the headers
+  # This problem was introduced on the 1.8.x branch in r1606976.
+  sbox.simple_commit()
+
+def delete_locks_on_depth_commit(sbox):
+  "delete locks on depth-limited commit"
+
+  sbox.build()
+  wc_dir = sbox.wc_dir
+
+  svntest.actions.run_and_verify_svn(None, [], 'lock',
+                                     '-m', 'All files',
+                                      *(sbox.ospath(x)
+                                        for x in ['iota', 'A/B/E/alpha',
+                                                  'A/B/E/beta', 'A/B/lambda',
+                                                  'A/D/G/pi', 'A/D/G/rho',
+                                                  'A/D/G/tau', 'A/D/H/chi',
+                                                  'A/D/H/omega', 'A/D/H/psi',
+                                                  'A/D/gamma', 'A/mu']))
+
+  sbox.simple_rm("A")
+
+  expected_output = svntest.wc.State(wc_dir, {
+    'A' : Item(verb='Deleting'),
+  })
+
+  expected_status = svntest.wc.State(wc_dir, {
+    ''      : Item(status='  ', wc_rev='1'),
+    'iota'  : Item(status='  ', wc_rev='1'),
+  })
+
+  svntest.actions.run_and_verify_commit(wc_dir, expected_output,
+                                        expected_status, [],
+                                        wc_dir, '--depth', 'immediates')
+
+  sbox.simple_update() # r2
+
+  svntest.actions.run_and_verify_svn(None, [], 'cp',
+                                     sbox.repo_url + '/A@1', sbox.ospath('A'))
+
+  expected_output = [
+    'Adding         %s\n' % sbox.ospath('A'),
+    'svn: The depth of this commit is \'immediates\', but copies ' \
+        'are always performed recursively in the repository.\n',
+    'Committing transaction...\n',
+    'Committed revision 3.\n',
+  ]
+
+  # Verifying the warning line... so can't use verify_commit()
+  svntest.actions.run_and_verify_svn(expected_output, [],
+                                     'commit', wc_dir, '--depth', 'immediates',
+                                     '-mm')
+
+  # Verify that all locks are gone at the server and at the client
+  expected_status = svntest.actions.get_virginal_state(wc_dir, 3)
+  expected_status.tweak('', 'iota', wc_rev=2)
+  svntest.actions.run_and_verify_status(wc_dir, expected_status)
+
+@Issue(4557)
+@XFail(svntest.main.is_ra_type_dav)
+def replace_dir_with_lots_of_locked_files(sbox):
+  "replace directory containing lots of locked files"
+
+  sbox.build()
+  wc_dir = sbox.wc_dir
+
+  # A lot of paths.
+  nfiles = 75 # NOTE: test XPASSES with 50 files!!!
+  locked_paths = []
+  for i in range(nfiles):
+      locked_paths.append(sbox.ospath("A/locked_files/file-%i" % i))
+
+  # Create files at these paths
+  os.mkdir(sbox.ospath("A/locked_files"))
+  for file_path in locked_paths:
+    svntest.main.file_write(file_path, "This is '%s'.\n" % (file_path,))
+  sbox.simple_add("A/locked_files")
+  sbox.simple_commit()
+  sbox.simple_update()
+
+  # lock all the files
+  svntest.actions.run_and_verify_svn(None, [], 'lock',
+                                     '-m', 'All locks',
+                                      *locked_paths)
+  # Locally delete A (regression against earlier versions, which
+  #                   always used a special non-standard request)
+  sbox.simple_rm("A")
+
+  # But a further replacement never worked
+  sbox.simple_mkdir("A")
+  # And an additional propset didn't work either
+  # (but doesn't require all lock tokens recursively)
+  sbox.simple_propset("k", "v", "A")
+
+  # Commit the deletion
+  # XFAIL: As of 1.8.10, this commit fails with:
+  #  svn: E175002: Unexpected HTTP status 400 'Bad Request' on '<path>'
+  # and the following error in the httpd error log:
+  #  request failed: error reading the headers
+  # This problem was introduced on the 1.8.x branch in r1606976.
+  sbox.simple_commit()
+
 ########################################################################
 # Run the tests
 
@@ -2102,10 +2544,21 @@ test_list = [ None,
               lock_unlock_deleted,
               commit_stolen_lock,
               drop_locks_on_parent_deletion,
+              copy_with_lock,
+              lock_hook_messages,
+              failing_post_hooks,
+              break_delete_add,
               dav_lock_timeout,
+              create_dav_lock_timeout,
               non_root_locks,
+              many_locks_hooks,
               dav_lock_refresh,
               delete_locked_file_with_percent,
+              lock_commit_bump,
+              copy_dir_with_locked_file,
+              delete_dir_with_lots_of_locked_files,
+              delete_locks_on_depth_commit,
+              replace_dir_with_lots_of_locked_files,
             ]
 
 if __name__ == '__main__':