path: root/subversion/tests/cmdline/special_tests.py

#!/usr/bin/env python
#
#  special_tests.py:  testing special and reserved file handling
#
#  Subversion is a tool for revision control.
#  See http://subversion.apache.org for more information.
#
# ====================================================================
#    Licensed to the Apache Software Foundation (ASF) under one
#    or more contributor license agreements.  See the NOTICE file
#    distributed with this work for additional information
#    regarding copyright ownership.  The ASF licenses this file
#    to you under the Apache License, Version 2.0 (the
#    "License"); you may not use this file except in compliance
#    with the License.  You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
#    Unless required by applicable law or agreed to in writing,
#    software distributed under the License is distributed on an
#    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
#    KIND, either express or implied.  See the License for the
#    specific language governing permissions and limitations
#    under the License.
######################################################################

# General modules
import sys, os, re, copy, stat

# Our testing module
import svntest

from svntest.main import server_has_mergeinfo, run_svn, file_write

# (abbreviation)
Skip = svntest.testcase.Skip_deco
SkipUnless = svntest.testcase.SkipUnless_deco
XFail = svntest.testcase.XFail_deco
Issues = svntest.testcase.Issues_deco
Issue = svntest.testcase.Issue_deco
Wimp = svntest.testcase.Wimp_deco
Item = svntest.wc.StateItem


######################################################################
# Tests
#
#   Each test must return on success or raise on failure.


#----------------------------------------------------------------------
def general_symlink(sbox):
  "general symlink handling"

  sbox.build()
  wc_dir = sbox.wc_dir

  # First try to just commit a symlink
  newfile_path = sbox.ospath('newfile')

  sbox.simple_append('linktarget', 'this is just a link target')
  sbox.simple_add('linktarget')
  sbox.simple_add_symlink('linktarget', 'newfile')

  expected_output = svntest.wc.State(wc_dir, {
    'newfile' : Item(verb='Adding'),
    'linktarget' : Item(verb='Adding'),
    })

  # Run a diff and verify that we get the correct output
  exit_code, stdout_lines, stderr_lines = svntest.main.run_svn(1, 'diff',
                                                               wc_dir)

  regex = '^\+link linktarget'
  for line in stdout_lines:
    if re.match(regex, line):
      break
  else:
    raise svntest.Failure

  # Commit and make sure everything is good
  expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
  expected_status.add({
    'newfile' : Item(status='  ', wc_rev=2),
    'linktarget' : Item(status='  ', wc_rev=2),
    })

  svntest.actions.run_and_verify_commit(wc_dir, expected_output,
                                        expected_status)

  ## Now we should update to the previous version, verify that no
  ## symlink is present, then update back to HEAD and see if the symlink
  ## is regenerated properly.
  svntest.actions.run_and_verify_svn(None, [],
                                     'up', '-r', '1', wc_dir)

  # Is the symlink gone?
  if os.path.isfile(newfile_path) or os.path.islink(newfile_path):
    raise svntest.Failure

  svntest.actions.run_and_verify_svn(None, [],
                                     'up', '-r', '2', wc_dir)

  # Is the symlink back?
  if svntest.main.is_posix_os():
    new_target = os.readlink(newfile_path)
    if new_target != 'linktarget':
      raise svntest.Failure

  ## Now change the target of the symlink, verify that it is shown as
  ## modified and that a commit succeeds.
  os.remove(newfile_path)
  if svntest.main.is_posix_os():
    os.symlink('A', newfile_path)
  else:
    sbox.simple_append('newfile', 'link A', truncate = True)

  was_cwd = os.getcwd()
  os.chdir(wc_dir)
  svntest.actions.run_and_verify_svn([ "M       newfile\n" ], [], 'st')

  os.chdir(was_cwd)

  expected_output = svntest.wc.State(wc_dir, {
    'newfile' : Item(verb='Sending'),
    })

  expected_status = svntest.actions.get_virginal_state(wc_dir, 2)
  expected_status.add({
    'newfile' : Item(status='  ', wc_rev=3),
    'linktarget' : Item(status='  ', wc_rev=2),
    })

  svntest.actions.run_and_verify_commit(wc_dir, expected_output,
                                        expected_status)


@SkipUnless(svntest.main.is_posix_os)
def replace_file_with_symlink(sbox):
  "replace a normal file with a special file"

  sbox.build()
  wc_dir = sbox.wc_dir

  # First replace a normal file with a symlink and make sure we get an
  # error
  iota_path = os.path.join(wc_dir, 'iota')
  os.remove(iota_path)
  os.symlink('A', iota_path)

  # Does status show the obstruction?
  was_cwd = os.getcwd()
  os.chdir(wc_dir)
  svntest.actions.run_and_verify_svn([ "~       iota\n" ], [], 'st')

  # And does a commit fail?
  os.chdir(was_cwd)
  exit_code, stdout_lines, stderr_lines = svntest.main.run_svn(1, 'ci', '-m',
                                                               'log msg',
                                                               wc_dir)

  regex = 'svn: E145001: Commit failed'
  for line in stderr_lines:
    if re.match(regex, line):
      break
  else:
    raise svntest.Failure


@SkipUnless(svntest.main.is_posix_os)
def import_export_symlink(sbox):
  "import and export a symlink"

  sbox.build()
  wc_dir = sbox.wc_dir

  # create a new symlink to import
  new_path = os.path.join(wc_dir, 'new_file')

  os.symlink('linktarget', new_path)

  # import this symlink into the repository
  url = sbox.repo_url + "/dirA/dirB/new_link"
  exit_code, output, errput = svntest.actions.run_and_verify_svn(
    None, [], 'import',
    '-m', 'log msg', new_path, url)

  regex = "(Committed|Imported) revision [0-9]+."
  for line in output:
    if re.match(regex, line):
      break
  else:
    raise svntest.Failure

  # remove the unversioned link
  os.remove(new_path)

  # run update and verify that the symlink is put back into place
  svntest.actions.run_and_verify_svn(None, [],
                                     'up', wc_dir)

  # Is the symlink back?
  link_path = wc_dir + "/dirA/dirB/new_link"
  new_target = os.readlink(link_path)
  if new_target != 'linktarget':
    raise svntest.Failure

  ## Now we will try exporting from both the working copy and the
  ## repository directly, verifying that the symlink is created in
  ## both cases.

  for export_src, dest_dir in [(sbox.wc_dir, 'export-wc'),
                               (sbox.repo_url, 'export-url')]:
    export_target = sbox.add_wc_path(dest_dir)
    svntest.actions.run_and_verify_svn(None, [],
                                       'export', export_src, export_target)

    # is the link at the correct place?
    link_path = os.path.join(export_target, "dirA/dirB/new_link")
    new_target = os.readlink(link_path)
    if new_target != 'linktarget':
      raise svntest.Failure


#----------------------------------------------------------------------
# Regression test for issue 1986
@Issue(1986)
def copy_tree_with_symlink(sbox):
  "'svn cp dir1 dir2' which contains a symlink"

  sbox.build()
  wc_dir = sbox.wc_dir

  # Create a versioned symlink within directory 'A/D/H'.
  newfile_path = sbox.ospath('A/D/H/newfile')
  sbox.simple_append('A/D/H/linktarget', 'this is just a link target')
  sbox.simple_add('A/D/H/linktarget')
  sbox.simple_add_symlink('linktarget', 'A/D/H/newfile')

  expected_output = svntest.wc.State(wc_dir, {
    'A/D/H/newfile' : Item(verb='Adding'),
    'A/D/H/linktarget' : Item(verb='Adding'),
    })

  expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
  expected_status.add({
    'A/D/H/newfile' : Item(status='  ', wc_rev=2),
    'A/D/H/linktarget' : Item(status='  ', wc_rev=2),
    })

  svntest.actions.run_and_verify_commit(wc_dir, expected_output,
                                        expected_status)
  # Copy H to H2
  H_path = os.path.join(wc_dir, 'A', 'D', 'H')
  H2_path = os.path.join(wc_dir, 'A', 'D', 'H2')
  svntest.actions.run_and_verify_svn(None, [], 'cp', H_path, H2_path)

  # 'svn status' should show just "A/D/H2  A +".  Nothing broken.
  expected_status.add({
    'A/D/H2' : Item(status='A ', copied='+', wc_rev='-'),
    'A/D/H2/chi' : Item(status='  ', copied='+', wc_rev='-'),
    'A/D/H2/omega' : Item(status='  ', copied='+', wc_rev='-'),
    'A/D/H2/psi' : Item(status='  ', copied='+', wc_rev='-'),
    # linktarget and newfile are from r2, while h2 is from r1.
    'A/D/H2/linktarget' : Item(status='A ', copied='+', wc_rev='-',
                               entry_status='  '),
    'A/D/H2/newfile' : Item(status='A ', copied='+', wc_rev='-',
                            entry_status='  '),
    })
  svntest.actions.run_and_verify_status(wc_dir, expected_status)


@SkipUnless(svntest.main.is_posix_os)
def replace_symlink_with_file(sbox):
  "replace a special file with a non-special file"

  sbox.build()
  wc_dir = sbox.wc_dir

  # Create a new special file and commit it.
  newfile_path = os.path.join(wc_dir, 'newfile')
  linktarget_path = os.path.join(wc_dir, 'linktarget')
  svntest.main.file_append(linktarget_path, 'this is just a link target')
  os.symlink('linktarget', newfile_path)
  svntest.main.run_svn(None, 'add', newfile_path, linktarget_path)

  expected_output = svntest.wc.State(wc_dir, {
    'newfile' : Item(verb='Adding'),
    'linktarget' : Item(verb='Adding'),
    })

  expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
  expected_status.add({
    'newfile' : Item(status='  ', wc_rev=2),
    'linktarget' : Item(status='  ', wc_rev=2),
    })

  svntest.actions.run_and_verify_commit(wc_dir, expected_output,
                                        expected_status)


  # Now replace the symlink with a normal file and try to commit, we
  # should get an error
  os.remove(newfile_path)
  svntest.main.file_append(newfile_path, "text of actual file")

  # Does status show the obstruction?
  was_cwd = os.getcwd()
  os.chdir(wc_dir)
  svntest.actions.run_and_verify_svn([ "~       newfile\n" ], [], 'st')

  # And does a commit fail?
  os.chdir(was_cwd)
  exit_code, stdout_lines, stderr_lines = svntest.main.run_svn(1, 'ci', '-m',
                                                               'log msg',
                                                               wc_dir)

  regex = 'svn: E145001: Commit failed'
  for line in stderr_lines:
    if re.match(regex, line):
      break
  else:
    raise svntest.Failure


#----------------------------------------------------------------------
def remove_symlink(sbox):
  "remove a symlink"

  sbox.build()
  wc_dir = sbox.wc_dir

  # Commit a symlink
  newfile_path = os.path.join(wc_dir, 'newfile')
  linktarget_path = os.path.join(wc_dir, 'linktarget')
  svntest.main.file_append(linktarget_path, 'this is just a link target')
  sbox.simple_add_symlink('linktarget', 'newfile')
  sbox.simple_add('linktarget')

  expected_output = svntest.wc.State(wc_dir, {
    'newfile' : Item(verb='Adding'),
    'linktarget' : Item(verb='Adding'),
    })

  expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
  expected_status.add({
    'newfile' : Item(status='  ', wc_rev=2),
    'linktarget' : Item(status='  ', wc_rev=2),
    })

  svntest.actions.run_and_verify_commit(wc_dir, expected_output,
                                        expected_status)

  # Now remove it
  svntest.actions.run_and_verify_svn(None, [], 'rm', newfile_path)

  # Commit and verify that it worked
  expected_output = svntest.wc.State(wc_dir, {
    'newfile' : Item(verb='Deleting'),
    })

  expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
  expected_status.add({
    'linktarget' : Item(status='  ', wc_rev=2),
    })

  svntest.actions.run_and_verify_commit(wc_dir, expected_output,
                                        expected_status)

#----------------------------------------------------------------------
@SkipUnless(server_has_mergeinfo)
@Issue(2530)
def merge_symlink_into_file(sbox):
  "merge symlink into file"

  sbox.build()
  wc_dir = sbox.wc_dir
  d_url = sbox.repo_url + '/A/D'
  dprime_url = sbox.repo_url + '/A/Dprime'

  gamma_path = sbox.ospath('A/D/gamma')
  gamma_prime_path = sbox.ospath('A/Dprime/gamma')

  # create a copy of the D directory to play with
  svntest.main.run_svn(None,
                       'copy', d_url, dprime_url, '-m', 'copy')
  svntest.main.run_svn(None,
                       'update', sbox.wc_dir)

  # remove A/Dprime/gamma
  svntest.main.run_svn(None, 'delete', gamma_prime_path)

  expected_output = svntest.wc.State(wc_dir, {
    'A/Dprime/gamma' : Item(verb='Deleting'),
    })

  svntest.actions.run_and_verify_commit(wc_dir, expected_output, None)

  # Commit a symlink in its place
  linktarget_path = os.path.join(wc_dir, 'linktarget')
  svntest.main.file_append(linktarget_path, 'this is just a link target')
  sbox.simple_add_symlink('linktarget', 'A/Dprime/gamma')

  expected_output = svntest.wc.State(wc_dir, {
    'A/Dprime/gamma' : Item(verb='Adding'),
    })

  svntest.actions.run_and_verify_commit(wc_dir, expected_output, None)

  # merge the creation of the symlink into the original directory
  svntest.main.run_svn(None,
                       'merge', '-r', '2:4', dprime_url,
                       os.path.join(wc_dir, 'A', 'D'))

  # now revert, we once got a strange error
  svntest.main.run_svn(None, 'revert', '-R', wc_dir)

  # assuming we got past the revert because someone fixed that bug, lets
  # try the merge and a commit, since that apparently used to throw us for
  # a loop, see issue 2530
  svntest.main.run_svn(None,
                       'merge', '-r', '2:4', dprime_url,
                       os.path.join(wc_dir, 'A', 'D'))

  expected_output = svntest.wc.State(wc_dir, {
    'A/D'       : Item(verb='Sending'),
    'A/D/gamma' : Item(verb='Replacing'),
    })

  svntest.actions.run_and_verify_commit(wc_dir, expected_output, None)



#----------------------------------------------------------------------
def merge_file_into_symlink(sbox):
  "merge file into symlink"

  sbox.build()
  wc_dir = sbox.wc_dir
  d_url = sbox.repo_url + '/A/D'
  dprime_url = sbox.repo_url + '/A/Dprime'

  gamma_path = os.path.join(wc_dir, 'A', 'D', 'gamma')
  gamma_prime_path = os.path.join(wc_dir, 'A', 'Dprime', 'gamma')

  # create a copy of the D directory to play with
  svntest.main.run_svn(None,
                       'copy', d_url, dprime_url, '-m', 'copy')
  svntest.main.run_svn(None,
                       'update', sbox.wc_dir)

  # remove A/Dprime/gamma
  svntest.main.run_svn(None, 'delete', gamma_prime_path)

  expected_output = svntest.wc.State(wc_dir, {
    'A/Dprime/gamma' : Item(verb='Deleting'),
    })

  svntest.actions.run_and_verify_commit(wc_dir, expected_output, None)

  # Commit a symlink in its place
  linktarget_path = os.path.join(wc_dir, 'linktarget')
  svntest.main.file_append(linktarget_path, 'this is just a link target')
  sbox.simple_add_symlink('linktarget', 'A/Dprime/gamma')

  expected_output = svntest.wc.State(wc_dir, {
    'A/Dprime/gamma' : Item(verb='Adding'),
    })

  svntest.actions.run_and_verify_commit(wc_dir, expected_output, None)

  svntest.main.file_write(gamma_path, 'changed file', 'w+')

  expected_output = svntest.wc.State(wc_dir, {
    'A/D/gamma' : Item(verb='Sending'),
    })

  svntest.actions.run_and_verify_commit(wc_dir, expected_output, None)

  # ok, now merge the change to the file into the symlink we created, this
  # gives us a weird error
  svntest.main.run_svn(None,
                       'merge', '-r', '4:5', '--allow-mixed-revisions', d_url,
                       os.path.join(wc_dir, 'A', 'Dprime'))

# Issue 2701: Tests to see repository with symlinks can be checked out on all
# platforms.
@Issue(2701)
def checkout_repo_with_symlinks(sbox):
  "checkout a repository containing symlinks"

  svntest.actions.load_repo(sbox, os.path.join(os.path.dirname(sys.argv[0]),
                                               'special_tests_data',
                                               'symlink.dump'),
                            create_wc=False)

  expected_output = svntest.wc.State(sbox.wc_dir, {
    'from': Item(status='A '),
    'to': Item(status='A '),
    })

  if svntest.main.is_os_windows():
    expected_link_contents = 'link to'
  else:
    expected_link_contents = ''

  expected_wc = svntest.wc.State('', {
    'from' : Item(contents=expected_link_contents),
    'to'   : Item(contents=''),
    })
  svntest.actions.run_and_verify_checkout(sbox.repo_url,
                                          sbox.wc_dir,
                                          expected_output,
                                          expected_wc)

#----------------------------------------------------------------------
# Issue 2716: 'svn diff' against a symlink to a directory within the wc
@Issue(2716)
def diff_symlink_to_dir(sbox):
  "diff a symlink to a directory"

  sbox.build(read_only = True)

  # Create a symlink to A/D as link.
  d_path = os.path.join('A', 'D')
  sbox.simple_add_symlink('A/D', 'link')

  os.chdir(sbox.wc_dir)

  # Now diff the wc itself and check the results.
  expected_output = [
    "Index: link\n",
    "===================================================================\n",
    "--- link\t(nonexistent)\n",
    "+++ link\t(working copy)\n",
    "@@ -0,0 +1 @@\n",
    "+link A/D\n",
    "\ No newline at end of file\n",
    "\n",
    "Property changes on: link\n",
    "___________________________________________________________________\n",
    "Added: svn:special\n",
    "## -0,0 +1 ##\n",
    "+*\n",
    "\\ No newline at end of property\n"
  ]
  svntest.actions.run_and_verify_svn(expected_output, [], 'diff',
                                     '.')
  # We should get the same output if we the diff the symlink itself.
  svntest.actions.run_and_verify_svn(expected_output, [], 'diff', 'link')

#----------------------------------------------------------------------
# Issue 2692 (part of): Check that the client can check out a repository
# that contains an unknown special file type.
@Issue(2692)
def checkout_repo_with_unknown_special_type(sbox):
  "checkout repository with unknown special file type"

  svntest.actions.load_repo(sbox, os.path.join(os.path.dirname(sys.argv[0]),
                                               'special_tests_data',
                                               'bad-special-type.dump'),
                            create_wc=False)

  expected_output = svntest.wc.State(sbox.wc_dir, {
    'special': Item(status='A '),
    })
  expected_wc = svntest.wc.State('', {
    'special' : Item(contents='gimble wabe'),
    })
  svntest.actions.run_and_verify_checkout(sbox.repo_url,
                                          sbox.wc_dir,
                                          expected_output,
                                          expected_wc)

def replace_symlink_with_dir(sbox):
  "replace a special file with a directory"

  svntest.actions.load_repo(sbox, os.path.join(os.path.dirname(sys.argv[0]),
                                               'special_tests_data',
                                               'symlink.dump'))

  wc_dir = sbox.wc_dir
  from_path = os.path.join(wc_dir, 'from')

  # Now replace the symlink with a directory and try to commit, we
  # should get an error
  os.remove(from_path)
  os.mkdir(from_path)

  # Does status show the obstruction?
  was_cwd = os.getcwd()
  os.chdir(wc_dir)
  svntest.actions.run_and_verify_svn([ "~       from\n" ], [], 'st')

  # The commit shouldn't do anything.
  # I'd expect a failed commit here, but replacing a file locally with a
  # directory seems to make svn think the file is unchanged.
  os.chdir(was_cwd)
  expected_output = svntest.wc.State(wc_dir, {
  })

  error_re_string = '.*E145001: (Entry|Node).*has.*changed (special|kind).*'

  svntest.actions.run_and_verify_commit(wc_dir, expected_output,
                                        None, error_re_string)

# test for issue #1808: svn up deletes local symlink that obstructs
# versioned file
@Issue(1808)
def update_obstructing_symlink(sbox):
  "symlink obstructs incoming delete"

  sbox.build()
  wc_dir = sbox.wc_dir
  mu_path = sbox.ospath('A/mu')

  iota_abspath = os.path.abspath(sbox.ospath('iota'))

  # delete mu and replace it with an (not-added) symlink
  sbox.simple_rm('A/mu')
  sbox.simple_symlink(iota_abspath, 'A/mu')

  # delete pi and replace it with an added symlink
  sbox.simple_rm('A/D/G/pi')
  sbox.simple_add_symlink(iota_abspath, 'A/D/G/pi')

  if not os.path.exists(mu_path):
      raise svntest.Failure("mu should be there")

  # Now remove mu and pi in the repository
  svntest.main.run_svn(None, 'rm', '-m', 'log msg',
                       sbox.repo_url + '/A/mu',
                       sbox.repo_url + '/A/D/G/pi')

  # We expect tree conflicts
  expected_output = svntest.wc.State(wc_dir, {
    'A/mu':         Item(status='  ', treeconflict='C'),
    'A/D/G/pi':     Item(status='  ', treeconflict='C')
  })

  expected_status = svntest.actions.get_virginal_state(wc_dir, 2)
  expected_status.tweak('A/mu', status='? ', treeconflict='C',
                        wc_rev=None)

  expected_status.tweak('A/D/G/pi', status='A ',treeconflict='C',
                        wc_rev='-')

  svntest.actions.run_and_verify_update(wc_dir,
                                        expected_output, None,
                                        expected_status)

  expected_info = [
    {
      'Path': re.escape(sbox.ospath('A/D/G/pi')),
      'Tree conflict': 'local file replace, incoming file delete or move.*'
    },
    {
      'Path': re.escape(sbox.ospath('A/mu')),
      'Tree conflict': 'local file delete, incoming file delete or move.*'
    }
  ]

  svntest.actions.run_and_verify_info(expected_info,
                                      sbox.ospath('A/D/G/pi'),
                                      sbox.ospath('A/mu'))

  # check that the symlink is still there
  if not os.path.exists(mu_path):
      raise svntest.Failure("mu should be there")
  if svntest.main.is_posix_os():
    target = os.readlink(mu_path)
    if target != iota_abspath:
      raise svntest.Failure("mu no longer points to the same location")

def warn_on_reserved_name(sbox):
  "warn when attempt operation on a reserved name"
  sbox.build()
  reserved_path = os.path.join(sbox.wc_dir, svntest.main.get_admin_name())
  svntest.actions.run_and_verify_svn(
    None,
    ".*Skipping argument: E200025: '.+' ends in a reserved name.*",
    'lock', reserved_path)


def propvalue_normalized(sbox):
  "'ps svn:special' should normalize to '*'"

  sbox.build()
  wc_dir = sbox.wc_dir

  # Add a "symlink"
  iota2_path = sbox.ospath('iota2')
  svntest.main.file_write(iota2_path, "symlink destination")
  svntest.main.run_svn(None, 'add', iota2_path)
  svntest.main.run_svn(None, 'propset', 'svn:special', 'yes', iota2_path)
  if svntest.main.is_posix_os():
    os.remove(iota2_path)
    os.symlink("symlink destination", iota2_path)

  # Property value should be SVN_PROP_BOOLEAN_TRUE
  expected_propval = ['*']
  svntest.actions.run_and_verify_svn(expected_propval, [],
                                     'propget', '--no-newline', 'svn:special',
                                     iota2_path)

  # Commit and check again.
  expected_output = svntest.wc.State(wc_dir, {
    'iota2' : Item(verb='Adding'),
    })
  expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
  expected_status.add({
    'iota2' : Item(status='  ', wc_rev=2),
    })
  svntest.actions.run_and_verify_commit(wc_dir, expected_output,
                                        expected_status)

  svntest.main.run_svn(None, 'update', wc_dir)
  svntest.actions.run_and_verify_svn(expected_propval, [],
                                     'propget', '--no-newline', 'svn:special',
                                     iota2_path)


# on users@: http://mid.gmane.org/1292856447.8650.24.camel@nimble.325Bayport
@SkipUnless(svntest.main.is_posix_os)
def unrelated_changed_special_status(sbox):
  "commit foo while bar changed special status"

  sbox.build()
  wc_dir = sbox.wc_dir

  os.chdir(os.path.join(sbox.wc_dir, 'A/D/H'))

  open('chi', 'a').write('random local mod')
  os.unlink('psi')
  os.symlink('omega', 'psi') # omega is versioned!
  svntest.main.run_svn(None, 'changelist', 'chi cl', 'chi')
  svntest.actions.run_and_verify_svn(None, [], 'commit',
                                     '--changelist', 'chi cl',
                                     '-m', 'psi changed special status')

#----------------------------------------------------------------------
@Issue(3972)
def symlink_destination_change(sbox):
  "revert a symlink destination change"

  sbox.build()
  wc_dir = sbox.wc_dir

  # Create a new symlink and commit it.
  newfile_path = os.path.join(wc_dir, 'newfile')
  sbox.simple_add_symlink('linktarget', 'newfile')

  expected_output = svntest.wc.State(wc_dir, {
    'newfile' : Item(verb='Adding'),
    })

  expected_status = svntest.actions.get_virginal_state(wc_dir, 1)
  expected_status.add({
    'newfile' : Item(status='  ', wc_rev=2),
    })

  svntest.actions.run_and_verify_commit(wc_dir, expected_output,
                                        expected_status)

  # Modify the symlink to point somewhere else
  os.remove(newfile_path)
  if svntest.main.is_posix_os():
    os.symlink('linktarget2', newfile_path)
  else:
    sbox.simple_append('newfile', 'link linktarget2', truncate = True)

  expected_status.tweak('newfile', status='M ')
  svntest.actions.run_and_verify_status(wc_dir, expected_status)

  # Revert should restore the symlink to point to the original destination
  svntest.main.run_svn(None, 'revert', '-R', wc_dir)
  expected_status.tweak('newfile', status='  ')
  svntest.actions.run_and_verify_status(wc_dir, expected_status)

  # Issue 3972, repeat revert produces no output
  svntest.actions.run_and_verify_svn([], [], 'revert', '-R', wc_dir)
  svntest.actions.run_and_verify_status(wc_dir, expected_status)

  # Now replace the symlink with a normal file and try to commit, we

#----------------------------------------------------------------------
# This used to lose the special status in the target working copy
# (disk and metadata).
@Issue(3884)
def merge_foreign_symlink(sbox):
  "merge symlink-add from foreign repos"

  sbox.build()
  wc_dir = sbox.wc_dir

  # Make a copy of this repository and associated working copy.  Both
  # should have nothing but a Greek tree in them, and the two
  # repository UUIDs should differ.
  sbox2 = sbox.clone_dependent(True)
  sbox2.build()
  wc_dir2 = sbox2.wc_dir

  # convenience variables
  zeta_path = sbox.ospath('A/zeta')
  zeta2_path = sbox2.ospath('A/zeta')

  # sbox2 r2: create zeta2 in sbox2
  sbox2.simple_add_symlink('target', 'A/zeta')
  sbox2.simple_commit('A/zeta')


  # sbox1: merge that
  svntest.main.run_svn(None, 'merge', '-c', '2', sbox2.repo_url,
                       sbox.ospath(''))

  # Verify special status.
  expected_disk = svntest.main.greek_state.copy()
  expected_disk.add({
    'A/zeta': Item(contents="link target", props={ 'svn:special': '*' })
  })
  svntest.actions.verify_disk(sbox.ospath(''), expected_disk, True)

  # TODO: verify status:
  #   expected_status = svntest.actions.get_virginal_state(wc_dir, 2)
  #   expected_status.add({
  #     'A/zeta' : Item(status='A ', wc_rev='-', props={'svn:special': '*'}),
  #     })

#----------------------------------------------------------------------
# See also symlink_to_wc_svnversion().
@Issue(2557,3987)
@SkipUnless(svntest.main.is_posix_os)
def symlink_to_wc_basic(sbox):
  "operate on symlink to wc"

  sbox.build(read_only = True)
  wc_dir = sbox.wc_dir

  # Create a symlink
  symlink_path = sbox.add_wc_path('2')
  assert not os.path.islink(symlink_path)
  os.symlink(os.path.basename(wc_dir), symlink_path) ### implementation detail
  symlink_basename = os.path.basename(symlink_path)

  # Some basic tests
  wc_uuid = svntest.actions.get_wc_uuid(wc_dir)
  expected_info = [{
      'Path' : re.escape(os.path.join(symlink_path)),
      'Working Copy Root Path' : re.escape(os.path.abspath(wc_dir)),
      'Repository Root' : sbox.repo_url,
      'Repository UUID' : wc_uuid,
      'Revision' : '1',
      'Node Kind' : 'directory',
      'Schedule' : 'normal',
  }, {
      'Name' : 'iota',
      'Path' : re.escape(os.path.join(symlink_path, 'iota')),
      'Working Copy Root Path' : re.escape(os.path.abspath(wc_dir)),
      'Repository Root' : sbox.repo_url,
      'Repository UUID' : wc_uuid,
      'Revision' : '1',
      'Node Kind' : 'file',
      'Schedule' : 'normal',
  }]
  svntest.actions.run_and_verify_info(expected_info,
                                      symlink_path, symlink_path + '/iota')

#----------------------------------------------------------------------
# Similar to #2557/#3987; see symlink_to_wc_basic().
@Issue(2557,3987)
@SkipUnless(svntest.main.is_posix_os)
def symlink_to_wc_svnversion(sbox):
  "svnversion on symlink to wc"

  sbox.build(read_only = True)
  wc_dir = sbox.wc_dir

  # Create a symlink
  symlink_path = sbox.add_wc_path('2')
  assert not os.path.islink(symlink_path)
  os.symlink(os.path.basename(wc_dir), symlink_path) ### implementation detail
  symlink_basename = os.path.basename(symlink_path)

  # Some basic tests
  svntest.actions.run_and_verify_svnversion(symlink_path, sbox.repo_url,
                                            [ "1\n" ], [])

#----------------------------------------------------------------------
# Regression in 1.7.0: Update fails to change a symlink
def update_symlink(sbox):
  "update a symlink"

  svntest.actions.do_sleep_for_timestamps()

  sbox.build()
  wc_dir = sbox.wc_dir
  mu_path = sbox.ospath('A/mu')
  iota_path = sbox.ospath('iota')
  symlink_path = sbox.ospath('symlink')

  # create a symlink to /A/mu
  sbox.simple_add_symlink("A/mu", 'symlink')
  sbox.simple_commit()

  # change the symlink to /iota
  os.remove(symlink_path)
  if svntest.main.is_posix_os():
    os.symlink("iota", symlink_path)
  else:
    file_write(symlink_path, 'link iota')
  sbox.simple_commit()

  # update back to r2
  svntest.main.run_svn(False, 'update', '-r', '2', wc_dir)

  # now update to head; 1.7.0 throws an assertion here
  expected_output = svntest.wc.State(wc_dir, {
    'symlink'          : Item(status='U '),
  })
  expected_disk = svntest.main.greek_state.copy()
  expected_disk.add({'symlink': Item(contents="This is the file 'iota'.\n",
                                     props={'svn:special' : '*'})})
  expected_status = svntest.actions.get_virginal_state(wc_dir, 3)
  expected_status.add({
    'symlink'           : Item(status='  ', wc_rev='3'),
  })

  if not svntest.main.is_posix_os():
    expected_disk = None

  svntest.actions.run_and_verify_update(wc_dir,
                                        expected_output,
                                        expected_disk,
                                        expected_status,
                                        check_props=True)

#----------------------------------------------------------------------
@Issue(4091)
def replace_symlinks(sbox):
  "replace symlinks"
  sbox.build()
  wc = sbox.ospath

  # Some of these tests are implemented for git (in test script
  # t/t9100-git-svn-basic.sh) using the Perl bindings for Subversion.
  # Our issue #4091 is about 'svn update' failures in the git tests.

  sbox.simple_mkdir('A/D/G/Z')
  sbox.simple_mkdir('A/D/Gx')
  sbox.simple_mkdir('A/D/Gx/Z')
  sbox.simple_mkdir('A/D/Hx')
  sbox.simple_mkdir('A/D/Y')
  sbox.simple_mkdir('Ax')

  sbox.simple_add_symlink('../Y', 'A/D/H/Z')
  sbox.simple_add_symlink('../Y', 'A/D/Hx/Z')

  for p in ['Ax/mu',
            'A/D/Gx/pi',
            'A/D/Hx/chi',
            ]:
      file_write(wc(p), 'This starts as a normal file.\n')
      sbox.simple_add(p)
  for p in ['iota.sh',
            'A/mu.sh',
            'Ax/mu.sh',
            'A/D/gamma.sh',
            'A/B/E/beta.sh',
            'A/D/G/rho.sh',
            'A/D/Gx/rho.sh',
            'A/D/H/psi.sh',
            'A/D/Hx/psi.sh',
            ]:
      file_write(wc(p), '#!/bin/sh\necho "hello, svn!"\n')
      os.chmod(wc(p), svntest.main.S_ALL_RW | stat.S_IXUSR)
      sbox.simple_add(p)
      if not svntest.main.is_posix_os():
        sbox.simple_propset('svn:executable', 'X', p)
  sbox.simple_commit() # r2
  sbox.simple_update()
  expected_status = svntest.actions.get_virginal_state(sbox.wc_dir, 2)
  expected_status.add({
    'A/D/Y'         : Item(status='  ', wc_rev=2),
    'A/D/G/Z'       : Item(status='  ', wc_rev=2),
    'A/D/G/rho.sh'  : Item(status='  ', wc_rev=2),
    'A/D/Hx'        : Item(status='  ', wc_rev=2),
    'A/D/Hx/Z'      : Item(status='  ', wc_rev=2),
    'A/D/Hx/chi'    : Item(status='  ', wc_rev=2),
    'A/D/Hx/psi.sh' : Item(status='  ', wc_rev=2),
    'A/D/H/psi.sh'  : Item(status='  ', wc_rev=2),
    'A/D/H/Z'       : Item(status='  ', wc_rev=2),
    'A/D/Gx'        : Item(status='  ', wc_rev=2),
    'A/D/Gx/Z'      : Item(status='  ', wc_rev=2),
    'A/D/Gx/pi'     : Item(status='  ', wc_rev=2),
    'A/D/Gx/rho.sh' : Item(status='  ', wc_rev=2),
    'A/D/gamma.sh'  : Item(status='  ', wc_rev=2),
    'A/B/E/beta.sh' : Item(status='  ', wc_rev=2),
    'Ax'            : Item(status='  ', wc_rev=2),
    'Ax/mu'         : Item(status='  ', wc_rev=2),
    'Ax/mu.sh'      : Item(status='  ', wc_rev=2),
    'A/mu.sh'       : Item(status='  ', wc_rev=2),
    'iota.sh'       : Item(status='  ', wc_rev=2),
    })
  expected_status_r2 = copy.deepcopy(expected_status)
  svntest.actions.run_and_verify_status(sbox.wc_dir, expected_status_r2)

  # Failing git-svn test: 'new symlink is added to a file that was
  # also just made executable', i.e., in the same revision.
  sbox.simple_propset("svn:executable", "X", 'A/B/E/alpha')
  sbox.simple_add_symlink('alpha', 'A/B/E/sym-alpha')

  # Add a symlink to a file made non-executable in the same revision.
  sbox.simple_propdel("svn:executable", 'A/B/E/beta.sh')
  sbox.simple_add_symlink('beta.sh', 'A/B/E/sym-beta.sh')

  # Replace a normal {file, exec, dir} with a symlink to the same kind
  # via Subversion replacement.
  sbox.simple_rm('A/D/G/pi',
                 'A/D/G/rho.sh',
                 #'A/D/G/Z', # Ooops, not compatible with --bin=svn1.6.
                 )
  sbox.simple_add_symlink('../gamma', 'A/D/G/pi')
  sbox.simple_add_symlink('../gamma.sh', 'A/D/G/rho.sh')
  #sbox.simple_add_symlink('../Y', 'A/D/G/Z')

  # Replace a symlink to {file, exec, dir} with a normal item of the
  # same kind via Subversion replacement.
  sbox.simple_rm('A/D/H/chi',
                 'A/D/H/psi.sh',
                 #'A/D/H/Z',
                 )
  sbox.simple_add_symlink('../gamma', 'A/D/H/chi')
  sbox.simple_add_symlink('../gamma.sh', 'A/D/H/psi.sh')
  #sbox.simple_add_symlink('../Y', 'A/D/H/Z')

  # Replace a normal {file, exec} with a symlink to {exec, file} via
  # Subversion replacement.
  sbox.simple_rm('A/mu',
                 'A/mu.sh')
  sbox.simple_add_symlink('../iota2', 'A/mu')
  sbox.simple_add_symlink('../iota', 'A/mu.sh')

  # Ditto, without the Subversion replacement.  Failing git-svn test
  # 'executable file becomes a symlink to bar/zzz (file)'.
  if svntest.main.is_posix_os():
    os.remove(wc('Ax/mu'))
    os.remove(wc('Ax/mu.sh'))
    os.symlink('../iota2', wc('Ax/mu'))
    os.symlink('../iota', wc('Ax/mu.sh'))
  else:
    # At least modify the file a bit

    # ### Somehow this breaks the test when using multiline data?
    # ### Is that intended behavior?

    file_write(sbox.ospath('Ax/mu'), 'Link to iota2')
    file_write(sbox.ospath('Ax/mu.sh'), 'Link to iota')

  sbox.simple_propset('svn:special', 'X',
                      'Ax/mu',
                      'Ax/mu.sh')
  sbox.simple_propdel('svn:executable', 'Ax/mu.sh')

  ### TODO Replace a normal {file, exec, dir, dir} with a symlink to
  ### {dir, dir, file, exec}.  And the same symlink-to-normal.

  expected_status.tweak('A/D/G/pi',
                        'A/D/G/rho.sh',
                        'A/D/H/psi.sh',
                        'A/D/H/chi',
                        'A/mu',
                        'A/mu.sh',
                        status='RM')
  expected_status.tweak('A/B/E/beta.sh',
                        'A/B/E/alpha',
                        status=' M')
  expected_status.tweak('Ax/mu',
                        'Ax/mu.sh',
                        status='MM')
  expected_status.add({
      'A/B/E/sym-alpha'   : Item(status='A ', wc_rev=0),
      'A/B/E/sym-beta.sh' : Item(status='A ', wc_rev=0),
      })
  svntest.actions.run_and_verify_status(sbox.wc_dir, expected_status)

  sbox.simple_commit() # r3
  sbox.simple_update()

  expected_status.tweak(status='  ', wc_rev=3)
  expected_status_r3 = expected_status
  svntest.actions.run_and_verify_status(sbox.wc_dir, expected_status_r3)

  # Try updating from HEAD-1 to HEAD.  This is currently XFAIL as the
  # update to HEAD-1 produces a tree conflict.
  run_svn(None, 'up', '-r2', sbox.wc_dir)
  svntest.actions.run_and_verify_status(sbox.wc_dir, expected_status_r2)
  sbox.simple_update()
  svntest.actions.run_and_verify_status(sbox.wc_dir, expected_status_r3)


@Issue(4102)
@SkipUnless(svntest.main.is_posix_os)
def externals_as_symlink_targets(sbox):
  "externals as symlink targets"
  sbox.build()
  wc = sbox.ospath

  # Control: symlink to normal dir and file.
  os.symlink('E', wc('sym_E'))
  os.symlink('mu', wc('sym_mu'))

  # Test case: symlink to external dir and file.
  sbox.simple_propset("svn:externals",
                      '^/A/B/E ext_E\n'
                      '^/A/mu ext_mu',
                      '')
  sbox.simple_update()
  os.symlink('ext_E', wc('sym_ext_E'))
  os.symlink('ext_mu', wc('sym_ext_mu'))

  # Adding symlinks to normal items and to a file external is OK.
  sbox.simple_add('sym_E', 'sym_mu', 'sym_ext_mu')

  ### Adding a symlink to an external dir failed with
  ###   svn: E200009: Could not add all targets because some targets are
  ###   already versioned
  sbox.simple_add('sym_ext_E')

  sbox.simple_commit()

#----------------------------------------------------------------------
@XFail()
@Issue(4119)
def cat_added_symlink(sbox):
  "cat added symlink"

  sbox.build(read_only = True)

  kappa_path = sbox.ospath('kappa')
  sbox.simple_add_symlink('iota', 'kappa')
  svntest.actions.run_and_verify_svn("link iota", [],
                                     "cat", kappa_path)

#----------------------------------------------------------------------
def incoming_symlink_changes(sbox):
  "verify incoming symlink change behavior"

  sbox.build()
  wc_dir = sbox.wc_dir

  sbox.simple_add_symlink('iota', 's-replace')
  sbox.simple_add_symlink('iota', 's-in-place')
  sbox.simple_add_symlink('iota', 's-type')
  sbox.simple_append('s-reverse', 'link iota')
  sbox.simple_add('s-reverse')
  sbox.simple_commit() # r2

  # Replace s-replace
  sbox.simple_rm('s-replace')
  # Note that we don't use 'A/mu' as the length of that matches 'iota', which
  # would make us depend on timestamp changes for detecting differences.
  sbox.simple_add_symlink('A/D/G/pi', 's-replace')

  # Change target of s-in-place
  if svntest.main.is_posix_os():
    os.remove(sbox.ospath('s-in-place'))
    os.symlink('A/D/G/pi', sbox.ospath('s-in-place'))
  else:
    sbox.simple_append('s-in-place', 'link A/D/G/pi', truncate = True)

  # r3
  expected_output = svntest.wc.State(wc_dir, {
    's-replace'         : Item(verb='Replacing'),
    's-in-place'        : Item(verb='Sending'),
  })
  svntest.actions.run_and_verify_commit(wc_dir,
                                        expected_output, None)

  # r4
  svntest.main.run_svnmucc('propdel', 'svn:special',
                           sbox.repo_url + '/s-type',
                           '-m', 'Turn s-type into a file')

  # r5
  svntest.main.run_svnmucc('propset', 'svn:special', 'X',
                           sbox.repo_url + '/s-reverse',
                           '-m', 'Turn s-reverse into a symlink')

  # Currently we expect to see 'U'pdates, but we would like to see
  # replacements
  expected_output = svntest.wc.State(wc_dir, {
    's-reverse'         : Item(status=' U'),
    's-type'            : Item(status=' U'),
  })
  expected_status = svntest.actions.get_virginal_state(wc_dir, 5)
  expected_status.add({
    's-type'            : Item(status='  ', wc_rev='5'),
    's-replace'         : Item(status='  ', wc_rev='5'),
    's-reverse'         : Item(status='  ', wc_rev='5'),
    's-in-place'        : Item(status='  ', wc_rev='5'),
  })

  # Update to HEAD/r5 to fetch the r4 and r5 symlink changes
  svntest.actions.run_and_verify_update(wc_dir,
                                        expected_output,
                                        None,
                                        expected_status,
                                        check_props=True)

  # Update back to r2, to prepare some local changes
  expected_output = svntest.wc.State(wc_dir, {
    # s-replace is D + A
    's-replace'         : Item(status='A ', prev_status='D '),
    's-in-place'        : Item(status='U '),
    's-reverse'         : Item(status=' U'),
    's-type'            : Item(status=' U'),
  })
  expected_status.tweak(wc_rev=2)

  svntest.actions.run_and_verify_update(wc_dir,
                                        expected_output,
                                        None,
                                        expected_status,
                                        [], True,
                                        wc_dir, '-r', '2')

  # Ok, now add a property on all of them to make future symlinkness changes
  # a tree conflict
  # ### We should also try this with a 'textual change'
  sbox.simple_propset('x', 'y', 's-replace', 's-in-place', 's-reverse', 's-type')

  expected_output = svntest.wc.State(wc_dir, {
    's-replace'         : Item(prev_status = '  ', prev_treeconflict='C',
                               status='  ', treeconflict='A'),
    's-in-place'        : Item(status='U '),
    's-reverse'         : Item(status='  ', treeconflict='C'),
    's-type'            : Item(status='  ', treeconflict='C'),
  })
  expected_status.tweak(wc_rev=5)
  expected_status.tweak('s-replace', 's-reverse', 's-type', status='RM',
                        copied='+', treeconflict='C', wc_rev='-')
  expected_status.tweak('s-in-place', status=' M')

  svntest.actions.run_and_verify_update(wc_dir,
                                        expected_output,
                                        None,
                                        expected_status,
                                        check_props=True)

#----------------------------------------------------------------------
@Issue(4479)
def multiline_special(sbox):
  "multiline file with svn:special"

  sbox.build()
  wc_dir = sbox.wc_dir

  sbox.simple_append('iota', 'A second line.\n')
  sbox.simple_commit();
  tmp = sbox.get_tempname()
  svntest.main.file_write(tmp, '*', 'w+')
  svntest.main.run_svnmucc('propsetf', 'svn:special', tmp,
                           sbox.repo_url + '/iota',
                           '-m', 'set svn:special')

  sbox.simple_update(revision=1);
  sbox.simple_update();

  expected_disk = svntest.main.greek_state.copy()
  expected_disk.tweak()
  expected_disk.tweak('iota',
                      contents="This is the file 'iota'.\nA second line.\n",
                      props={'svn:special' : '*'})
  svntest.actions.verify_disk(wc_dir, expected_disk.old_tree(), True)

#----------------------------------------------------------------------
@Issue(4482)
@XFail(svntest.main.is_posix_os)
def multiline_symlink_special(sbox):
  "multiline link file with svn:special"

  sbox.build()
  wc_dir = sbox.wc_dir

  sbox.simple_append('dodgy-link1', 'link foo\n')
  sbox.simple_append('dodgy-link2', 'link foo\nbar\n')
  svntest.main.run_svnmucc('put', sbox.ospath('dodgy-link1'), 'dodgy-link1',
                           'put', sbox.ospath('dodgy-link2'), 'dodgy-link2',
                           'propset', 'svn:special', 'X', 'dodgy-link1',
                           'propset', 'svn:special', 'X', 'dodgy-link2',
                           '-U', sbox.repo_url,
                           '-m', 'Create dodgy symlinks')
  os.remove(sbox.ospath('dodgy-link1'))
  os.remove(sbox.ospath('dodgy-link2'))

  sbox.simple_update();

  expected_status = svntest.actions.get_virginal_state(wc_dir, 2)
  expected_status.add({
      'dodgy-link1' : Item(status='  ', wc_rev=2),
      'dodgy-link2' : Item(status='  ', wc_rev=2),
      })
  # XFAIL: Only content before \n used when creating the link but all
  # content used when detecting modifications, so the pristine working
  # copy shows up as modified.
  svntest.actions.run_and_verify_status(wc_dir, expected_status)

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


# list all tests here, starting with None:
test_list = [ None,
              general_symlink,
              replace_file_with_symlink,
              import_export_symlink,
              copy_tree_with_symlink,
              replace_symlink_with_file,
              remove_symlink,
              merge_symlink_into_file,
              merge_file_into_symlink,
              checkout_repo_with_symlinks,
              diff_symlink_to_dir,
              checkout_repo_with_unknown_special_type,
              replace_symlink_with_dir,
              update_obstructing_symlink,
              warn_on_reserved_name,
              propvalue_normalized,
              unrelated_changed_special_status,
              symlink_destination_change,
              merge_foreign_symlink,
              symlink_to_wc_basic,
              symlink_to_wc_svnversion,
              update_symlink,
              replace_symlinks,
              externals_as_symlink_targets,
              cat_added_symlink,
              incoming_symlink_changes,
              multiline_special,
              multiline_symlink_special,
             ]

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


### End of file.