#!/usr/bin/env python
#
#  commit_tests.py:  testing fancy commit cases.
#
#  Subversion is a tool for revision control. 
#  See http://subversion.tigris.org for more information.
#    
# ====================================================================
# Copyright (c) 2000-2001 CollabNet.  All rights reserved.
#
# This software is licensed as described in the file COPYING, which
# you should have received as part of this distribution.  The terms
# are also available at http://subversion.tigris.org/license-1.html.
# If newer versions of this license are posted there, you may use a
# newer version instead, at your option.
#
######################################################################

# General modules
import string, sys, os

# Our testing module
import svntest

# (abbreviation)
path_index = svntest.actions.path_index
  

######################################################################
# Utilities
#

def get_standard_status_list(wc_dir):
  """Return a status list reflecting the local mods made by
  make_standard_slew_of_changes()."""

  status_list = svntest.actions.get_virginal_status_list(wc_dir, '1')

  ### todo:  use status-hash below instead.

  # `.'
  status_list[0][3]['status'] = '_M'

  # A/B/lambda, A/D
  status_list[5][3]['status'] = 'M '
  status_list[11][3]['status'] = 'M '

  # A/B/E, A/D/H/chi
  status_list[6][3]['status'] = 'R '
  status_list[18][3]['status'] = 'R '

  # A/B/E/alpha, A/B/E/beta, A/C, A/D/gamma
  status_list[7][3]['status'] = 'D '
  status_list[8][3]['status'] = 'D '
  status_list[10][3]['status'] = 'D '
  status_list[12][3]['status'] = 'D '
  status_list[15][3]['status'] = 'D '
  
  # A/D/G/pi, A/D/H/omega
  status_list[14][3]['status'] = '_M'
  status_list[20][3]['status'] = 'MM'

  # New things
  status_list.append([os.path.join(wc_dir, 'Q'), None, {},
                      {'status' : 'A ',
                       'wc_rev' : '0',
                       'repos_rev' : '1'}])
  status_list.append([os.path.join(wc_dir, 'Q', 'floo'), None, {},
                      {'status' : 'A ',
                       'wc_rev' : '0',
                       'repos_rev' : '1'}])
  status_list.append([os.path.join(wc_dir, 'A', 'D', 'H', 'gloo'), None, {},
                      {'status' : 'A ',
                       'wc_rev' : '0',
                       'repos_rev' : '1'}])
  status_list.append([os.path.join(wc_dir, 'A', 'B', 'E', 'bloo'), None, {},
                      {'status' : 'A ',
                       'wc_rev' : '0',
                       'repos_rev' : '1'}])

  return status_list
  

def make_standard_slew_of_changes(wc_dir):
  """Make a specific set of local mods to WC_DIR.  These will be used
  by every commit-test.  Verify the 'svn status' output, return 0 on
  success."""

  # Cache current working directory, move into wc_dir
  was_cwd = os.getcwd()
  os.chdir(wc_dir)

  # Add a directory
  os.mkdir('Q')
  svntest.main.run_svn(None, 'add', 'Q')
  
  # Remove two directories
  svntest.main.run_svn(None, 'rm', os.path.join('A', 'B', 'E'))
  svntest.main.run_svn(None, 'rm', os.path.join('A', 'C'))
  
  # Replace one of the removed directories
  svntest.main.run_svn(None, 'add', os.path.join('A', 'B', 'E'))
  
  # Make property mods to two directories
  svntest.main.run_svn(None, 'propset', 'foo', 'bar', os.curdir)
  svntest.main.run_svn(None, 'propset', 'foo2', 'bar2', os.path.join('A', 'D'))
  
  # Add three files
  svntest.main.file_append(os.path.join('A', 'B', 'E', 'bloo'), "hi")
  svntest.main.file_append(os.path.join('A', 'D', 'H', 'gloo'), "hello")
  svntest.main.file_append(os.path.join('Q', 'floo'), "yo")
  svntest.main.run_svn(None, 'add', os.path.join('A', 'B', 'E', 'bloo'))
  svntest.main.run_svn(None, 'add', os.path.join('A', 'D', 'H', 'gloo'))
  svntest.main.run_svn(None, 'add', os.path.join('Q', 'floo'))
  
  # Remove three files
  svntest.main.run_svn(None, 'rm', os.path.join('A', 'D', 'G', 'rho'))
  svntest.main.run_svn(None, 'rm', os.path.join('A', 'D', 'H', 'chi'))
  svntest.main.run_svn(None, 'rm', os.path.join('A', 'D', 'gamma'))
  
  # Replace one of the removed files
  svntest.main.run_svn(None, 'add', os.path.join('A', 'D', 'H', 'chi'))
  
  # Make textual mods to two files
  svntest.main.file_append(os.path.join('A', 'B', 'lambda'), "new ltext")
  svntest.main.file_append(os.path.join('A', 'D', 'H', 'omega'), "new otext")
  
  # Make property mods to three files
  svntest.main.run_svn(None, 'propset', 'blue', 'azul',
                       os.path.join('A', 'D', 'H', 'omega'))  
  svntest.main.run_svn(None, 'propset', 'green', 'verde',
                       os.path.join('Q', 'floo'))
  svntest.main.run_svn(None, 'propset', 'red', 'rojo',
                       os.path.join('A', 'D', 'G', 'pi'))  

  # Restore the CWD.
  os.chdir(was_cwd)
  
  # Build an expected status tree.
  status_list = get_standard_status_list(wc_dir)
  expected_status_tree = svntest.tree.build_generic_tree(status_list)

  # Verify status -- all local mods should be present.
  if svntest.actions.run_and_verify_status(wc_dir, expected_status_tree):
    return 1

  return 0


######################################################################
# Tests
#
#   Each test must return 0 on success or non-zero on failure.


#----------------------------------------------------------------------

def commit_one_file(sbox):
  "commit one file."

  if sbox.build():
    return 1

  wc_dir = sbox.wc_dir

  # Make standard slew of changes to working copy.
  if make_standard_slew_of_changes(wc_dir): return 1

  # Create expected output tree.
  omega_path = os.path.join(wc_dir, 'A', 'D', 'H', 'omega') 
  output_list = [ [omega_path, None, {}, {'verb' : 'Sending' }] ]
  expected_output_tree = svntest.tree.build_generic_tree(output_list)

  # Created expected status tree.
  status_list = get_standard_status_list(wc_dir) # pre-commit status
  for item in status_list:
    item[3]['repos_rev'] = '2'     # post-commit status
    if (item[0] == omega_path):
      item[3]['wc_rev'] = '2'
      item[3]['status'] = '__'
  expected_status_tree = svntest.tree.build_generic_tree(status_list)

  # Commit the one file.
  return svntest.actions.run_and_verify_commit (wc_dir,
                                                expected_output_tree,
                                                expected_status_tree,
                                                None,
                                                None, None,
                                                None, None,
                                                omega_path)

  
#----------------------------------------------------------------------

def commit_one_new_file(sbox):
  "commit one newly added file."

  if sbox.build():
    return 1

  wc_dir = sbox.wc_dir

  # Make standard slew of changes to working copy.
  if make_standard_slew_of_changes(wc_dir): return 1

  # Create expected output tree.
  gloo_path = os.path.join(wc_dir, 'A', 'D', 'H', 'gloo') 
  output_list = [ [gloo_path, None, {}, {'verb' : 'Adding' }] ]
  expected_output_tree = svntest.tree.build_generic_tree(output_list)

  # Created expected status tree.
  status_list = get_standard_status_list(wc_dir) # pre-commit status
  for item in status_list:
    item[3]['repos_rev'] = '2'     # post-commit status
    if (item[0] == gloo_path):
      item[3]['wc_rev'] = '2'
      item[3]['status'] = '_ '
  expected_status_tree = svntest.tree.build_generic_tree(status_list)

  # Commit the one file.
  return svntest.actions.run_and_verify_commit (wc_dir,
                                                expected_output_tree,
                                                expected_status_tree,
                                                None,
                                                None, None,
                                                None, None,
                                                gloo_path)

  
#----------------------------------------------------------------------

def commit_multiple_targets(sbox):
  "commit multiple targets"

  if sbox.build():
    return 1

  wc_dir = sbox.wc_dir

  # This test will commit three targets:  psi, B, and pi.  In that order.

  # Make local mods to many files.
  AB_path = os.path.join(wc_dir, 'A', 'B')
  lambda_path = os.path.join(wc_dir, 'A', 'B', 'lambda')
  rho_path = os.path.join(wc_dir, 'A', 'D', 'G', 'rho')
  pi_path = os.path.join(wc_dir, 'A', 'D', 'G', 'pi')
  omega_path = os.path.join(wc_dir, 'A', 'D', 'H', 'omega')
  psi_path = os.path.join(wc_dir, 'A', 'D', 'H', 'psi')
  svntest.main.file_append (lambda_path, 'new appended text for lambda')
  svntest.main.file_append (rho_path, 'new appended text for rho')
  svntest.main.file_append (pi_path, 'new appended text for pi')
  svntest.main.file_append (omega_path, 'new appended text for omega')
  svntest.main.file_append (psi_path, 'new appended text for psi')

  # Just for kicks, add a property to A/D/G as well.  We'll make sure
  # that it *doesn't* get committed.
  ADG_path = os.path.join(wc_dir, 'A', 'D', 'G')
  svntest.main.run_svn(None, 'propset', 'foo', 'bar', ADG_path)

  # Created expected output tree for 'svn ci'.  We should see changes
  # only on these three targets, no others.  
  output_list = [ [psi_path, None, {}, {'verb' : 'Sending' }],
                  [lambda_path, None, {}, {'verb' : 'Sending' }],
                  [pi_path, None, {}, {'verb' : 'Sending' }] ]
  expected_output_tree = svntest.tree.build_generic_tree(output_list)

  # Create expected status tree; all local revisions should be at 1,
  # but our three targets should be at 2.
  status_list = svntest.actions.get_virginal_status_list(wc_dir, '2')
  for item in status_list:
    if ((item[0] != psi_path) and (item[0] != lambda_path)
        and (item[0] != pi_path)):
      item[3]['wc_rev'] = '1'
    # rho and omega should still display as locally modified:
    if ((item[0] == rho_path) or (item[0] == omega_path)):
      item[3]['status'] = 'M '
    # A/D/G should still have a local property set, too.
    if (item[0] == ADG_path):
      item[3]['status'] = '_M'
  expected_status_tree = svntest.tree.build_generic_tree(status_list)

  return svntest.actions.run_and_verify_commit (wc_dir,
                                                expected_output_tree,
                                                expected_status_tree,
                                                None,
                                                None, None,
                                                None, None,
                                                psi_path, AB_path, pi_path)

#----------------------------------------------------------------------


def commit_multiple_targets_2(sbox):
  "commit multiple targets, 2nd variation"

  if sbox.build():
    return 1

  wc_dir = sbox.wc_dir

  # This test will commit three targets:  psi, B, omega and pi.  In that order.

  # Make local mods to many files.
  AB_path = os.path.join(wc_dir, 'A', 'B')
  lambda_path = os.path.join(wc_dir, 'A', 'B', 'lambda')
  rho_path = os.path.join(wc_dir, 'A', 'D', 'G', 'rho')
  pi_path = os.path.join(wc_dir, 'A', 'D', 'G', 'pi')
  omega_path = os.path.join(wc_dir, 'A', 'D', 'H', 'omega')
  psi_path = os.path.join(wc_dir, 'A', 'D', 'H', 'psi')
  svntest.main.file_append (lambda_path, 'new appended text for lambda')
  svntest.main.file_append (rho_path, 'new appended text for rho')
  svntest.main.file_append (pi_path, 'new appended text for pi')
  svntest.main.file_append (omega_path, 'new appended text for omega')
  svntest.main.file_append (psi_path, 'new appended text for psi')

  # Just for kicks, add a property to A/D/G as well.  We'll make sure
  # that it *doesn't* get committed.
  ADG_path = os.path.join(wc_dir, 'A', 'D', 'G')
  svntest.main.run_svn(None, 'propset', 'foo', 'bar', ADG_path)

  # Created expected output tree for 'svn ci'.  We should see changes
  # only on these three targets, no others.  
  output_list = [ [psi_path, None, {}, {'verb' : 'Sending' }],
                  [lambda_path, None, {}, {'verb' : 'Sending' }],
                  [omega_path, None, {}, {'verb' : 'Sending' }],
                  [pi_path, None, {}, {'verb' : 'Sending' }] ]
  expected_output_tree = svntest.tree.build_generic_tree(output_list)

  # Create expected status tree; all local revisions should be at 1,
  # but our four targets should be at 2.
  status_list = svntest.actions.get_virginal_status_list(wc_dir, '2')
  for item in status_list:
    if ((item[0] != psi_path) and (item[0] != lambda_path)
        and (item[0] != pi_path) and (item[0] != omega_path)):
      item[3]['wc_rev'] = '1'
    # rho should still display as locally modified:
    if (item[0] == rho_path):
      item[3]['status'] = 'M '
    # A/D/G should still have a local property set, too.
    if (item[0] == ADG_path):
      item[3]['status'] = '_M'
  expected_status_tree = svntest.tree.build_generic_tree(status_list)

  return svntest.actions.run_and_verify_commit (wc_dir,
                                                expected_output_tree,
                                                expected_status_tree,
                                                None,
                                                None, None,
                                                None, None,
                                                psi_path, AB_path,
                                                omega_path, pi_path)

#----------------------------------------------------------------------

def commit_inclusive_dir(sbox):
  "commit wc_dir/A/D -- includes D. (anchor=A, tgt=D)"

  if sbox.build():
    return 1

  wc_dir = sbox.wc_dir

  # Make standard slew of changes to working copy.
  if make_standard_slew_of_changes(wc_dir): return 1

  # Create expected output tree.
  D_path = os.path.join(wc_dir, 'A', 'D')
  pi_path = os.path.join(wc_dir, 'A', 'D', 'G', 'pi')
  rho_path = os.path.join(wc_dir, 'A', 'D', 'G', 'rho')
  gloo_path = os.path.join(wc_dir, 'A', 'D', 'H', 'gloo')
  chi_path = os.path.join(wc_dir, 'A', 'D', 'H', 'chi')
  omega_path = os.path.join(wc_dir, 'A', 'D', 'H', 'omega')
  gamma_path = os.path.join(wc_dir, 'A', 'D', 'gamma')
  
  output_list = [ [D_path, None, {}, {'verb' : 'Sending' }],
                  [pi_path, None, {}, {'verb' : 'Sending'}],
                  [rho_path, None, {}, {'verb' : 'Deleting'}],
                  [gloo_path, None, {}, {'verb' : 'Adding'}],
                  [chi_path, None, {}, {'verb' : 'Replacing'}],
                  [omega_path, None, {}, {'verb' : 'Sending'}],
                  [gamma_path, None, {}, {'verb' : 'Deleting'}] ]
                  
  expected_output_tree = svntest.tree.build_generic_tree(output_list)

  # Created expected status tree.
  status_list = get_standard_status_list(wc_dir) # pre-commit status
  status_list.pop(path_index(status_list, rho_path))
  status_list.pop(path_index(status_list, gamma_path))
  for item in status_list:
    item[3]['repos_rev'] = '2'     # post-commit status
    if (item[0] == D_path) or (item[0] == pi_path) or (item[0] == omega_path):
      item[3]['wc_rev'] = '2'
      item[3]['status'] = '__'
    if (item[0] == chi_path) or (item[0] == gloo_path):
      item[3]['wc_rev'] = '2'
      item[3]['status'] = '_ '
      
  expected_status_tree = svntest.tree.build_generic_tree(status_list)

  # Commit the one file.
  return svntest.actions.run_and_verify_commit (wc_dir,
                                                expected_output_tree,
                                                expected_status_tree,
                                                None,
                                                None, None,
                                                None, None,
                                                D_path)

#----------------------------------------------------------------------

def commit_top_dir(sbox):
  "commit wc_dir -- (anchor=wc_dir, tgt={})"

  if sbox.build():
    return 1

  wc_dir = sbox.wc_dir

  # Make standard slew of changes to working copy.
  if make_standard_slew_of_changes(wc_dir): return 1

  # Create expected output tree.
  top_path = wc_dir
  Q_path = os.path.join(wc_dir, 'Q')
  floo_path = os.path.join(wc_dir, 'Q', 'floo')
  E_path = os.path.join(wc_dir, 'A', 'B', 'E')
  bloo_path = os.path.join(wc_dir, 'A', 'B', 'E', 'bloo')
  lambda_path = os.path.join(wc_dir, 'A', 'B', 'lambda')
  C_path = os.path.join(wc_dir, 'A', 'C')
  D_path = os.path.join(wc_dir, 'A', 'D')
  pi_path = os.path.join(wc_dir, 'A', 'D', 'G', 'pi')
  rho_path = os.path.join(wc_dir, 'A', 'D', 'G', 'rho')
  gloo_path = os.path.join(wc_dir, 'A', 'D', 'H', 'gloo')
  chi_path = os.path.join(wc_dir, 'A', 'D', 'H', 'chi')
  omega_path = os.path.join(wc_dir, 'A', 'D', 'H', 'omega')
  gamma_path = os.path.join(wc_dir, 'A', 'D', 'gamma')
  
  output_list = [ [top_path, None, {}, {'verb' : 'Sending'}],
                  [Q_path, None, {}, {'verb' : 'Adding'}],
                  [floo_path, None, {}, {'verb' : 'Adding'}],
                  [E_path, None, {}, {'verb' : 'Replacing'}],
                  [bloo_path, None, {}, {'verb' : 'Adding'}],
                  [lambda_path, None, {}, {'verb' : 'Sending'}],
                  [C_path, None, {}, {'verb' : 'Deleting'}],                  
                  [D_path, None, {}, {'verb' : 'Sending' }],
                  [pi_path, None, {}, {'verb' : 'Sending'}],
                  [rho_path, None, {}, {'verb' : 'Deleting'}],
                  [gloo_path, None, {}, {'verb' : 'Adding'}],
                  [chi_path, None, {}, {'verb' : 'Replacing'}],
                  [omega_path, None, {}, {'verb' : 'Sending'}],
                  [gamma_path, None, {}, {'verb' : 'Deleting'}] ]
                  
  expected_output_tree = svntest.tree.build_generic_tree(output_list)

  # Created expected status tree.
  status_list = get_standard_status_list(wc_dir) # pre-commit status
  status_list.pop(path_index(status_list, rho_path))
  status_list.pop(path_index(status_list, gamma_path))
  status_list.pop(path_index(status_list, C_path))
  status_list.pop(path_index(status_list,
                             os.path.join(wc_dir,'A','B','E','alpha')))
  status_list.pop(path_index(status_list,
                             os.path.join(wc_dir,'A','B','E','beta')))
  for item in status_list:    
    item[3]['repos_rev'] = '2'     # post-commit status
    if ((item[0] == D_path)
        or (item[0] == pi_path)
        or (item[0] == omega_path)
        or (item[0] == floo_path)
        or (item[0] == top_path)):
      item[3]['wc_rev'] = '2'
      item[3]['status'] = '__'
    if ((item[0] == chi_path)
        or (item[0] == Q_path)
        or (item[0] == E_path)
        or (item[0] == bloo_path)
        or (item[0] == lambda_path)
        or (item[0] == gloo_path)):
      item[3]['wc_rev'] = '2'
      item[3]['status'] = '_ '
      
  expected_status_tree = svntest.tree.build_generic_tree(status_list)

  # Commit the one file.
  return svntest.actions.run_and_verify_commit (wc_dir,
                                                expected_output_tree,
                                                expected_status_tree,
                                                None,
                                                None, None,
                                                None, None,
                                                wc_dir)

#----------------------------------------------------------------------

# Regression test for bug reported by Jon Trowbridge:
# 
#    From: Jon Trowbridge <trow@ximian.com>
#    Subject:  svn segfaults if you commit a file that hasn't been added
#    To: dev@subversion.tigris.org
#    Date: 17 Jul 2001 03:20:55 -0500
#    Message-Id: <995358055.16975.5.camel@morimoto>
#   
#    The problem is that report_single_mod in libsvn_wc/adm_crawler.c is
#    called with its entry parameter as NULL, but the code doesn't
#    check that entry is non-NULL before trying to dereference it.
#
# This bug never had an issue number.
#
def commit_unversioned_thing(sbox):
  "committing unversioned object produces error"

  if sbox.build():
    return 1

  wc_dir = sbox.wc_dir

  # Create an unversioned file in the wc.
  svntest.main.file_append(os.path.join(wc_dir, 'blorg'), "nothing to see")

  # Commit a non-existent file and *expect* failure:
  return svntest.actions.run_and_verify_commit (wc_dir,
                                                None,
                                                None,
                                                "Can't find an entry",
                                                None, None,
                                                None, None,
                                                os.path.join(wc_dir,'blorg'))

#----------------------------------------------------------------------

# regression test for bug #391

def nested_dir_replacements(sbox):
  "replace two nested dirs, verify empty contents"

  if sbox.build():
    return 1

  wc_dir = sbox.wc_dir

  # Delete and re-add A/D (a replacement), and A/D/H (another replace).
  svntest.main.run_svn(None, 'rm', os.path.join(wc_dir, 'A', 'D'))
  svntest.main.run_svn(None, 'add', os.path.join(wc_dir, 'A', 'D'))
  svntest.main.run_svn(None, 'add', os.path.join(wc_dir, 'A', 'D', 'H'))
                       
  # For kicks, add new file A/D/bloo.
  svntest.main.file_append(os.path.join(wc_dir, 'A', 'D', 'bloo'), "hi")
  svntest.main.run_svn(None, 'add', os.path.join(wc_dir, 'A', 'D', 'bloo'))
  
  # Verify pre-commit status:
  #    - A/D and A/D/H should both be scheduled as "R" at rev 0
  #    - A/D/bloo scheduled as "A" at rev 0
  #    - ALL other children of A/D scheduled as "D" at rev 1

  sl = svntest.actions.get_virginal_status_list(wc_dir, '1')

  sl[path_index(sl, os.path.join(wc_dir, 'A', 'D'))][3]['status'] = "R "
  sl[path_index(sl, os.path.join(wc_dir, 'A', 'D'))][3]['wc_rev'] = "0"  
  sl[path_index(sl, os.path.join(wc_dir, 'A', 'D', 'H'))][3]['status'] = "R "
  sl[path_index(sl, os.path.join(wc_dir, 'A', 'D', 'H'))][3]['wc_rev'] = "0"  
  sl.append([os.path.join(wc_dir, 'A', 'D', 'bloo'), None, {},
             {'status' : 'A ',
              'wc_rev' : '0',
              'repos_rev' : '1'}])

  sl[path_index(sl, os.path.join(wc_dir, 'A', 'D', 'G'))][3]['status'] = "D "
  sl[path_index(sl, os.path.join(wc_dir, 'A', 'D', 'G', 'pi'))][3]['status'] = "D "
  sl[path_index(sl, os.path.join(wc_dir, 'A', 'D', 'G', 'rho'))][3]['status'] = "D "
  sl[path_index(sl, os.path.join(wc_dir, 'A', 'D', 'G', 'tau'))][3]['status'] = "D "
  sl[path_index(sl, os.path.join(wc_dir, 'A', 'D', 'H', 'chi'))][3]['status'] = "D "
  sl[path_index(sl, os.path.join(wc_dir, 'A', 'D', 'H', 'omega'))][3]['status'] = "D "
  sl[path_index(sl, os.path.join(wc_dir, 'A', 'D', 'H', 'psi'))][3]['status'] = "D "
  sl[path_index(sl, os.path.join(wc_dir, 'A', 'D', 'gamma'))][3]['status'] = "D "
  expected_status_tree = svntest.tree.build_generic_tree(sl)
  if svntest.actions.run_and_verify_status(wc_dir, expected_status_tree):
    return 1

  # Build expected post-commit trees:

  # Create expected output tree.
  output_list = [ [os.path.join(wc_dir, 'A', 'D'),
                   None, {}, {'verb' : 'Replacing' }],
                  [os.path.join(wc_dir, 'A', 'D', 'H'),
                   None, {}, {'verb' : 'Adding' }],
                  [os.path.join(wc_dir, 'A', 'D', 'bloo'),
                   None, {}, {'verb' : 'Adding' }] ]
  expected_output_tree = svntest.tree.build_generic_tree(output_list)

  # Created expected status tree.
  sl = svntest.actions.get_virginal_status_list(wc_dir, '2')
  for item in sl:
    item[3]['wc_rev'] = '1'
  
  sl[path_index(sl, os.path.join(wc_dir, 'A', 'D'))][3]['wc_rev'] = "2"  
  sl[path_index(sl, os.path.join(wc_dir, 'A', 'D', 'H'))][3]['wc_rev'] = "2"  
  sl.append([os.path.join(wc_dir, 'A', 'D', 'bloo'), None, {},
             {'status' : '_ ',
              'wc_rev' : '2',
              'repos_rev' : '2'}])

  sl.pop(path_index(sl, os.path.join(wc_dir, 'A', 'D', 'G')))
  sl.pop(path_index(sl, os.path.join(wc_dir, 'A', 'D', 'G', 'pi')))
  sl.pop(path_index(sl, os.path.join(wc_dir, 'A', 'D', 'G', 'rho')))
  sl.pop(path_index(sl, os.path.join(wc_dir, 'A', 'D', 'G', 'tau')))
  sl.pop(path_index(sl, os.path.join(wc_dir, 'A', 'D', 'H', 'chi')))
  sl.pop(path_index(sl, os.path.join(wc_dir, 'A', 'D', 'H', 'omega')))
  sl.pop(path_index(sl, os.path.join(wc_dir, 'A', 'D', 'H', 'psi')))
  sl.pop(path_index(sl, os.path.join(wc_dir, 'A', 'D', 'gamma')))
    
  expected_status_tree = svntest.tree.build_generic_tree(sl)

  # Commit from the top of the working copy and verify output & status.
  return svntest.actions.run_and_verify_commit (wc_dir,
                                                expected_output_tree,
                                                expected_status_tree,
                                                None,
                                                None, None,
                                                None, None,
                                                wc_dir)

#----------------------------------------------------------------------

# Testing part 1 of the "Greg Hudson" problem -- specifically, that
# our use of the "existence=deleted" flag is working properly in cases
# where the parent directory's revision lags behind a deleted child's
# revision.

def hudson_part_1(sbox):
  "hudson prob 1.0:  delete file, commit, update"

  if sbox.build():
    return 1

  wc_dir = sbox.wc_dir

  # Remove gamma from the working copy.
  gamma_path = os.path.join(wc_dir, 'A', 'D', 'gamma') 
  svntest.main.run_svn(None, 'rm', gamma_path)

  # Create expected commit output.
  output_list = [ [gamma_path, None, {}, {'verb' : 'Deleting' }] ]
  expected_output_tree = svntest.tree.build_generic_tree(output_list)
  
  # After committing, status should show no sign of gamma.
  status_list = svntest.actions.get_virginal_status_list(wc_dir, '2')
  for item in status_list:
    item[3]['wc_rev'] = '1'
  status_list.pop(path_index(status_list, gamma_path))
  expected_status_tree = svntest.tree.build_generic_tree(status_list)
  
  # Commit the deletion of gamma and verify.
  if svntest.actions.run_and_verify_commit (wc_dir,
                                            expected_output_tree,
                                            expected_status_tree,
                                            None, None, None, None, None,
                                            wc_dir):
    return 1

  # Now gamma should be marked as `deleted' under the hood.  When we
  # update, we should see a no-op removal of gamma, and a perfect,
  # virginal status list at revision 2.  (The `deleted' entry should
  # be removed.)
  
  # Expected output of update:  nothing.
  expected_output_tree = svntest.tree.build_generic_tree(\
    [ [gamma_path, None, {}, {'status' : 'D ' }] ])

  # Expected disk tree:  everything.
  my_greek_tree = svntest.main.copy_greek_tree()
  expected_disk_tree = svntest.tree.build_generic_tree(my_greek_tree)
  
  # Expected status after update:  totally clean revision 2, minus gamma.
  status_list = svntest.actions.get_virginal_status_list(wc_dir, '2')
  status_list.pop(path_index(status_list, gamma_path))  
  expected_status_tree = svntest.tree.build_generic_tree(status_list)

  return svntest.actions.run_and_verify_update(wc_dir,
                                               expected_output_tree,
                                               expected_disk_tree,
                                               expected_status_tree,
                                               None, None, None, None,
                                               0)

#----------------------------------------------------------------------

# Testing part 1 of the "Greg Hudson" problem -- variation on previous
# test, removing a directory instead of a file this time.

def hudson_part_1_variation_1(sbox):
  "hudson prob 1.1:  delete dir, commit, update"

  if sbox.build():
    return 1

  wc_dir = sbox.wc_dir

  # Remove H from the working copy.
  H_path = os.path.join(wc_dir, 'A', 'D', 'H') 
  svntest.main.run_svn(None, 'rm', H_path)

  # Create expected commit output.
  output_list = [ [H_path, None, {}, {'verb' : 'Deleting' }] ]
  expected_output_tree = svntest.tree.build_generic_tree(output_list)
  
  # After committing, status should show no sign of H or its contents
  status_list = svntest.actions.get_virginal_status_list(wc_dir, '2')
  for item in status_list:
    item[3]['wc_rev'] = '1'
  status_list.pop(path_index(status_list, H_path))
  status_list.pop(path_index(status_list, os.path.join(H_path, 'chi')))
  status_list.pop(path_index(status_list, os.path.join(H_path, 'omega')))
  status_list.pop(path_index(status_list, os.path.join(H_path, 'psi')))
  expected_status_tree = svntest.tree.build_generic_tree(status_list)
  
  # Commit the deletion of H and verify.
  if svntest.actions.run_and_verify_commit (wc_dir,
                                            expected_output_tree,
                                            expected_status_tree,
                                            None, None, None, None, None,
                                            wc_dir):
    return 1

  # Now H should be marked as `deleted' under the hood.  When we
  # update, we should see a no-op removal of H, and a perfect, virginal
  # status list at revision 2.  (The `deleted' entry should be removed.)
  
  # Expected output of update:  H gets a no-op deletion.
  expected_output_tree = svntest.tree.build_generic_tree(\
    [ [H_path, None, {}, {'status' : 'D ' }] ])

  # Expected disk tree:  everything.
  my_greek_tree = svntest.main.copy_greek_tree()
  expected_disk_tree = svntest.tree.build_generic_tree(my_greek_tree)

  # Expected status after update:  totally clean revision 2, minus H.
  status_list = svntest.actions.get_virginal_status_list(wc_dir, '2')
  status_list.pop(path_index(status_list, H_path))
  status_list.pop(path_index(status_list, os.path.join(H_path, 'chi')))
  status_list.pop(path_index(status_list, os.path.join(H_path, 'omega')))
  status_list.pop(path_index(status_list, os.path.join(H_path, 'psi')))
  expected_status_tree = svntest.tree.build_generic_tree(status_list)

  return svntest.actions.run_and_verify_update(wc_dir,
                                               expected_output_tree,
                                               expected_disk_tree,
                                               expected_status_tree,
                                               None, None, None, None,
                                               0)

#----------------------------------------------------------------------

# Testing part 1 of the "Greg Hudson" problem -- variation 2.  In this
# test, we make sure that a file that is BOTH `deleted' and scheduled
# for addition can be correctly committed & merged.

def hudson_part_1_variation_2(sbox):
  "hudson prob 1.2:  delete, commit, re-add, commit"

  if sbox.build():
    return 1

  wc_dir = sbox.wc_dir

  # Remove gamma from the working copy.
  gamma_path = os.path.join(wc_dir, 'A', 'D', 'gamma') 
  svntest.main.run_svn(None, 'rm', gamma_path)

  # Create expected commit output.
  output_list = [ [gamma_path, None, {}, {'verb' : 'Deleting' }] ]
  expected_output_tree = svntest.tree.build_generic_tree(output_list)
  
  # After committing, status should show no sign of gamma.
  status_list = svntest.actions.get_virginal_status_list(wc_dir, '2')
  for item in status_list:
    item[3]['wc_rev'] = '1'
  status_list.pop(path_index(status_list, gamma_path))
  expected_status_tree = svntest.tree.build_generic_tree(status_list)
  
  # Commit the deletion of gamma and verify.
  if svntest.actions.run_and_verify_commit (wc_dir,
                                            expected_output_tree,
                                            expected_status_tree,
                                            None, None, None, None, None,
                                            wc_dir):
    return 1

  # Now gamma should be marked as `deleted' under the hood.
  # Go ahead and re-add gamma, so that is *also* scheduled for addition.
  svntest.main.run_svn(None, 'add', gamma_path)

  # For sanity, examine status: it should show a revision 2 tree with
  # gamma scheduled for addition.
  status_list = svntest.actions.get_virginal_status_list(wc_dir, '2')
  for item in status_list:
    item[3]['wc_rev'] = '1'
    if item[0] == gamma_path:
      item[3]['wc_rev'] = '0'
      item[3]['status'] = 'A '
  expected_status_tree = svntest.tree.build_generic_tree(status_list)

  if svntest.actions.run_and_verify_status (wc_dir, expected_status_tree):
    return 1

  # Create expected commit output.
  output_list = [ [gamma_path, None, {}, {'verb' : 'Adding' }] ]
  expected_output_tree = svntest.tree.build_generic_tree(output_list)
  
  # After committing, status should show only gamma at revision 2.
  status_list = svntest.actions.get_virginal_status_list(wc_dir, '3')
  for item in status_list:
    if item[0] != gamma_path:
      item[3]['wc_rev'] = '1'
  expected_status_tree = svntest.tree.build_generic_tree(status_list)

  return svntest.actions.run_and_verify_commit (wc_dir,
                                                expected_output_tree,
                                                expected_status_tree,
                                                None, None, None, None, None,
                                                wc_dir)


#----------------------------------------------------------------------

# Testing part 2 of the "Greg Hudson" problem.
#
# In this test, we make sure that we're UNABLE to commit a propchange
# on an out-of-date directory.

def hudson_part_2(sbox):
  "hudson prob 2.0:  prop commit on old dir fails."

  if sbox.build():
    return 1

  wc_dir = sbox.wc_dir

  # Remove gamma from the working copy.
  D_path = os.path.join(wc_dir, 'A', 'D')
  gamma_path = os.path.join(wc_dir, 'A', 'D', 'gamma') 
  svntest.main.run_svn(None, 'rm', gamma_path)

  # Create expected commit output.
  output_list = [ [gamma_path, None, {}, {'verb' : 'Deleting' }] ]
  expected_output_tree = svntest.tree.build_generic_tree(output_list)
  
  # After committing, status should show no sign of gamma.
  status_list = svntest.actions.get_virginal_status_list(wc_dir, '2')
  for item in status_list:
    item[3]['wc_rev'] = '1'
  status_list.pop(path_index(status_list, gamma_path))
  expected_status_tree = svntest.tree.build_generic_tree(status_list)
  
  # Commit the deletion of gamma and verify.
  if svntest.actions.run_and_verify_commit (wc_dir,
                                            expected_output_tree,
                                            expected_status_tree,
                                            None, None, None, None, None,
                                            wc_dir):
    return 1

  # Now gamma should be marked as `deleted' under the hood, at
  # revision 2.  Meanwhile, A/D is still lagging at revision 1.

  # Make a propchange on A/D
  svntest.main.run_svn(None, 'ps', 'foo', 'bar', D_path)

  # Commit and *expect* a repository Merge failure:
  return svntest.actions.run_and_verify_commit (wc_dir,
                                                None,
                                                None,
                                                "not up-to-date",
                                                None, None,
                                                None, None,
                                                wc_dir)


#----------------------------------------------------------------------

def hook_test(sbox):
  "hook testing."

  if sbox.build():
    return 1

  # Get paths to the working copy and repository
  wc_dir = sbox.wc_dir
  repo_dir = sbox.repo_dir

  # Setup the hook configs to echo data back
  start_commit_hook = svntest.main.get_start_commit_hook_path (repo_dir)
  svntest.main.file_append (start_commit_hook,
                            """#!/bin/sh
                            echo $1""")
  os.chmod (start_commit_hook, 0755)

  pre_commit_hook = svntest.main.get_pre_commit_hook_path (repo_dir)
  svntest.main.file_append (pre_commit_hook,
                            """#!/bin/sh
                            echo $1 $2 """)
  os.chmod (pre_commit_hook, 0755)

  post_commit_hook = svntest.main.get_post_commit_hook_path (repo_dir)
  svntest.main.file_append (post_commit_hook,
                            """#!/bin/sh
                            echo $1 $2 """)
  os.chmod (post_commit_hook, 0755)

  # Modify iota just so there is something to commit.
  iota_path = os.path.join (wc_dir, "iota")
  svntest.main.file_append (iota_path, "More stuff in iota")

  # Now, commit and examine the output (we happen to know that the
  # filesystem will report an absolute path because that's the way the
  # filesystem is created by this test suite.
  abs_repo_dir = os.path.abspath (repo_dir)
  expected_output = (abs_repo_dir + "\n",
                     abs_repo_dir + " 1\n",
                     abs_repo_dir + " 2\n")
  output, errput = svntest.main.run_svn ('ci', '--quiet', wc_dir)

  # Make sure we got the right output.
  if len (expected_output) != len (output): return 1
  for index in range (len (output)):
    if output[index] != expected_output[index]: return 1
    
  return 0


#----------------------------------------------------------------------

# Regression test for bug #469, whereby merge() was once reporting
# erroneous conflicts due to Ancestor < Target < Source, in terms of
# node-rev-id parentage.

def merge_mixed_revisions(sbox):
  "commit mixed-rev wc (no erronous merge error)"

  if sbox.build():
    return 1

  wc_dir = sbox.wc_dir

  # Make some convenient paths.
  iota_path = os.path.join(wc_dir, 'iota')
  H_path = os.path.join(wc_dir, 'A', 'D', 'H')
  chi_path = os.path.join(wc_dir, 'A', 'D', 'H', 'chi')
  omega_path = os.path.join(wc_dir, 'A', 'D', 'H', 'omega')
  psi_path = os.path.join(wc_dir, 'A', 'D', 'H', 'psi')

  # Here's the reproduction formula, in 5 parts.
  # Hoo, what a buildup of state!
  
  # 1. echo "moo" >> iota; echo "moo" >> A/D/H/chi; svn ci
  svntest.main.file_append(iota_path, "moo")
  svntest.main.file_append(chi_path, "moo")
  output_list = [ [iota_path, None, {}, {'verb' : 'Sending' }],
                  [chi_path, None, {}, {'verb' : 'Sending' }] ]
  expected_output_tree = svntest.tree.build_generic_tree(output_list)
  status_list = svntest.actions.get_virginal_status_list(wc_dir, '2')
  for item in status_list:
    if not ((item[0] == iota_path) or (item[0] == chi_path)):
      item[3]['wc_rev'] = '1'
  expected_status_tree = svntest.tree.build_generic_tree(status_list)
  if svntest.actions.run_and_verify_commit (wc_dir,
                                            expected_output_tree,
                                            expected_status_tree,
                                            None, None, None, None, None,
                                            wc_dir):
    return 1


  # 2. svn up A/D/H
  status_list = []
  status_list.append([H_path, None, {},
                      {'status' : '_ ',
                       'wc_rev' : '2', 'repos_rev' : '2'}])
  status_list.append([chi_path, None, {},
                      {'status' : '_ ', 
                       'wc_rev' : '2', 'repos_rev' : '2'}])
  status_list.append([omega_path, None, {},
                      {'status' : '_ ', 
                       'wc_rev' : '2', 'repos_rev' : '2'}])
  status_list.append([psi_path, None, {},
                      {'status' : '_ ', 
                       'wc_rev' : '2', 'repos_rev' : '2'}])
  expected_status_tree = svntest.tree.build_generic_tree(status_list)
  my_greek_tree = [['omega', "This is the file 'omega'.", {}, {}],
                   ['chi', "This is the file 'chi'.moo", {}, {}],
                   ['psi', "This is the file 'psi'.", {}, {}]]
  expected_disk_tree = svntest.tree.build_generic_tree(my_greek_tree)
  expected_output_tree = svntest.tree.build_generic_tree([])
  if svntest.actions.run_and_verify_update (H_path,
                                            expected_output_tree,
                                            expected_disk_tree,
                                            expected_status_tree,
                                            None, None, None, None,
                                            0):
    return 1


  # 3. echo "moo" >> iota; svn ci iota
  svntest.main.file_append(iota_path, "moo2")
  output_list = [[iota_path, None, {}, {'verb' : 'Sending' }]]
  expected_output_tree = svntest.tree.build_generic_tree(output_list)
  status_list = svntest.actions.get_virginal_status_list(wc_dir, '3')
  for item in status_list:
    if not (item[0] == iota_path):
      item[3]['wc_rev'] = '1'
    if ((item[0] == H_path) or (item[0] == omega_path)
        or (item[0] == chi_path) or (item[0] == psi_path)):
      item[3]['wc_rev'] = '2'    
  expected_status_tree = svntest.tree.build_generic_tree(status_list)
  if svntest.actions.run_and_verify_commit (wc_dir,
                                            expected_output_tree,
                                            expected_status_tree,
                                            None, None, None, None, None,
                                            wc_dir):
    return 1


  # 4. echo "moo" >> A/D/H/chi; svn ci A/D/H/chi
  svntest.main.file_append(chi_path, "moo3")
  output_list = [[chi_path, None, {}, {'verb' : 'Sending' }]]
  expected_output_tree = svntest.tree.build_generic_tree(output_list)
  status_list = svntest.actions.get_virginal_status_list(wc_dir, '4')
  for item in status_list:
    if not (item[0] == chi_path):
      item[3]['wc_rev'] = '1'
    if ((item[0] == H_path) or (item[0] == omega_path)
        or (item[0] == psi_path)):
      item[3]['wc_rev'] = '2'
    if item[0] == iota_path:
      item[3]['wc_rev'] = '3'
  expected_status_tree = svntest.tree.build_generic_tree(status_list)
  if svntest.actions.run_and_verify_commit (wc_dir,
                                            expected_output_tree,
                                            expected_status_tree,
                                            None, None, None, None, None,
                                            wc_dir):
    return 1

  # 5. echo "moo" >> iota; svn ci iota
  svntest.main.file_append(iota_path, "moomoo")
  output_list = [[iota_path, None, {}, {'verb' : 'Sending' }]]
  expected_output_tree = svntest.tree.build_generic_tree(output_list)
  status_list = svntest.actions.get_virginal_status_list(wc_dir, '5')
  for item in status_list:
    if not (item[0] == iota_path):
      item[3]['wc_rev'] = '1'
    if ((item[0] == H_path) or (item[0] == omega_path)
        or (item[0] == psi_path)):
      item[3]['wc_rev'] = '2'
    if item[0] == chi_path:
      item[3]['wc_rev'] = '4'
  expected_status_tree = svntest.tree.build_generic_tree(status_list)
  if svntest.actions.run_and_verify_commit (wc_dir,
                                            expected_output_tree,
                                            expected_status_tree,
                                            None, None, None, None, None,
                                            wc_dir):
    return 1

  # At this point, here is what our tree should look like:
  # _    1       (     5)  working_copies/commit_tests-10
  # _    1       (     5)  working_copies/commit_tests-10/A
  # _    1       (     5)  working_copies/commit_tests-10/A/B
  # _    1       (     5)  working_copies/commit_tests-10/A/B/E
  # _    1       (     5)  working_copies/commit_tests-10/A/B/E/alpha
  # _    1       (     5)  working_copies/commit_tests-10/A/B/E/beta
  # _    1       (     5)  working_copies/commit_tests-10/A/B/F
  # _    1       (     5)  working_copies/commit_tests-10/A/B/lambda
  # _    1       (     5)  working_copies/commit_tests-10/A/C
  # _    1       (     5)  working_copies/commit_tests-10/A/D
  # _    1       (     5)  working_copies/commit_tests-10/A/D/G
  # _    1       (     5)  working_copies/commit_tests-10/A/D/G/pi
  # _    1       (     5)  working_copies/commit_tests-10/A/D/G/rho
  # _    1       (     5)  working_copies/commit_tests-10/A/D/G/tau
  # _    2       (     5)  working_copies/commit_tests-10/A/D/H
  # _    4       (     5)  working_copies/commit_tests-10/A/D/H/chi
  # _    2       (     5)  working_copies/commit_tests-10/A/D/H/omega
  # _    2       (     5)  working_copies/commit_tests-10/A/D/H/psi
  # _    1       (     5)  working_copies/commit_tests-10/A/D/gamma
  # _    1       (     5)  working_copies/commit_tests-10/A/mu
  # _    5       (     5)  working_copies/commit_tests-10/iota

  # At this point, we're ready to modify omega and iota, and commit
  # from the top.  We should *not* get a conflict!

  svntest.main.file_append(iota_path, "finalmoo")
  svntest.main.file_append(omega_path, "finalmoo")
  output_list = [ [iota_path, None, {}, {'verb' : 'Sending' }],
                  [omega_path, None, {}, {'verb' : 'Sending' }] ]
  expected_output_tree = svntest.tree.build_generic_tree(output_list)
  status_list = svntest.actions.get_virginal_status_list(wc_dir, '6')
  for item in status_list:
    if not ((item[0] == iota_path) or (item[0] == omega_path)):
      item[3]['wc_rev'] = '1'
    if ((item[0] == H_path) or (item[0] == psi_path)):
      item[3]['wc_rev'] = '2'
    if item[0] == chi_path:
      item[3]['wc_rev'] = '4'
  expected_status_tree = svntest.tree.build_generic_tree(status_list)
  return svntest.actions.run_and_verify_commit (wc_dir,
                                                expected_output_tree,
                                                expected_status_tree,
                                                None, None, None, None, None,
                                                wc_dir)

#----------------------------------------------------------------------

def commit_uri_unsafe(sbox):
  "commit files and dirs with URI-unsafe characters"

  if sbox.build():
    return 1

  wc_dir = sbox.wc_dir

  # Make some convenient paths.
  hash_dir = os.path.join(wc_dir, '#hash#')
  nasty_dir = os.path.join(wc_dir, '#![]{}()<>%')
  space_path = os.path.join(wc_dir, 'A', 'D', 'space path')
  bang_path = os.path.join(wc_dir, 'A', 'D', 'H', 'bang!')
  bracket_path = os.path.join(wc_dir, 'A', 'D', 'H', 'bra[ket')
  brace_path = os.path.join(wc_dir, 'A', 'D', 'H', 'bra{e')
  angle_path = os.path.join(wc_dir, 'A', 'D', 'H', '<angle>')
  paren_path = os.path.join(wc_dir, 'A', 'D', 'pare)(theses')
  percent_path = os.path.join(wc_dir, '#hash#', 'percen%')
  nasty_path = os.path.join(wc_dir, 'A', '#![]{}()<>%')

  os.mkdir(hash_dir)
  os.mkdir(nasty_dir)
  svntest.main.file_append(space_path, "This path has a space in it.")
  svntest.main.file_append(bang_path, "This path has a bang in it.")
  svntest.main.file_append(bracket_path, "This path has a bracket in it.")
  svntest.main.file_append(brace_path, "This path has a brace in it.")
  svntest.main.file_append(angle_path, "This path has angle brackets in it.")
  svntest.main.file_append(paren_path, "This path has parentheses in it.")
  svntest.main.file_append(percent_path, "This path has a percent in it.")
  svntest.main.file_append(nasty_path, "This path has all sorts of ick in it.")

  output_list = []
  add_list = [hash_dir,
              nasty_dir, # not xml-safe
              space_path,
              bang_path,
              bracket_path,
              brace_path,
              angle_path, # not xml-safe
              paren_path,
              percent_path,
              nasty_path, # not xml-safe
              ]
  for item in add_list:
    svntest.main.run_svn(None, 'add', item)
    item_list = [item, None, {}, {'verb' : 'Adding'}]
    output_list.append(item_list)
  expected_output_tree = svntest.tree.build_generic_tree(output_list)

  status_list = svntest.actions.get_virginal_status_list(wc_dir, '2')
  
  # Items in the status list are all at rev 1
  for item in status_list:
    item[3]['wc_rev'] = '1'

  # Items in our add list will be at rev 2
  for item in add_list:
    item_list = [item, None, {}, {'wc_rev': '2', 'repos_rev': '2',
                                  'status': '_ '}]
    status_list.append(item_list)

  expected_status_tree = svntest.tree.build_generic_tree(status_list)
  return svntest.actions.run_and_verify_commit (wc_dir,
                                                expected_output_tree,
                                                expected_status_tree,
                                                None, None, None, None, None,
                                                wc_dir)


#----------------------------------------------------------------------

def commit_deleted_edited(sbox):
  "commit files that have been deleted, but also edited"

  if sbox.build():
    return 1

  wc_dir = sbox.wc_dir

  # Make some convenient paths.
  iota_path = os.path.join(wc_dir, 'iota')
  mu_path = os.path.join(wc_dir, 'A', 'mu')

  # Edit the files.
  svntest.main.file_append(iota_path, "This file has been edited.")
  svntest.main.file_append(mu_path, "This file has been edited.")

  # Schedule the files for removal.
  svntest.main.run_svn(None, 'remove', iota_path)
  svntest.main.run_svn(None, 'remove', mu_path)

  # Make our output list
  output_list = [(iota_path, None, {}, {'verb' : 'Deleting'}),
                 (mu_path, None, {}, {'verb' : 'Deleting'})]
  expected_output_tree = svntest.tree.build_generic_tree(output_list)

  # Items in the status list are all at rev 1, except the two things
  # we changed...but then, they don't exist at all.
  status_list = svntest.actions.get_virginal_status_list(wc_dir, '2')
  status_list.pop(path_index(status_list, iota_path))
  status_list.pop(path_index(status_list, mu_path))
  for item in status_list:
    item[3]['wc_rev'] = '1'
  expected_status_tree = svntest.tree.build_generic_tree(status_list)
  return svntest.actions.run_and_verify_commit (wc_dir,
                                                expected_output_tree,
                                                expected_status_tree,
                                                None, None, None, None, None,
                                                wc_dir)
  
#----------------------------------------------------------------------

def commit_in_dir_scheduled_for_addition(sbox):
  "commit a file inside dir scheduled for addition"

  if sbox.build():
    return 1

  wc_dir = sbox.wc_dir

  A_path = os.path.join(wc_dir, 'A')
  Z_path = os.path.join(wc_dir, 'Z')
  mu_path = os.path.join(wc_dir, 'Z', 'mu')

  svntest.main.run_svn(None, 'move', A_path, Z_path)

  # Commit a copied thing inside an added-with-history directory,
  # expecting a specific error to occur!
  if svntest.actions.run_and_verify_commit (wc_dir,
                                            None,
                                            None,
                                            "unversioned",
                                            None, None,
                                            None, None,
                                            mu_path):
    return 1
  
  Q_path = os.path.join(wc_dir, 'Q')
  bloo_path = os.path.join(Q_path, 'bloo')

  os.mkdir(Q_path)
  svntest.main.file_append(bloo_path, "New contents.")
  svntest.main.run_svn(None, 'add', '--recursive', Q_path)
  
  # Commit a regular added thing inside an added directory,
  # expecting a specific error to occur!
  return svntest.actions.run_and_verify_commit (wc_dir,
                                                None,
                                                None,
                                                "unversioned",
                                                None, None,
                                                None, None,
                                                bloo_path)
  
#----------------------------------------------------------------------

def commit_rmd_and_deleted_file(sbox):
  "commit deleted (and missing) file"

  if sbox.build():
    return 1

  wc_dir = sbox.wc_dir
  mu_path = os.path.join(wc_dir, 'A', 'mu')

  # 'svn remove' mu
  svntest.main.run_svn(None, 'rm', mu_path)

  # Now, physically remove mu from disk
  os.unlink(mu_path)

  # Commit, hoping to see no errors
  out, err = svntest.main.run_svn(None, 'commit', '-m', '"logmsg"', mu_path)
  if len(err) != 0:
    return 1

  return 0

########################################################################
# Run the tests


# list all tests here, starting with None:
test_list = [ None,
              commit_one_file,
              commit_one_new_file,
              commit_multiple_targets,
              commit_multiple_targets_2,
              commit_inclusive_dir,
              commit_top_dir,
              commit_unversioned_thing,
              nested_dir_replacements,
              hudson_part_1,
              hudson_part_1_variation_1,
              hudson_part_1_variation_2,
              hudson_part_2,
              ## ### todo: comment this back in when it's working
              ## hook_test,
              merge_mixed_revisions,
              commit_uri_unsafe,
              commit_deleted_edited,
              commit_in_dir_scheduled_for_addition,
              commit_rmd_and_deleted_file,
             ]

if __name__ == '__main__':
  svntest.main.run_tests(test_list)
  # NOTREACHED


### End of file.
# local variables:
# eval: (load-file "../../../../tools/dev/svn-dev.el")
# end: