filemerge: fix the wrong placements of messages in prompt

Mistakenly, the local-changed-other-deleted-message was put in
other-change-local-deleted and vice versa. This followups on D4336.

Thanks to Yuya who spotted this.

Differential Revision: https://phab.mercurial-scm.org/D4375

mercurial/filemerge.py

@@ -1,1015 +1,1015 b''
 # filemerge.py - file-level merge handling for Mercurial
 #
 # Copyright 2006, 2007, 2008 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import contextlib
 import os
 import re
 import shutil
 
 from .i18n import _
 from .node import nullid, short
 
 from . import (
     encoding,
     error,
     formatter,
     match,
     pycompat,
     registrar,
     scmutil,
     simplemerge,
     tagmerge,
     templatekw,
     templater,
     util,
 )
 
 from .utils import (
     procutil,
     stringutil,
 )
 
 def _toolstr(ui, tool, part, *args):
     return ui.config("merge-tools", tool + "." + part, *args)
 
 def _toolbool(ui, tool, part,*args):
     return ui.configbool("merge-tools", tool + "." + part, *args)
 
 def _toollist(ui, tool, part):
     return ui.configlist("merge-tools", tool + "." + part)
 
 internals = {}
 # Merge tools to document.
 internalsdoc = {}
 
 internaltool = registrar.internalmerge()
 
 # internal tool merge types
 nomerge = internaltool.nomerge
 mergeonly = internaltool.mergeonly # just the full merge, no premerge
 fullmerge = internaltool.fullmerge # both premerge and merge
 
 _localchangedotherdeletedmsg = _(
-    "file '%(fd)s' was deleted in local%(l)s but was modified in other%(o)s.\n"
+    "file '%(fd)s' was deleted in other%(o)s but was modified in local%(l)s.\n"
     "What do you want to do?\n"
     "use (c)hanged version, (d)elete, or leave (u)nresolved?"
     "$$ &Changed $$ &Delete $$ &Unresolved")
 
 _otherchangedlocaldeletedmsg = _(
-    "file '%(fd)s' was deleted in other%(o)s but was modified in local%(l)s.\n"
+    "file '%(fd)s' was deleted in local%(l)s but was modified in other%(o)s.\n"
     "What do you want to do?\n"
     "use (c)hanged version, leave (d)eleted, or "
     "leave (u)nresolved?"
     "$$ &Changed $$ &Deleted $$ &Unresolved")
 
 class absentfilectx(object):
     """Represents a file that's ostensibly in a context but is actually not
     present in it.
 
     This is here because it's very specific to the filemerge code for now --
     other code is likely going to break with the values this returns."""
     def __init__(self, ctx, f):
         self._ctx = ctx
         self._f = f
 
     def path(self):
         return self._f
 
     def size(self):
         return None
 
     def data(self):
         return None
 
     def filenode(self):
         return nullid
 
     _customcmp = True
     def cmp(self, fctx):
         """compare with other file context
 
         returns True if different from fctx.
         """
         return not (fctx.isabsent() and
                     fctx.ctx() == self.ctx() and
                     fctx.path() == self.path())
 
     def flags(self):
         return ''
 
     def changectx(self):
         return self._ctx
 
     def isbinary(self):
         return False
 
     def isabsent(self):
         return True
 
 def _findtool(ui, tool):
     if tool in internals:
         return tool
     cmd = _toolstr(ui, tool, "executable", tool)
     if cmd.startswith('python:'):
         return cmd
     return findexternaltool(ui, tool)
 
 def _quotetoolpath(cmd):
     if cmd.startswith('python:'):
         return cmd
     return procutil.shellquote(cmd)
 
 def findexternaltool(ui, tool):
     for kn in ("regkey", "regkeyalt"):
         k = _toolstr(ui, tool, kn)
         if not k:
             continue
         p = util.lookupreg(k, _toolstr(ui, tool, "regname"))
         if p:
             p = procutil.findexe(p + _toolstr(ui, tool, "regappend", ""))
             if p:
                 return p
     exe = _toolstr(ui, tool, "executable", tool)
     return procutil.findexe(util.expandpath(exe))
 
 def _picktool(repo, ui, path, binary, symlink, changedelete):
     strictcheck = ui.configbool('merge', 'strict-capability-check')
 
     def hascapability(tool, capability, strict=False):
         if tool in internals:
             return strict and internals[tool].capabilities.get(capability)
         return _toolbool(ui, tool, capability)
 
     def supportscd(tool):
         return tool in internals and internals[tool].mergetype == nomerge
 
     def check(tool, pat, symlink, binary, changedelete):
         tmsg = tool
         if pat:
             tmsg = _("%s (for pattern %s)") % (tool, pat)
         if not _findtool(ui, tool):
             if pat: # explicitly requested tool deserves a warning
                 ui.warn(_("couldn't find merge tool %s\n") % tmsg)
             else: # configured but non-existing tools are more silent
                 ui.note(_("couldn't find merge tool %s\n") % tmsg)
         elif symlink and not hascapability(tool, "symlink", strictcheck):
             ui.warn(_("tool %s can't handle symlinks\n") % tmsg)
         elif binary and not hascapability(tool, "binary", strictcheck):
             ui.warn(_("tool %s can't handle binary\n") % tmsg)
         elif changedelete and not supportscd(tool):
             # the nomerge tools are the only tools that support change/delete
             # conflicts
             pass
         elif not procutil.gui() and _toolbool(ui, tool, "gui"):
             ui.warn(_("tool %s requires a GUI\n") % tmsg)
         else:
             return True
         return False
 
     # internal config: ui.forcemerge
     # forcemerge comes from command line arguments, highest priority
     force = ui.config('ui', 'forcemerge')
     if force:
         toolpath = _findtool(ui, force)
         if changedelete and not supportscd(toolpath):
             return ":prompt", None
         else:
             if toolpath:
                 return (force, _quotetoolpath(toolpath))
             else:
                 # mimic HGMERGE if given tool not found
                 return (force, force)
 
     # HGMERGE takes next precedence
     hgmerge = encoding.environ.get("HGMERGE")
     if hgmerge:
         if changedelete and not supportscd(hgmerge):
             return ":prompt", None
         else:
             return (hgmerge, hgmerge)
 
     # then patterns
 
     # whether binary capability should be checked strictly
     binarycap = binary and strictcheck
 
     for pat, tool in ui.configitems("merge-patterns"):
         mf = match.match(repo.root, '', [pat])
         if mf(path) and check(tool, pat, symlink, binarycap, changedelete):
             if binary and not hascapability(tool, "binary", strict=True):
                 ui.warn(_("warning: check merge-patterns configurations,"
                           " if %r for binary file %r is unintentional\n"
                           "(see 'hg help merge-tools'"
                           " for binary files capability)\n")
                         % (pycompat.bytestr(tool), pycompat.bytestr(path)))
             toolpath = _findtool(ui, tool)
             return (tool, _quotetoolpath(toolpath))
 
     # then merge tools
     tools = {}
     disabled = set()
     for k, v in ui.configitems("merge-tools"):
         t = k.split('.')[0]
         if t not in tools:
             tools[t] = int(_toolstr(ui, t, "priority"))
         if _toolbool(ui, t, "disabled"):
             disabled.add(t)
     names = tools.keys()
     tools = sorted([(-p, tool) for tool, p in tools.items()
                     if tool not in disabled])
     uimerge = ui.config("ui", "merge")
     if uimerge:
         # external tools defined in uimerge won't be able to handle
         # change/delete conflicts
         if check(uimerge, path, symlink, binary, changedelete):
             if uimerge not in names and not changedelete:
                 return (uimerge, uimerge)
             tools.insert(0, (None, uimerge)) # highest priority
     tools.append((None, "hgmerge")) # the old default, if found
     for p, t in tools:
         if check(t, None, symlink, binary, changedelete):
             toolpath = _findtool(ui, t)
             return (t, _quotetoolpath(toolpath))
 
     # internal merge or prompt as last resort
     if symlink or binary or changedelete:
         if not changedelete and len(tools):
             # any tool is rejected by capability for symlink or binary
             ui.warn(_("no tool found to merge %s\n") % path)
         return ":prompt", None
     return ":merge", None
 
 def _eoltype(data):
     "Guess the EOL type of a file"
     if '\0' in data: # binary
         return None
     if '\r\n' in data: # Windows
         return '\r\n'
     if '\r' in data: # Old Mac
         return '\r'
     if '\n' in data: # UNIX
         return '\n'
     return None # unknown
 
 def _matcheol(file, back):
     "Convert EOL markers in a file to match origfile"
     tostyle = _eoltype(back.data()) # No repo.wread filters?
     if tostyle:
         data = util.readfile(file)
         style = _eoltype(data)
         if style:
             newdata = data.replace(style, tostyle)
             if newdata != data:
                 util.writefile(file, newdata)
 
 @internaltool('prompt', nomerge)
 def _iprompt(repo, mynode, orig, fcd, fco, fca, toolconf, labels=None):
     """Asks the user which of the local `p1()` or the other `p2()` version to
     keep as the merged version."""
     ui = repo.ui
     fd = fcd.path()
 
     # Avoid prompting during an in-memory merge since it doesn't support merge
     # conflicts.
     if fcd.changectx().isinmemory():
         raise error.InMemoryMergeConflictsError('in-memory merge does not '
                                                 'support file conflicts')
 
     prompts = partextras(labels)
     prompts['fd'] = fd
     try:
         if fco.isabsent():
             index = ui.promptchoice(
                 _localchangedotherdeletedmsg % prompts, 2)
             choice = ['local', 'other', 'unresolved'][index]
         elif fcd.isabsent():
             index = ui.promptchoice(
                 _otherchangedlocaldeletedmsg % prompts, 2)
             choice = ['other', 'local', 'unresolved'][index]
         else:
             index = ui.promptchoice(
                 _("keep (l)ocal%(l)s, take (o)ther%(o)s, or leave (u)nresolved"
                   " for %(fd)s?"
                   "$$ &Local $$ &Other $$ &Unresolved") % prompts, 2)
             choice = ['local', 'other', 'unresolved'][index]
 
         if choice == 'other':
             return _iother(repo, mynode, orig, fcd, fco, fca, toolconf,
                            labels)
         elif choice == 'local':
             return _ilocal(repo, mynode, orig, fcd, fco, fca, toolconf,
                            labels)
         elif choice == 'unresolved':
             return _ifail(repo, mynode, orig, fcd, fco, fca, toolconf,
                           labels)
     except error.ResponseExpected:
         ui.write("\n")
         return _ifail(repo, mynode, orig, fcd, fco, fca, toolconf,
                       labels)
 
 @internaltool('local', nomerge)
 def _ilocal(repo, mynode, orig, fcd, fco, fca, toolconf, labels=None):
     """Uses the local `p1()` version of files as the merged version."""
     return 0, fcd.isabsent()
 
 @internaltool('other', nomerge)
 def _iother(repo, mynode, orig, fcd, fco, fca, toolconf, labels=None):
     """Uses the other `p2()` version of files as the merged version."""
     if fco.isabsent():
         # local changed, remote deleted -- 'deleted' picked
         _underlyingfctxifabsent(fcd).remove()
         deleted = True
     else:
         _underlyingfctxifabsent(fcd).write(fco.data(), fco.flags())
         deleted = False
     return 0, deleted
 
 @internaltool('fail', nomerge)
 def _ifail(repo, mynode, orig, fcd, fco, fca, toolconf, labels=None):
     """
     Rather than attempting to merge files that were modified on both
     branches, it marks them as unresolved. The resolve command must be
     used to resolve these conflicts."""
     # for change/delete conflicts write out the changed version, then fail
     if fcd.isabsent():
         _underlyingfctxifabsent(fcd).write(fco.data(), fco.flags())
     return 1, False
 
 def _underlyingfctxifabsent(filectx):
     """Sometimes when resolving, our fcd is actually an absentfilectx, but
     we want to write to it (to do the resolve). This helper returns the
     underyling workingfilectx in that case.
     """
     if filectx.isabsent():
         return filectx.changectx()[filectx.path()]
     else:
         return filectx
 
 def _premerge(repo, fcd, fco, fca, toolconf, files, labels=None):
     tool, toolpath, binary, symlink, scriptfn = toolconf
     if symlink or fcd.isabsent() or fco.isabsent():
         return 1
     unused, unused, unused, back = files
 
     ui = repo.ui
 
     validkeep = ['keep', 'keep-merge3']
 
     # do we attempt to simplemerge first?
     try:
         premerge = _toolbool(ui, tool, "premerge", not binary)
     except error.ConfigError:
         premerge = _toolstr(ui, tool, "premerge", "").lower()
         if premerge not in validkeep:
             _valid = ', '.join(["'" + v + "'" for v in validkeep])
             raise error.ConfigError(_("%s.premerge not valid "
                                       "('%s' is neither boolean nor %s)") %
                                     (tool, premerge, _valid))
 
     if premerge:
         if premerge == 'keep-merge3':
             if not labels:
                 labels = _defaultconflictlabels
             if len(labels) < 3:
                 labels.append('base')
         r = simplemerge.simplemerge(ui, fcd, fca, fco, quiet=True, label=labels)
         if not r:
             ui.debug(" premerge successful\n")
             return 0
         if premerge not in validkeep:
             # restore from backup and try again
             _restorebackup(fcd, back)
     return 1 # continue merging
 
 def _mergecheck(repo, mynode, orig, fcd, fco, fca, toolconf):
     tool, toolpath, binary, symlink, scriptfn = toolconf
     if symlink:
         repo.ui.warn(_('warning: internal %s cannot merge symlinks '
                        'for %s\n') % (tool, fcd.path()))
         return False
     if fcd.isabsent() or fco.isabsent():
         repo.ui.warn(_('warning: internal %s cannot merge change/delete '
                        'conflict for %s\n') % (tool, fcd.path()))
         return False
     return True
 
 def _merge(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels, mode):
     """
     Uses the internal non-interactive simple merge algorithm for merging
     files. It will fail if there are any conflicts and leave markers in
     the partially merged file. Markers will have two sections, one for each side
     of merge, unless mode equals 'union' which suppresses the markers."""
     ui = repo.ui
 
     r = simplemerge.simplemerge(ui, fcd, fca, fco, label=labels, mode=mode)
     return True, r, False
 
 @internaltool('union', fullmerge,
               _("warning: conflicts while merging %s! "
                 "(edit, then use 'hg resolve --mark')\n"),
               precheck=_mergecheck)
 def _iunion(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None):
     """
     Uses the internal non-interactive simple merge algorithm for merging
     files. It will use both left and right sides for conflict regions.
     No markers are inserted."""
     return _merge(repo, mynode, orig, fcd, fco, fca, toolconf,
                   files, labels, 'union')
 
 @internaltool('merge', fullmerge,
               _("warning: conflicts while merging %s! "
                 "(edit, then use 'hg resolve --mark')\n"),
               precheck=_mergecheck)
 def _imerge(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None):
     """
     Uses the internal non-interactive simple merge algorithm for merging
     files. It will fail if there are any conflicts and leave markers in
     the partially merged file. Markers will have two sections, one for each side
     of merge."""
     return _merge(repo, mynode, orig, fcd, fco, fca, toolconf,
                   files, labels, 'merge')
 
 @internaltool('merge3', fullmerge,
               _("warning: conflicts while merging %s! "
                 "(edit, then use 'hg resolve --mark')\n"),
               precheck=_mergecheck)
 def _imerge3(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None):
     """
     Uses the internal non-interactive simple merge algorithm for merging
     files. It will fail if there are any conflicts and leave markers in
     the partially merged file. Marker will have three sections, one from each
     side of the merge and one for the base content."""
     if not labels:
         labels = _defaultconflictlabels
     if len(labels) < 3:
         labels.append('base')
     return _imerge(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels)
 
 def _imergeauto(repo, mynode, orig, fcd, fco, fca, toolconf, files,
                 labels=None, localorother=None):
     """
     Generic driver for _imergelocal and _imergeother
     """
     assert localorother is not None
     tool, toolpath, binary, symlink, scriptfn = toolconf
     r = simplemerge.simplemerge(repo.ui, fcd, fca, fco, label=labels,
                                 localorother=localorother)
     return True, r
 
 @internaltool('merge-local', mergeonly, precheck=_mergecheck)
 def _imergelocal(*args, **kwargs):
     """
     Like :merge, but resolve all conflicts non-interactively in favor
     of the local `p1()` changes."""
     success, status = _imergeauto(localorother='local', *args, **kwargs)
     return success, status, False
 
 @internaltool('merge-other', mergeonly, precheck=_mergecheck)
 def _imergeother(*args, **kwargs):
     """
     Like :merge, but resolve all conflicts non-interactively in favor
     of the other `p2()` changes."""
     success, status = _imergeauto(localorother='other', *args, **kwargs)
     return success, status, False
 
 @internaltool('tagmerge', mergeonly,
               _("automatic tag merging of %s failed! "
                 "(use 'hg resolve --tool :merge' or another merge "
                 "tool of your choice)\n"))
 def _itagmerge(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None):
     """
     Uses the internal tag merge algorithm (experimental).
     """
     success, status = tagmerge.merge(repo, fcd, fco, fca)
     return success, status, False
 
 @internaltool('dump', fullmerge, binary=True, symlink=True)
 def _idump(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None):
     """
     Creates three versions of the files to merge, containing the
     contents of local, other and base. These files can then be used to
     perform a merge manually. If the file to be merged is named
     ``a.txt``, these files will accordingly be named ``a.txt.local``,
     ``a.txt.other`` and ``a.txt.base`` and they will be placed in the
     same directory as ``a.txt``.
 
     This implies premerge. Therefore, files aren't dumped, if premerge
     runs successfully. Use :forcedump to forcibly write files out.
     """
     a = _workingpath(repo, fcd)
     fd = fcd.path()
 
     from . import context
     if isinstance(fcd, context.overlayworkingfilectx):
         raise error.InMemoryMergeConflictsError('in-memory merge does not '
                                                 'support the :dump tool.')
 
     util.writefile(a + ".local", fcd.decodeddata())
     repo.wwrite(fd + ".other", fco.data(), fco.flags())
     repo.wwrite(fd + ".base", fca.data(), fca.flags())
     return False, 1, False
 
 @internaltool('forcedump', mergeonly, binary=True, symlink=True)
 def _forcedump(repo, mynode, orig, fcd, fco, fca, toolconf, files,
                 labels=None):
     """
     Creates three versions of the files as same as :dump, but omits premerge.
     """
     return _idump(repo, mynode, orig, fcd, fco, fca, toolconf, files,
                 labels=labels)
 
 def _xmergeimm(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None):
     # In-memory merge simply raises an exception on all external merge tools,
     # for now.
     #
     # It would be possible to run most tools with temporary files, but this
     # raises the question of what to do if the user only partially resolves the
     # file -- we can't leave a merge state. (Copy to somewhere in the .hg/
     # directory and tell the user how to get it is my best idea, but it's
     # clunky.)
     raise error.InMemoryMergeConflictsError('in-memory merge does not support '
                                             'external merge tools')
 
 def _xmerge(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None):
     tool, toolpath, binary, symlink, scriptfn = toolconf
     if fcd.isabsent() or fco.isabsent():
         repo.ui.warn(_('warning: %s cannot merge change/delete conflict '
                        'for %s\n') % (tool, fcd.path()))
         return False, 1, None
     unused, unused, unused, back = files
     localpath = _workingpath(repo, fcd)
     args = _toolstr(repo.ui, tool, "args")
 
     with _maketempfiles(repo, fco, fca, repo.wvfs.join(back.path()),
                         "$output" in args) as temppaths:
         basepath, otherpath, localoutputpath = temppaths
         outpath = ""
         mylabel, otherlabel = labels[:2]
         if len(labels) >= 3:
             baselabel = labels[2]
         else:
             baselabel = 'base'
         env = {'HG_FILE': fcd.path(),
                'HG_MY_NODE': short(mynode),
                'HG_OTHER_NODE': short(fco.changectx().node()),
                'HG_BASE_NODE': short(fca.changectx().node()),
                'HG_MY_ISLINK': 'l' in fcd.flags(),
                'HG_OTHER_ISLINK': 'l' in fco.flags(),
                'HG_BASE_ISLINK': 'l' in fca.flags(),
                'HG_MY_LABEL': mylabel,
                'HG_OTHER_LABEL': otherlabel,
                'HG_BASE_LABEL': baselabel,
                }
         ui = repo.ui
 
         if "$output" in args:
             # read input from backup, write to original
             outpath = localpath
             localpath = localoutputpath
         replace = {'local': localpath, 'base': basepath, 'other': otherpath,
                    'output': outpath, 'labellocal': mylabel,
                    'labelother': otherlabel, 'labelbase': baselabel}
         args = util.interpolate(
             br'\$', replace, args,
             lambda s: procutil.shellquote(util.localpath(s)))
         if _toolbool(ui, tool, "gui"):
             repo.ui.status(_('running merge tool %s for file %s\n') %
                            (tool, fcd.path()))
         if scriptfn is None:
             cmd = toolpath + ' ' + args
             repo.ui.debug('launching merge tool: %s\n' % cmd)
             r = ui.system(cmd, cwd=repo.root, environ=env,
                           blockedtag='mergetool')
         else:
             repo.ui.debug('launching python merge script: %s:%s\n' %
                           (toolpath, scriptfn))
             r = 0
             try:
                 # avoid cycle cmdutil->merge->filemerge->extensions->cmdutil
                 from . import extensions
                 mod = extensions.loadpath(toolpath, 'hgmerge.%s' % tool)
             except Exception:
                 raise error.Abort(_("loading python merge script failed: %s") %
                                   toolpath)
             mergefn = getattr(mod, scriptfn, None)
             if mergefn is None:
                 raise error.Abort(_("%s does not have function: %s") %
                                   (toolpath, scriptfn))
             argslist = procutil.shellsplit(args)
             # avoid cycle cmdutil->merge->filemerge->hook->extensions->cmdutil
             from . import hook
             ret, raised = hook.pythonhook(ui, repo, "merge", toolpath,
                                           mergefn, {'args': argslist}, True)
             if raised:
                 r = 1
         repo.ui.debug('merge tool returned: %d\n' % r)
         return True, r, False
 
 def _formatconflictmarker(ctx, template, label, pad):
     """Applies the given template to the ctx, prefixed by the label.
 
     Pad is the minimum width of the label prefix, so that multiple markers
     can have aligned templated parts.
     """
     if ctx.node() is None:
         ctx = ctx.p1()
 
     props = {'ctx': ctx}
     templateresult = template.renderdefault(props)
 
     label = ('%s:' % label).ljust(pad + 1)
     mark = '%s %s' % (label, templateresult)
 
     if mark:
         mark = mark.splitlines()[0] # split for safety
 
     # 8 for the prefix of conflict marker lines (e.g. '<<<<<<< ')
     return stringutil.ellipsis(mark, 80 - 8)
 
 _defaultconflictlabels = ['local', 'other']
 
 def _formatlabels(repo, fcd, fco, fca, labels, tool=None):
     """Formats the given labels using the conflict marker template.
 
     Returns a list of formatted labels.
     """
     cd = fcd.changectx()
     co = fco.changectx()
     ca = fca.changectx()
 
     ui = repo.ui
     template = ui.config('ui', 'mergemarkertemplate')
     if tool is not None:
         template = _toolstr(ui, tool, 'mergemarkertemplate', template)
     template = templater.unquotestring(template)
     tres = formatter.templateresources(ui, repo)
     tmpl = formatter.maketemplater(ui, template, defaults=templatekw.keywords,
                                    resources=tres)
 
     pad = max(len(l) for l in labels)
 
     newlabels = [_formatconflictmarker(cd, tmpl, labels[0], pad),
                  _formatconflictmarker(co, tmpl, labels[1], pad)]
     if len(labels) > 2:
         newlabels.append(_formatconflictmarker(ca, tmpl, labels[2], pad))
     return newlabels
 
 def partextras(labels):
     """Return a dictionary of extra labels for use in prompts to the user
 
     Intended use is in strings of the form "(l)ocal%(l)s".
     """
     if labels is None:
         return {
             "l": "",
             "o": "",
         }
 
     return {
         "l": " [%s]" % labels[0],
         "o": " [%s]" % labels[1],
     }
 
 def _restorebackup(fcd, back):
     # TODO: Add a workingfilectx.write(otherfilectx) path so we can use
     # util.copy here instead.
     fcd.write(back.data(), fcd.flags())
 
 def _makebackup(repo, ui, wctx, fcd, premerge):
     """Makes and returns a filectx-like object for ``fcd``'s backup file.
 
     In addition to preserving the user's pre-existing modifications to `fcd`
     (if any), the backup is used to undo certain premerges, confirm whether a
     merge changed anything, and determine what line endings the new file should
     have.
 
     Backups only need to be written once (right before the premerge) since their
     content doesn't change afterwards.
     """
     if fcd.isabsent():
         return None
     # TODO: Break this import cycle somehow. (filectx -> ctx -> fileset ->
     # merge -> filemerge). (I suspect the fileset import is the weakest link)
     from . import context
     a = _workingpath(repo, fcd)
     back = scmutil.origpath(ui, repo, a)
     inworkingdir = (back.startswith(repo.wvfs.base) and not
         back.startswith(repo.vfs.base))
     if isinstance(fcd, context.overlayworkingfilectx) and inworkingdir:
         # If the backup file is to be in the working directory, and we're
         # merging in-memory, we must redirect the backup to the memory context
         # so we don't disturb the working directory.
         relpath = back[len(repo.wvfs.base) + 1:]
         if premerge:
             wctx[relpath].write(fcd.data(), fcd.flags())
         return wctx[relpath]
     else:
         if premerge:
             # Otherwise, write to wherever path the user specified the backups
             # should go. We still need to switch based on whether the source is
             # in-memory so we can use the fast path of ``util.copy`` if both are
             # on disk.
             if isinstance(fcd, context.overlayworkingfilectx):
                 util.writefile(back, fcd.data())
             else:
                 util.copyfile(a, back)
         # A arbitraryfilectx is returned, so we can run the same functions on
         # the backup context regardless of where it lives.
         return context.arbitraryfilectx(back, repo=repo)
 
 @contextlib.contextmanager
 def _maketempfiles(repo, fco, fca, localpath, uselocalpath):
     """Writes out `fco` and `fca` as temporary files, and (if uselocalpath)
     copies `localpath` to another temporary file, so an external merge tool may
     use them.
     """
     tmproot = None
     tmprootprefix = repo.ui.config('experimental', 'mergetempdirprefix')
     if tmprootprefix:
         tmproot = pycompat.mkdtemp(prefix=tmprootprefix)
 
     def maketempfrompath(prefix, path):
         fullbase, ext = os.path.splitext(path)
         pre = "%s~%s" % (os.path.basename(fullbase), prefix)
         if tmproot:
             name = os.path.join(tmproot, pre)
             if ext:
                 name += ext
             f = open(name, r"wb")
         else:
             fd, name = pycompat.mkstemp(prefix=pre + '.', suffix=ext)
             f = os.fdopen(fd, r"wb")
         return f, name
 
     def tempfromcontext(prefix, ctx):
         f, name = maketempfrompath(prefix, ctx.path())
         data = repo.wwritedata(ctx.path(), ctx.data())
         f.write(data)
         f.close()
         return name
 
     b = tempfromcontext("base", fca)
     c = tempfromcontext("other", fco)
     d = localpath
     if uselocalpath:
         # We start off with this being the backup filename, so remove the .orig
         # to make syntax-highlighting more likely.
         if d.endswith('.orig'):
             d, _ = os.path.splitext(d)
         f, d = maketempfrompath("local", d)
         with open(localpath, 'rb') as src:
             f.write(src.read())
         f.close()
 
     try:
         yield b, c, d
     finally:
         if tmproot:
             shutil.rmtree(tmproot)
         else:
             util.unlink(b)
             util.unlink(c)
             # if not uselocalpath, d is the 'orig'/backup file which we
             # shouldn't delete.
             if d and uselocalpath:
                 util.unlink(d)
 
 def _filemerge(premerge, repo, wctx, mynode, orig, fcd, fco, fca, labels=None):
     """perform a 3-way merge in the working directory
 
     premerge = whether this is a premerge
     mynode = parent node before merge
     orig = original local filename before merge
     fco = other file context
     fca = ancestor file context
     fcd = local file context for current/destination file
 
     Returns whether the merge is complete, the return value of the merge, and
     a boolean indicating whether the file was deleted from disk."""
 
     if not fco.cmp(fcd): # files identical?
         return True, None, False
 
     ui = repo.ui
     fd = fcd.path()
     binary = fcd.isbinary() or fco.isbinary() or fca.isbinary()
     symlink = 'l' in fcd.flags() + fco.flags()
     changedelete = fcd.isabsent() or fco.isabsent()
     tool, toolpath = _picktool(repo, ui, fd, binary, symlink, changedelete)
     scriptfn = None
     if tool in internals and tool.startswith('internal:'):
         # normalize to new-style names (':merge' etc)
         tool = tool[len('internal'):]
     if toolpath and toolpath.startswith('python:'):
         invalidsyntax = False
         if toolpath.count(':') >= 2:
             script, scriptfn = toolpath[7:].rsplit(':', 1)
             if not scriptfn:
                 invalidsyntax = True
             # missing :callable can lead to spliting on windows drive letter
             if '\\' in scriptfn or '/' in scriptfn:
                 invalidsyntax = True
         else:
             invalidsyntax = True
         if invalidsyntax:
             raise error.Abort(_("invalid 'python:' syntax: %s") % toolpath)
         toolpath = script
     ui.debug("picked tool '%s' for %s (binary %s symlink %s changedelete %s)\n"
              % (tool, fd, pycompat.bytestr(binary), pycompat.bytestr(symlink),
                     pycompat.bytestr(changedelete)))
 
     if tool in internals:
         func = internals[tool]
         mergetype = func.mergetype
         onfailure = func.onfailure
         precheck = func.precheck
         isexternal = False
     else:
         if wctx.isinmemory():
             func = _xmergeimm
         else:
             func = _xmerge
         mergetype = fullmerge
         onfailure = _("merging %s failed!\n")
         precheck = None
         isexternal = True
 
     toolconf = tool, toolpath, binary, symlink, scriptfn
 
     if mergetype == nomerge:
         r, deleted = func(repo, mynode, orig, fcd, fco, fca, toolconf, labels)
         return True, r, deleted
 
     if premerge:
         if orig != fco.path():
             ui.status(_("merging %s and %s to %s\n") % (orig, fco.path(), fd))
         else:
             ui.status(_("merging %s\n") % fd)
 
     ui.debug("my %s other %s ancestor %s\n" % (fcd, fco, fca))
 
     if precheck and not precheck(repo, mynode, orig, fcd, fco, fca,
                                  toolconf):
         if onfailure:
             if wctx.isinmemory():
                 raise error.InMemoryMergeConflictsError('in-memory merge does '
                                                         'not support merge '
                                                         'conflicts')
             ui.warn(onfailure % fd)
         return True, 1, False
 
     back = _makebackup(repo, ui, wctx, fcd, premerge)
     files = (None, None, None, back)
     r = 1
     try:
         internalmarkerstyle = ui.config('ui', 'mergemarkers')
         if isexternal:
             markerstyle = _toolstr(ui, tool, 'mergemarkers')
         else:
             markerstyle = internalmarkerstyle
 
         if not labels:
             labels = _defaultconflictlabels
         formattedlabels = labels
         if markerstyle != 'basic':
             formattedlabels = _formatlabels(repo, fcd, fco, fca, labels,
                                             tool=tool)
 
         if premerge and mergetype == fullmerge:
             # conflict markers generated by premerge will use 'detailed'
             # settings if either ui.mergemarkers or the tool's mergemarkers
             # setting is 'detailed'. This way tools can have basic labels in
             # space-constrained areas of the UI, but still get full information
             # in conflict markers if premerge is 'keep' or 'keep-merge3'.
             premergelabels = labels
             labeltool = None
             if markerstyle != 'basic':
                 # respect 'tool's mergemarkertemplate (which defaults to
                 # ui.mergemarkertemplate)
                 labeltool = tool
             if internalmarkerstyle != 'basic' or markerstyle != 'basic':
                 premergelabels = _formatlabels(repo, fcd, fco, fca,
                                                premergelabels, tool=labeltool)
 
             r = _premerge(repo, fcd, fco, fca, toolconf, files,
                           labels=premergelabels)
             # complete if premerge successful (r is 0)
             return not r, r, False
 
         needcheck, r, deleted = func(repo, mynode, orig, fcd, fco, fca,
                                      toolconf, files, labels=formattedlabels)
 
         if needcheck:
             r = _check(repo, r, ui, tool, fcd, files)
 
         if r:
             if onfailure:
                 if wctx.isinmemory():
                     raise error.InMemoryMergeConflictsError('in-memory merge '
                                                             'does not support '
                                                             'merge conflicts')
                 ui.warn(onfailure % fd)
             _onfilemergefailure(ui)
 
         return True, r, deleted
     finally:
         if not r and back is not None:
             back.remove()
 
 def _haltmerge():
     msg = _('merge halted after failed merge (see hg resolve)')
     raise error.InterventionRequired(msg)
 
 def _onfilemergefailure(ui):
     action = ui.config('merge', 'on-failure')
     if action == 'prompt':
         msg = _('continue merge operation (yn)?' '$$ &Yes $$ &No')
         if ui.promptchoice(msg, 0) == 1:
             _haltmerge()
     if action == 'halt':
         _haltmerge()
     # default action is 'continue', in which case we neither prompt nor halt
 
 def hasconflictmarkers(data):
     return bool(re.search("^(<<<<<<< .*|=======|>>>>>>> .*)$", data,
                           re.MULTILINE))
 
 def _check(repo, r, ui, tool, fcd, files):
     fd = fcd.path()
     unused, unused, unused, back = files
 
     if not r and (_toolbool(ui, tool, "checkconflicts") or
                   'conflicts' in _toollist(ui, tool, "check")):
         if hasconflictmarkers(fcd.data()):
             r = 1
 
     checked = False
     if 'prompt' in _toollist(ui, tool, "check"):
         checked = True
         if ui.promptchoice(_("was merge of '%s' successful (yn)?"
                              "$$ &Yes $$ &No") % fd, 1):
             r = 1
 
     if not r and not checked and (_toolbool(ui, tool, "checkchanged") or
                                   'changed' in
                                   _toollist(ui, tool, "check")):
         if back is not None and not fcd.cmp(back):
             if ui.promptchoice(_(" output file %s appears unchanged\n"
                                  "was merge successful (yn)?"
                                  "$$ &Yes $$ &No") % fd, 1):
                 r = 1
 
     if back is not None and _toolbool(ui, tool, "fixeol"):
         _matcheol(_workingpath(repo, fcd), back)
 
     return r
 
 def _workingpath(repo, ctx):
     return repo.wjoin(ctx.path())
 
 def premerge(repo, wctx, mynode, orig, fcd, fco, fca, labels=None):
     return _filemerge(True, repo, wctx, mynode, orig, fcd, fco, fca,
                       labels=labels)
 
 def filemerge(repo, wctx, mynode, orig, fcd, fco, fca, labels=None):
     return _filemerge(False, repo, wctx, mynode, orig, fcd, fco, fca,
                       labels=labels)
 
 def loadinternalmerge(ui, extname, registrarobj):
     """Load internal merge tool from specified registrarobj
     """
     for name, func in registrarobj._table.iteritems():
         fullname = ':' + name
         internals[fullname] = func
         internals['internal:' + name] = func
         internalsdoc[fullname] = func
 
         capabilities = sorted([k for k, v in func.capabilities.items() if v])
         if capabilities:
             capdesc = "    (actual capabilities: %s)" % ', '.join(capabilities)
             func.__doc__ = (func.__doc__ +
                             pycompat.sysstr("\n\n%s" % capdesc))
 
     # to put i18n comments into hg.pot for automatically generated texts
 
     # i18n: "binary" and "symlik" are keywords
     # i18n: this text is added automatically
     _("    (actual capabilities: binary, symlink)")
     # i18n: "binary" is keyword
     # i18n: this text is added automatically
     _("    (actual capabilities: binary)")
     # i18n: "symlink" is keyword
     # i18n: this text is added automatically
     _("    (actual capabilities: symlink)")
 
 # load built-in merge tools explicitly to setup internalsdoc
 loadinternalmerge(None, None, internaltool)
 
 # tell hggettext to extract docstrings from these functions:
 i18nfunctions = internals.values()

tests/test-commit-amend.t

@@ -1,1284 +1,1284 b''
   $ hg init
 
 Setup:
 
   $ echo a >> a
   $ hg ci -Am 'base'
   adding a
 
 Refuse to amend public csets:
 
   $ hg phase -r . -p
   $ hg ci --amend
   abort: cannot amend public changesets
   (see 'hg help phases' for details)
   [255]
   $ hg phase -r . -f -d
 
   $ echo a >> a
   $ hg ci -Am 'base1'
 
 Nothing to amend:
 
   $ hg ci --amend -m 'base1'
   nothing changed
   [1]
 
   $ cat >> $HGRCPATH <<EOF
   > [hooks]
   > pretxncommit.foo = sh -c "echo \\"pretxncommit \$HG_NODE\\"; hg id -r \$HG_NODE"
   > EOF
 
 Amending changeset with changes in working dir:
 (and check that --message does not trigger an editor)
 
   $ echo a >> a
   $ HGEDITOR="\"sh\" \"`pwd`/editor.sh\"" hg commit --amend -m 'amend base1'
   pretxncommit 43f1ba15f28a50abf0aae529cf8a16bfced7b149
   43f1ba15f28a tip
   saved backup bundle to $TESTTMP/.hg/strip-backup/489edb5b847d-5ab4f721-amend.hg
   $ echo 'pretxncommit.foo = ' >> $HGRCPATH
   $ hg diff -c .
   diff -r ad120869acf0 -r 43f1ba15f28a a
   --- a/a	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,3 @@
    a
   +a
   +a
   $ hg log
   changeset:   1:43f1ba15f28a
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     amend base1
   
   changeset:   0:ad120869acf0
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     base
   
 
 Check proper abort for empty message
 
   $ cat > editor.sh << '__EOF__'
   > #!/bin/sh
   > echo "" > "$1"
   > __EOF__
 
 Update the existing file to ensure that the dirstate is not in pending state
 (where the status of some files in the working copy is not known yet). This in
 turn ensures that when the transaction is aborted due to an empty message during
 the amend, there should be no rollback.
   $ echo a >> a
 
   $ echo b > b
   $ hg add b
   $ hg summary
   parent: 1:43f1ba15f28a tip
    amend base1
   branch: default
   commit: 1 modified, 1 added, 1 unknown
   update: (current)
   phases: 2 draft
   $ HGEDITOR="\"sh\" \"`pwd`/editor.sh\"" hg commit --amend
   abort: empty commit message
   [255]
   $ hg summary
   parent: 1:43f1ba15f28a tip
    amend base1
   branch: default
   commit: 1 modified, 1 added, 1 unknown
   update: (current)
   phases: 2 draft
 
 Add new file along with modified existing file:
   $ hg ci --amend -m 'amend base1 new file'
   saved backup bundle to $TESTTMP/.hg/strip-backup/43f1ba15f28a-007467c2-amend.hg
 
 Remove file that was added in amended commit:
 (and test logfile option)
 (and test that logfile option do not trigger an editor)
 
   $ hg rm b
   $ echo 'amend base1 remove new file' > ../logfile
   $ HGEDITOR="\"sh\" \"`pwd`/editor.sh\"" hg ci --amend --logfile ../logfile
   saved backup bundle to $TESTTMP/.hg/strip-backup/c16295aaf401-1ada9901-amend.hg
 
   $ hg cat b
   b: no such file in rev 47343646fa3d
   [1]
 
 No changes, just a different message:
 
   $ hg ci -v --amend -m 'no changes, new message'
   amending changeset 47343646fa3d
   copying changeset 47343646fa3d to ad120869acf0
   committing files:
   a
   committing manifest
   committing changelog
   1 changesets found
   uncompressed size of bundle content:
        254 (changelog)
        163 (manifests)
        131  a
   saved backup bundle to $TESTTMP/.hg/strip-backup/47343646fa3d-c2758885-amend.hg
   1 changesets found
   uncompressed size of bundle content:
        250 (changelog)
        163 (manifests)
        131  a
   adding branch
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   committed changeset 1:401431e913a1
   $ hg diff -c .
   diff -r ad120869acf0 -r 401431e913a1 a
   --- a/a	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,4 @@
    a
   +a
   +a
   +a
   $ hg log
   changeset:   1:401431e913a1
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     no changes, new message
   
   changeset:   0:ad120869acf0
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     base
   
 
 Disable default date on commit so when -d isn't given, the old date is preserved:
 
   $ echo '[defaults]' >> $HGRCPATH
   $ echo 'commit=' >> $HGRCPATH
 
 Test -u/-d:
 
   $ cat > .hg/checkeditform.sh <<EOF
   > env | grep HGEDITFORM
   > true
   > EOF
   $ HGEDITOR="sh .hg/checkeditform.sh" hg ci --amend -u foo -d '1 0'
   HGEDITFORM=commit.amend.normal
   saved backup bundle to $TESTTMP/.hg/strip-backup/401431e913a1-5e8e532c-amend.hg
   $ echo a >> a
   $ hg ci --amend -u foo -d '1 0'
   saved backup bundle to $TESTTMP/.hg/strip-backup/d96b1d28ae33-677e0afb-amend.hg
   $ hg log -r .
   changeset:   1:a9a13940fc03
   tag:         tip
   user:        foo
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     no changes, new message
   
 
 Open editor with old commit message if a message isn't given otherwise:
 
   $ cat > editor.sh << '__EOF__'
   > #!/bin/sh
   > cat $1
   > echo "another precious commit message" > "$1"
   > __EOF__
 
 at first, test saving last-message.txt
 
   $ cat > .hg/hgrc << '__EOF__'
   > [hooks]
   > pretxncommit.test-saving-last-message = false
   > __EOF__
 
   $ rm -f .hg/last-message.txt
   $ hg commit --amend -v -m "message given from command line"
   amending changeset a9a13940fc03
   copying changeset a9a13940fc03 to ad120869acf0
   committing files:
   a
   committing manifest
   committing changelog
   running hook pretxncommit.test-saving-last-message: false
   transaction abort!
   rollback completed
   abort: pretxncommit.test-saving-last-message hook exited with status 1
   [255]
   $ cat .hg/last-message.txt
   message given from command line (no-eol)
 
   $ rm -f .hg/last-message.txt
   $ HGEDITOR="\"sh\" \"`pwd`/editor.sh\"" hg commit --amend -v
   amending changeset a9a13940fc03
   copying changeset a9a13940fc03 to ad120869acf0
   no changes, new message
   
   
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: foo
   HG: branch 'default'
   HG: changed a
   committing files:
   a
   committing manifest
   committing changelog
   running hook pretxncommit.test-saving-last-message: false
   transaction abort!
   rollback completed
   abort: pretxncommit.test-saving-last-message hook exited with status 1
   [255]
 
   $ cat .hg/last-message.txt
   another precious commit message
 
   $ cat > .hg/hgrc << '__EOF__'
   > [hooks]
   > pretxncommit.test-saving-last-message =
   > __EOF__
 
 then, test editing custom commit message
 
   $ HGEDITOR="\"sh\" \"`pwd`/editor.sh\"" hg commit --amend -v
   amending changeset a9a13940fc03
   copying changeset a9a13940fc03 to ad120869acf0
   no changes, new message
   
   
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: foo
   HG: branch 'default'
   HG: changed a
   committing files:
   a
   committing manifest
   committing changelog
   1 changesets found
   uncompressed size of bundle content:
        249 (changelog)
        163 (manifests)
        133  a
   saved backup bundle to $TESTTMP/.hg/strip-backup/a9a13940fc03-7c2e8674-amend.hg
   1 changesets found
   uncompressed size of bundle content:
        257 (changelog)
        163 (manifests)
        133  a
   adding branch
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   committed changeset 1:64a124ba1b44
 
 Same, but with changes in working dir (different code path):
 
   $ echo a >> a
   $ HGEDITOR="\"sh\" \"`pwd`/editor.sh\"" hg commit --amend -v
   amending changeset 64a124ba1b44
   another precious commit message
   
   
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: foo
   HG: branch 'default'
   HG: changed a
   committing files:
   a
   committing manifest
   committing changelog
   1 changesets found
   uncompressed size of bundle content:
        257 (changelog)
        163 (manifests)
        133  a
   saved backup bundle to $TESTTMP/.hg/strip-backup/64a124ba1b44-10374b8f-amend.hg
   1 changesets found
   uncompressed size of bundle content:
        257 (changelog)
        163 (manifests)
        135  a
   adding branch
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   committed changeset 1:7892795b8e38
 
   $ rm editor.sh
   $ hg log -r .
   changeset:   1:7892795b8e38
   tag:         tip
   user:        foo
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     another precious commit message
   
 
 Moving bookmarks, preserve active bookmark:
 
   $ hg book book1
   $ hg book book2
   $ hg ci --amend -m 'move bookmarks'
   saved backup bundle to $TESTTMP/.hg/strip-backup/7892795b8e38-3fb46217-amend.hg
   $ hg book
      book1                     1:8311f17e2616
    * book2                     1:8311f17e2616
   $ echo a >> a
   $ hg ci --amend -m 'move bookmarks'
   saved backup bundle to $TESTTMP/.hg/strip-backup/8311f17e2616-f0504fe3-amend.hg
   $ hg book
      book1                     1:a3b65065808c
    * book2                     1:a3b65065808c
 
 abort does not loose bookmarks
 
   $ cat > editor.sh << '__EOF__'
   > #!/bin/sh
   > echo "" > "$1"
   > __EOF__
   $ echo a >> a
   $ HGEDITOR="\"sh\" \"`pwd`/editor.sh\"" hg commit --amend
   abort: empty commit message
   [255]
   $ hg book
      book1                     1:a3b65065808c
    * book2                     1:a3b65065808c
   $ hg revert -Caq
   $ rm editor.sh
 
   $ echo '[defaults]' >> $HGRCPATH
   $ echo "commit=-d '0 0'" >> $HGRCPATH
 
 Moving branches:
 
   $ hg branch foo
   marked working directory as branch foo
   (branches are permanent and global, did you want a bookmark?)
   $ echo a >> a
   $ hg ci -m 'branch foo'
   $ hg branch default -f
   marked working directory as branch default
   $ hg ci --amend -m 'back to default'
   saved backup bundle to $TESTTMP/.hg/strip-backup/f8339a38efe1-c18453c9-amend.hg
   $ hg branches
   default                        2:9c07515f2650
 
 Close branch:
 
   $ hg up -q 0
   $ echo b >> b
   $ hg branch foo
   marked working directory as branch foo
   (branches are permanent and global, did you want a bookmark?)
   $ hg ci -Am 'fork'
   adding b
   $ echo b >> b
   $ hg ci -mb
   $ hg ci --amend --close-branch -m 'closing branch foo'
   saved backup bundle to $TESTTMP/.hg/strip-backup/c962248fa264-54245dc7-amend.hg
 
 Same thing, different code path:
 
   $ echo b >> b
   $ hg ci -m 'reopen branch'
   reopening closed branch head 4
   $ echo b >> b
   $ hg ci --amend --close-branch
   saved backup bundle to $TESTTMP/.hg/strip-backup/027371728205-b900d9fa-amend.hg
   $ hg branches
   default                        2:9c07515f2650
 
 Refuse to amend during a merge:
 
   $ hg up -q default
   $ hg merge foo
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci --amend
   abort: cannot amend while merging
   [255]
   $ hg ci -m 'merge'
 
 Refuse to amend if there is a merge conflict (issue5805):
 
   $ hg up -q foo
   $ echo c > a
   $ hg up default -t :fail
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges
   [1]
   $ hg resolve -l
   U a
 
   $ hg ci --amend
   abort: unresolved merge conflicts (see 'hg help resolve')
   [255]
 
   $ hg up -qC .
 
 Follow copies/renames:
 
   $ hg mv b c
   $ hg ci -m 'b -> c'
   $ hg mv c d
   $ hg ci --amend -m 'b -> d'
   saved backup bundle to $TESTTMP/.hg/strip-backup/42f3f27a067d-f23cc9f7-amend.hg
   $ hg st --rev '.^' --copies d
   A d
     b
   $ hg cp d e
   $ hg ci -m 'e = d'
   $ hg cp e f
   $ hg ci --amend -m 'f = d'
   saved backup bundle to $TESTTMP/.hg/strip-backup/9198f73182d5-251d584a-amend.hg
   $ hg st --rev '.^' --copies f
   A f
     d
 
   $ mv f f.orig
   $ hg rm -A f
   $ hg ci -m removef
   $ hg cp a f
   $ mv f.orig f
   $ hg ci --amend -m replacef
   saved backup bundle to $TESTTMP/.hg/strip-backup/f0993ab6b482-eda301bf-amend.hg
   $ hg st --change . --copies
   $ hg log -r . --template "{file_copies}\n"
   
 
 Move added file (issue3410):
 
   $ echo g >> g
   $ hg ci -Am g
   adding g
   $ hg mv g h
   $ hg ci --amend
   saved backup bundle to $TESTTMP/.hg/strip-backup/58585e3f095c-0f5ebcda-amend.hg
   $ hg st --change . --copies h
   A h
   $ hg log -r . --template "{file_copies}\n"
   
 
 Can't rollback an amend:
 
   $ hg rollback
   no rollback information available
   [1]
 
 Preserve extra dict (issue3430):
 
   $ hg branch a
   marked working directory as branch a
   (branches are permanent and global, did you want a bookmark?)
   $ echo a >> a
   $ hg ci -ma
   $ hg ci --amend -m "a'"
   saved backup bundle to $TESTTMP/.hg/strip-backup/39a162f1d65e-9dfe13d8-amend.hg
   $ hg log -r . --template "{branch}\n"
   a
   $ hg ci --amend -m "a''"
   saved backup bundle to $TESTTMP/.hg/strip-backup/d5ca7b1ac72b-0b4c1a34-amend.hg
   $ hg log -r . --template "{branch}\n"
   a
 
 Also preserve other entries in the dict that are in the old commit,
 first graft something so there's an additional entry:
 
   $ hg up 0 -q
   $ echo z > z
   $ hg ci -Am 'fork'
   adding z
   created new head
   $ hg up 11
   5 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg graft 12
   grafting 12:2647734878ef "fork" (tip)
   $ hg ci --amend -m 'graft amend'
   saved backup bundle to $TESTTMP/.hg/strip-backup/fe8c6f7957ca-25638666-amend.hg
   $ hg log -r . --debug | grep extra
   extra:       amend_source=fe8c6f7957ca1665ed77496ed7a07657d469ac60
   extra:       branch=a
   extra:       source=2647734878ef0236dda712fae9c1651cf694ea8a
 
 Preserve phase
 
   $ hg phase '.^::.'
   11: draft
   13: draft
   $ hg phase --secret --force .
   $ hg phase '.^::.'
   11: draft
   13: secret
   $ hg commit --amend -m 'amend for phase' -q
   $ hg phase '.^::.'
   11: draft
   13: secret
 
 Test amend with obsolete
 ---------------------------
 
 Enable obsolete
 
   $ cat >> $HGRCPATH << EOF
   > [experimental]
   > evolution.createmarkers=True
   > evolution.allowunstable=True
   > EOF
 
 Amend with no files changes
 
   $ hg id -n
   13
   $ hg ci --amend -m 'babar'
   $ hg id -n
   14
   $ hg log -Gl 3 --style=compact
   @  14[tip]:11   682950e85999   1970-01-01 00:00 +0000   test
   |    babar
   |
   | o  12:0   2647734878ef   1970-01-01 00:00 +0000   test
   | |    fork
   | ~
   o  11   0ddb275cfad1   1970-01-01 00:00 +0000   test
   |    a''
   ~
   $ hg log -Gl 4 --hidden --style=compact
   @  14[tip]:11   682950e85999   1970-01-01 00:00 +0000   test
   |    babar
   |
   | x  13:11   5167600b0f7a   1970-01-01 00:00 +0000   test
   |/     amend for phase
   |
   | o  12:0   2647734878ef   1970-01-01 00:00 +0000   test
   | |    fork
   | ~
   o  11   0ddb275cfad1   1970-01-01 00:00 +0000   test
   |    a''
   ~
 
 Amend with files changes
 
 (note: the extra commit over 15 is a temporary junk I would be happy to get
 ride of)
 
   $ echo 'babar' >> a
   $ hg commit --amend
   $ hg log -Gl 6 --hidden --style=compact
   @  15[tip]:11   a5b42b49b0d5   1970-01-01 00:00 +0000   test
   |    babar
   |
   | x  14:11   682950e85999   1970-01-01 00:00 +0000   test
   |/     babar
   |
   | x  13:11   5167600b0f7a   1970-01-01 00:00 +0000   test
   |/     amend for phase
   |
   | o  12:0   2647734878ef   1970-01-01 00:00 +0000   test
   | |    fork
   | ~
   o  11   0ddb275cfad1   1970-01-01 00:00 +0000   test
   |    a''
   |
   o  10   5fa75032e226   1970-01-01 00:00 +0000   test
   |    g
   ~
 
 
 Test that amend does not make it easy to create obsolescence cycle
 ---------------------------------------------------------------------
 
   $ hg id -r 14 --hidden
   682950e85999 (a)
   $ hg revert -ar 14 --hidden
   reverting a
   $ hg commit --amend
   $ hg id
   37973c7e0b61 (a) tip
 
 Test that rewriting leaving instability behind is allowed
 ---------------------------------------------------------------------
 
   $ hg up '.^'
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo 'b' >> a
   $ hg log --style compact -r 'children(.)'
   16[tip]:11   37973c7e0b61   1970-01-01 00:00 +0000   test
     babar
   
   $ hg commit --amend
   1 new orphan changesets
   $ hg log -r 'orphan()'
   changeset:   16:37973c7e0b61
   branch:      a
   parent:      11:0ddb275cfad1
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   instability: orphan
   summary:     babar
   
 
 Amend a merge changeset (with renames and conflicts from the second parent):
 
   $ hg up -q default
   $ hg branch -q bar
   $ hg cp a aa
   $ hg mv z zz
   $ echo cc > cc
   $ hg add cc
   $ hg ci -m aazzcc
   $ hg up -q default
   $ echo a >> a
   $ echo dd > cc
   $ hg add cc
   $ hg ci -m aa
   $ hg merge -q bar
   warning: conflicts while merging cc! (edit, then use 'hg resolve --mark')
   [1]
   $ hg resolve -m cc
   (no more unresolved files)
   $ hg ci -m 'merge bar'
   $ hg log --config diff.git=1 -pr .
   changeset:   20:163cfd7219f7
   tag:         tip
   parent:      19:30d96aeaf27b
   parent:      18:1aa437659d19
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     merge bar
   
   diff --git a/a b/aa
   copy from a
   copy to aa
   diff --git a/cc b/cc
   --- a/cc
   +++ b/cc
   @@ -1,1 +1,5 @@
   +<<<<<<< working copy: 30d96aeaf27b - test: aa
    dd
   +=======
   +cc
   +>>>>>>> merge rev:    1aa437659d19 bar - test: aazzcc
   diff --git a/z b/zz
   rename from z
   rename to zz
   
   $ hg debugrename aa
   aa renamed from a:a80d06849b333b8a3d5c445f8ba3142010dcdc9e
   $ hg debugrename zz
   zz renamed from z:69a1b67522704ec122181c0890bd16e9d3e7516a
   $ hg debugrename cc
   cc not renamed
   $ HGEDITOR="sh .hg/checkeditform.sh" hg ci --amend -m 'merge bar (amend message)' --edit
   HGEDITFORM=commit.amend.merge
   $ hg log --config diff.git=1 -pr .
   changeset:   21:bca52d4ed186
   tag:         tip
   parent:      19:30d96aeaf27b
   parent:      18:1aa437659d19
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     merge bar (amend message)
   
   diff --git a/a b/aa
   copy from a
   copy to aa
   diff --git a/cc b/cc
   --- a/cc
   +++ b/cc
   @@ -1,1 +1,5 @@
   +<<<<<<< working copy: 30d96aeaf27b - test: aa
    dd
   +=======
   +cc
   +>>>>>>> merge rev:    1aa437659d19 bar - test: aazzcc
   diff --git a/z b/zz
   rename from z
   rename to zz
   
   $ hg debugrename aa
   aa renamed from a:a80d06849b333b8a3d5c445f8ba3142010dcdc9e
   $ hg debugrename zz
   zz renamed from z:69a1b67522704ec122181c0890bd16e9d3e7516a
   $ hg debugrename cc
   cc not renamed
   $ hg mv zz z
   $ hg ci --amend -m 'merge bar (undo rename)'
   $ hg log --config diff.git=1 -pr .
   changeset:   22:12594a98ca3f
   tag:         tip
   parent:      19:30d96aeaf27b
   parent:      18:1aa437659d19
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     merge bar (undo rename)
   
   diff --git a/a b/aa
   copy from a
   copy to aa
   diff --git a/cc b/cc
   --- a/cc
   +++ b/cc
   @@ -1,1 +1,5 @@
   +<<<<<<< working copy: 30d96aeaf27b - test: aa
    dd
   +=======
   +cc
   +>>>>>>> merge rev:    1aa437659d19 bar - test: aazzcc
   
   $ hg debugrename z
   z not renamed
 
 Amend a merge changeset (with renames during the merge):
 
   $ hg up -q bar
   $ echo x > x
   $ hg add x
   $ hg ci -m x
   $ hg up -q default
   $ hg merge -q bar
   $ hg mv aa aaa
   $ echo aa >> aaa
   $ hg ci -m 'merge bar again'
   $ hg log --config diff.git=1 -pr .
   changeset:   24:dffde028b388
   tag:         tip
   parent:      22:12594a98ca3f
   parent:      23:4c94d5bc65f5
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     merge bar again
   
   diff --git a/aa b/aa
   deleted file mode 100644
   --- a/aa
   +++ /dev/null
   @@ -1,2 +0,0 @@
   -a
   -a
   diff --git a/aaa b/aaa
   new file mode 100644
   --- /dev/null
   +++ b/aaa
   @@ -0,0 +1,3 @@
   +a
   +a
   +aa
   diff --git a/x b/x
   new file mode 100644
   --- /dev/null
   +++ b/x
   @@ -0,0 +1,1 @@
   +x
   
   $ hg debugrename aaa
   aaa renamed from aa:37d9b5d994eab34eda9c16b195ace52c7b129980
   $ hg mv aaa aa
   $ hg ci --amend -m 'merge bar again (undo rename)'
   $ hg log --config diff.git=1 -pr .
   changeset:   25:18e3ba160489
   tag:         tip
   parent:      22:12594a98ca3f
   parent:      23:4c94d5bc65f5
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     merge bar again (undo rename)
   
   diff --git a/aa b/aa
   --- a/aa
   +++ b/aa
   @@ -1,2 +1,3 @@
    a
    a
   +aa
   diff --git a/x b/x
   new file mode 100644
   --- /dev/null
   +++ b/x
   @@ -0,0 +1,1 @@
   +x
   
   $ hg debugrename aa
   aa not renamed
   $ hg debugrename -r '.^' aa
   aa renamed from a:a80d06849b333b8a3d5c445f8ba3142010dcdc9e
 
 Amend a merge changeset (with manifest-level conflicts):
 
   $ hg up -q bar
   $ hg rm aa
   $ hg ci -m 'rm aa'
   $ hg up -q default
   $ echo aa >> aa
   $ hg ci -m aa
   $ hg merge -q bar --config ui.interactive=True << EOF
   > c
   > EOF
-  file 'aa' was deleted in local [working copy] but was modified in other [merge rev].
+  file 'aa' was deleted in other [merge rev] but was modified in local [working copy].
   What do you want to do?
   use (c)hanged version, (d)elete, or leave (u)nresolved? c
   $ hg ci -m 'merge bar (with conflicts)'
   $ hg log --config diff.git=1 -pr .
   changeset:   28:b4c3035e2544
   tag:         tip
   parent:      27:4b216ca5ba97
   parent:      26:67db8847a540
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     merge bar (with conflicts)
   
   
   $ hg rm aa
   $ hg ci --amend -m 'merge bar (with conflicts, amended)'
   $ hg log --config diff.git=1 -pr .
   changeset:   29:1205ed810051
   tag:         tip
   parent:      27:4b216ca5ba97
   parent:      26:67db8847a540
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     merge bar (with conflicts, amended)
   
   diff --git a/aa b/aa
   deleted file mode 100644
   --- a/aa
   +++ /dev/null
   @@ -1,4 +0,0 @@
   -a
   -a
   -aa
   -aa
   
 Issue 3445: amending with --close-branch a commit that created a new head should fail
 This shouldn't be possible:
 
   $ hg up -q default
   $ hg branch closewithamend
   marked working directory as branch closewithamend
   $ echo foo > foo
   $ hg add foo
   $ hg ci -m..
   $ hg ci --amend --close-branch -m 'closing'
   abort: can only close branch heads
   [255]
 
 This silliness fails:
 
   $ hg branch silliness
   marked working directory as branch silliness
   $ echo b >> b
   $ hg ci --close-branch -m'open and close'
   abort: can only close branch heads
   [255]
 
 Test that amend with --secret creates new secret changeset forcibly
 ---------------------------------------------------------------------
 
   $ hg phase '.^::.'
   29: draft
   30: draft
   $ hg commit --amend --secret -m 'amend as secret' -q
   $ hg phase '.^::.'
   29: draft
   31: secret
 
 Test that amend with --edit invokes editor forcibly
 ---------------------------------------------------
 
   $ hg parents --template "{desc}\n"
   amend as secret
   $ HGEDITOR=cat hg commit --amend -m "editor should be suppressed"
   $ hg parents --template "{desc}\n"
   editor should be suppressed
 
   $ hg status --rev '.^1::.'
   A foo
   $ HGEDITOR=cat hg commit --amend -m "editor should be invoked" --edit
   editor should be invoked
   
   
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: test
   HG: branch 'silliness'
   HG: added foo
   $ hg parents --template "{desc}\n"
   editor should be invoked
 
 Test that "diff()" in committemplate works correctly for amending
 -----------------------------------------------------------------
 
   $ cat >> .hg/hgrc <<EOF
   > [committemplate]
   > changeset.commit.amend = {desc}\n
   >     HG: M: {file_mods}
   >     HG: A: {file_adds}
   >     HG: R: {file_dels}
   >     {splitlines(diff()) % 'HG: {line}\n'}
   > EOF
 
   $ hg parents --template "M: {file_mods}\nA: {file_adds}\nR: {file_dels}\n"
   M: 
   A: foo
   R: 
   $ hg status -amr
   $ HGEDITOR=cat hg commit --amend -e -m "expecting diff of foo"
   expecting diff of foo
   
   HG: M: 
   HG: A: foo
   HG: R: 
   HG: diff -r 1205ed810051 foo
   HG: --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   HG: +++ b/foo	Thu Jan 01 00:00:00 1970 +0000
   HG: @@ -0,0 +1,1 @@
   HG: +foo
 
   $ echo y > y
   $ hg add y
   $ HGEDITOR=cat hg commit --amend -e -m "expecting diff of foo and y"
   expecting diff of foo and y
   
   HG: M: 
   HG: A: foo y
   HG: R: 
   HG: diff -r 1205ed810051 foo
   HG: --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   HG: +++ b/foo	Thu Jan 01 00:00:00 1970 +0000
   HG: @@ -0,0 +1,1 @@
   HG: +foo
   HG: diff -r 1205ed810051 y
   HG: --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   HG: +++ b/y	Thu Jan 01 00:00:00 1970 +0000
   HG: @@ -0,0 +1,1 @@
   HG: +y
 
   $ hg rm a
   $ HGEDITOR=cat hg commit --amend -e -m "expecting diff of a, foo and y"
   expecting diff of a, foo and y
   
   HG: M: 
   HG: A: foo y
   HG: R: a
   HG: diff -r 1205ed810051 a
   HG: --- a/a	Thu Jan 01 00:00:00 1970 +0000
   HG: +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
   HG: @@ -1,2 +0,0 @@
   HG: -a
   HG: -a
   HG: diff -r 1205ed810051 foo
   HG: --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   HG: +++ b/foo	Thu Jan 01 00:00:00 1970 +0000
   HG: @@ -0,0 +1,1 @@
   HG: +foo
   HG: diff -r 1205ed810051 y
   HG: --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   HG: +++ b/y	Thu Jan 01 00:00:00 1970 +0000
   HG: @@ -0,0 +1,1 @@
   HG: +y
 
   $ hg rm x
   $ HGEDITOR=cat hg commit --amend -e -m "expecting diff of a, foo, x and y"
   expecting diff of a, foo, x and y
   
   HG: M: 
   HG: A: foo y
   HG: R: a x
   HG: diff -r 1205ed810051 a
   HG: --- a/a	Thu Jan 01 00:00:00 1970 +0000
   HG: +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
   HG: @@ -1,2 +0,0 @@
   HG: -a
   HG: -a
   HG: diff -r 1205ed810051 foo
   HG: --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   HG: +++ b/foo	Thu Jan 01 00:00:00 1970 +0000
   HG: @@ -0,0 +1,1 @@
   HG: +foo
   HG: diff -r 1205ed810051 x
   HG: --- a/x	Thu Jan 01 00:00:00 1970 +0000
   HG: +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
   HG: @@ -1,1 +0,0 @@
   HG: -x
   HG: diff -r 1205ed810051 y
   HG: --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   HG: +++ b/y	Thu Jan 01 00:00:00 1970 +0000
   HG: @@ -0,0 +1,1 @@
   HG: +y
 
   $ echo cccc >> cc
   $ hg status -amr
   M cc
   $ HGEDITOR=cat hg commit --amend -e -m "cc should be excluded" -X cc
   cc should be excluded
   
   HG: M: 
   HG: A: foo y
   HG: R: a x
   HG: diff -r 1205ed810051 a
   HG: --- a/a	Thu Jan 01 00:00:00 1970 +0000
   HG: +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
   HG: @@ -1,2 +0,0 @@
   HG: -a
   HG: -a
   HG: diff -r 1205ed810051 foo
   HG: --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   HG: +++ b/foo	Thu Jan 01 00:00:00 1970 +0000
   HG: @@ -0,0 +1,1 @@
   HG: +foo
   HG: diff -r 1205ed810051 x
   HG: --- a/x	Thu Jan 01 00:00:00 1970 +0000
   HG: +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
   HG: @@ -1,1 +0,0 @@
   HG: -x
   HG: diff -r 1205ed810051 y
   HG: --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   HG: +++ b/y	Thu Jan 01 00:00:00 1970 +0000
   HG: @@ -0,0 +1,1 @@
   HG: +y
 
 Check for issue4405
 -------------------
 
 Setup the repo with a file that gets moved in a second commit.
   $ hg init repo
   $ cd repo
   $ touch a0
   $ hg add a0
   $ hg commit -m a0
   $ hg mv a0 a1
   $ hg commit -m a1
   $ hg up -q 0
   $ hg log -G --template '{rev} {desc}'
   o  1 a1
   |
   @  0 a0
   
 
 Now we branch the repro, but re-use the file contents, so we have a divergence
 in the file revlog topology and the changelog topology.
   $ hg revert --rev 1 --all
   removing a0
   adding a1
   $ hg ci -qm 'a1-amend'
   $ hg log -G --template '{rev} {desc}'
   @  2 a1-amend
   |
   | o  1 a1
   |/
   o  0 a0
   
 
 The way mercurial does amends is by folding the working copy and old commit
 together into another commit (rev 3). During this process, _findlimit is called
 to  check how far back to look for the transitive closure of file copy
 information, but due to the divergence of the filelog and changelog graph
 topologies, before _findlimit was fixed, it returned a rev which was not far
 enough back in this case.
   $ hg mv a1 a2
   $ hg status --copies --rev 0
   A a2
     a0
   R a0
   $ hg ci --amend -q
   $ hg log -G --template '{rev} {desc}'
   @  3 a1-amend
   |
   | o  1 a1
   |/
   o  0 a0
   
 
 Before the fix, the copy information was lost.
   $ hg status --copies --rev 0
   A a2
     a0
   R a0
   $ cd ..
 
 Check that amend properly preserve rename from directory rename (issue-4516)
 
 If a parent of the merge renames a full directory, any files added to the old
 directory in the other parent will be renamed to the new directory. For some
 reason, the rename metadata was when amending such merge. This test ensure we
 do not regress. We have a dedicated repo because it needs a setup with renamed
 directory)
 
   $ hg init issue4516
   $ cd issue4516
   $ mkdir olddirname
   $ echo line1 > olddirname/commonfile.py
   $ hg add olddirname/commonfile.py
   $ hg ci -m first
 
   $ hg branch newdirname
   marked working directory as branch newdirname
   (branches are permanent and global, did you want a bookmark?)
   $ hg mv olddirname newdirname
   moving olddirname/commonfile.py to newdirname/commonfile.py
   $ hg ci -m rename
 
   $ hg update default
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo line1 > olddirname/newfile.py
   $ hg add olddirname/newfile.py
   $ hg ci -m log
 
   $ hg up newdirname
   1 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ # create newdirname/newfile.py
   $ hg merge default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m add
   $ 
   $ hg debugrename newdirname/newfile.py
   newdirname/newfile.py renamed from olddirname/newfile.py:690b295714aed510803d3020da9c70fca8336def
   $ hg status -C --change .
   A newdirname/newfile.py
   $ hg status -C --rev 1
   A newdirname/newfile.py
   $ hg status -C --rev 2
   A newdirname/commonfile.py
     olddirname/commonfile.py
   A newdirname/newfile.py
     olddirname/newfile.py
   R olddirname/commonfile.py
   R olddirname/newfile.py
   $ hg debugindex newdirname/newfile.py
      rev linkrev nodeid       p1           p2
        0       3 34a4d536c0c0 000000000000 000000000000
 
   $ echo a >> newdirname/commonfile.py
   $ hg ci --amend -m bug
   $ hg debugrename newdirname/newfile.py
   newdirname/newfile.py renamed from olddirname/newfile.py:690b295714aed510803d3020da9c70fca8336def
   $ hg debugindex newdirname/newfile.py
      rev linkrev nodeid       p1           p2
        0       3 34a4d536c0c0 000000000000 000000000000
 
 #if execbit
 
 Test if amend preserves executable bit changes
   $ chmod +x newdirname/commonfile.py
   $ hg ci -m chmod
   $ hg ci --amend -m "chmod amended"
   $ hg ci --amend -m "chmod amended second time"
   $ hg log -p --git -r .
   changeset:   7:b1326f52dddf
   branch:      newdirname
   tag:         tip
   parent:      4:7fd235f7cb2f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     chmod amended second time
   
   diff --git a/newdirname/commonfile.py b/newdirname/commonfile.py
   old mode 100644
   new mode 100755
   
 #endif
 
 Test amend with file inclusion options
 --------------------------------------
 
 These tests ensure that we are always amending some files that were part of the
 pre-amend commit. We want to test that the remaining files in the pre-amend
 commit were not changed in the amended commit. We do so by performing a diff of
 the amended commit against its parent commit.
   $ cd ..
   $ hg init testfileinclusions
   $ cd testfileinclusions
   $ echo a > a
   $ echo b > b
   $ hg commit -Aqm "Adding a and b"
 
 Only add changes to a particular file
   $ echo a >> a
   $ echo b >> b
   $ hg commit --amend -I a
   $ hg diff --git -r null -r .
   diff --git a/a b/a
   new file mode 100644
   --- /dev/null
   +++ b/a
   @@ -0,0 +1,2 @@
   +a
   +a
   diff --git a/b b/b
   new file mode 100644
   --- /dev/null
   +++ b/b
   @@ -0,0 +1,1 @@
   +b
 
   $ echo a >> a
   $ hg commit --amend b
   $ hg diff --git -r null -r .
   diff --git a/a b/a
   new file mode 100644
   --- /dev/null
   +++ b/a
   @@ -0,0 +1,2 @@
   +a
   +a
   diff --git a/b b/b
   new file mode 100644
   --- /dev/null
   +++ b/b
   @@ -0,0 +1,2 @@
   +b
   +b
 
 Exclude changes to a particular file
   $ echo b >> b
   $ hg commit --amend -X a
   $ hg diff --git -r null -r .
   diff --git a/a b/a
   new file mode 100644
   --- /dev/null
   +++ b/a
   @@ -0,0 +1,2 @@
   +a
   +a
   diff --git a/b b/b
   new file mode 100644
   --- /dev/null
   +++ b/b
   @@ -0,0 +1,3 @@
   +b
   +b
   +b
 
 Check the addremove flag
   $ echo c > c
   $ rm a
   $ hg commit --amend -A
   removing a
   adding c
   $ hg diff --git -r null -r .
   diff --git a/b b/b
   new file mode 100644
   --- /dev/null
   +++ b/b
   @@ -0,0 +1,3 @@
   +b
   +b
   +b
   diff --git a/c b/c
   new file mode 100644
   --- /dev/null
   +++ b/c
   @@ -0,0 +1,1 @@
   +c

tests/test-copy-move-merge.t

@@ -1,172 +1,172 b''
 Test for the full copytracing algorithm
 =======================================
 
   $ hg init t
   $ cd t
 
   $ echo 1 > a
   $ hg ci -qAm "first"
 
   $ hg cp a b
   $ hg mv a c
   $ echo 2 >> b
   $ echo 2 >> c
 
   $ hg ci -qAm "second"
 
   $ hg co -C 0
   1 files updated, 0 files merged, 2 files removed, 0 files unresolved
 
   $ echo 0 > a
   $ echo 1 >> a
 
   $ hg ci -qAm "other"
 
   $ hg merge --debug
     searching for copies back to rev 1
     unmatched files in other:
      b
      c
     all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      src: 'a' -> dst: 'b' *
      src: 'a' -> dst: 'c' *
     checking for directory renames
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: b8bf91eeebbc, local: add3f11052fa+, remote: 17c05bb7fcb6
    preserving a for resolve of b
    preserving a for resolve of c
   removing a
   starting 4 threads for background file closing (?)
    b: remote moved from a -> m (premerge)
   picked tool ':merge' for b (binary False symlink False changedelete False)
   merging a and b to b
   my b@add3f11052fa+ other b@17c05bb7fcb6 ancestor a@b8bf91eeebbc
    premerge successful
    c: remote moved from a -> m (premerge)
   picked tool ':merge' for c (binary False symlink False changedelete False)
   merging a and c to c
   my c@add3f11052fa+ other c@17c05bb7fcb6 ancestor a@b8bf91eeebbc
    premerge successful
   0 files updated, 2 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
 file b
   $ cat b
   0
   1
   2
 
 file c
   $ cat c
   0
   1
   2
 
 Test disabling copy tracing
 
 - first verify copy metadata was kept
 
   $ hg up -qC 2
   $ hg rebase --keep -d 1 -b 2 --config extensions.rebase=
   rebasing 2:add3f11052fa "other" (tip)
   merging b and a to b
   merging c and a to c
 
   $ cat b
   0
   1
   2
 
 - next verify copy metadata is lost when disabled
 
   $ hg strip -r . --config extensions.strip=
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/t/.hg/strip-backup/550bd84c0cd3-fc575957-backup.hg
   $ hg up -qC 2
   $ hg rebase --keep -d 1 -b 2 --config extensions.rebase= --config experimental.copytrace=off --config ui.interactive=True << EOF
   > c
   > EOF
   rebasing 2:add3f11052fa "other" (tip)
-  file 'a' was deleted in other [source] but was modified in local [dest].
+  file 'a' was deleted in local [dest] but was modified in other [source].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
 
   $ cat b
   1
   2
 
   $ cd ..
 
 Verify disabling copy tracing still keeps copies from rebase source
 
   $ hg init copydisable
   $ cd copydisable
   $ touch a
   $ hg ci -Aqm 'add a'
   $ touch b
   $ hg ci -Aqm 'add b, c'
   $ hg cp b x
   $ echo x >> x
   $ hg ci -qm 'copy b->x'
   $ hg up -q 1
   $ touch z
   $ hg ci -Aqm 'add z'
   $ hg log -G -T '{rev} {desc}\n'
   @  3 add z
   |
   | o  2 copy b->x
   |/
   o  1 add b, c
   |
   o  0 add a
   
   $ hg rebase -d . -b 2 --config extensions.rebase= --config experimental.copytrace=off
   rebasing 2:6adcf8c12e7d "copy b->x"
   saved backup bundle to $TESTTMP/copydisable/.hg/strip-backup/6adcf8c12e7d-ce4b3e75-rebase.hg
   $ hg up -q 3
   $ hg log -f x -T '{rev} {desc}\n'
   3 copy b->x
   1 add b, c
 
   $ cd ../
 
 Verify we duplicate existing copies, instead of detecting them
 
   $ hg init copydisable3
   $ cd copydisable3
   $ touch a
   $ hg ci -Aqm 'add a'
   $ hg cp a b
   $ hg ci -Aqm 'copy a->b'
   $ hg mv b c
   $ hg ci -Aqm 'move b->c'
   $ hg up -q 0
   $ hg cp a b
   $ echo b >> b
   $ hg ci -Aqm 'copy a->b (2)'
   $ hg log -G -T '{rev} {desc}\n'
   @  3 copy a->b (2)
   |
   | o  2 move b->c
   | |
   | o  1 copy a->b
   |/
   o  0 add a
   
   $ hg rebase -d 2 -s 3 --config extensions.rebase= --config experimental.copytrace=off
   rebasing 3:47e1a9e6273b "copy a->b (2)" (tip)
   saved backup bundle to $TESTTMP/copydisable3/.hg/strip-backup/47e1a9e6273b-2d099c59-rebase.hg
 
   $ hg log -G -f b
   @  changeset:   3:76024fb4b05b
   :  tag:         tip
   :  user:        test
   :  date:        Thu Jan 01 00:00:00 1970 +0000
   :  summary:     copy a->b (2)
   :
   o  changeset:   0:ac82d8b1f7c4
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     add a
   

tests/test-copytrace-heuristics.t

@@ -1,718 +1,718 b''
 Test for the heuristic copytracing algorithm
 ============================================
 
   $ cat >> $TESTTMP/copytrace.sh << '__EOF__'
   > initclient() {
   > cat >> $1/.hg/hgrc <<EOF
   > [experimental]
   > copytrace = heuristics
   > copytrace.sourcecommitlimit = -1
   > EOF
   > }
   > __EOF__
   $ . "$TESTTMP/copytrace.sh"
 
   $ cat >> $HGRCPATH << EOF
   > [extensions]
   > rebase=
   > shelve=
   > EOF
 
 NOTE: calling initclient() set copytrace.sourcecommitlimit=-1 as we want to
 prevent the full copytrace algorithm to run and test the heuristic algorithm
 without complexing the test cases with public and draft commits.
 
 Check filename heuristics (same dirname and same basename)
 ----------------------------------------------------------
 
   $ hg init repo
   $ initclient repo
   $ cd repo
   $ echo a > a
   $ mkdir dir
   $ echo a > dir/file.txt
   $ hg addremove
   adding a
   adding dir/file.txt
   $ hg ci -m initial
   $ hg mv a b
   $ hg mv -q dir dir2
   $ hg ci -m 'mv a b, mv dir/ dir2/'
   $ hg up -q 0
   $ echo b > a
   $ echo b > dir/file.txt
   $ hg ci -qm 'mod a, mod dir/file.txt'
 
   $ hg log -G -T 'changeset: {node}\n desc: {desc}\n'
   @  changeset: 557f403c0afd2a3cf15d7e2fb1f1001a8b85e081
   |   desc: mod a, mod dir/file.txt
   | o  changeset: 928d74bc9110681920854d845c06959f6dfc9547
   |/    desc: mv a b, mv dir/ dir2/
   o  changeset: 3c482b16e54596fed340d05ffaf155f156cda7ee
       desc: initial
 
   $ hg rebase -s . -d 1
   rebasing 2:557f403c0afd "mod a, mod dir/file.txt" (tip)
   merging b and a to b
   merging dir2/file.txt and dir/file.txt to dir2/file.txt
   saved backup bundle to $TESTTMP/repo/.hg/strip-backup/557f403c0afd-9926eeff-rebase.hg
   $ cd ..
   $ rm -rf repo
 
 Make sure filename heuristics do not when they are not related
 --------------------------------------------------------------
 
   $ hg init repo
   $ initclient repo
   $ cd repo
   $ echo 'somecontent' > a
   $ hg add a
   $ hg ci -m initial
   $ hg rm a
   $ echo 'completelydifferentcontext' > b
   $ hg add b
   $ hg ci -m 'rm a, add b'
   $ hg up -q 0
   $ printf 'somecontent\nmoarcontent' > a
   $ hg ci -qm 'mode a'
 
   $ hg log -G -T 'changeset: {node}\n desc: {desc}\n'
   @  changeset: d526312210b9e8f795d576a77dc643796384d86e
   |   desc: mode a
   | o  changeset: 46985f76c7e5e5123433527f5c8526806145650b
   |/    desc: rm a, add b
   o  changeset: e5b71fb099c29d9172ef4a23485aaffd497e4cc0
       desc: initial
 
   $ hg rebase -s . -d 1
   rebasing 2:d526312210b9 "mode a" (tip)
-  file 'a' was deleted in other [source] but was modified in local [dest].
+  file 'a' was deleted in local [dest] but was modified in other [source].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
 
   $ cd ..
   $ rm -rf repo
 
 Test when lca didn't modified the file that was moved
 -----------------------------------------------------
 
   $ hg init repo
   $ initclient repo
   $ cd repo
   $ echo 'somecontent' > a
   $ hg add a
   $ hg ci -m initial
   $ echo c > c
   $ hg add c
   $ hg ci -m randomcommit
   $ hg mv a b
   $ hg ci -m 'mv a b'
   $ hg up -q 1
   $ echo b > a
   $ hg ci -qm 'mod a'
 
   $ hg log -G -T 'changeset: {node}\n desc: {desc}, phase: {phase}\n'
   @  changeset: 9d5cf99c3d9f8e8b05ba55421f7f56530cfcf3bc
   |   desc: mod a, phase: draft
   | o  changeset: d760186dd240fc47b91eb9f0b58b0002aaeef95d
   |/    desc: mv a b, phase: draft
   o  changeset: 48e1b6ba639d5d7fb313fa7989eebabf99c9eb83
   |   desc: randomcommit, phase: draft
   o  changeset: e5b71fb099c29d9172ef4a23485aaffd497e4cc0
       desc: initial, phase: draft
 
   $ hg rebase -s . -d 2
   rebasing 3:9d5cf99c3d9f "mod a" (tip)
   merging b and a to b
   saved backup bundle to $TESTTMP/repo/.hg/strip-backup/9d5cf99c3d9f-f02358cc-rebase.hg
   $ cd ..
   $ rm -rf repo
 
 Rebase "backwards"
 ------------------
 
   $ hg init repo
   $ initclient repo
   $ cd repo
   $ echo 'somecontent' > a
   $ hg add a
   $ hg ci -m initial
   $ echo c > c
   $ hg add c
   $ hg ci -m randomcommit
   $ hg mv a b
   $ hg ci -m 'mv a b'
   $ hg up -q 2
   $ echo b > b
   $ hg ci -qm 'mod b'
 
   $ hg log -G -T 'changeset: {node}\n desc: {desc}\n'
   @  changeset: fbe97126b3969056795c462a67d93faf13e4d298
   |   desc: mod b
   o  changeset: d760186dd240fc47b91eb9f0b58b0002aaeef95d
   |   desc: mv a b
   o  changeset: 48e1b6ba639d5d7fb313fa7989eebabf99c9eb83
   |   desc: randomcommit
   o  changeset: e5b71fb099c29d9172ef4a23485aaffd497e4cc0
       desc: initial
 
   $ hg rebase -s . -d 0
   rebasing 3:fbe97126b396 "mod b" (tip)
   merging a and b to a
   saved backup bundle to $TESTTMP/repo/.hg/strip-backup/fbe97126b396-cf5452a1-rebase.hg
   $ cd ..
   $ rm -rf repo
 
 Check a few potential move candidates
 -------------------------------------
 
   $ hg init repo
   $ initclient repo
   $ cd repo
   $ mkdir dir
   $ echo a > dir/a
   $ hg add dir/a
   $ hg ci -qm initial
   $ hg mv dir/a dir/b
   $ hg ci -qm 'mv dir/a dir/b'
   $ mkdir dir2
   $ echo b > dir2/a
   $ hg add dir2/a
   $ hg ci -qm 'create dir2/a'
   $ hg up -q 0
   $ echo b > dir/a
   $ hg ci -qm 'mod dir/a'
 
   $ hg log -G -T 'changeset: {node}\n desc: {desc}\n'
   @  changeset: 6b2f4cece40fd320f41229f23821256ffc08efea
   |   desc: mod dir/a
   | o  changeset: 4494bf7efd2e0dfdd388e767fb913a8a3731e3fa
   | |   desc: create dir2/a
   | o  changeset: b1784dfab6ea6bfafeb11c0ac50a2981b0fe6ade
   |/    desc: mv dir/a dir/b
   o  changeset: 36859b8907c513a3a87ae34ba5b1e7eea8c20944
       desc: initial
 
   $ hg rebase -s . -d 2
   rebasing 3:6b2f4cece40f "mod dir/a" (tip)
   merging dir/b and dir/a to dir/b
   saved backup bundle to $TESTTMP/repo/.hg/strip-backup/6b2f4cece40f-503efe60-rebase.hg
   $ cd ..
   $ rm -rf repo
 
 Test the copytrace.movecandidateslimit with many move candidates
 ----------------------------------------------------------------
 
   $ hg init repo
   $ initclient repo
   $ cd repo
   $ echo a > a
   $ hg add a
   $ hg ci -m initial
   $ hg mv a foo
   $ echo a > b
   $ echo a > c
   $ echo a > d
   $ echo a > e
   $ echo a > f
   $ echo a > g
   $ hg add b
   $ hg add c
   $ hg add d
   $ hg add e
   $ hg add f
   $ hg add g
   $ hg ci -m 'mv a foo, add many files'
   $ hg up -q ".^"
   $ echo b > a
   $ hg ci -m 'mod a'
   created new head
 
   $ hg log -G -T 'changeset: {node}\n desc: {desc}\n'
   @  changeset: ef716627c70bf4ca0bdb623cfb0d6fe5b9acc51e
   |   desc: mod a
   | o  changeset: 8329d5c6bf479ec5ca59b9864f3f45d07213f5a4
   |/    desc: mv a foo, add many files
   o  changeset: 1451231c87572a7d3f92fc210b4b35711c949a98
       desc: initial
 
 With small limit
 
   $ hg rebase -s 2 -d 1 --config experimental.copytrace.movecandidateslimit=0
   rebasing 2:ef716627c70b "mod a" (tip)
   skipping copytracing for 'a', more candidates than the limit: 7
-  file 'a' was deleted in other [source] but was modified in local [dest].
+  file 'a' was deleted in local [dest] but was modified in other [source].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
 
   $ hg rebase --abort
   rebase aborted
 
 With default limit which is 100
 
   $ hg rebase -s 2 -d 1
   rebasing 2:ef716627c70b "mod a" (tip)
   merging foo and a to foo
   saved backup bundle to $TESTTMP/repo/.hg/strip-backup/ef716627c70b-24681561-rebase.hg
 
   $ cd ..
   $ rm -rf repo
 
 Move file in one branch and delete it in another
 -----------------------------------------------
 
   $ hg init repo
   $ initclient repo
   $ cd repo
   $ echo a > a
   $ hg add a
   $ hg ci -m initial
   $ hg mv a b
   $ hg ci -m 'mv a b'
   $ hg up -q ".^"
   $ hg rm a
   $ hg ci -m 'del a'
   created new head
 
   $ hg log -G -T 'changeset: {node}\n desc: {desc}, phase: {phase}\n'
   @  changeset: 7d61ee3b1e48577891a072024968428ba465c47b
   |   desc: del a, phase: draft
   | o  changeset: 472e38d57782172f6c6abed82a94ca0d998c3a22
   |/    desc: mv a b, phase: draft
   o  changeset: 1451231c87572a7d3f92fc210b4b35711c949a98
       desc: initial, phase: draft
 
   $ hg rebase -s 1 -d 2
   rebasing 1:472e38d57782 "mv a b"
   saved backup bundle to $TESTTMP/repo/.hg/strip-backup/472e38d57782-17d50e29-rebase.hg
   $ hg up -q c492ed3c7e35dcd1dc938053b8adf56e2cfbd062
   $ ls
   b
   $ cd ..
   $ rm -rf repo
 
 Move a directory in draft branch
 --------------------------------
 
   $ hg init repo
   $ initclient repo
   $ cd repo
   $ mkdir dir
   $ echo a > dir/a
   $ hg add dir/a
   $ hg ci -qm initial
   $ echo b > dir/a
   $ hg ci -qm 'mod dir/a'
   $ hg up -q ".^"
   $ hg mv -q dir/ dir2
   $ hg ci -qm 'mv dir/ dir2/'
 
   $ hg log -G -T 'changeset: {node}\n desc: {desc}\n'
   @  changeset: a33d80b6e352591dfd82784e1ad6cdd86b25a239
   |   desc: mv dir/ dir2/
   | o  changeset: 6b2f4cece40fd320f41229f23821256ffc08efea
   |/    desc: mod dir/a
   o  changeset: 36859b8907c513a3a87ae34ba5b1e7eea8c20944
       desc: initial
 
   $ hg rebase -s . -d 1
   rebasing 2:a33d80b6e352 "mv dir/ dir2/" (tip)
   merging dir/a and dir2/a to dir2/a
   saved backup bundle to $TESTTMP/repo/.hg/strip-backup/a33d80b6e352-fecb9ada-rebase.hg
   $ cd ..
   $ rm -rf server
   $ rm -rf repo
 
 Move file twice and rebase mod on top of moves
 ----------------------------------------------
 
   $ hg init repo
   $ initclient repo
   $ cd repo
   $ echo a > a
   $ hg add a
   $ hg ci -m initial
   $ hg mv a b
   $ hg ci -m 'mv a b'
   $ hg mv b c
   $ hg ci -m 'mv b c'
   $ hg up -q 0
   $ echo c > a
   $ hg ci -m 'mod a'
   created new head
 
   $ hg log -G -T 'changeset: {node}\n desc: {desc}\n'
   @  changeset: d413169422167a3fa5275fc5d71f7dea9f5775f3
   |   desc: mod a
   | o  changeset: d3efd280421d24f9f229997c19e654761c942a71
   | |   desc: mv b c
   | o  changeset: 472e38d57782172f6c6abed82a94ca0d998c3a22
   |/    desc: mv a b
   o  changeset: 1451231c87572a7d3f92fc210b4b35711c949a98
       desc: initial
   $ hg rebase -s . -d 2
   rebasing 3:d41316942216 "mod a" (tip)
   merging c and a to c
   saved backup bundle to $TESTTMP/repo/.hg/strip-backup/d41316942216-2b5949bc-rebase.hg
 
   $ cd ..
   $ rm -rf repo
 
 Move file twice and rebase moves on top of mods
 -----------------------------------------------
 
   $ hg init repo
   $ initclient repo
   $ cd repo
   $ echo a > a
   $ hg add a
   $ hg ci -m initial
   $ hg mv a b
   $ hg ci -m 'mv a b'
   $ hg mv b c
   $ hg ci -m 'mv b c'
   $ hg up -q 0
   $ echo c > a
   $ hg ci -m 'mod a'
   created new head
   $ hg log -G -T 'changeset: {node}\n desc: {desc}\n'
   @  changeset: d413169422167a3fa5275fc5d71f7dea9f5775f3
   |   desc: mod a
   | o  changeset: d3efd280421d24f9f229997c19e654761c942a71
   | |   desc: mv b c
   | o  changeset: 472e38d57782172f6c6abed82a94ca0d998c3a22
   |/    desc: mv a b
   o  changeset: 1451231c87572a7d3f92fc210b4b35711c949a98
       desc: initial
   $ hg rebase -s 1 -d .
   rebasing 1:472e38d57782 "mv a b"
   merging a and b to b
   rebasing 2:d3efd280421d "mv b c"
   merging b and c to c
   saved backup bundle to $TESTTMP/repo/.hg/strip-backup/472e38d57782-ab8d3c58-rebase.hg
 
   $ cd ..
   $ rm -rf repo
 
 Move one file and add another file in the same folder in one branch, modify file in another branch
 --------------------------------------------------------------------------------------------------
 
   $ hg init repo
   $ initclient repo
   $ cd repo
   $ echo a > a
   $ hg add a
   $ hg ci -m initial
   $ hg mv a b
   $ hg ci -m 'mv a b'
   $ echo c > c
   $ hg add c
   $ hg ci -m 'add c'
   $ hg up -q 0
   $ echo b > a
   $ hg ci -m 'mod a'
   created new head
 
   $ hg log -G -T 'changeset: {node}\n desc: {desc}\n'
   @  changeset: ef716627c70bf4ca0bdb623cfb0d6fe5b9acc51e
   |   desc: mod a
   | o  changeset: b1a6187e79fbce851bb584eadcb0cc4a80290fd9
   | |   desc: add c
   | o  changeset: 472e38d57782172f6c6abed82a94ca0d998c3a22
   |/    desc: mv a b
   o  changeset: 1451231c87572a7d3f92fc210b4b35711c949a98
       desc: initial
 
   $ hg rebase -s . -d 2
   rebasing 3:ef716627c70b "mod a" (tip)
   merging b and a to b
   saved backup bundle to $TESTTMP/repo/.hg/strip-backup/ef716627c70b-24681561-rebase.hg
   $ ls
   b
   c
   $ cat b
   b
   $ rm -rf repo
 
 Merge test
 ----------
 
   $ hg init repo
   $ initclient repo
   $ cd repo
   $ echo a > a
   $ hg add a
   $ hg ci -m initial
   $ echo b > a
   $ hg ci -m 'modify a'
   $ hg up -q 0
   $ hg mv a b
   $ hg ci -m 'mv a b'
   created new head
   $ hg up -q 2
 
   $ hg log -G -T 'changeset: {node}\n desc: {desc}\n'
   @  changeset: 472e38d57782172f6c6abed82a94ca0d998c3a22
   |   desc: mv a b
   | o  changeset: b0357b07f79129a3d08a68621271ca1352ae8a09
   |/    desc: modify a
   o  changeset: 1451231c87572a7d3f92fc210b4b35711c949a98
       desc: initial
 
   $ hg merge 1
   merging b and a to b
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m merge
   $ ls
   b
   $ cd ..
   $ rm -rf repo
 
 Copy and move file
 ------------------
 
   $ hg init repo
   $ initclient repo
   $ cd repo
   $ echo a > a
   $ hg add a
   $ hg ci -m initial
   $ hg cp a c
   $ hg mv a b
   $ hg ci -m 'cp a c, mv a b'
   $ hg up -q 0
   $ echo b > a
   $ hg ci -m 'mod a'
   created new head
 
   $ hg log -G -T 'changeset: {node}\n desc: {desc}\n'
   @  changeset: ef716627c70bf4ca0bdb623cfb0d6fe5b9acc51e
   |   desc: mod a
   | o  changeset: 4fc3fd13fbdb89ada6b75bfcef3911a689a0dde8
   |/    desc: cp a c, mv a b
   o  changeset: 1451231c87572a7d3f92fc210b4b35711c949a98
       desc: initial
 
   $ hg rebase -s . -d 1
   rebasing 2:ef716627c70b "mod a" (tip)
   merging b and a to b
   merging c and a to c
   saved backup bundle to $TESTTMP/repo/repo/.hg/strip-backup/ef716627c70b-24681561-rebase.hg
   $ ls
   b
   c
   $ cat b
   b
   $ cat c
   b
   $ cd ..
   $ rm -rf repo
 
 Do a merge commit with many consequent moves in one branch
 ----------------------------------------------------------
 
   $ hg init repo
   $ initclient repo
   $ cd repo
   $ echo a > a
   $ hg add a
   $ hg ci -m initial
   $ echo b > a
   $ hg ci -qm 'mod a'
   $ hg up -q ".^"
   $ hg mv a b
   $ hg ci -qm 'mv a b'
   $ hg mv b c
   $ hg ci -qm 'mv b c'
   $ hg up -q 1
   $ hg log -G -T 'changeset: {node}\n desc: {desc}\n'
   o  changeset: d3efd280421d24f9f229997c19e654761c942a71
   |   desc: mv b c
   o  changeset: 472e38d57782172f6c6abed82a94ca0d998c3a22
   |   desc: mv a b
   | @  changeset: ef716627c70bf4ca0bdb623cfb0d6fe5b9acc51e
   |/    desc: mod a
   o  changeset: 1451231c87572a7d3f92fc210b4b35711c949a98
       desc: initial
 
   $ hg merge 3
   merging a and c to c
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -qm 'merge'
   $ hg log -G -T 'changeset: {node}\n desc: {desc}, phase: {phase}\n'
   @    changeset: cd29b0d08c0f39bfed4cde1b40e30f419db0c825
   |\    desc: merge, phase: draft
   | o  changeset: d3efd280421d24f9f229997c19e654761c942a71
   | |   desc: mv b c, phase: draft
   | o  changeset: 472e38d57782172f6c6abed82a94ca0d998c3a22
   | |   desc: mv a b, phase: draft
   o |  changeset: ef716627c70bf4ca0bdb623cfb0d6fe5b9acc51e
   |/    desc: mod a, phase: draft
   o  changeset: 1451231c87572a7d3f92fc210b4b35711c949a98
       desc: initial, phase: draft
   $ ls
   c
   $ cd ..
   $ rm -rf repo
 
 Test shelve/unshelve
 -------------------
 
   $ hg init repo
   $ initclient repo
   $ cd repo
   $ echo a > a
   $ hg add a
   $ hg ci -m initial
   $ echo b > a
   $ hg shelve
   shelved as default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg mv a b
   $ hg ci -m 'mv a b'
 
   $ hg log -G -T 'changeset: {node}\n desc: {desc}\n'
   @  changeset: 472e38d57782172f6c6abed82a94ca0d998c3a22
   |   desc: mv a b
   o  changeset: 1451231c87572a7d3f92fc210b4b35711c949a98
       desc: initial
   $ hg unshelve
   unshelving change 'default'
   rebasing shelved changes
   merging b and a to b
   $ ls
   b
   $ cat b
   b
   $ cd ..
   $ rm -rf repo
 
 Test full copytrace ability on draft branch
 -------------------------------------------
 
 File directory and base name changed in same move
   $ hg init repo
   $ initclient repo
   $ mkdir repo/dir1
   $ cd repo/dir1
   $ echo a > a
   $ hg add a
   $ hg ci -qm initial
   $ cd ..
   $ hg mv -q dir1 dir2
   $ hg mv dir2/a dir2/b
   $ hg ci -qm 'mv a b; mv dir1 dir2'
   $ hg up -q '.^'
   $ cd dir1
   $ echo b >> a
   $ cd ..
   $ hg ci -qm 'mod a'
 
   $ hg log -G -T 'changeset {node}\n desc {desc}, phase: {phase}\n'
   @  changeset 6207d2d318e710b882e3d5ada2a89770efc42c96
   |   desc mod a, phase: draft
   | o  changeset abffdd4e3dfc04bc375034b970299b2a309a1cce
   |/    desc mv a b; mv dir1 dir2, phase: draft
   o  changeset 81973cd24b58db2fdf18ce3d64fb2cc3284e9ab3
       desc initial, phase: draft
 
   $ hg rebase -s . -d 1 --config experimental.copytrace.sourcecommitlimit=100
   rebasing 2:6207d2d318e7 "mod a" (tip)
   merging dir2/b and dir1/a to dir2/b
   saved backup bundle to $TESTTMP/repo/repo/.hg/strip-backup/6207d2d318e7-1c9779ad-rebase.hg
   $ cat dir2/b
   a
   b
   $ cd ..
   $ rm -rf repo
 
 Move directory in one merge parent, while adding file to original directory
 in other merge parent. File moved on rebase.
 
   $ hg init repo
   $ initclient repo
   $ mkdir repo/dir1
   $ cd repo/dir1
   $ echo dummy > dummy
   $ hg add dummy
   $ cd ..
   $ hg ci -qm initial
   $ cd dir1
   $ echo a > a
   $ hg add a
   $ cd ..
   $ hg ci -qm 'hg add dir1/a'
   $ hg up -q '.^'
   $ hg mv -q dir1 dir2
   $ hg ci -qm 'mv dir1 dir2'
 
   $ hg log -G -T 'changeset {node}\n desc {desc}, phase: {phase}\n'
   @  changeset e8919e7df8d036e07b906045eddcd4a42ff1915f
   |   desc mv dir1 dir2, phase: draft
   | o  changeset 7c7c6f339be00f849c3cb2df738ca91db78b32c8
   |/    desc hg add dir1/a, phase: draft
   o  changeset a235dcce55dcf42034c4e374cb200662d0bb4a13
       desc initial, phase: draft
 
   $ hg rebase -s . -d 1 --config experimental.copytrace.sourcecommitlimit=100
   rebasing 2:e8919e7df8d0 "mv dir1 dir2" (tip)
   saved backup bundle to $TESTTMP/repo/repo/.hg/strip-backup/e8919e7df8d0-f62fab62-rebase.hg
   $ ls dir2
   a
   dummy
   $ rm -rf repo
 
 Testing the sourcecommitlimit config
 -----------------------------------
 
   $ hg init repo
   $ initclient repo
   $ cd repo
   $ echo a > a
   $ hg ci -Aqm "added a"
   $ echo "more things" >> a
   $ hg ci -qm "added more things to a"
   $ hg up 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo b > b
   $ hg ci -Aqm "added b"
   $ mkdir foo
   $ hg mv a foo/bar
   $ hg ci -m "Moved a to foo/bar"
   $ hg log -G -T 'changeset {node}\n desc {desc}, phase: {phase}\n'
   @  changeset b4b0f7880e500b5c364a5f07b4a2b167de7a6fb0
   |   desc Moved a to foo/bar, phase: draft
   o  changeset 5f6d8a4bf34ab274ccc9f631c2536964b8a3666d
   |   desc added b, phase: draft
   | o  changeset 8b6e13696c38e8445a759516474640c2f8dddef6
   |/    desc added more things to a, phase: draft
   o  changeset 9092f1db7931481f93b37d5c9fbcfc341bcd7318
       desc added a, phase: draft
 
 When the sourcecommitlimit is small and we have more drafts, we use heuristics only
 
   $ hg rebase -s 8b6e13696 -d .
   rebasing 1:8b6e13696c38 "added more things to a"
-  file 'a' was deleted in other [source] but was modified in local [dest].
+  file 'a' was deleted in local [dest] but was modified in other [source].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
 
 But when we have "sourcecommitlimit > (no. of drafts from base to c1)", we do
 fullcopytracing
 
   $ hg rebase --abort
   rebase aborted
   $ hg rebase -s 8b6e13696 -d . --config experimental.copytrace.sourcecommitlimit=100
   rebasing 1:8b6e13696c38 "added more things to a"
   merging foo/bar and a to foo/bar
   saved backup bundle to $TESTTMP/repo/repo/repo/.hg/strip-backup/8b6e13696c38-fc14ac83-rebase.hg
   $ cd ..
   $ rm -rf repo

tests/test-largefiles-update.t

@@ -1,795 +1,795 b''
 #require no-reposimplestore
 
 This file focuses mainly on updating largefiles in the working
 directory (and ".hg/largefiles/dirstate")
 
   $ cat >> $HGRCPATH <<EOF
   > [ui]
   > merge = internal:fail
   > [extensions]
   > largefiles =
   > [extdiff]
   > # for portability:
   > pdiff = sh "$RUNTESTDIR/pdiff"
   > EOF
 
   $ hg init repo
   $ cd repo
 
   $ echo large1 > large1
   $ echo large2 > large2
   $ hg add --large large1 large2
   $ echo normal1 > normal1
   $ hg add normal1
   $ hg commit -m '#0'
   $ echo 'large1 in #1' > large1
   $ echo 'normal1 in #1' > normal1
   $ hg commit -m '#1'
   $ hg pdiff -r '.^' --config extensions.extdiff=
   diff -Nru repo.0d9d9b8dc9a3/.hglf/large1 repo/.hglf/large1
   --- repo.0d9d9b8dc9a3/.hglf/large1	* (glob)
   +++ repo/.hglf/large1	* (glob)
   @@ -1* +1* @@ (glob)
   -4669e532d5b2c093a78eca010077e708a071bb64
   +58e24f733a964da346e2407a2bee99d9001184f5
   diff -Nru repo.0d9d9b8dc9a3/normal1 repo/normal1
   --- repo.0d9d9b8dc9a3/normal1	* (glob)
   +++ repo/normal1	* (glob)
   @@ -1* +1* @@ (glob)
   -normal1
   +normal1 in #1
   [1]
   $ hg update -q -C 0
   $ echo 'large2 in #2' > large2
   $ hg commit -m '#2'
   created new head
 
 Test that update also updates the lfdirstate of 'unsure' largefiles after
 hashing them:
 
 The previous operations will usually have left us with largefiles with a mtime
 within the same second as the dirstate was written.
 The lfdirstate entries will thus have been written with an invalidated/unset
 mtime to make sure further changes within the same second is detected.
 We will however occasionally be "lucky" and get a tick between writing
 largefiles and writing dirstate so we get valid lfdirstate timestamps. The
 following verification is thus disabled but can be verified manually.
 
 #if false
   $ hg debugdirstate --large --nodate
   n 644          7 unset               large1
   n 644         13 unset               large2
 #endif
 
 Wait to make sure we get a tick so the mtime of the largefiles become valid.
 
   $ sleep 1
 
 A linear merge will update standins before performing the actual merge. It will
 do a lfdirstate status walk and find 'unset'/'unsure' files, hash them, and
 update the corresponding standins.
 Verify that it actually marks the clean files as clean in lfdirstate so
 we don't have to hash them again next time we update.
 
   $ hg up
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   updated to "f74e50bd9e55: #2"
   1 other heads for branch "default"
   $ hg debugdirstate --large --nodate
   n 644          7 set                 large1
   n 644         13 set                 large2
 
 Test that lfdirstate keeps track of last modification of largefiles and
 prevents unnecessary hashing of content - also after linear/noop update
 
   $ sleep 1
   $ hg st
   $ hg debugdirstate --large --nodate
   n 644          7 set                 large1
   n 644         13 set                 large2
   $ hg up
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   updated to "f74e50bd9e55: #2"
   1 other heads for branch "default"
   $ hg debugdirstate --large --nodate
   n 644          7 set                 large1
   n 644         13 set                 large2
 
 Test that "hg merge" updates largefiles from "other" correctly
 
 (getting largefiles from "other" normally)
 
   $ hg status -A large1
   C large1
   $ cat large1
   large1
   $ cat .hglf/large1
   4669e532d5b2c093a78eca010077e708a071bb64
   $ hg merge --config debug.dirstate.delaywrite=2
   getting changed largefiles
   1 largefiles updated, 0 removed
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg status -A large1
   M large1
   $ cat large1
   large1 in #1
   $ cat .hglf/large1
   58e24f733a964da346e2407a2bee99d9001184f5
   $ hg diff -c 1 --nodates .hglf/large1 | grep '^[+-][0-9a-z]'
   -4669e532d5b2c093a78eca010077e708a071bb64
   +58e24f733a964da346e2407a2bee99d9001184f5
 
 (getting largefiles from "other" via conflict prompt)
 
   $ hg update -q -C 2
   $ echo 'large1 in #3' > large1
   $ echo 'normal1 in #3' > normal1
   $ hg commit -m '#3'
   $ cat .hglf/large1
   e5bb990443d6a92aaf7223813720f7566c9dd05b
   $ hg merge --config debug.dirstate.delaywrite=2 --config ui.interactive=True <<EOF
   > o
   > EOF
   largefile large1 has a merge conflict
   ancestor was 4669e532d5b2c093a78eca010077e708a071bb64
   keep (l)ocal e5bb990443d6a92aaf7223813720f7566c9dd05b or
   take (o)ther 58e24f733a964da346e2407a2bee99d9001184f5? o
   merging normal1
   warning: conflicts while merging normal1! (edit, then use 'hg resolve --mark')
   getting changed largefiles
   1 largefiles updated, 0 removed
   0 files updated, 1 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
   $ hg status -A large1
   M large1
   $ cat large1
   large1 in #1
   $ cat .hglf/large1
   58e24f733a964da346e2407a2bee99d9001184f5
   $ rm normal1.orig
 
 (merge non-existing largefiles from "other" via conflict prompt -
 make sure the following commit doesn't abort in a confusing way when trying to
 mark the non-existing file as normal in lfdirstate)
 
   $ mv .hg/largefiles/58e24f733a964da346e2407a2bee99d9001184f5 .
   $ hg update -q -C 3
   $ hg merge --config largefiles.usercache=not --config debug.dirstate.delaywrite=2 --tool :local --config ui.interactive=True <<EOF
   > o
   > EOF
   largefile large1 has a merge conflict
   ancestor was 4669e532d5b2c093a78eca010077e708a071bb64
   keep (l)ocal e5bb990443d6a92aaf7223813720f7566c9dd05b or
   take (o)ther 58e24f733a964da346e2407a2bee99d9001184f5? o
   getting changed largefiles
   large1: largefile 58e24f733a964da346e2407a2bee99d9001184f5 not available from file:/*/$TESTTMP/repo (glob)
   0 largefiles updated, 0 removed
   0 files updated, 2 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg commit -m '1-2-3 testing' --config largefiles.usercache=not
   large1: largefile 58e24f733a964da346e2407a2bee99d9001184f5 not available from local store
   $ hg up -C . --config largefiles.usercache=not
   getting changed largefiles
   large1: largefile 58e24f733a964da346e2407a2bee99d9001184f5 not available from file:/*/$TESTTMP/repo (glob)
   0 largefiles updated, 0 removed
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg st large1
   ! large1
   $ hg rollback -q
   $ mv 58e24f733a964da346e2407a2bee99d9001184f5 .hg/largefiles/
 
 Test that "hg revert -r REV" updates largefiles from "REV" correctly
 
   $ hg update -q -C 3
   $ hg status -A large1
   C large1
   $ cat large1
   large1 in #3
   $ cat .hglf/large1
   e5bb990443d6a92aaf7223813720f7566c9dd05b
   $ hg diff -c 1 --nodates .hglf/large1 | grep '^[+-][0-9a-z]'
   -4669e532d5b2c093a78eca010077e708a071bb64
   +58e24f733a964da346e2407a2bee99d9001184f5
   $ hg revert --no-backup -r 1 --config debug.dirstate.delaywrite=2 large1
   $ hg status -A large1
   M large1
   $ cat large1
   large1 in #1
   $ cat .hglf/large1
   58e24f733a964da346e2407a2bee99d9001184f5
 
 Test that "hg rollback" restores status of largefiles correctly
 
   $ hg update -C -q
   $ hg remove large1
   $ test -f .hglf/large1
   [1]
   $ hg forget large2
   $ test -f .hglf/large2
   [1]
   $ echo largeX > largeX
   $ hg add --large largeX
   $ cat .hglf/largeX
   
   $ hg commit -m 'will be rollback-ed soon'
   $ echo largeY > largeY
   $ hg add --large largeY
 
   $ hg status -A large1
   large1: $ENOENT$
 
   $ hg status -A large2
   ? large2
   $ hg status -A largeX
   C largeX
   $ hg status -A largeY
   A largeY
   $ hg rollback
   repository tip rolled back to revision 3 (undo commit)
   working directory now based on revision 3
   $ hg status -A large1
   R large1
   $ test -f .hglf/large1
   [1]
   $ hg status -A large2
   R large2
   $ test -f .hglf/large2
   [1]
   $ hg status -A largeX
   A largeX
   $ cat .hglf/largeX
   
   $ hg status -A largeY
   ? largeY
   $ test -f .hglf/largeY
   [1]
   $ rm largeY
 
 Test that "hg rollback" restores standins correctly
 
   $ hg commit -m 'will be rollback-ed soon'
   $ hg update -q -C 2
   $ cat large1
   large1
   $ cat .hglf/large1
   4669e532d5b2c093a78eca010077e708a071bb64
   $ cat large2
   large2 in #2
   $ cat .hglf/large2
   3cfce6277e7668985707b6887ce56f9f62f6ccd9
 
   $ hg rollback -q -f
   $ cat large1
   large1
   $ cat .hglf/large1
   4669e532d5b2c093a78eca010077e708a071bb64
   $ cat large2
   large2 in #2
   $ cat .hglf/large2
   3cfce6277e7668985707b6887ce56f9f62f6ccd9
 
 (rollback the parent of the working directory, when the parent of it
 is not branch-tip)
 
   $ hg update -q -C 1
   $ cat .hglf/large1
   58e24f733a964da346e2407a2bee99d9001184f5
   $ cat .hglf/large2
   1deebade43c8c498a3c8daddac0244dc55d1331d
 
   $ echo normalX > normalX
   $ hg add normalX
   $ hg commit -m 'will be rollback-ed soon'
   $ hg rollback -q
 
   $ cat .hglf/large1
   58e24f733a964da346e2407a2bee99d9001184f5
   $ cat .hglf/large2
   1deebade43c8c498a3c8daddac0244dc55d1331d
   $ rm normalX
 
 Test that "hg status" shows status of largefiles correctly just after
 automated commit like rebase/transplant
 
   $ cat >> .hg/hgrc <<EOF
   > [extensions]
   > rebase =
   > strip =
   > transplant =
   > EOF
   $ hg update -q -C 1
   $ hg remove large1
   $ echo largeX > largeX
   $ hg add --large largeX
   $ hg commit -m '#4'
 
   $ hg rebase -s 1 -d 2 --keep
   rebasing 1:72518492caa6 "#1"
   rebasing 4:07d6153b5c04 "#4" (tip)
 
   $ hg status -A large1
   large1: $ENOENT$
 
   $ hg status -A largeX
   C largeX
   $ hg strip -q 5
 
   $ hg update -q -C 2
   $ hg transplant -q 1 4
 
   $ hg status -A large1
   large1: $ENOENT$
 
   $ hg status -A largeX
   C largeX
   $ hg strip -q 5
 
   $ hg update -q -C 2
   $ hg transplant -q --merge 1 --merge 4
 
   $ hg status -A large1
   large1: $ENOENT$
 
   $ hg status -A largeX
   C largeX
   $ hg strip -q 5
 
 Test that linear merge can detect modification (and conflict) correctly
 
 (linear merge without conflict)
 
   $ echo 'large2 for linear merge (no conflict)' > large2
   $ hg update 3 --config debug.dirstate.delaywrite=2
   getting changed largefiles
   1 largefiles updated, 0 removed
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg status -A large2
   M large2
   $ cat large2
   large2 for linear merge (no conflict)
   $ cat .hglf/large2
   9c4bf8f1b33536d6e5f89447e10620cfe52ea710
 
 (linear merge with conflict, choosing "other")
 
   $ hg update -q -C 2
   $ echo 'large1 for linear merge (conflict)' > large1
   $ hg update 3 --config ui.interactive=True <<EOF
   > o
   > EOF
   largefile large1 has a merge conflict
   ancestor was 4669e532d5b2c093a78eca010077e708a071bb64
   keep (l)ocal ba94c2efe5b7c5e0af8d189295ce00553b0612b7 or
   take (o)ther e5bb990443d6a92aaf7223813720f7566c9dd05b? o
   getting changed largefiles
   1 largefiles updated, 0 removed
   1 files updated, 1 files merged, 0 files removed, 0 files unresolved
   $ hg status -A large1
   C large1
   $ cat large1
   large1 in #3
   $ cat .hglf/large1
   e5bb990443d6a92aaf7223813720f7566c9dd05b
 
 (linear merge with conflict, choosing "local")
 
   $ hg update -q -C 2
   $ echo 'large1 for linear merge (conflict)' > large1
   $ hg update 3 --config debug.dirstate.delaywrite=2
   largefile large1 has a merge conflict
   ancestor was 4669e532d5b2c093a78eca010077e708a071bb64
   keep (l)ocal ba94c2efe5b7c5e0af8d189295ce00553b0612b7 or
   take (o)ther e5bb990443d6a92aaf7223813720f7566c9dd05b? l
   1 files updated, 1 files merged, 0 files removed, 0 files unresolved
   $ hg status -A large1
   M large1
   $ cat large1
   large1 for linear merge (conflict)
   $ cat .hglf/large1
   ba94c2efe5b7c5e0af8d189295ce00553b0612b7
 
 Test a linear merge to a revision containing same-name normal file
 
   $ hg update -q -C 3
   $ hg remove large2
   $ echo 'large2 as normal file' > large2
   $ hg add large2
   $ echo 'large3 as normal file' > large3
   $ hg add large3
   $ hg commit -m '#5'
   $ hg manifest
   .hglf/large1
   large2
   large3
   normal1
 
 (modified largefile is already switched to normal)
 
   $ hg update -q -C 2
   $ echo 'modified large2 for linear merge' > large2
   $ hg update -q 5
   remote turned local largefile large2 into a normal file
   keep (l)argefile or use (n)ormal file? l
   $ hg debugdirstate --nodates | grep large2
   a   0         -1 unset               .hglf/large2
   r   0          0 set                 large2
   $ hg status -A large2
   A large2
   $ cat large2
   modified large2 for linear merge
 
 (added largefile is already committed as normal)
 
   $ hg update -q -C 2
   $ echo 'large3 as large file for linear merge' > large3
   $ hg add --large large3
   $ hg update -q 5
   remote turned local largefile large3 into a normal file
   keep (l)argefile or use (n)ormal file? l
   $ hg debugdirstate --nodates | grep large3
   a   0         -1 unset               .hglf/large3
   r   0          0 set                 large3
   $ hg status -A large3
   A large3
   $ cat large3
   large3 as large file for linear merge
   $ rm -f large3 .hglf/large3
 
 Test that the internal linear merging works correctly
 (both heads are stripped to keep pairing of revision number and commit log)
 
   $ hg update -q -C 2
   $ hg strip 3 4
   saved backup bundle to $TESTTMP/repo/.hg/strip-backup/9530e27857f7-2e7b195d-backup.hg
   $ mv .hg/strip-backup/9530e27857f7-2e7b195d-backup.hg $TESTTMP
 
 (internal linear merging at "hg pull --update")
 
   $ echo 'large1 for linear merge (conflict)' > large1
   $ echo 'large2 for linear merge (conflict with normal file)' > large2
   $ hg pull --update --config debug.dirstate.delaywrite=2 $TESTTMP/9530e27857f7-2e7b195d-backup.hg
   pulling from $TESTTMP/9530e27857f7-2e7b195d-backup.hg
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 5 changes to 5 files
   new changesets 9530e27857f7:d65e59e952a9
   remote turned local largefile large2 into a normal file
   keep (l)argefile or use (n)ormal file? l
   largefile large1 has a merge conflict
   ancestor was 4669e532d5b2c093a78eca010077e708a071bb64
   keep (l)ocal ba94c2efe5b7c5e0af8d189295ce00553b0612b7 or
   take (o)ther e5bb990443d6a92aaf7223813720f7566c9dd05b? l
   2 files updated, 1 files merged, 0 files removed, 0 files unresolved
   updated to "d65e59e952a9: #5"
   1 other heads for branch "default"
 
   $ hg status -A large1
   M large1
   $ cat large1
   large1 for linear merge (conflict)
   $ cat .hglf/large1
   ba94c2efe5b7c5e0af8d189295ce00553b0612b7
   $ hg status -A large2
   A large2
   $ cat large2
   large2 for linear merge (conflict with normal file)
   $ cat .hglf/large2
   d7591fe9be0f6227d90bddf3e4f52ff41fc1f544
 
 (internal linear merging at "hg unbundle --update")
 
   $ hg update -q -C 2
   $ hg rollback -q
 
   $ echo 'large1 for linear merge (conflict)' > large1
   $ echo 'large2 for linear merge (conflict with normal file)' > large2
   $ hg unbundle --update --config debug.dirstate.delaywrite=2 $TESTTMP/9530e27857f7-2e7b195d-backup.hg
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 5 changes to 5 files
   new changesets 9530e27857f7:d65e59e952a9
   remote turned local largefile large2 into a normal file
   keep (l)argefile or use (n)ormal file? l
   largefile large1 has a merge conflict
   ancestor was 4669e532d5b2c093a78eca010077e708a071bb64
   keep (l)ocal ba94c2efe5b7c5e0af8d189295ce00553b0612b7 or
   take (o)ther e5bb990443d6a92aaf7223813720f7566c9dd05b? l
   2 files updated, 1 files merged, 0 files removed, 0 files unresolved
   updated to "d65e59e952a9: #5"
   1 other heads for branch "default"
 
   $ hg status -A large1
   M large1
   $ cat large1
   large1 for linear merge (conflict)
   $ cat .hglf/large1
   ba94c2efe5b7c5e0af8d189295ce00553b0612b7
   $ hg status -A large2
   A large2
   $ cat large2
   large2 for linear merge (conflict with normal file)
   $ cat .hglf/large2
   d7591fe9be0f6227d90bddf3e4f52ff41fc1f544
 
 (internal linear merging in subrepo at "hg update")
 
   $ cd ..
   $ hg init subparent
   $ cd subparent
 
   $ hg clone -q -u 2 ../repo sub
   $ cat > .hgsub <<EOF
   > sub = sub
   > EOF
   $ hg add .hgsub
   $ hg commit -m '#0@parent'
   $ cat .hgsubstate
   f74e50bd9e5594b7cf1e6c5cbab86ddd25f3ca2f sub
   $ hg -R sub update -q
   $ hg commit -m '#1@parent'
   $ cat .hgsubstate
   d65e59e952a9638e2ce863b41a420ca723dd3e8d sub
   $ hg update -q 0
 
   $ echo 'large1 for linear merge (conflict)' > sub/large1
   $ echo 'large2 for linear merge (conflict with normal file)' > sub/large2
   $ hg update --config ui.interactive=True --config debug.dirstate.delaywrite=2 <<EOF
   > m
   > r
   > l
   > l
   > EOF
    subrepository sub diverged (local revision: f74e50bd9e55, remote revision: d65e59e952a9)
   (M)erge, keep (l)ocal [working copy] or keep (r)emote [destination]? m
    subrepository sources for sub differ (in checked out version)
   use (l)ocal source (f74e50bd9e55) or (r)emote source (d65e59e952a9)? r
   remote turned local largefile large2 into a normal file
   keep (l)argefile or use (n)ormal file? l
   largefile large1 has a merge conflict
   ancestor was 4669e532d5b2c093a78eca010077e708a071bb64
   keep (l)ocal ba94c2efe5b7c5e0af8d189295ce00553b0612b7 or
   take (o)ther e5bb990443d6a92aaf7223813720f7566c9dd05b? l
   2 files updated, 1 files merged, 0 files removed, 0 files unresolved
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg -R sub status -A sub/large1
   M sub/large1
   $ cat sub/large1
   large1 for linear merge (conflict)
   $ cat sub/.hglf/large1
   ba94c2efe5b7c5e0af8d189295ce00553b0612b7
   $ hg -R sub status -A sub/large2
   A sub/large2
   $ cat sub/large2
   large2 for linear merge (conflict with normal file)
   $ cat sub/.hglf/large2
   d7591fe9be0f6227d90bddf3e4f52ff41fc1f544
 
   $ cd ..
   $ cd repo
 
 Test that rebase updates largefiles in the working directory even if
 it is aborted by conflict.
 
   $ hg update -q -C 3
   $ cat .hglf/large1
   e5bb990443d6a92aaf7223813720f7566c9dd05b
   $ cat large1
   large1 in #3
   $ hg rebase -s 1 -d 3 --keep --config ui.interactive=True <<EOF
   > o
   > EOF
   rebasing 1:72518492caa6 "#1"
   largefile large1 has a merge conflict
   ancestor was 4669e532d5b2c093a78eca010077e708a071bb64
   keep (l)ocal e5bb990443d6a92aaf7223813720f7566c9dd05b or
   take (o)ther 58e24f733a964da346e2407a2bee99d9001184f5? o
   merging normal1
   warning: conflicts while merging normal1! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
   $ cat .hglf/large1
   58e24f733a964da346e2407a2bee99d9001184f5
   $ cat large1
   large1 in #1
   $ rm normal1.orig
 
 Test that rebase updates standins for manually modified largefiles at
 the 1st commit of resuming.
 
   $ echo "manually modified before 'hg rebase --continue'" > large1
   $ hg resolve -m normal1
   (no more unresolved files)
   continue: hg rebase --continue
   $ hg rebase --continue --config ui.interactive=True <<EOF
   > c
   > EOF
   rebasing 1:72518492caa6 "#1"
   rebasing 4:07d6153b5c04 "#4"
-  file '.hglf/large1' was deleted in local [dest] but was modified in other [source].
+  file '.hglf/large1' was deleted in other [source] but was modified in local [dest].
   What do you want to do?
   use (c)hanged version, (d)elete, or leave (u)nresolved? c
 
   $ hg diff -c "tip~1" --nodates .hglf/large1 | grep '^[+-][0-9a-z]'
   -e5bb990443d6a92aaf7223813720f7566c9dd05b
   +8a4f783556e7dea21139ca0466eafce954c75c13
   $ rm -f large1
   $ hg update -q -C tip
   $ cat large1
   manually modified before 'hg rebase --continue'
 
 Test that transplant updates largefiles, of which standins are safely
 changed, even if it is aborted by conflict of other.
 
   $ hg update -q -C 5
   $ cat .hglf/large1
   e5bb990443d6a92aaf7223813720f7566c9dd05b
   $ cat large1
   large1 in #3
   $ hg diff -c 4 .hglf/largeX | grep '^[+-][0-9a-z]'
   +fa44618ea25181aff4f48b70428294790cec9f61
   $ hg transplant 4
   applying 07d6153b5c04
   patching file .hglf/large1
   Hunk #1 FAILED at 0
   1 out of 1 hunks FAILED -- saving rejects to file .hglf/large1.rej
   patch failed to apply
   abort: fix up the working directory and run hg transplant --continue
   [255]
   $ hg status -A large1
   C large1
   $ cat .hglf/large1
   e5bb990443d6a92aaf7223813720f7566c9dd05b
   $ cat large1
   large1 in #3
   $ hg status -A largeX
   A largeX
   $ cat .hglf/largeX
   fa44618ea25181aff4f48b70428294790cec9f61
   $ cat largeX
   largeX
 
 Test that transplant updates standins for manually modified largefiles
 at the 1st commit of resuming.
 
   $ echo "manually modified before 'hg transplant --continue'" > large1
   $ hg transplant --continue
   07d6153b5c04 transplanted as f1bf30eb88cc
   $ hg diff -c tip .hglf/large1 | grep '^[+-][0-9a-z]'
   -e5bb990443d6a92aaf7223813720f7566c9dd05b
   +6a4f36d4075fbe0f30ec1d26ca44e63c05903671
   $ rm -f large1
   $ hg update -q -C tip
   $ cat large1
   manually modified before 'hg transplant --continue'
 
 Test that "hg status" doesn't show removal of largefiles not managed
 in the target context.
 
   $ hg update -q -C 4
   $ hg remove largeX
   $ hg status -A largeX
   R largeX
   $ hg status -A --rev '.^1' largeX
 
 #if execbit
 
 Test that "hg status" against revisions other than parent notices exec
 bit changes of largefiles.
 
   $ hg update -q -C 4
 
 (the case that large2 doesn't have exec bit in the target context but
 in the working context)
 
   $ chmod +x large2
   $ hg status -A --rev 0 large2
   M large2
   $ hg commit -m 'chmod +x large2'
 
 (the case that large2 has exec bit in the target context but not in
 the working context)
 
   $ echo dummy > dummy
   $ hg add dummy
   $ hg commit -m 'revision for separation'
   $ chmod -x large2
   $ hg status -A --rev '.^1' large2
   M large2
 
 #else
 
 Test that "hg status" against revisions other than parent ignores exec
 bit correctly on the platform being unaware of it.
 
   $ hg update -q -C 4
 
   $ cat > ../exec-bit.patch <<EOF
   > # HG changeset patch
   > # User test
   > # Date 0 0
   > #      Thu Jan 01 00:00:00 1970 +0000
   > # Node ID be1b433a65b12b27b5519d92213e14f7e1769b90
   > # Parent  07d6153b5c04313efb75deec9ba577de7faeb727
   > chmod +x large2
   > 
   > diff --git a/.hglf/large2 b/.hglf/large2
   > old mode 100644
   > new mode 100755
   > EOF
   $ hg import --exact --bypass ../exec-bit.patch
   applying ../exec-bit.patch
   $ hg status -A --rev tip large2
   C large2
 
 #endif
 
 The fileset revset is evaluated for each revision, instead of once on wdir(),
 and then patterns matched on each revision.  Here, no exec bits are set in
 wdir(), but a matching revision is detected.
 
 (Teach large2 is not an executable. Maybe this is a bug of largefiles.)
 #if execbit
   $ chmod -x .hglf/large2
 #endif
 
   $ hg files 'set:exec()'
   [1]
   $ hg log -qr 'file("set:exec()")'
   9:be1b433a65b1
 
 Test a fatal error interrupting an update. Verify that status report dirty
 files correctly after an interrupted update. Also verify that checking all
 hashes reveals it isn't clean.
 
 Start with clean dirstates:
   $ hg up --quiet --clean --rev "8^"
   $ sleep 1
   $ hg st
 Update standins without updating largefiles - large1 is modified and largeX is
 added:
   $ cat << EOF > ../crashupdatelfiles.py
   > import hgext.largefiles.lfutil
   > def getlfilestoupdate(oldstandins, newstandins):
   >      raise SystemExit(7)
   > hgext.largefiles.lfutil.getlfilestoupdate = getlfilestoupdate
   > EOF
   $ hg up -Cr "8" --config extensions.crashupdatelfiles=../crashupdatelfiles.py
   [7]
 Check large1 content and status ... and that update will undo modifications:
   $ cat large1
   large1 in #3
   $ hg st
   M large1
   ! largeX
   $ hg up -Cr .
   getting changed largefiles
   2 largefiles updated, 0 removed
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat large1
   manually modified before 'hg transplant --continue'
   $ hg st
 Force largefiles rehashing and check that all changes have been caught by
 status and update:
   $ rm .hg/largefiles/dirstate
   $ hg st
 
   $ cd ..
 
 Test that "hg convert" avoids copying largefiles from the working
 directory into store, because "hg convert" doesn't update largefiles
 in the working directory (removing files under ".cache/largefiles"
 forces "hg convert" to copy corresponding largefiles)
 
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > convert =
   > EOF
 
   $ rm $TESTTMP/.cache/largefiles/6a4f36d4075fbe0f30ec1d26ca44e63c05903671
   $ hg convert -q repo repo.converted

tests/test-merge-changedelete.t

@@ -1,1130 +1,1130 b''
 Tests for change/delete conflicts, including:
 b5605d88dc27: Make ui.prompt repeat on "unrecognized response" again
  (issue897)
 
 840e2b315c1f: Fix misleading error and prompts during update/merge
  (issue556)
 
 Make sure HGMERGE doesn't interfere with the test
   $ unset HGMERGE
 
   $ status() {
   >     echo "--- status ---"
   >     hg st -A file1 file2 file3
   >     echo "--- resolve --list ---"
   >     hg resolve --list file1 file2 file3
   >     echo "--- debugmergestate ---"
   >     hg debugmergestate
   >     for file in file1 file2 file3; do
   >         if [ -f $file ]; then
   >             echo "--- $file ---"
   >             cat $file
   >         else
   >             echo "*** $file does not exist"
   >         fi
   >     done
   > }
 
   $ hg init repo
   $ cd repo
 
   $ echo 1 > file1
   $ echo 2 > file2
   $ echo 3 > file3
   $ hg ci -Am 'added files'
   adding file1
   adding file2
   adding file3
 
   $ hg rm file1
   $ echo changed >> file2
   $ echo changed1 >> file3
   $ hg ci -m 'removed file1, changed file2, changed file3'
 
   $ hg co 0
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ echo changed >> file1
   $ hg rm file2
   $ echo changed2 >> file3
   $ hg ci -m 'changed file1, removed file2, changed file3'
   created new head
 
 
 Non-interactive merge:
 
   $ hg merge -y
-  file 'file1' was deleted in local [working copy] but was modified in other [merge rev].
+  file 'file1' was deleted in other [merge rev] but was modified in local [working copy].
   What do you want to do?
   use (c)hanged version, (d)elete, or leave (u)nresolved? u
-  file 'file2' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'file2' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   merging file3
   warning: conflicts while merging file3! (edit, then use 'hg resolve --mark')
   0 files updated, 0 files merged, 0 files removed, 3 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
 
   $ status
   --- status ---
   M file2
   M file3
   C file1
   --- resolve --list ---
   U file1
   U file2
   U file3
   --- debugmergestate ---
   * version 2 records
   local: 13910f48cf7bdb2a0ba6e24b4900e4fdd5739dd4
   other: 10f9a0a634e82080907e62f075ab119cbc565ea6
   labels:
     local: working copy
     other: merge rev
   file extras: file1 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file1 (record type "C", state "u", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node b8e02f6433738021a065f94175c7cd23db5f05be)
     other path: file1 (node null)
   file extras: file2 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file2 (record type "C", state "u", hash null)
     local path: file2 (flags "")
     ancestor path: file2 (node 5d9299349fc01ddd25d0070d149b124d8f10411e)
     other path: file2 (node e7c1328648519852e723de86c0c0525acd779257)
   file extras: file3 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file3 (record type "F", state "u", hash d5b0a58bc47161b1b8a831084b366f757c4f0b11)
     local path: file3 (flags "")
     ancestor path: file3 (node 2661d26c649684b482d10f91960cc3db683c38b4)
     other path: file3 (node a2644c43e210356772c7772a8674544a62e06beb)
   --- file1 ---
   1
   changed
   --- file2 ---
   2
   changed
   --- file3 ---
   3
   <<<<<<< working copy: 13910f48cf7b - test: changed file1, removed file2, chan...
   changed2
   =======
   changed1
   >>>>>>> merge rev:    10f9a0a634e8 - test: removed file1, changed file2, chan...
 
 
 Interactive merge:
 
   $ hg co -C
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   updated to "13910f48cf7b: changed file1, removed file2, changed file3"
   1 other heads for branch "default"
 
   $ hg merge --config ui.interactive=true <<EOF
   > c
   > d
   > EOF
-  file 'file1' was deleted in local [working copy] but was modified in other [merge rev].
+  file 'file1' was deleted in other [merge rev] but was modified in local [working copy].
   What do you want to do?
   use (c)hanged version, (d)elete, or leave (u)nresolved? c
-  file 'file2' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'file2' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? d
   merging file3
   warning: conflicts while merging file3! (edit, then use 'hg resolve --mark')
   0 files updated, 2 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
 
   $ status
   --- status ---
   file2: * (glob)
   M file3
   C file1
   --- resolve --list ---
   R file1
   R file2
   U file3
   --- debugmergestate ---
   * version 2 records
   local: 13910f48cf7bdb2a0ba6e24b4900e4fdd5739dd4
   other: 10f9a0a634e82080907e62f075ab119cbc565ea6
   labels:
     local: working copy
     other: merge rev
   file extras: file1 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file1 (record type "C", state "r", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node b8e02f6433738021a065f94175c7cd23db5f05be)
     other path: file1 (node null)
   file extras: file2 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file2 (record type "C", state "r", hash null)
     local path: file2 (flags "")
     ancestor path: file2 (node 5d9299349fc01ddd25d0070d149b124d8f10411e)
     other path: file2 (node e7c1328648519852e723de86c0c0525acd779257)
   file extras: file3 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file3 (record type "F", state "u", hash d5b0a58bc47161b1b8a831084b366f757c4f0b11)
     local path: file3 (flags "")
     ancestor path: file3 (node 2661d26c649684b482d10f91960cc3db683c38b4)
     other path: file3 (node a2644c43e210356772c7772a8674544a62e06beb)
   --- file1 ---
   1
   changed
   *** file2 does not exist
   --- file3 ---
   3
   <<<<<<< working copy: 13910f48cf7b - test: changed file1, removed file2, chan...
   changed2
   =======
   changed1
   >>>>>>> merge rev:    10f9a0a634e8 - test: removed file1, changed file2, chan...
 
 
 Interactive merge with bad input:
 
   $ hg co -C
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   updated to "13910f48cf7b: changed file1, removed file2, changed file3"
   1 other heads for branch "default"
 
   $ hg merge --config ui.interactive=true <<EOF
   > foo
   > bar
   > d
   > baz
   > c
   > EOF
-  file 'file1' was deleted in local [working copy] but was modified in other [merge rev].
+  file 'file1' was deleted in other [merge rev] but was modified in local [working copy].
   What do you want to do?
   use (c)hanged version, (d)elete, or leave (u)nresolved? foo
   unrecognized response
-  file 'file1' was deleted in local [working copy] but was modified in other [merge rev].
+  file 'file1' was deleted in other [merge rev] but was modified in local [working copy].
   What do you want to do?
   use (c)hanged version, (d)elete, or leave (u)nresolved? bar
   unrecognized response
-  file 'file1' was deleted in local [working copy] but was modified in other [merge rev].
+  file 'file1' was deleted in other [merge rev] but was modified in local [working copy].
   What do you want to do?
   use (c)hanged version, (d)elete, or leave (u)nresolved? d
-  file 'file2' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'file2' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? baz
   unrecognized response
-  file 'file2' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'file2' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
   merging file3
   warning: conflicts while merging file3! (edit, then use 'hg resolve --mark')
   0 files updated, 1 files merged, 1 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
 
   $ status
   --- status ---
   M file2
   M file3
   R file1
   --- resolve --list ---
   R file1
   R file2
   U file3
   --- debugmergestate ---
   * version 2 records
   local: 13910f48cf7bdb2a0ba6e24b4900e4fdd5739dd4
   other: 10f9a0a634e82080907e62f075ab119cbc565ea6
   labels:
     local: working copy
     other: merge rev
   file extras: file1 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file1 (record type "C", state "r", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node b8e02f6433738021a065f94175c7cd23db5f05be)
     other path: file1 (node null)
   file extras: file2 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file2 (record type "C", state "r", hash null)
     local path: file2 (flags "")
     ancestor path: file2 (node 5d9299349fc01ddd25d0070d149b124d8f10411e)
     other path: file2 (node e7c1328648519852e723de86c0c0525acd779257)
   file extras: file3 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file3 (record type "F", state "u", hash d5b0a58bc47161b1b8a831084b366f757c4f0b11)
     local path: file3 (flags "")
     ancestor path: file3 (node 2661d26c649684b482d10f91960cc3db683c38b4)
     other path: file3 (node a2644c43e210356772c7772a8674544a62e06beb)
   *** file1 does not exist
   --- file2 ---
   2
   changed
   --- file3 ---
   3
   <<<<<<< working copy: 13910f48cf7b - test: changed file1, removed file2, chan...
   changed2
   =======
   changed1
   >>>>>>> merge rev:    10f9a0a634e8 - test: removed file1, changed file2, chan...
 
 
 Interactive merge with not enough input:
 
   $ hg co -C
   2 files updated, 0 files merged, 1 files removed, 0 files unresolved
   updated to "13910f48cf7b: changed file1, removed file2, changed file3"
   1 other heads for branch "default"
 
   $ hg merge --config ui.interactive=true <<EOF
   > d
   > EOF
-  file 'file1' was deleted in local [working copy] but was modified in other [merge rev].
+  file 'file1' was deleted in other [merge rev] but was modified in local [working copy].
   What do you want to do?
   use (c)hanged version, (d)elete, or leave (u)nresolved? d
-  file 'file2' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'file2' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? 
   merging file3
   warning: conflicts while merging file3! (edit, then use 'hg resolve --mark')
   0 files updated, 0 files merged, 1 files removed, 2 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
 
   $ status
   --- status ---
   M file2
   M file3
   R file1
   --- resolve --list ---
   R file1
   U file2
   U file3
   --- debugmergestate ---
   * version 2 records
   local: 13910f48cf7bdb2a0ba6e24b4900e4fdd5739dd4
   other: 10f9a0a634e82080907e62f075ab119cbc565ea6
   labels:
     local: working copy
     other: merge rev
   file extras: file1 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file1 (record type "C", state "r", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node b8e02f6433738021a065f94175c7cd23db5f05be)
     other path: file1 (node null)
   file extras: file2 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file2 (record type "C", state "u", hash null)
     local path: file2 (flags "")
     ancestor path: file2 (node 5d9299349fc01ddd25d0070d149b124d8f10411e)
     other path: file2 (node e7c1328648519852e723de86c0c0525acd779257)
   file extras: file3 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file3 (record type "F", state "u", hash d5b0a58bc47161b1b8a831084b366f757c4f0b11)
     local path: file3 (flags "")
     ancestor path: file3 (node 2661d26c649684b482d10f91960cc3db683c38b4)
     other path: file3 (node a2644c43e210356772c7772a8674544a62e06beb)
   *** file1 does not exist
   --- file2 ---
   2
   changed
   --- file3 ---
   3
   <<<<<<< working copy: 13910f48cf7b - test: changed file1, removed file2, chan...
   changed2
   =======
   changed1
   >>>>>>> merge rev:    10f9a0a634e8 - test: removed file1, changed file2, chan...
 
 Choose local versions of files
 
   $ hg co -C
   2 files updated, 0 files merged, 1 files removed, 0 files unresolved
   updated to "13910f48cf7b: changed file1, removed file2, changed file3"
   1 other heads for branch "default"
 
   $ hg merge --tool :local
   0 files updated, 3 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ status 2>&1 | tee $TESTTMP/local.status
   --- status ---
   file2: * (glob)
   M file3
   C file1
   --- resolve --list ---
   R file1
   R file2
   R file3
   --- debugmergestate ---
   * version 2 records
   local: 13910f48cf7bdb2a0ba6e24b4900e4fdd5739dd4
   other: 10f9a0a634e82080907e62f075ab119cbc565ea6
   labels:
     local: working copy
     other: merge rev
   file extras: file1 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file1 (record type "C", state "r", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node b8e02f6433738021a065f94175c7cd23db5f05be)
     other path: file1 (node null)
   file extras: file2 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file2 (record type "C", state "r", hash null)
     local path: file2 (flags "")
     ancestor path: file2 (node 5d9299349fc01ddd25d0070d149b124d8f10411e)
     other path: file2 (node e7c1328648519852e723de86c0c0525acd779257)
   file extras: file3 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file3 (record type "F", state "r", hash d5b0a58bc47161b1b8a831084b366f757c4f0b11)
     local path: file3 (flags "")
     ancestor path: file3 (node 2661d26c649684b482d10f91960cc3db683c38b4)
     other path: file3 (node a2644c43e210356772c7772a8674544a62e06beb)
   --- file1 ---
   1
   changed
   *** file2 does not exist
   --- file3 ---
   3
   changed2
 
 Choose other versions of files
 
   $ hg co -C
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   updated to "13910f48cf7b: changed file1, removed file2, changed file3"
   1 other heads for branch "default"
 
   $ hg merge --tool :other
   0 files updated, 2 files merged, 1 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ status 2>&1 | tee $TESTTMP/other.status
   --- status ---
   M file2
   M file3
   R file1
   --- resolve --list ---
   R file1
   R file2
   R file3
   --- debugmergestate ---
   * version 2 records
   local: 13910f48cf7bdb2a0ba6e24b4900e4fdd5739dd4
   other: 10f9a0a634e82080907e62f075ab119cbc565ea6
   labels:
     local: working copy
     other: merge rev
   file extras: file1 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file1 (record type "C", state "r", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node b8e02f6433738021a065f94175c7cd23db5f05be)
     other path: file1 (node null)
   file extras: file2 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file2 (record type "C", state "r", hash null)
     local path: file2 (flags "")
     ancestor path: file2 (node 5d9299349fc01ddd25d0070d149b124d8f10411e)
     other path: file2 (node e7c1328648519852e723de86c0c0525acd779257)
   file extras: file3 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file3 (record type "F", state "r", hash d5b0a58bc47161b1b8a831084b366f757c4f0b11)
     local path: file3 (flags "")
     ancestor path: file3 (node 2661d26c649684b482d10f91960cc3db683c38b4)
     other path: file3 (node a2644c43e210356772c7772a8674544a62e06beb)
   *** file1 does not exist
   --- file2 ---
   2
   changed
   --- file3 ---
   3
   changed1
 
 Fail
 
   $ hg co -C
   2 files updated, 0 files merged, 1 files removed, 0 files unresolved
   updated to "13910f48cf7b: changed file1, removed file2, changed file3"
   1 other heads for branch "default"
 
   $ hg merge --tool :fail
   0 files updated, 0 files merged, 0 files removed, 3 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
   $ status 2>&1 | tee $TESTTMP/fail.status
   --- status ---
   M file2
   M file3
   C file1
   --- resolve --list ---
   U file1
   U file2
   U file3
   --- debugmergestate ---
   * version 2 records
   local: 13910f48cf7bdb2a0ba6e24b4900e4fdd5739dd4
   other: 10f9a0a634e82080907e62f075ab119cbc565ea6
   labels:
     local: working copy
     other: merge rev
   file extras: file1 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file1 (record type "C", state "u", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node b8e02f6433738021a065f94175c7cd23db5f05be)
     other path: file1 (node null)
   file extras: file2 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file2 (record type "C", state "u", hash null)
     local path: file2 (flags "")
     ancestor path: file2 (node 5d9299349fc01ddd25d0070d149b124d8f10411e)
     other path: file2 (node e7c1328648519852e723de86c0c0525acd779257)
   file extras: file3 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file3 (record type "F", state "u", hash d5b0a58bc47161b1b8a831084b366f757c4f0b11)
     local path: file3 (flags "")
     ancestor path: file3 (node 2661d26c649684b482d10f91960cc3db683c38b4)
     other path: file3 (node a2644c43e210356772c7772a8674544a62e06beb)
   --- file1 ---
   1
   changed
   --- file2 ---
   2
   changed
   --- file3 ---
   3
   changed2
 
 Force prompts with no input (should be similar to :fail)
 
   $ hg co -C
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   updated to "13910f48cf7b: changed file1, removed file2, changed file3"
   1 other heads for branch "default"
 
   $ hg merge --config ui.interactive=True --tool :prompt
-  file 'file1' was deleted in local [working copy] but was modified in other [merge rev].
+  file 'file1' was deleted in other [merge rev] but was modified in local [working copy].
   What do you want to do?
   use (c)hanged version, (d)elete, or leave (u)nresolved? 
-  file 'file2' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'file2' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? 
   keep (l)ocal [working copy], take (o)ther [merge rev], or leave (u)nresolved for file3? 
   0 files updated, 0 files merged, 0 files removed, 3 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
   $ status 2>&1 | tee $TESTTMP/prompt.status
   --- status ---
   M file2
   M file3
   C file1
   --- resolve --list ---
   U file1
   U file2
   U file3
   --- debugmergestate ---
   * version 2 records
   local: 13910f48cf7bdb2a0ba6e24b4900e4fdd5739dd4
   other: 10f9a0a634e82080907e62f075ab119cbc565ea6
   labels:
     local: working copy
     other: merge rev
   file extras: file1 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file1 (record type "C", state "u", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node b8e02f6433738021a065f94175c7cd23db5f05be)
     other path: file1 (node null)
   file extras: file2 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file2 (record type "C", state "u", hash null)
     local path: file2 (flags "")
     ancestor path: file2 (node 5d9299349fc01ddd25d0070d149b124d8f10411e)
     other path: file2 (node e7c1328648519852e723de86c0c0525acd779257)
   file extras: file3 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file3 (record type "F", state "u", hash d5b0a58bc47161b1b8a831084b366f757c4f0b11)
     local path: file3 (flags "")
     ancestor path: file3 (node 2661d26c649684b482d10f91960cc3db683c38b4)
     other path: file3 (node a2644c43e210356772c7772a8674544a62e06beb)
   --- file1 ---
   1
   changed
   --- file2 ---
   2
   changed
   --- file3 ---
   3
   changed2
   $ cmp $TESTTMP/fail.status $TESTTMP/prompt.status || diff -U8 $TESTTMP/fail.status $TESTTMP/prompt.status
 
 
 Force prompts
 
   $ hg co -C
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   updated to "13910f48cf7b: changed file1, removed file2, changed file3"
   1 other heads for branch "default"
 
   $ hg merge --tool :prompt
-  file 'file1' was deleted in local [working copy] but was modified in other [merge rev].
+  file 'file1' was deleted in other [merge rev] but was modified in local [working copy].
   What do you want to do?
   use (c)hanged version, (d)elete, or leave (u)nresolved? u
-  file 'file2' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'file2' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   keep (l)ocal [working copy], take (o)ther [merge rev], or leave (u)nresolved for file3? u
   0 files updated, 0 files merged, 0 files removed, 3 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
   $ status
   --- status ---
   M file2
   M file3
   C file1
   --- resolve --list ---
   U file1
   U file2
   U file3
   --- debugmergestate ---
   * version 2 records
   local: 13910f48cf7bdb2a0ba6e24b4900e4fdd5739dd4
   other: 10f9a0a634e82080907e62f075ab119cbc565ea6
   labels:
     local: working copy
     other: merge rev
   file extras: file1 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file1 (record type "C", state "u", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node b8e02f6433738021a065f94175c7cd23db5f05be)
     other path: file1 (node null)
   file extras: file2 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file2 (record type "C", state "u", hash null)
     local path: file2 (flags "")
     ancestor path: file2 (node 5d9299349fc01ddd25d0070d149b124d8f10411e)
     other path: file2 (node e7c1328648519852e723de86c0c0525acd779257)
   file extras: file3 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file3 (record type "F", state "u", hash d5b0a58bc47161b1b8a831084b366f757c4f0b11)
     local path: file3 (flags "")
     ancestor path: file3 (node 2661d26c649684b482d10f91960cc3db683c38b4)
     other path: file3 (node a2644c43e210356772c7772a8674544a62e06beb)
   --- file1 ---
   1
   changed
   --- file2 ---
   2
   changed
   --- file3 ---
   3
   changed2
 
 Choose to merge all files
 
   $ hg co -C
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   updated to "13910f48cf7b: changed file1, removed file2, changed file3"
   1 other heads for branch "default"
 
   $ hg merge --tool :merge3
-  file 'file1' was deleted in local [working copy] but was modified in other [merge rev].
+  file 'file1' was deleted in other [merge rev] but was modified in local [working copy].
   What do you want to do?
   use (c)hanged version, (d)elete, or leave (u)nresolved? u
-  file 'file2' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'file2' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   merging file3
   warning: conflicts while merging file3! (edit, then use 'hg resolve --mark')
   0 files updated, 0 files merged, 0 files removed, 3 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
   $ status
   --- status ---
   M file2
   M file3
   C file1
   --- resolve --list ---
   U file1
   U file2
   U file3
   --- debugmergestate ---
   * version 2 records
   local: 13910f48cf7bdb2a0ba6e24b4900e4fdd5739dd4
   other: 10f9a0a634e82080907e62f075ab119cbc565ea6
   labels:
     local: working copy
     other: merge rev
   file extras: file1 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file1 (record type "C", state "u", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node b8e02f6433738021a065f94175c7cd23db5f05be)
     other path: file1 (node null)
   file extras: file2 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file2 (record type "C", state "u", hash null)
     local path: file2 (flags "")
     ancestor path: file2 (node 5d9299349fc01ddd25d0070d149b124d8f10411e)
     other path: file2 (node e7c1328648519852e723de86c0c0525acd779257)
   file extras: file3 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file3 (record type "F", state "u", hash d5b0a58bc47161b1b8a831084b366f757c4f0b11)
     local path: file3 (flags "")
     ancestor path: file3 (node 2661d26c649684b482d10f91960cc3db683c38b4)
     other path: file3 (node a2644c43e210356772c7772a8674544a62e06beb)
   --- file1 ---
   1
   changed
   --- file2 ---
   2
   changed
   --- file3 ---
   3
   <<<<<<< working copy: 13910f48cf7b - test: changed file1, removed file2, chan...
   changed2
   ||||||| base
   =======
   changed1
   >>>>>>> merge rev:    10f9a0a634e8 - test: removed file1, changed file2, chan...
 
 Exercise transitions between local, other, fail and prompt, and make sure the
 dirstate stays consistent. (Compare with each other and to the above
 invocations.)
 
   $ testtransitions() {
   >     # this traversal order covers every transition
   >     tools="local other prompt local fail other local prompt other fail prompt fail local"
   >     lasttool="merge3"
   >     for tool in $tools; do
   >         echo "=== :$lasttool -> :$tool ==="
   >         ref="$TESTTMP/$tool.status"
   >         hg resolve --unmark --all
   >         hg resolve --tool ":$tool" --all --config ui.interactive=True
   >         status > "$TESTTMP/compare.status" 2>&1
   >         echo '--- diff of status ---'
   >         if cmp "$TESTTMP/$tool.status" "$TESTTMP/compare.status" || diff -U8 "$TESTTMP/$tool.status" "$TESTTMP/compare.status"; then
   >             echo '(status identical)'
   >         fi
   >         lasttool="$tool"
   >         echo
   >     done
   > }
 
   $ testtransitions
   === :merge3 -> :local ===
   (no more unresolved files)
   --- diff of status ---
   (status identical)
   
   === :local -> :other ===
   (no more unresolved files)
   --- diff of status ---
   (status identical)
   
   === :other -> :prompt ===
-  file 'file1' was deleted in local [working copy] but was modified in other [merge rev].
+  file 'file1' was deleted in other [merge rev] but was modified in local [working copy].
   What do you want to do?
   use (c)hanged version, (d)elete, or leave (u)nresolved? 
-  file 'file2' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'file2' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? 
   keep (l)ocal [working copy], take (o)ther [merge rev], or leave (u)nresolved for file3? 
   --- diff of status ---
   (status identical)
   
   === :prompt -> :local ===
   (no more unresolved files)
   --- diff of status ---
   (status identical)
   
   === :local -> :fail ===
   --- diff of status ---
   (status identical)
   
   === :fail -> :other ===
   (no more unresolved files)
   --- diff of status ---
   (status identical)
   
   === :other -> :local ===
   (no more unresolved files)
   --- diff of status ---
   (status identical)
   
   === :local -> :prompt ===
-  file 'file1' was deleted in local [working copy] but was modified in other [merge rev].
+  file 'file1' was deleted in other [merge rev] but was modified in local [working copy].
   What do you want to do?
   use (c)hanged version, (d)elete, or leave (u)nresolved? 
-  file 'file2' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'file2' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? 
   keep (l)ocal [working copy], take (o)ther [merge rev], or leave (u)nresolved for file3? 
   --- diff of status ---
   (status identical)
   
   === :prompt -> :other ===
   (no more unresolved files)
   --- diff of status ---
   (status identical)
   
   === :other -> :fail ===
   --- diff of status ---
   (status identical)
   
   === :fail -> :prompt ===
-  file 'file1' was deleted in local [working copy] but was modified in other [merge rev].
+  file 'file1' was deleted in other [merge rev] but was modified in local [working copy].
   What do you want to do?
   use (c)hanged version, (d)elete, or leave (u)nresolved? 
-  file 'file2' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'file2' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? 
   keep (l)ocal [working copy], take (o)ther [merge rev], or leave (u)nresolved for file3? 
   --- diff of status ---
   (status identical)
   
   === :prompt -> :fail ===
   --- diff of status ---
   (status identical)
   
   === :fail -> :local ===
   (no more unresolved files)
   --- diff of status ---
   (status identical)
   
 
 
 Non-interactive linear update
 
   $ hg co -C 0
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo changed >> file1
   $ hg rm file2
   $ hg update 1 -y
-  file 'file1' was deleted in local [working copy] but was modified in other [destination].
+  file 'file1' was deleted in other [destination] but was modified in local [working copy].
   What do you want to do?
   use (c)hanged version, (d)elete, or leave (u)nresolved? u
-  file 'file2' was deleted in other [destination] but was modified in local [working copy].
+  file 'file2' was deleted in local [working copy] but was modified in other [destination].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   1 files updated, 0 files merged, 0 files removed, 2 files unresolved
   use 'hg resolve' to retry unresolved file merges
   [1]
   $ status
   --- status ---
   A file1
   C file2
   C file3
   --- resolve --list ---
   U file1
   U file2
   --- debugmergestate ---
   * version 2 records
   local: ab57bf49aa276a22d35a473592d4c34b5abc3eff
   other: 10f9a0a634e82080907e62f075ab119cbc565ea6
   labels:
     local: working copy
     other: destination
   file extras: file1 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file1 (record type "C", state "u", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node b8e02f6433738021a065f94175c7cd23db5f05be)
     other path: file1 (node null)
   file extras: file2 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file2 (record type "C", state "u", hash null)
     local path: file2 (flags "")
     ancestor path: file2 (node 5d9299349fc01ddd25d0070d149b124d8f10411e)
     other path: file2 (node e7c1328648519852e723de86c0c0525acd779257)
   --- file1 ---
   1
   changed
   --- file2 ---
   2
   changed
   --- file3 ---
   3
   changed1
 
 Choose local versions of files
 
   $ hg co -C 0
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo changed >> file1
   $ hg rm file2
   $ hg update 1 --tool :local
   1 files updated, 2 files merged, 0 files removed, 0 files unresolved
   $ status 2>&1 | tee $TESTTMP/local.status
   --- status ---
   file2: * (glob)
   A file1
   C file3
   --- resolve --list ---
   R file1
   R file2
   --- debugmergestate ---
   * version 2 records
   local: ab57bf49aa276a22d35a473592d4c34b5abc3eff
   other: 10f9a0a634e82080907e62f075ab119cbc565ea6
   labels:
     local: working copy
     other: destination
   file extras: file1 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file1 (record type "C", state "r", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node b8e02f6433738021a065f94175c7cd23db5f05be)
     other path: file1 (node null)
   file extras: file2 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file2 (record type "C", state "r", hash null)
     local path: file2 (flags "")
     ancestor path: file2 (node 5d9299349fc01ddd25d0070d149b124d8f10411e)
     other path: file2 (node e7c1328648519852e723de86c0c0525acd779257)
   --- file1 ---
   1
   changed
   *** file2 does not exist
   --- file3 ---
   3
   changed1
 
 Choose other versions of files
 
   $ hg co -C 0
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo changed >> file1
   $ hg rm file2
   $ hg update 1 --tool :other
   1 files updated, 1 files merged, 1 files removed, 0 files unresolved
   $ status 2>&1 | tee $TESTTMP/other.status
   --- status ---
   file1: * (glob)
   C file2
   C file3
   --- resolve --list ---
   R file1
   R file2
   --- debugmergestate ---
   * version 2 records
   local: ab57bf49aa276a22d35a473592d4c34b5abc3eff
   other: 10f9a0a634e82080907e62f075ab119cbc565ea6
   labels:
     local: working copy
     other: destination
   file extras: file1 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file1 (record type "C", state "r", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node b8e02f6433738021a065f94175c7cd23db5f05be)
     other path: file1 (node null)
   file extras: file2 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file2 (record type "C", state "r", hash null)
     local path: file2 (flags "")
     ancestor path: file2 (node 5d9299349fc01ddd25d0070d149b124d8f10411e)
     other path: file2 (node e7c1328648519852e723de86c0c0525acd779257)
   *** file1 does not exist
   --- file2 ---
   2
   changed
   --- file3 ---
   3
   changed1
 
 Fail
 
   $ hg co -C 0
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo changed >> file1
   $ hg rm file2
   $ hg update 1 --tool :fail
   1 files updated, 0 files merged, 0 files removed, 2 files unresolved
   use 'hg resolve' to retry unresolved file merges
   [1]
   $ status 2>&1 | tee $TESTTMP/fail.status
   --- status ---
   A file1
   C file2
   C file3
   --- resolve --list ---
   U file1
   U file2
   --- debugmergestate ---
   * version 2 records
   local: ab57bf49aa276a22d35a473592d4c34b5abc3eff
   other: 10f9a0a634e82080907e62f075ab119cbc565ea6
   labels:
     local: working copy
     other: destination
   file extras: file1 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file1 (record type "C", state "u", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node b8e02f6433738021a065f94175c7cd23db5f05be)
     other path: file1 (node null)
   file extras: file2 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file2 (record type "C", state "u", hash null)
     local path: file2 (flags "")
     ancestor path: file2 (node 5d9299349fc01ddd25d0070d149b124d8f10411e)
     other path: file2 (node e7c1328648519852e723de86c0c0525acd779257)
   --- file1 ---
   1
   changed
   --- file2 ---
   2
   changed
   --- file3 ---
   3
   changed1
 
 Force prompts with no input
 
   $ hg co -C 0
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo changed >> file1
   $ hg rm file2
   $ hg update 1 --config ui.interactive=True --tool :prompt
-  file 'file1' was deleted in local [working copy] but was modified in other [destination].
+  file 'file1' was deleted in other [destination] but was modified in local [working copy].
   What do you want to do?
   use (c)hanged version, (d)elete, or leave (u)nresolved? 
-  file 'file2' was deleted in other [destination] but was modified in local [working copy].
+  file 'file2' was deleted in local [working copy] but was modified in other [destination].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? 
   1 files updated, 0 files merged, 0 files removed, 2 files unresolved
   use 'hg resolve' to retry unresolved file merges
   [1]
   $ status 2>&1 | tee $TESTTMP/prompt.status
   --- status ---
   A file1
   C file2
   C file3
   --- resolve --list ---
   U file1
   U file2
   --- debugmergestate ---
   * version 2 records
   local: ab57bf49aa276a22d35a473592d4c34b5abc3eff
   other: 10f9a0a634e82080907e62f075ab119cbc565ea6
   labels:
     local: working copy
     other: destination
   file extras: file1 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file1 (record type "C", state "u", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node b8e02f6433738021a065f94175c7cd23db5f05be)
     other path: file1 (node null)
   file extras: file2 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file2 (record type "C", state "u", hash null)
     local path: file2 (flags "")
     ancestor path: file2 (node 5d9299349fc01ddd25d0070d149b124d8f10411e)
     other path: file2 (node e7c1328648519852e723de86c0c0525acd779257)
   --- file1 ---
   1
   changed
   --- file2 ---
   2
   changed
   --- file3 ---
   3
   changed1
   $ cmp $TESTTMP/fail.status $TESTTMP/prompt.status || diff -U8 $TESTTMP/fail.status $TESTTMP/prompt.status
 
 Choose to merge all files
 
   $ hg co -C 0
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo changed >> file1
   $ hg rm file2
   $ hg update 1 --tool :merge3
-  file 'file1' was deleted in local [working copy] but was modified in other [destination].
+  file 'file1' was deleted in other [destination] but was modified in local [working copy].
   What do you want to do?
   use (c)hanged version, (d)elete, or leave (u)nresolved? u
-  file 'file2' was deleted in other [destination] but was modified in local [working copy].
+  file 'file2' was deleted in local [working copy] but was modified in other [destination].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   1 files updated, 0 files merged, 0 files removed, 2 files unresolved
   use 'hg resolve' to retry unresolved file merges
   [1]
   $ status
   --- status ---
   A file1
   C file2
   C file3
   --- resolve --list ---
   U file1
   U file2
   --- debugmergestate ---
   * version 2 records
   local: ab57bf49aa276a22d35a473592d4c34b5abc3eff
   other: 10f9a0a634e82080907e62f075ab119cbc565ea6
   labels:
     local: working copy
     other: destination
   file extras: file1 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file1 (record type "C", state "u", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node b8e02f6433738021a065f94175c7cd23db5f05be)
     other path: file1 (node null)
   file extras: file2 (ancestorlinknode = ab57bf49aa276a22d35a473592d4c34b5abc3eff)
   file: file2 (record type "C", state "u", hash null)
     local path: file2 (flags "")
     ancestor path: file2 (node 5d9299349fc01ddd25d0070d149b124d8f10411e)
     other path: file2 (node e7c1328648519852e723de86c0c0525acd779257)
   --- file1 ---
   1
   changed
   --- file2 ---
   2
   changed
   --- file3 ---
   3
   changed1
 
 Test transitions between different merge tools
 
   $ testtransitions
   === :merge3 -> :local ===
   (no more unresolved files)
   --- diff of status ---
   (status identical)
   
   === :local -> :other ===
   (no more unresolved files)
   --- diff of status ---
   (status identical)
   
   === :other -> :prompt ===
-  file 'file1' was deleted in local [working copy] but was modified in other [destination].
+  file 'file1' was deleted in other [destination] but was modified in local [working copy].
   What do you want to do?
   use (c)hanged version, (d)elete, or leave (u)nresolved? 
-  file 'file2' was deleted in other [destination] but was modified in local [working copy].
+  file 'file2' was deleted in local [working copy] but was modified in other [destination].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? 
   --- diff of status ---
   (status identical)
   
   === :prompt -> :local ===
   (no more unresolved files)
   --- diff of status ---
   (status identical)
   
   === :local -> :fail ===
   --- diff of status ---
   (status identical)
   
   === :fail -> :other ===
   (no more unresolved files)
   --- diff of status ---
   (status identical)
   
   === :other -> :local ===
   (no more unresolved files)
   --- diff of status ---
   (status identical)
   
   === :local -> :prompt ===
-  file 'file1' was deleted in local [working copy] but was modified in other [destination].
+  file 'file1' was deleted in other [destination] but was modified in local [working copy].
   What do you want to do?
   use (c)hanged version, (d)elete, or leave (u)nresolved? 
-  file 'file2' was deleted in other [destination] but was modified in local [working copy].
+  file 'file2' was deleted in local [working copy] but was modified in other [destination].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? 
   --- diff of status ---
   (status identical)
   
   === :prompt -> :other ===
   (no more unresolved files)
   --- diff of status ---
   (status identical)
   
   === :other -> :fail ===
   --- diff of status ---
   (status identical)
   
   === :fail -> :prompt ===
-  file 'file1' was deleted in local [working copy] but was modified in other [destination].
+  file 'file1' was deleted in other [destination] but was modified in local [working copy].
   What do you want to do?
   use (c)hanged version, (d)elete, or leave (u)nresolved? 
-  file 'file2' was deleted in other [destination] but was modified in local [working copy].
+  file 'file2' was deleted in local [working copy] but was modified in other [destination].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? 
   --- diff of status ---
   (status identical)
   
   === :prompt -> :fail ===
   --- diff of status ---
   (status identical)
   
   === :fail -> :local ===
   (no more unresolved files)
   --- diff of status ---
   (status identical)
   

tests/test-merge-force.t

@@ -1,845 +1,845 b''
 Set up a base, local, and remote changeset, as well as the working copy state.
 Files names are of the form base_remote_local_working-copy. For example,
 content1_content2_content1_content2-untracked represents a
 file that was modified in the remote changeset, left untouched in the
 local changeset, and then modified in the working copy to match the
 remote content, then finally forgotten.
 
   $ hg init repo
   $ cd repo
 
 Create base changeset
 
   $ $PYTHON $TESTDIR/generate-working-copy-states.py state 3 1
   $ hg addremove -q --similarity 0
   $ hg commit -qm 'base'
 
 Create remote changeset
 
   $ $PYTHON $TESTDIR/generate-working-copy-states.py state 3 2
   $ hg addremove -q --similarity 0
   $ hg commit -qm 'remote'
 
 Create local changeset
 
   $ hg update -q 0
   $ $PYTHON $TESTDIR/generate-working-copy-states.py state 3 3
   $ hg addremove -q --similarity 0
   $ hg commit -qm 'local'
 
 Set up working directory
 
   $ $PYTHON $TESTDIR/generate-working-copy-states.py state 3 wc
   $ hg addremove -q --similarity 0
   $ hg forget *_*_*_*-untracked
   $ rm *_*_*_missing-*
 
   $ hg status -A
   M content1_content1_content1_content4-tracked
   M content1_content1_content3_content1-tracked
   M content1_content1_content3_content4-tracked
   M content1_content2_content1_content2-tracked
   M content1_content2_content1_content4-tracked
   M content1_content2_content2_content1-tracked
   M content1_content2_content2_content4-tracked
   M content1_content2_content3_content1-tracked
   M content1_content2_content3_content2-tracked
   M content1_content2_content3_content4-tracked
   M content1_missing_content1_content4-tracked
   M content1_missing_content3_content1-tracked
   M content1_missing_content3_content4-tracked
   M missing_content2_content2_content4-tracked
   M missing_content2_content3_content2-tracked
   M missing_content2_content3_content4-tracked
   M missing_missing_content3_content4-tracked
   A content1_content1_missing_content1-tracked
   A content1_content1_missing_content4-tracked
   A content1_content2_missing_content1-tracked
   A content1_content2_missing_content2-tracked
   A content1_content2_missing_content4-tracked
   A content1_missing_missing_content1-tracked
   A content1_missing_missing_content4-tracked
   A missing_content2_missing_content2-tracked
   A missing_content2_missing_content4-tracked
   A missing_missing_missing_content4-tracked
   R content1_content1_content1_content1-untracked
   R content1_content1_content1_content4-untracked
   R content1_content1_content1_missing-untracked
   R content1_content1_content3_content1-untracked
   R content1_content1_content3_content3-untracked
   R content1_content1_content3_content4-untracked
   R content1_content1_content3_missing-untracked
   R content1_content2_content1_content1-untracked
   R content1_content2_content1_content2-untracked
   R content1_content2_content1_content4-untracked
   R content1_content2_content1_missing-untracked
   R content1_content2_content2_content1-untracked
   R content1_content2_content2_content2-untracked
   R content1_content2_content2_content4-untracked
   R content1_content2_content2_missing-untracked
   R content1_content2_content3_content1-untracked
   R content1_content2_content3_content2-untracked
   R content1_content2_content3_content3-untracked
   R content1_content2_content3_content4-untracked
   R content1_content2_content3_missing-untracked
   R content1_missing_content1_content1-untracked
   R content1_missing_content1_content4-untracked
   R content1_missing_content1_missing-untracked
   R content1_missing_content3_content1-untracked
   R content1_missing_content3_content3-untracked
   R content1_missing_content3_content4-untracked
   R content1_missing_content3_missing-untracked
   R missing_content2_content2_content2-untracked
   R missing_content2_content2_content4-untracked
   R missing_content2_content2_missing-untracked
   R missing_content2_content3_content2-untracked
   R missing_content2_content3_content3-untracked
   R missing_content2_content3_content4-untracked
   R missing_content2_content3_missing-untracked
   R missing_missing_content3_content3-untracked
   R missing_missing_content3_content4-untracked
   R missing_missing_content3_missing-untracked
   ! content1_content1_content1_missing-tracked
   ! content1_content1_content3_missing-tracked
   ! content1_content1_missing_missing-tracked
   ! content1_content2_content1_missing-tracked
   ! content1_content2_content2_missing-tracked
   ! content1_content2_content3_missing-tracked
   ! content1_content2_missing_missing-tracked
   ! content1_missing_content1_missing-tracked
   ! content1_missing_content3_missing-tracked
   ! content1_missing_missing_missing-tracked
   ! missing_content2_content2_missing-tracked
   ! missing_content2_content3_missing-tracked
   ! missing_content2_missing_missing-tracked
   ! missing_missing_content3_missing-tracked
   ! missing_missing_missing_missing-tracked
   ? content1_content1_missing_content1-untracked
   ? content1_content1_missing_content4-untracked
   ? content1_content2_missing_content1-untracked
   ? content1_content2_missing_content2-untracked
   ? content1_content2_missing_content4-untracked
   ? content1_missing_missing_content1-untracked
   ? content1_missing_missing_content4-untracked
   ? missing_content2_missing_content2-untracked
   ? missing_content2_missing_content4-untracked
   ? missing_missing_missing_content4-untracked
   C content1_content1_content1_content1-tracked
   C content1_content1_content3_content3-tracked
   C content1_content2_content1_content1-tracked
   C content1_content2_content2_content2-tracked
   C content1_content2_content3_content3-tracked
   C content1_missing_content1_content1-tracked
   C content1_missing_content3_content3-tracked
   C missing_content2_content2_content2-tracked
   C missing_content2_content3_content3-tracked
   C missing_missing_content3_content3-tracked
 
 Merge with remote
 
 # Notes:
 # - local and remote changed content1_content2_*_content2-untracked
 #   in the same way, so it could potentially be left alone
 
   $ hg merge -f --tool internal:merge3 'desc("remote")' 2>&1 | tee $TESTTMP/merge-output-1
-  file 'content1_missing_content1_content4-tracked' was deleted in local [working copy] but was modified in other [merge rev].
+  file 'content1_missing_content1_content4-tracked' was deleted in other [merge rev] but was modified in local [working copy].
   What do you want to do?
   use (c)hanged version, (d)elete, or leave (u)nresolved? u
-  file 'content1_missing_content3_content3-tracked' was deleted in local [working copy] but was modified in other [merge rev].
+  file 'content1_missing_content3_content3-tracked' was deleted in other [merge rev] but was modified in local [working copy].
   What do you want to do?
   use (c)hanged version, (d)elete, or leave (u)nresolved? u
-  file 'content1_missing_content3_content4-tracked' was deleted in local [working copy] but was modified in other [merge rev].
+  file 'content1_missing_content3_content4-tracked' was deleted in other [merge rev] but was modified in local [working copy].
   What do you want to do?
   use (c)hanged version, (d)elete, or leave (u)nresolved? u
-  file 'content1_missing_missing_content4-tracked' was deleted in local [working copy] but was modified in other [merge rev].
+  file 'content1_missing_missing_content4-tracked' was deleted in other [merge rev] but was modified in local [working copy].
   What do you want to do?
   use (c)hanged version, (d)elete, or leave (u)nresolved? u
-  file 'content1_content2_content1_content1-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_content1_content1-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_content2_content1_content2-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_content1_content2-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_content2_content1_content4-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_content1_content4-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_content2_content1_missing-tracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_content1_missing-tracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_content2_content1_missing-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_content1_missing-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_content2_content2_content1-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_content2_content1-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_content2_content2_content2-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_content2_content2-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_content2_content2_content4-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_content2_content4-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_content2_content2_missing-tracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_content2_missing-tracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_content2_content2_missing-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_content2_missing-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_content2_content3_content1-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_content3_content1-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_content2_content3_content2-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_content3_content2-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_content2_content3_content3-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_content3_content3-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_content2_content3_content4-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_content3_content4-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_content2_content3_missing-tracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_content3_missing-tracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_content2_content3_missing-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_content3_missing-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_content2_missing_content1-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_missing_content1-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_content2_missing_content2-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_missing_content2-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_content2_missing_content4-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_missing_content4-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_content2_missing_missing-tracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_missing_missing-tracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_content2_missing_missing-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_missing_missing-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   merging content1_content2_content1_content4-tracked
   merging content1_content2_content2_content1-tracked
   merging content1_content2_content2_content4-tracked
   merging content1_content2_content3_content1-tracked
   merging content1_content2_content3_content3-tracked
   merging content1_content2_content3_content4-tracked
   merging content1_content2_missing_content1-tracked
   merging content1_content2_missing_content4-tracked
   merging missing_content2_content2_content4-tracked
   merging missing_content2_content3_content3-tracked
   merging missing_content2_content3_content4-tracked
   merging missing_content2_missing_content4-tracked
   merging missing_content2_missing_content4-untracked
   warning: conflicts while merging content1_content2_content1_content4-tracked! (edit, then use 'hg resolve --mark')
   warning: conflicts while merging content1_content2_content2_content4-tracked! (edit, then use 'hg resolve --mark')
   warning: conflicts while merging content1_content2_content3_content3-tracked! (edit, then use 'hg resolve --mark')
   warning: conflicts while merging content1_content2_content3_content4-tracked! (edit, then use 'hg resolve --mark')
   warning: conflicts while merging content1_content2_missing_content4-tracked! (edit, then use 'hg resolve --mark')
   warning: conflicts while merging missing_content2_content2_content4-tracked! (edit, then use 'hg resolve --mark')
   warning: conflicts while merging missing_content2_content3_content3-tracked! (edit, then use 'hg resolve --mark')
   warning: conflicts while merging missing_content2_content3_content4-tracked! (edit, then use 'hg resolve --mark')
   warning: conflicts while merging missing_content2_missing_content4-tracked! (edit, then use 'hg resolve --mark')
   warning: conflicts while merging missing_content2_missing_content4-untracked! (edit, then use 'hg resolve --mark')
   18 files updated, 3 files merged, 8 files removed, 35 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
 
 Check which files need to be resolved (should correspond to the output above).
 This should be the files for which the base (1st filename segment), the remote
 (2nd segment) and the working copy (4th segment) are all different.
 
 Interestingly, one untracked file got merged and added, which corresponds to the
 odd 'if force and branchmerge and different' case in manifestmerge().
 
   $ hg resolve -l
   U content1_content2_content1_content1-untracked
   U content1_content2_content1_content2-untracked
   U content1_content2_content1_content4-tracked
   U content1_content2_content1_content4-untracked
   U content1_content2_content1_missing-tracked
   U content1_content2_content1_missing-untracked
   R content1_content2_content2_content1-tracked
   U content1_content2_content2_content1-untracked
   U content1_content2_content2_content2-untracked
   U content1_content2_content2_content4-tracked
   U content1_content2_content2_content4-untracked
   U content1_content2_content2_missing-tracked
   U content1_content2_content2_missing-untracked
   R content1_content2_content3_content1-tracked
   U content1_content2_content3_content1-untracked
   U content1_content2_content3_content2-untracked
   U content1_content2_content3_content3-tracked
   U content1_content2_content3_content3-untracked
   U content1_content2_content3_content4-tracked
   U content1_content2_content3_content4-untracked
   U content1_content2_content3_missing-tracked
   U content1_content2_content3_missing-untracked
   R content1_content2_missing_content1-tracked
   U content1_content2_missing_content1-untracked
   U content1_content2_missing_content2-untracked
   U content1_content2_missing_content4-tracked
   U content1_content2_missing_content4-untracked
   U content1_content2_missing_missing-tracked
   U content1_content2_missing_missing-untracked
   U content1_missing_content1_content4-tracked
   U content1_missing_content3_content3-tracked
   U content1_missing_content3_content4-tracked
   U content1_missing_missing_content4-tracked
   U missing_content2_content2_content4-tracked
   U missing_content2_content3_content3-tracked
   U missing_content2_content3_content4-tracked
   U missing_content2_missing_content4-tracked
   U missing_content2_missing_content4-untracked
 
 Check status and file content
 
 Some files get added (e.g. content1_content2_content1_content1-untracked)
 
 It is not intuitive that content1_content2_content1_content4-tracked gets
 merged while content1_content2_content1_content4-untracked gets overwritten.
 Any *_content2_*-untracked triggers the modified/deleted prompt and then gets
 overwritten.
 
 A lot of untracked files become tracked, for example
 content1_content2_content2_content2-untracked.
 
 *_missing_missing_missing-tracked is reported as removed ('R'), which
 doesn't make sense since the file did not exist in the parent, but on the
 other hand, merged-in additions are reported as modifications, which is
 almost as strange.
 
 missing_missing_content3_missing-tracked becomes removed ('R'), even though
 the remote side did not touch the file
 
   $ checkstatus() {
   >   for f in `$PYTHON $TESTDIR/generate-working-copy-states.py filelist 3`
   >   do
   >     echo
   >     hg status -A $f
   >     if test -f $f
   >     then
   >       cat $f
   >     else
   >       echo '<missing>'
   >     fi
   >   done
   > }
   $ checkstatus 2>&1 | tee $TESTTMP/status1
   
   C content1_content1_content1_content1-tracked
   content1
   
   R content1_content1_content1_content1-untracked
   content1
   
   M content1_content1_content1_content4-tracked
   content4
   
   R content1_content1_content1_content4-untracked
   content4
   
   ! content1_content1_content1_missing-tracked
   <missing>
   
   R content1_content1_content1_missing-untracked
   <missing>
   
   M content1_content1_content3_content1-tracked
   content1
   
   R content1_content1_content3_content1-untracked
   content1
   
   C content1_content1_content3_content3-tracked
   content3
   
   R content1_content1_content3_content3-untracked
   content3
   
   M content1_content1_content3_content4-tracked
   content4
   
   R content1_content1_content3_content4-untracked
   content4
   
   ! content1_content1_content3_missing-tracked
   <missing>
   
   R content1_content1_content3_missing-untracked
   <missing>
   
   A content1_content1_missing_content1-tracked
   content1
   
   ? content1_content1_missing_content1-untracked
   content1
   
   A content1_content1_missing_content4-tracked
   content4
   
   ? content1_content1_missing_content4-untracked
   content4
   
   ! content1_content1_missing_missing-tracked
   <missing>
   
   content1_content1_missing_missing-untracked: * (glob)
   <missing>
   
   M content1_content2_content1_content1-tracked
   content2
   
   M content1_content2_content1_content1-untracked
   content2
   
   M content1_content2_content1_content2-tracked
   content2
   
   M content1_content2_content1_content2-untracked
   content2
   
   M content1_content2_content1_content4-tracked
   <<<<<<< working copy: 0447570f1af6 - test: local
   content4
   ||||||| base
   content1
   =======
   content2
   >>>>>>> merge rev:    85100b8c675b - test: remote
   
   M content1_content2_content1_content4-untracked
   content2
   
   M content1_content2_content1_missing-tracked
   content2
   
   M content1_content2_content1_missing-untracked
   content2
   
   M content1_content2_content2_content1-tracked
   content2
   
   M content1_content2_content2_content1-untracked
   content2
   
   C content1_content2_content2_content2-tracked
   content2
   
   M content1_content2_content2_content2-untracked
   content2
   
   M content1_content2_content2_content4-tracked
   <<<<<<< working copy: 0447570f1af6 - test: local
   content4
   ||||||| base
   content1
   =======
   content2
   >>>>>>> merge rev:    85100b8c675b - test: remote
   
   M content1_content2_content2_content4-untracked
   content2
   
   M content1_content2_content2_missing-tracked
   content2
   
   M content1_content2_content2_missing-untracked
   content2
   
   M content1_content2_content3_content1-tracked
   content2
   
   M content1_content2_content3_content1-untracked
   content2
   
   M content1_content2_content3_content2-tracked
   content2
   
   M content1_content2_content3_content2-untracked
   content2
   
   M content1_content2_content3_content3-tracked
   <<<<<<< working copy: 0447570f1af6 - test: local
   content3
   ||||||| base
   content1
   =======
   content2
   >>>>>>> merge rev:    85100b8c675b - test: remote
   
   M content1_content2_content3_content3-untracked
   content2
   
   M content1_content2_content3_content4-tracked
   <<<<<<< working copy: 0447570f1af6 - test: local
   content4
   ||||||| base
   content1
   =======
   content2
   >>>>>>> merge rev:    85100b8c675b - test: remote
   
   M content1_content2_content3_content4-untracked
   content2
   
   M content1_content2_content3_missing-tracked
   content2
   
   M content1_content2_content3_missing-untracked
   content2
   
   M content1_content2_missing_content1-tracked
   content2
   
   M content1_content2_missing_content1-untracked
   content2
   
   M content1_content2_missing_content2-tracked
   content2
   
   M content1_content2_missing_content2-untracked
   content2
   
   M content1_content2_missing_content4-tracked
   <<<<<<< working copy: 0447570f1af6 - test: local
   content4
   ||||||| base
   content1
   =======
   content2
   >>>>>>> merge rev:    85100b8c675b - test: remote
   
   M content1_content2_missing_content4-untracked
   content2
   
   M content1_content2_missing_missing-tracked
   content2
   
   M content1_content2_missing_missing-untracked
   content2
   
   R content1_missing_content1_content1-tracked
   <missing>
   
   R content1_missing_content1_content1-untracked
   content1
   
   M content1_missing_content1_content4-tracked
   content4
   
   R content1_missing_content1_content4-untracked
   content4
   
   R content1_missing_content1_missing-tracked
   <missing>
   
   R content1_missing_content1_missing-untracked
   <missing>
   
   R content1_missing_content3_content1-tracked
   <missing>
   
   R content1_missing_content3_content1-untracked
   content1
   
   C content1_missing_content3_content3-tracked
   content3
   
   R content1_missing_content3_content3-untracked
   content3
   
   M content1_missing_content3_content4-tracked
   content4
   
   R content1_missing_content3_content4-untracked
   content4
   
   R content1_missing_content3_missing-tracked
   <missing>
   
   R content1_missing_content3_missing-untracked
   <missing>
   
   R content1_missing_missing_content1-tracked
   <missing>
   
   ? content1_missing_missing_content1-untracked
   content1
   
   A content1_missing_missing_content4-tracked
   content4
   
   ? content1_missing_missing_content4-untracked
   content4
   
   R content1_missing_missing_missing-tracked
   <missing>
   
   content1_missing_missing_missing-untracked: * (glob)
   <missing>
   
   C missing_content2_content2_content2-tracked
   content2
   
   M missing_content2_content2_content2-untracked
   content2
   
   M missing_content2_content2_content4-tracked
   <<<<<<< working copy: 0447570f1af6 - test: local
   content4
   ||||||| base
   =======
   content2
   >>>>>>> merge rev:    85100b8c675b - test: remote
   
   M missing_content2_content2_content4-untracked
   content2
   
   M missing_content2_content2_missing-tracked
   content2
   
   M missing_content2_content2_missing-untracked
   content2
   
   M missing_content2_content3_content2-tracked
   content2
   
   M missing_content2_content3_content2-untracked
   content2
   
   M missing_content2_content3_content3-tracked
   <<<<<<< working copy: 0447570f1af6 - test: local
   content3
   ||||||| base
   =======
   content2
   >>>>>>> merge rev:    85100b8c675b - test: remote
   
   M missing_content2_content3_content3-untracked
   content2
   
   M missing_content2_content3_content4-tracked
   <<<<<<< working copy: 0447570f1af6 - test: local
   content4
   ||||||| base
   =======
   content2
   >>>>>>> merge rev:    85100b8c675b - test: remote
   
   M missing_content2_content3_content4-untracked
   content2
   
   M missing_content2_content3_missing-tracked
   content2
   
   M missing_content2_content3_missing-untracked
   content2
   
   M missing_content2_missing_content2-tracked
   content2
   
   M missing_content2_missing_content2-untracked
   content2
   
   M missing_content2_missing_content4-tracked
   <<<<<<< working copy: 0447570f1af6 - test: local
   content4
   ||||||| base
   =======
   content2
   >>>>>>> merge rev:    85100b8c675b - test: remote
   
   M missing_content2_missing_content4-untracked
   <<<<<<< working copy: 0447570f1af6 - test: local
   content4
   ||||||| base
   =======
   content2
   >>>>>>> merge rev:    85100b8c675b - test: remote
   
   M missing_content2_missing_missing-tracked
   content2
   
   M missing_content2_missing_missing-untracked
   content2
   
   C missing_missing_content3_content3-tracked
   content3
   
   R missing_missing_content3_content3-untracked
   content3
   
   M missing_missing_content3_content4-tracked
   content4
   
   R missing_missing_content3_content4-untracked
   content4
   
   R missing_missing_content3_missing-tracked
   <missing>
   
   R missing_missing_content3_missing-untracked
   <missing>
   
   A missing_missing_missing_content4-tracked
   content4
   
   ? missing_missing_missing_content4-untracked
   content4
   
   R missing_missing_missing_missing-tracked
   <missing>
   
   missing_missing_missing_missing-untracked: * (glob)
   <missing>
 
   $ for f in `$PYTHON $TESTDIR/generate-working-copy-states.py filelist 3`
   > do
   >   if test -f ${f}.orig
   >   then
   >     echo ${f}.orig:
   >     cat ${f}.orig
   >   fi
   > done
   content1_content2_content1_content4-tracked.orig:
   content4
   content1_content2_content2_content4-tracked.orig:
   content4
   content1_content2_content3_content3-tracked.orig:
   content3
   content1_content2_content3_content4-tracked.orig:
   content4
   content1_content2_missing_content4-tracked.orig:
   content4
   missing_content2_content2_content4-tracked.orig:
   content4
   missing_content2_content3_content3-tracked.orig:
   content3
   missing_content2_content3_content4-tracked.orig:
   content4
   missing_content2_missing_content4-tracked.orig:
   content4
   missing_content2_missing_content4-untracked.orig:
   content4
 
 Re-resolve and check status
 
   $ hg resolve --unmark --all
   $ hg resolve --all --tool :local
   (no more unresolved files)
   $ hg resolve --unmark --all
   $ hg resolve --all --tool internal:merge3
-  file 'content1_content2_content1_content1-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_content1_content1-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_content2_content1_content2-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_content1_content2-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   merging content1_content2_content1_content4-tracked
-  file 'content1_content2_content1_content4-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_content1_content4-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_content2_content1_missing-tracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_content1_missing-tracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_content2_content1_missing-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_content1_missing-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   merging content1_content2_content2_content1-tracked
-  file 'content1_content2_content2_content1-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_content2_content1-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_content2_content2_content2-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_content2_content2-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   merging content1_content2_content2_content4-tracked
-  file 'content1_content2_content2_content4-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_content2_content4-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_content2_content2_missing-tracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_content2_missing-tracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_content2_content2_missing-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_content2_missing-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   merging content1_content2_content3_content1-tracked
-  file 'content1_content2_content3_content1-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_content3_content1-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_content2_content3_content2-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_content3_content2-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   merging content1_content2_content3_content3-tracked
-  file 'content1_content2_content3_content3-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_content3_content3-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   merging content1_content2_content3_content4-tracked
-  file 'content1_content2_content3_content4-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_content3_content4-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_content2_content3_missing-tracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_content3_missing-tracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_content2_content3_missing-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_content3_missing-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   merging content1_content2_missing_content1-tracked
-  file 'content1_content2_missing_content1-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_missing_content1-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_content2_missing_content2-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_missing_content2-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   merging content1_content2_missing_content4-tracked
-  file 'content1_content2_missing_content4-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_missing_content4-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_content2_missing_missing-tracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_missing_missing-tracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_content2_missing_missing-untracked' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'content1_content2_missing_missing-untracked' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
-  file 'content1_missing_content1_content4-tracked' was deleted in local [working copy] but was modified in other [merge rev].
+  file 'content1_missing_content1_content4-tracked' was deleted in other [merge rev] but was modified in local [working copy].
   What do you want to do?
   use (c)hanged version, (d)elete, or leave (u)nresolved? u
-  file 'content1_missing_content3_content3-tracked' was deleted in local [working copy] but was modified in other [merge rev].
+  file 'content1_missing_content3_content3-tracked' was deleted in other [merge rev] but was modified in local [working copy].
   What do you want to do?
   use (c)hanged version, (d)elete, or leave (u)nresolved? u
-  file 'content1_missing_content3_content4-tracked' was deleted in local [working copy] but was modified in other [merge rev].
+  file 'content1_missing_content3_content4-tracked' was deleted in other [merge rev] but was modified in local [working copy].
   What do you want to do?
   use (c)hanged version, (d)elete, or leave (u)nresolved? u
-  file 'content1_missing_missing_content4-tracked' was deleted in local [working copy] but was modified in other [merge rev].
+  file 'content1_missing_missing_content4-tracked' was deleted in other [merge rev] but was modified in local [working copy].
   What do you want to do?
   use (c)hanged version, (d)elete, or leave (u)nresolved? u
   merging missing_content2_content2_content4-tracked
   merging missing_content2_content3_content3-tracked
   merging missing_content2_content3_content4-tracked
   merging missing_content2_missing_content4-tracked
   merging missing_content2_missing_content4-untracked
   warning: conflicts while merging content1_content2_content1_content4-tracked! (edit, then use 'hg resolve --mark')
   warning: conflicts while merging content1_content2_content2_content4-tracked! (edit, then use 'hg resolve --mark')
   warning: conflicts while merging content1_content2_content3_content3-tracked! (edit, then use 'hg resolve --mark')
   warning: conflicts while merging content1_content2_content3_content4-tracked! (edit, then use 'hg resolve --mark')
   warning: conflicts while merging content1_content2_missing_content4-tracked! (edit, then use 'hg resolve --mark')
   warning: conflicts while merging missing_content2_content2_content4-tracked! (edit, then use 'hg resolve --mark')
   warning: conflicts while merging missing_content2_content3_content3-tracked! (edit, then use 'hg resolve --mark')
   warning: conflicts while merging missing_content2_content3_content4-tracked! (edit, then use 'hg resolve --mark')
   warning: conflicts while merging missing_content2_missing_content4-tracked! (edit, then use 'hg resolve --mark')
   warning: conflicts while merging missing_content2_missing_content4-untracked! (edit, then use 'hg resolve --mark')
   [1]
   $ checkstatus > $TESTTMP/status2 2>&1
   $ cmp $TESTTMP/status1 $TESTTMP/status2 || diff -U8 $TESTTMP/status1 $TESTTMP/status2
 
 Set up working directory again
 
   $ hg -q update --clean 2
   $ hg --config extensions.purge= purge
   $ $PYTHON $TESTDIR/generate-working-copy-states.py state 3 wc
   $ hg addremove -q --similarity 0
   $ hg forget *_*_*_*-untracked
   $ rm *_*_*_missing-*
 
 Merge with checkunknown = warn, see that behavior is the same as before
   $ hg merge -f --tool internal:merge3 'desc("remote")' --config merge.checkunknown=warn > $TESTTMP/merge-output-2 2>&1
   [1]
   $ cmp $TESTTMP/merge-output-1 $TESTTMP/merge-output-2 || diff -U8 $TESTTMP/merge-output-1 $TESTTMP/merge-output-2

tests/test-merge-remove.t

@@ -1,116 +1,116 b''
   $ hg init
 
   $ echo foo > foo
   $ echo bar > bar
   $ hg ci -qAm 'add foo bar'
 
   $ echo foo2 >> foo
   $ echo bleh > bar
   $ hg ci -m 'change foo bar'
 
   $ hg up -qC 0
   $ hg mv foo foo1
   $ echo foo1 > foo1
   $ hg cat foo >> foo1
   $ hg ci -m 'mv foo foo1'
   created new head
 
   $ hg merge
   merging foo1 and foo to foo1
   1 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ hg debugstate --nodates
   m   0         -2 unset               bar
   m   0         -2 unset               foo1
   copy: foo -> foo1
 
   $ hg st -q
   M bar
   M foo1
 
 
 Removing foo1 and bar:
 
   $ cp foo1 F
   $ cp bar B
   $ hg rm -f foo1 bar
 
   $ hg debugstate --nodates
   r   0         -1 set                 bar
   r   0         -1 set                 foo1
   copy: foo -> foo1
 
   $ hg st -qC
   R bar
   R foo1
 
 
 Re-adding foo1 and bar:
 
   $ cp F foo1
   $ cp B bar
   $ hg add -v foo1 bar
   adding bar
   adding foo1
 
   $ hg debugstate --nodates
   n   0         -2 unset               bar
   n   0         -2 unset               foo1
   copy: foo -> foo1
 
   $ hg st -qC
   M bar
   M foo1
     foo
 
 
 Reverting foo1 and bar:
 
   $ hg revert -vr . foo1 bar
   saving current version of bar as bar.orig
   reverting bar
   saving current version of foo1 as foo1.orig
   reverting foo1
 
   $ hg debugstate --nodates
   n   0         -2 unset               bar
   n   0         -2 unset               foo1
   copy: foo -> foo1
 
   $ hg st -qC
   M bar
   M foo1
     foo
 
   $ hg diff
 
 Merge should not overwrite local file that is untracked after remove
 
   $ rm *
   $ hg up -qC
   $ hg rm bar
   $ hg ci -m 'remove bar'
   $ echo 'memories of buried pirate treasure' > bar
   $ hg merge
   bar: untracked file differs
   abort: untracked files in working directory differ from files in requested revision
   [255]
   $ cat bar
   memories of buried pirate treasure
 
 Those who use force will lose
 
   $ hg merge -f
-  file 'bar' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'bar' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   merging foo1 and foo to foo1
   0 files updated, 1 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
   $ cat bar
   bleh
   $ hg st
   M bar
   M foo1

tests/test-merge-subrepos.t

@@ -1,140 +1,140 b''
   $ hg init
 
   $ echo a > a
   $ hg ci -qAm 'add a'
 
   $ hg init subrepo
   $ echo 'subrepo = http://example.net/libfoo' > .hgsub
   $ hg ci -qAm 'added subrepo'
 
   $ hg up -qC 0
   $ echo ax > a
   $ hg ci -m 'changed a'
   created new head
 
   $ hg up -qC 1
   $ cd subrepo
   $ echo b > b
   $ hg add b
   $ cd ..
 
 Should fail, since there are added files to subrepo:
 
   $ hg merge
   abort: uncommitted changes in subrepository "subrepo"
   [255]
 
 Deleted files trigger a '+' marker in top level repos.  Deleted files are also
 noticed by `update --check` in the top level repo.
 
   $ hg ci -Sqm 'add b'
   $ echo change > subrepo/b
 
   $ hg ci -Sm 'change b'
   committing subrepository subrepo
 
   $ rm a
   $ hg id
   9bfe45a197d7+ tip
   $ hg sum
   parent: 4:9bfe45a197d7 tip
    change b
   branch: default
   commit: 1 deleted (clean)
   update: 1 new changesets, 2 branch heads (merge)
   phases: 5 draft
 
   $ hg up --check -r '.^'
   abort: uncommitted changes
   [255]
   $ hg st -S
   ! a
   $ hg up -Cq .
 
 Test that dirty is consistent through subrepos
 
   $ rm subrepo/b
 
 A deleted subrepo file is flagged as dirty, like the top level repo
 
   $ hg id --config extensions.blackbox= --config blackbox.dirty=True
   9bfe45a197d7+ tip
   $ cat .hg/blackbox.log
   * @9bfe45a197d7b0ab09bf287729dd57e9619c9da5+ (*)> serve --cmdserver chgunix * (glob) (chg !)
   * @9bfe45a197d7b0ab09bf287729dd57e9619c9da5+ (*)> id --config *extensions.blackbox=* --config *blackbox.dirty=True* (glob)
   * @9bfe45a197d7b0ab09bf287729dd57e9619c9da5+ (*)> id --config *extensions.blackbox=* --config *blackbox.dirty=True* exited 0 * (glob)
 
 TODO: a deleted file should be listed as such, like the top level repo
 
   $ hg sum
   parent: 4:9bfe45a197d7 tip
    change b
   branch: default
   commit: (clean)
   update: 1 new changesets, 2 branch heads (merge)
   phases: 5 draft
 
 Modified subrepo files are noticed by `update --check` and `summary`
 
   $ echo mod > subrepo/b
   $ hg st -S
   M subrepo/b
 
   $ hg up -r '.^' --check
   abort: uncommitted changes in subrepository "subrepo"
   [255]
 
   $ hg sum
   parent: 4:9bfe45a197d7 tip
    change b
   branch: default
   commit: 1 subrepos
   update: 1 new changesets, 2 branch heads (merge)
   phases: 5 draft
 
 TODO: why is -R needed here?  If it's because the subrepo is treated as a
 discrete unit, then this should probably warn or something.
   $ hg revert -R subrepo --no-backup subrepo/b -r .
 
   $ rm subrepo/b
   $ hg st -S
   ! subrepo/b
 
 `hg update --check` notices a subrepo with a missing file, like it notices a
 missing file in the top level repo.
 
   $ hg up -r '.^' --check
   abort: uncommitted changes in subrepository "subrepo"
   [255]
 
   $ hg up -r '.^' --config ui.interactive=True << EOF
   > d
   > EOF
-  file 'b' was deleted in other [destination] but was modified in local [working copy].
+  file 'b' was deleted in local [working copy] but was modified in other [destination].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? d
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 XXX: There's a difference between wdir() and '.', so there should be a status.
 `hg files -S` from the top is also missing 'subrepo/b'.
 
   $ hg st -S
   $ hg st -R subrepo
   $ hg files -R subrepo
   [1]
   $ hg files -R subrepo -r '.'
   subrepo/b
 
   $ hg bookmark -r tip @other
   $ echo xyz > subrepo/c
   $ hg ci -SAm 'add c'
   adding subrepo/c
   committing subrepository subrepo
   created new head
   $ rm subrepo/c
 
 Merge sees deleted subrepo files as an uncommitted change
 
   $ hg merge @other
   abort: uncommitted changes in subrepository "subrepo"
   [255]

tests/test-rebase-newancestor.t

@@ -1,426 +1,426 b''
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > rebase=
   > drawdag=$TESTDIR/drawdag.py
   > [alias]
   > tglog = log -G --template "{rev}: {node|short} '{desc}' {branches}\n"
   > EOF
 
   $ hg init repo
   $ cd repo
 
   $ echo A > a
   $ echo >> a
   $ hg ci -Am A
   adding a
 
   $ echo B > a
   $ echo >> a
   $ hg ci -m B
 
   $ echo C > a
   $ echo >> a
   $ hg ci -m C
 
   $ hg up -q -C 0
 
   $ echo D >> a
   $ hg ci -Am AD
   created new head
 
   $ hg tglog
   @  3: 3878212183bd 'AD'
   |
   | o  2: 30ae917c0e4f 'C'
   | |
   | o  1: 0f4f7cb4f549 'B'
   |/
   o  0: 1e635d440a73 'A'
   
   $ hg rebase -s 1 -d 3
   rebasing 1:0f4f7cb4f549 "B"
   merging a
   rebasing 2:30ae917c0e4f "C"
   merging a
   saved backup bundle to $TESTTMP/repo/.hg/strip-backup/0f4f7cb4f549-82b3b163-rebase.hg
 
   $ hg tglog
   o  3: 25773bc4b4b0 'C'
   |
   o  2: c09015405f75 'B'
   |
   @  1: 3878212183bd 'AD'
   |
   o  0: 1e635d440a73 'A'
   
 
   $ cd ..
 
 
 Test rebasing of merges with ancestors of the rebase destination - a situation
 that often happens when trying to recover from repeated merging with a mainline
 branch.
 
 The test case creates a dev branch that contains a couple of merges from the
 default branch. When rebasing to the default branch, these merges would be
 merges with ancestors on the same branch. The merges _could_ contain some
 interesting conflict resolutions or additional changes in the merge commit, but
 that is mixed up with the actual merge stuff and there is in general no way to
 separate them.
 
 Note: The dev branch contains _no_ changes to f-default. It might be unclear
 how rebasing of ancestor merges should be handled, but the current behavior
 with spurious prompts for conflicts in files that didn't change seems very
 wrong.
 
   $ hg init ancestor-merge
   $ cd ancestor-merge
 
   $ touch f-default
   $ hg ci -Aqm 'default: create f-default'
 
   $ hg branch -q dev
   $ hg ci -qm 'dev: create branch'
 
   $ echo stuff > f-dev
   $ hg ci -Aqm 'dev: f-dev stuff'
 
   $ hg up -q default
   $ echo stuff > f-default
   $ hg ci -m 'default: f-default stuff'
 
   $ hg up -q dev
   $ hg merge -q default
   $ hg ci -m 'dev: merge default'
 
   $ hg up -q default
   $ hg rm f-default
   $ hg ci -m 'default: remove f-default'
 
   $ hg up -q dev
   $ hg merge -q default
   $ hg ci -m 'dev: merge default'
 
   $ hg up -q default
   $ echo stuff > f-other
   $ hg ci -Aqm 'default: f-other stuff'
 
   $ hg tglog
   @  7: e08089805d82 'default: f-other stuff'
   |
   | o  6: 9455ee510502 'dev: merge default' dev
   |/|
   o |  5: 462860db70a1 'default: remove f-default'
   | |
   | o  4: 4b019212aaf6 'dev: merge default' dev
   |/|
   o |  3: f157ecfd2b6b 'default: f-default stuff'
   | |
   | o  2: ec2c14fb2984 'dev: f-dev stuff' dev
   | |
   | o  1: 1d1a643d390e 'dev: create branch' dev
   |/
   o  0: e90e8eb90b6f 'default: create f-default'
   
   $ hg clone -qU . ../ancestor-merge-2
 
 Full rebase all the way back from branching point:
 
   $ hg rebase -r 'only(dev,default)' -d default --config ui.interactive=True << EOF
   > c
   > EOF
   rebasing 1:1d1a643d390e "dev: create branch"
   note: rebase of 1:1d1a643d390e created no changes to commit
   rebasing 2:ec2c14fb2984 "dev: f-dev stuff"
   rebasing 4:4b019212aaf6 "dev: merge default"
-  file 'f-default' was deleted in other [source] but was modified in local [dest].
+  file 'f-default' was deleted in local [dest] but was modified in other [source].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
   rebasing 6:9455ee510502 "dev: merge default"
   saved backup bundle to $TESTTMP/ancestor-merge/.hg/strip-backup/1d1a643d390e-43e9e04b-rebase.hg
   $ hg tglog
   o  6: fbc098e72227 'dev: merge default'
   |
   o  5: eda7b7f46f5d 'dev: merge default'
   |
   o  4: 3e075b1c0a40 'dev: f-dev stuff'
   |
   @  3: e08089805d82 'default: f-other stuff'
   |
   o  2: 462860db70a1 'default: remove f-default'
   |
   o  1: f157ecfd2b6b 'default: f-default stuff'
   |
   o  0: e90e8eb90b6f 'default: create f-default'
   
 Grafty cherry picking rebasing:
 
   $ cd ../ancestor-merge-2
 
   $ hg phase -fdr0:
   $ hg rebase -r 'children(only(dev,default))' -d default --config ui.interactive=True << EOF
   > c
   > EOF
   rebasing 2:ec2c14fb2984 "dev: f-dev stuff"
   rebasing 4:4b019212aaf6 "dev: merge default"
-  file 'f-default' was deleted in other [source] but was modified in local [dest].
+  file 'f-default' was deleted in local [dest] but was modified in other [source].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
   rebasing 6:9455ee510502 "dev: merge default"
   saved backup bundle to $TESTTMP/ancestor-merge-2/.hg/strip-backup/ec2c14fb2984-62d0b222-rebase.hg
   $ hg tglog
   o  7: fbc098e72227 'dev: merge default'
   |
   o  6: eda7b7f46f5d 'dev: merge default'
   |
   o  5: 3e075b1c0a40 'dev: f-dev stuff'
   |
   o  4: e08089805d82 'default: f-other stuff'
   |
   o  3: 462860db70a1 'default: remove f-default'
   |
   o  2: f157ecfd2b6b 'default: f-default stuff'
   |
   | o  1: 1d1a643d390e 'dev: create branch' dev
   |/
   o  0: e90e8eb90b6f 'default: create f-default'
   
   $ cd ..
 
 
 Test order of parents of rebased merged with un-rebased changes as p1.
 
   $ hg init parentorder
   $ cd parentorder
   $ touch f
   $ hg ci -Aqm common
   $ touch change
   $ hg ci -Aqm change
   $ touch target
   $ hg ci -Aqm target
   $ hg up -qr 0
   $ touch outside
   $ hg ci -Aqm outside
   $ hg merge -qr 1
   $ hg ci -m 'merge p1 3=outside p2 1=ancestor'
   $ hg par
   changeset:   4:6990226659be
   tag:         tip
   parent:      3:f59da8fc0fcf
   parent:      1:dd40c13f7a6f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     merge p1 3=outside p2 1=ancestor
   
   $ hg up -qr 1
   $ hg merge -qr 3
   $ hg ci -qm 'merge p1 1=ancestor p2 3=outside'
   $ hg par
   changeset:   5:a57575f79074
   tag:         tip
   parent:      1:dd40c13f7a6f
   parent:      3:f59da8fc0fcf
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     merge p1 1=ancestor p2 3=outside
   
   $ hg tglog
   @    5: a57575f79074 'merge p1 1=ancestor p2 3=outside'
   |\
   +---o  4: 6990226659be 'merge p1 3=outside p2 1=ancestor'
   | |/
   | o  3: f59da8fc0fcf 'outside'
   | |
   +---o  2: a60552eb93fb 'target'
   | |
   o |  1: dd40c13f7a6f 'change'
   |/
   o  0: 02f0f58d5300 'common'
   
   $ hg rebase -r 4 -d 2
   rebasing 4:6990226659be "merge p1 3=outside p2 1=ancestor"
   saved backup bundle to $TESTTMP/parentorder/.hg/strip-backup/6990226659be-4d67a0d3-rebase.hg
   $ hg tip
   changeset:   5:cca50676b1c5
   tag:         tip
   parent:      2:a60552eb93fb
   parent:      3:f59da8fc0fcf
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     merge p1 3=outside p2 1=ancestor
   
   $ hg rebase -r 4 -d 2
   rebasing 4:a57575f79074 "merge p1 1=ancestor p2 3=outside"
   saved backup bundle to $TESTTMP/parentorder/.hg/strip-backup/a57575f79074-385426e5-rebase.hg
   $ hg tip
   changeset:   5:f9daf77ffe76
   tag:         tip
   parent:      2:a60552eb93fb
   parent:      3:f59da8fc0fcf
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     merge p1 1=ancestor p2 3=outside
   
   $ hg tglog
   @    5: f9daf77ffe76 'merge p1 1=ancestor p2 3=outside'
   |\
   +---o  4: cca50676b1c5 'merge p1 3=outside p2 1=ancestor'
   | |/
   | o  3: f59da8fc0fcf 'outside'
   | |
   o |  2: a60552eb93fb 'target'
   | |
   o |  1: dd40c13f7a6f 'change'
   |/
   o  0: 02f0f58d5300 'common'
   
 rebase of merge of ancestors
 
   $ hg up -qr 2
   $ hg merge -qr 3
   $ echo 'other change while merging future "rebase ancestors"' > other
   $ hg ci -Aqm 'merge rebase ancestors'
   $ hg rebase -d 5 -v
   rebasing 6:4c5f12f25ebe "merge rebase ancestors" (tip)
   resolving manifests
   removing other
   note: merging f9daf77ffe76+ and 4c5f12f25ebe using bids from ancestors a60552eb93fb and f59da8fc0fcf
   
   calculating bids for ancestor a60552eb93fb
   resolving manifests
   
   calculating bids for ancestor f59da8fc0fcf
   resolving manifests
   
   auction for merging merge bids
    other: consensus for g
   end of auction
   
   getting other
   committing files:
   other
   committing manifest
   committing changelog
   rebase merging completed
   1 changesets found
   uncompressed size of bundle content:
        199 (changelog)
        216 (manifests)
        182  other
   saved backup bundle to $TESTTMP/parentorder/.hg/strip-backup/4c5f12f25ebe-f46990e5-rebase.hg
   1 changesets found
   uncompressed size of bundle content:
        254 (changelog)
        167 (manifests)
        182  other
   adding branch
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   rebase completed
   $ hg tglog
   @  6: 113755df812b 'merge rebase ancestors'
   |
   o    5: f9daf77ffe76 'merge p1 1=ancestor p2 3=outside'
   |\
   +---o  4: cca50676b1c5 'merge p1 3=outside p2 1=ancestor'
   | |/
   | o  3: f59da8fc0fcf 'outside'
   | |
   o |  2: a60552eb93fb 'target'
   | |
   o |  1: dd40c13f7a6f 'change'
   |/
   o  0: 02f0f58d5300 'common'
   
 Due to the limitation of 3-way merge algorithm (1 merge base), rebasing a merge
 may include unwanted content:
 
   $ hg init $TESTTMP/dual-merge-base1
   $ cd $TESTTMP/dual-merge-base1
   $ hg debugdrawdag <<'EOS'
   >   F
   >  /|
   > D E
   > | |
   > B C
   > |/
   > A Z
   > |/
   > R
   > EOS
   $ hg rebase -r D+E+F -d Z
   rebasing 5:5f2c926dfecf "D" (D)
   rebasing 6:b296604d9846 "E" (E)
   rebasing 7:caa9781e507d "F" (F tip)
   abort: rebasing 7:caa9781e507d will include unwanted changes from 4:d6003a550c2c or 3:c1e6b162678d
   [255]
 
 The warning does not get printed if there is no unwanted change detected:
 
   $ hg init $TESTTMP/dual-merge-base2
   $ cd $TESTTMP/dual-merge-base2
   $ hg debugdrawdag <<'EOS'
   >   D
   >  /|
   > B C
   > |/
   > A Z
   > |/
   > R
   > EOS
   $ hg rebase -r B+C+D -d Z
   rebasing 3:c1e6b162678d "B" (B)
   rebasing 4:d6003a550c2c "C" (C)
   rebasing 5:c8f78076273e "D" (D tip)
   saved backup bundle to $TESTTMP/dual-merge-base2/.hg/strip-backup/d6003a550c2c-6f1424b6-rebase.hg
   $ hg manifest -r 'desc(D)'
   B
   C
   R
   Z
 
 The merge base could be different from old p1 (changed parent becomes new p1):
 
   $ hg init $TESTTMP/chosen-merge-base1
   $ cd $TESTTMP/chosen-merge-base1
   $ hg debugdrawdag <<'EOS'
   >   F
   >  /|
   > D E
   > | |
   > B C Z
   > EOS
   $ hg rebase -r D+F -d Z
   rebasing 3:004dc1679908 "D" (D)
   rebasing 5:4be4cbf6f206 "F" (F tip)
   saved backup bundle to $TESTTMP/chosen-merge-base1/.hg/strip-backup/004dc1679908-06a66a3c-rebase.hg
   $ hg manifest -r 'desc(F)'
   C
   D
   E
   Z
   $ hg log -r `hg log -r 'desc(F)' -T '{p1node}'` -T '{desc}\n'
   D
 
   $ hg init $TESTTMP/chosen-merge-base2
   $ cd $TESTTMP/chosen-merge-base2
   $ hg debugdrawdag <<'EOS'
   >   F
   >  /|
   > D E
   > | |
   > B C Z
   > EOS
   $ hg rebase -r E+F -d Z
   rebasing 4:974e4943c210 "E" (E)
   rebasing 5:4be4cbf6f206 "F" (F tip)
   saved backup bundle to $TESTTMP/chosen-merge-base2/.hg/strip-backup/974e4943c210-b2874da5-rebase.hg
   $ hg manifest -r 'desc(F)'
   B
   D
   E
   Z
   $ hg log -r `hg log -r 'desc(F)' -T '{p1node}'` -T '{desc}\n'
   E

tests/test-rename-merge2.t

@@ -1,1071 +1,1071 b''
 
   $ mkdir -p t
   $ cd t
   $ cat <<EOF > merge
   > import sys, os
   > f = open(sys.argv[1], "wb")
   > f.write("merge %s %s %s" % (sys.argv[1], sys.argv[2], sys.argv[3]))
   > f.close()
   > EOF
 
 perform a test merge with possible renaming
 args:
 $1 = action in local branch
 $2 = action in remote branch
 $3 = action in working dir
 $4 = expected result
 
   $ tm()
   > {
   >     hg init t
   >     cd t
   >     echo "[merge]" >> .hg/hgrc
   >     echo "followcopies = 1" >> .hg/hgrc
   > 
   >     # base
   >     echo base > a
   >     echo base > rev # used to force commits
   >     hg add a rev
   >     hg ci -m "base"
   > 
   >     # remote
   >     echo remote > rev
   >     if [ "$2" != "" ] ; then $2 ; fi
   >     hg ci -m "remote"
   > 
   >     # local
   >     hg co -q 0
   >     echo local > rev
   >     if [ "$1" != "" ] ; then $1 ; fi
   >     hg ci -m "local"
   > 
   >     # working dir
   >     echo local > rev
   >     if [ "$3" != "" ] ; then $3 ; fi
   > 
   >     # merge
   >     echo "--------------"
   >     echo "test L:$1 R:$2 W:$3 - $4"
   >     echo "--------------"
   >     hg merge -y --debug --traceback --tool="$PYTHON ../merge"
   > 
   >     echo "--------------"
   >     hg status -camC -X rev
   > 
   >     hg ci -m "merge"
   > 
   >     echo "--------------"
   >     echo
   > 
   >     cd ..
   >     rm -r t
   > }
   $ up() {
   >     cp rev $1
   >     hg add $1 2> /dev/null
   >     if [ "$2" != "" ] ; then
   >         cp rev $2
   >         hg add $2 2> /dev/null
   >     fi
   > }
   $ uc() { up $1; hg cp $1 $2; } # update + copy
   $ um() { up $1; hg mv $1 $2; }
   $ nc() { hg cp $1 $2; } # just copy
   $ nm() { hg mv $1 $2; } # just move
   $ tm "up a  " "nc a b" "      " "1  get local a to b"
   created new head
   --------------
   test L:up a   R:nc a b W:       - 1  get local a to b
   --------------
     searching for copies back to rev 1
     unmatched files in other:
      b
     all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      src: 'a' -> dst: 'b' *
     checking for directory renames
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 924404dff337, local: e300d1c794ec+, remote: 4ce40f5aca24
    preserving a for resolve of b
    preserving rev for resolve of rev
   starting 4 threads for background file closing (?)
    b: remote copied from a -> m (premerge)
   picked tool '* ../merge' for b (binary False symlink False changedelete False) (glob)
   merging a and b to b
   my b@e300d1c794ec+ other b@4ce40f5aca24 ancestor a@924404dff337
    premerge successful
    rev: versions differ -> m (premerge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   merging rev
   my rev@e300d1c794ec+ other rev@4ce40f5aca24 ancestor rev@924404dff337
    rev: versions differ -> m (merge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   my rev@e300d1c794ec+ other rev@4ce40f5aca24 ancestor rev@924404dff337
   launching merge tool: * ../merge *$TESTTMP/t/t/rev* * * (glob)
   merge tool returned: 0
   0 files updated, 2 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M b
     a
   C a
   --------------
   
   $ tm "nc a b" "up a  " "      " "2  get rem change to a and b"
   created new head
   --------------
   test L:nc a b R:up a   W:       - 2  get rem change to a and b
   --------------
     searching for copies back to rev 1
     unmatched files in local:
      b
     all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      src: 'a' -> dst: 'b' *
     checking for directory renames
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 924404dff337, local: 86a2aa42fc76+, remote: f4db7e329e71
    preserving b for resolve of b
    preserving rev for resolve of rev
    a: remote is newer -> g
   getting a
    b: local copied/moved from a -> m (premerge)
   picked tool '* ../merge' for b (binary False symlink False changedelete False) (glob)
   merging b and a to b
   my b@86a2aa42fc76+ other a@f4db7e329e71 ancestor a@924404dff337
    premerge successful
    rev: versions differ -> m (premerge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   merging rev
   my rev@86a2aa42fc76+ other rev@f4db7e329e71 ancestor rev@924404dff337
    rev: versions differ -> m (merge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   my rev@86a2aa42fc76+ other rev@f4db7e329e71 ancestor rev@924404dff337
   launching merge tool: * ../merge *$TESTTMP/t/t/rev* * * (glob)
   merge tool returned: 0
   1 files updated, 2 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M a
   M b
     a
   --------------
   
   $ tm "up a  " "nm a b" "      " "3  get local a change to b, remove a"
   created new head
   --------------
   test L:up a   R:nm a b W:       - 3  get local a change to b, remove a
   --------------
     searching for copies back to rev 1
     unmatched files in other:
      b
     all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      src: 'a' -> dst: 'b' *
     checking for directory renames
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 924404dff337, local: e300d1c794ec+, remote: bdb19105162a
    preserving a for resolve of b
    preserving rev for resolve of rev
   removing a
   starting 4 threads for background file closing (?)
    b: remote moved from a -> m (premerge)
   picked tool '* ../merge' for b (binary False symlink False changedelete False) (glob)
   merging a and b to b
   my b@e300d1c794ec+ other b@bdb19105162a ancestor a@924404dff337
    premerge successful
    rev: versions differ -> m (premerge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   merging rev
   my rev@e300d1c794ec+ other rev@bdb19105162a ancestor rev@924404dff337
    rev: versions differ -> m (merge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   my rev@e300d1c794ec+ other rev@bdb19105162a ancestor rev@924404dff337
   launching merge tool: * ../merge *$TESTTMP/t/t/rev* * * (glob)
   merge tool returned: 0
   0 files updated, 2 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M b
     a
   --------------
   
   $ tm "nm a b" "up a  " "      " "4  get remote change to b"
   created new head
   --------------
   test L:nm a b R:up a   W:       - 4  get remote change to b
   --------------
     searching for copies back to rev 1
     unmatched files in local:
      b
     all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      src: 'a' -> dst: 'b' *
     checking for directory renames
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 924404dff337, local: 02963e448370+, remote: f4db7e329e71
    preserving b for resolve of b
    preserving rev for resolve of rev
   starting 4 threads for background file closing (?)
    b: local copied/moved from a -> m (premerge)
   picked tool '* ../merge' for b (binary False symlink False changedelete False) (glob)
   merging b and a to b
   my b@02963e448370+ other a@f4db7e329e71 ancestor a@924404dff337
    premerge successful
    rev: versions differ -> m (premerge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   merging rev
   my rev@02963e448370+ other rev@f4db7e329e71 ancestor rev@924404dff337
    rev: versions differ -> m (merge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   my rev@02963e448370+ other rev@f4db7e329e71 ancestor rev@924404dff337
   launching merge tool: * ../merge *$TESTTMP/t/t/rev* * * (glob)
   merge tool returned: 0
   0 files updated, 2 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M b
     a
   --------------
   
   $ tm "      " "nc a b" "      " "5  get b"
   created new head
   --------------
   test L:       R:nc a b W:       - 5  get b
   --------------
     searching for copies back to rev 1
     unmatched files in other:
      b
     all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      src: 'a' -> dst: 'b' 
     checking for directory renames
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 924404dff337, local: 94b33a1b7f2d+, remote: 4ce40f5aca24
    preserving rev for resolve of rev
    b: remote created -> g
   getting b
    rev: versions differ -> m (premerge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   merging rev
   my rev@94b33a1b7f2d+ other rev@4ce40f5aca24 ancestor rev@924404dff337
    rev: versions differ -> m (merge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   my rev@94b33a1b7f2d+ other rev@4ce40f5aca24 ancestor rev@924404dff337
   launching merge tool: * ../merge *$TESTTMP/t/t/rev* * * (glob)
   merge tool returned: 0
   1 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M b
   C a
   --------------
   
   $ tm "nc a b" "      " "      " "6  nothing"
   created new head
   --------------
   test L:nc a b R:       W:       - 6  nothing
   --------------
     searching for copies back to rev 1
     unmatched files in local:
      b
     all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      src: 'a' -> dst: 'b' 
     checking for directory renames
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 924404dff337, local: 86a2aa42fc76+, remote: 97c705ade336
    preserving rev for resolve of rev
   starting 4 threads for background file closing (?)
    rev: versions differ -> m (premerge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   merging rev
   my rev@86a2aa42fc76+ other rev@97c705ade336 ancestor rev@924404dff337
    rev: versions differ -> m (merge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   my rev@86a2aa42fc76+ other rev@97c705ade336 ancestor rev@924404dff337
   launching merge tool: * ../merge *$TESTTMP/t/t/rev* * * (glob)
   merge tool returned: 0
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   C a
   C b
   --------------
   
   $ tm "      " "nm a b" "      " "7  get b"
   created new head
   --------------
   test L:       R:nm a b W:       - 7  get b
   --------------
     searching for copies back to rev 1
     unmatched files in other:
      b
     all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      src: 'a' -> dst: 'b' 
     checking for directory renames
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 924404dff337, local: 94b33a1b7f2d+, remote: bdb19105162a
    preserving rev for resolve of rev
    a: other deleted -> r
   removing a
    b: remote created -> g
   getting b
    rev: versions differ -> m (premerge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   merging rev
   my rev@94b33a1b7f2d+ other rev@bdb19105162a ancestor rev@924404dff337
    rev: versions differ -> m (merge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   my rev@94b33a1b7f2d+ other rev@bdb19105162a ancestor rev@924404dff337
   launching merge tool: * ../merge *$TESTTMP/t/t/rev* * * (glob)
   merge tool returned: 0
   1 files updated, 1 files merged, 1 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M b
   --------------
   
   $ tm "nm a b" "      " "      " "8  nothing"
   created new head
   --------------
   test L:nm a b R:       W:       - 8  nothing
   --------------
     searching for copies back to rev 1
     unmatched files in local:
      b
     all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      src: 'a' -> dst: 'b' 
     checking for directory renames
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 924404dff337, local: 02963e448370+, remote: 97c705ade336
    preserving rev for resolve of rev
   starting 4 threads for background file closing (?)
    rev: versions differ -> m (premerge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   merging rev
   my rev@02963e448370+ other rev@97c705ade336 ancestor rev@924404dff337
    rev: versions differ -> m (merge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   my rev@02963e448370+ other rev@97c705ade336 ancestor rev@924404dff337
   launching merge tool: * ../merge *$TESTTMP/t/t/rev* * * (glob)
   merge tool returned: 0
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   C b
   --------------
   
   $ tm "um a b" "um a b" "      " "9  do merge with ancestor in a"
   created new head
   --------------
   test L:um a b R:um a b W:       - 9  do merge with ancestor in a
   --------------
     searching for copies back to rev 1
     unmatched files new in both:
      b
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 924404dff337, local: 62e7bf090eba+, remote: 49b6d8032493
    preserving b for resolve of b
    preserving rev for resolve of rev
   starting 4 threads for background file closing (?)
    b: both renamed from a -> m (premerge)
   picked tool '* ../merge' for b (binary False symlink False changedelete False) (glob)
   merging b
   my b@62e7bf090eba+ other b@49b6d8032493 ancestor a@924404dff337
    rev: versions differ -> m (premerge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   merging rev
   my rev@62e7bf090eba+ other rev@49b6d8032493 ancestor rev@924404dff337
    b: both renamed from a -> m (merge)
   picked tool '* ../merge' for b (binary False symlink False changedelete False) (glob)
   my b@62e7bf090eba+ other b@49b6d8032493 ancestor a@924404dff337
   launching merge tool: * ../merge *$TESTTMP/t/t/b* * * (glob)
   merge tool returned: 0
    rev: versions differ -> m (merge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   my rev@62e7bf090eba+ other rev@49b6d8032493 ancestor rev@924404dff337
   launching merge tool: * ../merge *$TESTTMP/t/t/rev* * * (glob)
   merge tool returned: 0
   0 files updated, 2 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M b
   --------------
   
 
 m "um a c" "um x c" "      " "10 do merge with no ancestor"
 
   $ tm "nm a b" "nm a c" "      " "11 get c, keep b"
   created new head
   --------------
   test L:nm a b R:nm a c W:       - 11 get c, keep b
   --------------
     searching for copies back to rev 1
     unmatched files in local:
      b
     unmatched files in other:
      c
     all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      src: 'a' -> dst: 'b' !
      src: 'a' -> dst: 'c' !
     checking for directory renames
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 924404dff337, local: 02963e448370+, remote: fe905ef2c33e
   note: possible conflict - a was renamed multiple times to:
    b
    c
    preserving rev for resolve of rev
    c: remote created -> g
   getting c
    rev: versions differ -> m (premerge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   merging rev
   my rev@02963e448370+ other rev@fe905ef2c33e ancestor rev@924404dff337
    rev: versions differ -> m (merge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   my rev@02963e448370+ other rev@fe905ef2c33e ancestor rev@924404dff337
   launching merge tool: * ../merge *$TESTTMP/t/t/rev* * * (glob)
   merge tool returned: 0
   1 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M c
   C b
   --------------
   
   $ tm "nc a b" "up b  " "      " "12 merge b no ancestor"
   created new head
   --------------
   test L:nc a b R:up b   W:       - 12 merge b no ancestor
   --------------
     searching for copies back to rev 1
     unmatched files new in both:
      b
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 924404dff337, local: 86a2aa42fc76+, remote: af30c7647fc7
    preserving b for resolve of b
    preserving rev for resolve of rev
   starting 4 threads for background file closing (?)
    b: both created -> m (premerge)
   picked tool '* ../merge' for b (binary False symlink False changedelete False) (glob)
   merging b
   my b@86a2aa42fc76+ other b@af30c7647fc7 ancestor b@000000000000
    rev: versions differ -> m (premerge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   merging rev
   my rev@86a2aa42fc76+ other rev@af30c7647fc7 ancestor rev@924404dff337
    b: both created -> m (merge)
   picked tool '* ../merge' for b (binary False symlink False changedelete False) (glob)
   my b@86a2aa42fc76+ other b@af30c7647fc7 ancestor b@000000000000
   launching merge tool: * ../merge *$TESTTMP/t/t/b* * * (glob)
   merge tool returned: 0
    rev: versions differ -> m (merge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   my rev@86a2aa42fc76+ other rev@af30c7647fc7 ancestor rev@924404dff337
   launching merge tool: * ../merge *$TESTTMP/t/t/rev* * * (glob)
   merge tool returned: 0
   0 files updated, 2 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M b
   C a
   --------------
   
   $ tm "up b  " "nm a b" "      " "13 merge b no ancestor"
   created new head
   --------------
   test L:up b   R:nm a b W:       - 13 merge b no ancestor
   --------------
     searching for copies back to rev 1
     unmatched files new in both:
      b
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 924404dff337, local: 59318016310c+, remote: bdb19105162a
    preserving b for resolve of b
    preserving rev for resolve of rev
    a: other deleted -> r
   removing a
   starting 4 threads for background file closing (?)
    b: both created -> m (premerge)
   picked tool '* ../merge' for b (binary False symlink False changedelete False) (glob)
   merging b
   my b@59318016310c+ other b@bdb19105162a ancestor b@000000000000
    rev: versions differ -> m (premerge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   merging rev
   my rev@59318016310c+ other rev@bdb19105162a ancestor rev@924404dff337
    b: both created -> m (merge)
   picked tool '* ../merge' for b (binary False symlink False changedelete False) (glob)
   my b@59318016310c+ other b@bdb19105162a ancestor b@000000000000
   launching merge tool: * ../merge *$TESTTMP/t/t/b* * * (glob)
   merge tool returned: 0
    rev: versions differ -> m (merge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   my rev@59318016310c+ other rev@bdb19105162a ancestor rev@924404dff337
   launching merge tool: * ../merge *$TESTTMP/t/t/rev* * * (glob)
   merge tool returned: 0
   0 files updated, 2 files merged, 1 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M b
   --------------
   
   $ tm "nc a b" "up a b" "      " "14 merge b no ancestor"
   created new head
   --------------
   test L:nc a b R:up a b W:       - 14 merge b no ancestor
   --------------
     searching for copies back to rev 1
     unmatched files new in both:
      b
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 924404dff337, local: 86a2aa42fc76+, remote: 8dbce441892a
    preserving b for resolve of b
    preserving rev for resolve of rev
    a: remote is newer -> g
   getting a
    b: both created -> m (premerge)
   picked tool '* ../merge' for b (binary False symlink False changedelete False) (glob)
   merging b
   my b@86a2aa42fc76+ other b@8dbce441892a ancestor b@000000000000
    rev: versions differ -> m (premerge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   merging rev
   my rev@86a2aa42fc76+ other rev@8dbce441892a ancestor rev@924404dff337
    b: both created -> m (merge)
   picked tool '* ../merge' for b (binary False symlink False changedelete False) (glob)
   my b@86a2aa42fc76+ other b@8dbce441892a ancestor b@000000000000
   launching merge tool: * ../merge *$TESTTMP/t/t/b* * * (glob)
   merge tool returned: 0
    rev: versions differ -> m (merge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   my rev@86a2aa42fc76+ other rev@8dbce441892a ancestor rev@924404dff337
   launching merge tool: * ../merge *$TESTTMP/t/t/rev* * * (glob)
   merge tool returned: 0
   1 files updated, 2 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M a
   M b
   --------------
   
   $ tm "up b  " "nm a b" "      " "15 merge b no ancestor, remove a"
   created new head
   --------------
   test L:up b   R:nm a b W:       - 15 merge b no ancestor, remove a
   --------------
     searching for copies back to rev 1
     unmatched files new in both:
      b
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 924404dff337, local: 59318016310c+, remote: bdb19105162a
    preserving b for resolve of b
    preserving rev for resolve of rev
    a: other deleted -> r
   removing a
   starting 4 threads for background file closing (?)
    b: both created -> m (premerge)
   picked tool '* ../merge' for b (binary False symlink False changedelete False) (glob)
   merging b
   my b@59318016310c+ other b@bdb19105162a ancestor b@000000000000
    rev: versions differ -> m (premerge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   merging rev
   my rev@59318016310c+ other rev@bdb19105162a ancestor rev@924404dff337
    b: both created -> m (merge)
   picked tool '* ../merge' for b (binary False symlink False changedelete False) (glob)
   my b@59318016310c+ other b@bdb19105162a ancestor b@000000000000
   launching merge tool: * ../merge *$TESTTMP/t/t/b* * * (glob)
   merge tool returned: 0
    rev: versions differ -> m (merge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   my rev@59318016310c+ other rev@bdb19105162a ancestor rev@924404dff337
   launching merge tool: * ../merge *$TESTTMP/t/t/rev* * * (glob)
   merge tool returned: 0
   0 files updated, 2 files merged, 1 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M b
   --------------
   
   $ tm "nc a b" "up a b" "      " "16 get a, merge b no ancestor"
   created new head
   --------------
   test L:nc a b R:up a b W:       - 16 get a, merge b no ancestor
   --------------
     searching for copies back to rev 1
     unmatched files new in both:
      b
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 924404dff337, local: 86a2aa42fc76+, remote: 8dbce441892a
    preserving b for resolve of b
    preserving rev for resolve of rev
    a: remote is newer -> g
   getting a
    b: both created -> m (premerge)
   picked tool '* ../merge' for b (binary False symlink False changedelete False) (glob)
   merging b
   my b@86a2aa42fc76+ other b@8dbce441892a ancestor b@000000000000
    rev: versions differ -> m (premerge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   merging rev
   my rev@86a2aa42fc76+ other rev@8dbce441892a ancestor rev@924404dff337
    b: both created -> m (merge)
   picked tool '* ../merge' for b (binary False symlink False changedelete False) (glob)
   my b@86a2aa42fc76+ other b@8dbce441892a ancestor b@000000000000
   launching merge tool: * ../merge *$TESTTMP/t/t/b* * * (glob)
   merge tool returned: 0
    rev: versions differ -> m (merge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   my rev@86a2aa42fc76+ other rev@8dbce441892a ancestor rev@924404dff337
   launching merge tool: * ../merge *$TESTTMP/t/t/rev* * * (glob)
   merge tool returned: 0
   1 files updated, 2 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M a
   M b
   --------------
   
   $ tm "up a b" "nc a b" "      " "17 keep a, merge b no ancestor"
   created new head
   --------------
   test L:up a b R:nc a b W:       - 17 keep a, merge b no ancestor
   --------------
     searching for copies back to rev 1
     unmatched files new in both:
      b
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 924404dff337, local: 0b76e65c8289+, remote: 4ce40f5aca24
    preserving b for resolve of b
    preserving rev for resolve of rev
   starting 4 threads for background file closing (?)
    b: both created -> m (premerge)
   picked tool '* ../merge' for b (binary False symlink False changedelete False) (glob)
   merging b
   my b@0b76e65c8289+ other b@4ce40f5aca24 ancestor b@000000000000
    rev: versions differ -> m (premerge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   merging rev
   my rev@0b76e65c8289+ other rev@4ce40f5aca24 ancestor rev@924404dff337
    b: both created -> m (merge)
   picked tool '* ../merge' for b (binary False symlink False changedelete False) (glob)
   my b@0b76e65c8289+ other b@4ce40f5aca24 ancestor b@000000000000
   launching merge tool: * ../merge *$TESTTMP/t/t/b* * * (glob)
   merge tool returned: 0
    rev: versions differ -> m (merge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   my rev@0b76e65c8289+ other rev@4ce40f5aca24 ancestor rev@924404dff337
   launching merge tool: * ../merge *$TESTTMP/t/t/rev* * * (glob)
   merge tool returned: 0
   0 files updated, 2 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M b
   C a
   --------------
   
   $ tm "nm a b" "up a b" "      " "18 merge b no ancestor"
   created new head
   --------------
   test L:nm a b R:up a b W:       - 18 merge b no ancestor
   --------------
     searching for copies back to rev 1
     unmatched files new in both:
      b
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 924404dff337, local: 02963e448370+, remote: 8dbce441892a
    preserving b for resolve of b
    preserving rev for resolve of rev
   starting 4 threads for background file closing (?)
    a: prompt deleted/changed -> m (premerge)
   picked tool ':prompt' for a (binary False symlink False changedelete True)
-  file 'a' was deleted in other [merge rev] but was modified in local [working copy].
+  file 'a' was deleted in local [working copy] but was modified in other [merge rev].
   What do you want to do?
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
    b: both created -> m (premerge)
   picked tool '* ../merge' for b (binary False symlink False changedelete False) (glob)
   merging b
   my b@02963e448370+ other b@8dbce441892a ancestor b@000000000000
    rev: versions differ -> m (premerge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   merging rev
   my rev@02963e448370+ other rev@8dbce441892a ancestor rev@924404dff337
    b: both created -> m (merge)
   picked tool '* ../merge' for b (binary False symlink False changedelete False) (glob)
   my b@02963e448370+ other b@8dbce441892a ancestor b@000000000000
   launching merge tool: * ../merge *$TESTTMP/t/t/b* * * (glob)
   merge tool returned: 0
    rev: versions differ -> m (merge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   my rev@02963e448370+ other rev@8dbce441892a ancestor rev@924404dff337
   launching merge tool: * ../merge *$TESTTMP/t/t/rev* * * (glob)
   merge tool returned: 0
   0 files updated, 2 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   --------------
   M a
   M b
   abort: unresolved merge conflicts (see 'hg help resolve')
   --------------
   
   $ tm "up a b" "nm a b" "      " "19 merge b no ancestor, prompt remove a"
   created new head
   --------------
   test L:up a b R:nm a b W:       - 19 merge b no ancestor, prompt remove a
   --------------
     searching for copies back to rev 1
     unmatched files new in both:
      b
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 924404dff337, local: 0b76e65c8289+, remote: bdb19105162a
    preserving a for resolve of a
    preserving b for resolve of b
    preserving rev for resolve of rev
   starting 4 threads for background file closing (?)
    a: prompt changed/deleted -> m (premerge)
   picked tool ':prompt' for a (binary False symlink False changedelete True)
-  file 'a' was deleted in local [working copy] but was modified in other [merge rev].
+  file 'a' was deleted in other [merge rev] but was modified in local [working copy].
   What do you want to do?
   use (c)hanged version, (d)elete, or leave (u)nresolved? u
    b: both created -> m (premerge)
   picked tool '* ../merge' for b (binary False symlink False changedelete False) (glob)
   merging b
   my b@0b76e65c8289+ other b@bdb19105162a ancestor b@000000000000
    rev: versions differ -> m (premerge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   merging rev
   my rev@0b76e65c8289+ other rev@bdb19105162a ancestor rev@924404dff337
    b: both created -> m (merge)
   picked tool '* ../merge' for b (binary False symlink False changedelete False) (glob)
   my b@0b76e65c8289+ other b@bdb19105162a ancestor b@000000000000
   launching merge tool: * ../merge *$TESTTMP/t/t/b* * * (glob)
   merge tool returned: 0
    rev: versions differ -> m (merge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   my rev@0b76e65c8289+ other rev@bdb19105162a ancestor rev@924404dff337
   launching merge tool: * ../merge *$TESTTMP/t/t/rev* * * (glob)
   merge tool returned: 0
   0 files updated, 2 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   --------------
   M b
   C a
   abort: unresolved merge conflicts (see 'hg help resolve')
   --------------
   
   $ tm "up a  " "um a b" "      " "20 merge a and b to b, remove a"
   created new head
   --------------
   test L:up a   R:um a b W:       - 20 merge a and b to b, remove a
   --------------
     searching for copies back to rev 1
     unmatched files in other:
      b
     all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      src: 'a' -> dst: 'b' *
     checking for directory renames
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 924404dff337, local: e300d1c794ec+, remote: 49b6d8032493
    preserving a for resolve of b
    preserving rev for resolve of rev
   removing a
   starting 4 threads for background file closing (?)
    b: remote moved from a -> m (premerge)
   picked tool '* ../merge' for b (binary False symlink False changedelete False) (glob)
   merging a and b to b
   my b@e300d1c794ec+ other b@49b6d8032493 ancestor a@924404dff337
    rev: versions differ -> m (premerge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   merging rev
   my rev@e300d1c794ec+ other rev@49b6d8032493 ancestor rev@924404dff337
    b: remote moved from a -> m (merge)
   picked tool '* ../merge' for b (binary False symlink False changedelete False) (glob)
   my b@e300d1c794ec+ other b@49b6d8032493 ancestor a@924404dff337
   launching merge tool: * ../merge *$TESTTMP/t/t/b* * * (glob)
   merge tool returned: 0
    rev: versions differ -> m (merge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   my rev@e300d1c794ec+ other rev@49b6d8032493 ancestor rev@924404dff337
   launching merge tool: * ../merge *$TESTTMP/t/t/rev* * * (glob)
   merge tool returned: 0
   0 files updated, 2 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M b
     a
   --------------
   
   $ tm "um a b" "up a  " "      " "21 merge a and b to b"
   created new head
   --------------
   test L:um a b R:up a   W:       - 21 merge a and b to b
   --------------
     searching for copies back to rev 1
     unmatched files in local:
      b
     all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      src: 'a' -> dst: 'b' *
     checking for directory renames
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 924404dff337, local: 62e7bf090eba+, remote: f4db7e329e71
    preserving b for resolve of b
    preserving rev for resolve of rev
   starting 4 threads for background file closing (?)
    b: local copied/moved from a -> m (premerge)
   picked tool '* ../merge' for b (binary False symlink False changedelete False) (glob)
   merging b and a to b
   my b@62e7bf090eba+ other a@f4db7e329e71 ancestor a@924404dff337
    rev: versions differ -> m (premerge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   merging rev
   my rev@62e7bf090eba+ other rev@f4db7e329e71 ancestor rev@924404dff337
    b: local copied/moved from a -> m (merge)
   picked tool '* ../merge' for b (binary False symlink False changedelete False) (glob)
   my b@62e7bf090eba+ other a@f4db7e329e71 ancestor a@924404dff337
   launching merge tool: * ../merge *$TESTTMP/t/t/b* * * (glob)
   merge tool returned: 0
    rev: versions differ -> m (merge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   my rev@62e7bf090eba+ other rev@f4db7e329e71 ancestor rev@924404dff337
   launching merge tool: * ../merge *$TESTTMP/t/t/rev* * * (glob)
   merge tool returned: 0
   0 files updated, 2 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M b
     a
   --------------
   
 
 m "nm a b" "um x a" "      " "22 get a, keep b"
 
   $ tm "nm a b" "up a c" "      " "23 get c, keep b"
   created new head
   --------------
   test L:nm a b R:up a c W:       - 23 get c, keep b
   --------------
     searching for copies back to rev 1
     unmatched files in local:
      b
     unmatched files in other:
      c
     all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      src: 'a' -> dst: 'b' *
     checking for directory renames
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 924404dff337, local: 02963e448370+, remote: 2b958612230f
    preserving b for resolve of b
    preserving rev for resolve of rev
    c: remote created -> g
   getting c
    b: local copied/moved from a -> m (premerge)
   picked tool '* ../merge' for b (binary False symlink False changedelete False) (glob)
   merging b and a to b
   my b@02963e448370+ other a@2b958612230f ancestor a@924404dff337
    premerge successful
    rev: versions differ -> m (premerge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   merging rev
   my rev@02963e448370+ other rev@2b958612230f ancestor rev@924404dff337
    rev: versions differ -> m (merge)
   picked tool '* ../merge' for rev (binary False symlink False changedelete False) (glob)
   my rev@02963e448370+ other rev@2b958612230f ancestor rev@924404dff337
   launching merge tool: * ../merge *$TESTTMP/t/t/rev* * * (glob)
   merge tool returned: 0
   1 files updated, 2 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   --------------
   M b
     a
   M c
   --------------
   
 
   $ cd ..
 
 
 Systematic and terse testing of merge merges and ancestor calculation:
 
 Expected result:
 
 \  a  m1  m2  dst
 0  -   f   f   f   "versions differ"
 1  f   g   g   g   "versions differ"
 2  f   f   f   f   "versions differ"
 3  f   f   g  f+g  "remote copied to " + f
 4  f   f   g   g   "remote moved to " + f
 5  f   g   f  f+g  "local copied to " + f2
 6  f   g   f   g   "local moved to " + f2
 7  -  (f)  f   f   "remote differs from untracked local"
 8  f  (f)  f   f   "remote differs from untracked local"
 
   $ hg init ancestortest
   $ cd ancestortest
   $ for x in 1 2 3 4 5 6 8; do mkdir $x; echo a > $x/f; done
   $ hg ci -Aqm "a"
   $ mkdir 0
   $ touch 0/f
   $ hg mv 1/f 1/g
   $ hg cp 5/f 5/g
   $ hg mv 6/f 6/g
   $ hg rm 8/f
   $ for x in */*; do echo m1 > $x; done
   $ hg ci -Aqm "m1"
   $ hg up -qr0
   $ mkdir 0 7
   $ touch 0/f 7/f
   $ hg mv 1/f 1/g
   $ hg cp 3/f 3/g
   $ hg mv 4/f 4/g
   $ for x in */*; do echo m2 > $x; done
   $ hg ci -Aqm "m2"
   $ hg up -qr1
   $ mkdir 7 8
   $ echo m > 7/f
   $ echo m > 8/f
   $ hg merge -f --tool internal:dump -v --debug -r2 | sed '/^resolving manifests/,$d' 2> /dev/null
     searching for copies back to rev 1
     unmatched files in local:
      5/g
      6/g
     unmatched files in other:
      3/g
      4/g
      7/f
     unmatched files new in both:
      0/f
      1/g
     all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      src: '3/f' -> dst: '3/g' *
      src: '4/f' -> dst: '4/g' *
      src: '5/f' -> dst: '5/g' *
      src: '6/f' -> dst: '6/g' *
     checking for directory renames
   $ hg mani
   0/f
   1/g
   2/f
   3/f
   4/f
   5/f
   5/g
   6/g
   $ for f in */*; do echo $f:; cat $f; done
   0/f:
   m1
   0/f.base:
   0/f.local:
   m1
   0/f.orig:
   m1
   0/f.other:
   m2
   1/g:
   m1
   1/g.base:
   a
   1/g.local:
   m1
   1/g.orig:
   m1
   1/g.other:
   m2
   2/f:
   m1
   2/f.base:
   a
   2/f.local:
   m1
   2/f.orig:
   m1
   2/f.other:
   m2
   3/f:
   m1
   3/f.base:
   a
   3/f.local:
   m1
   3/f.orig:
   m1
   3/f.other:
   m2
   3/g:
   m1
   3/g.base:
   a
   3/g.local:
   m1
   3/g.orig:
   m1
   3/g.other:
   m2
   4/g:
   m1
   4/g.base:
   a
   4/g.local:
   m1
   4/g.orig:
   m1
   4/g.other:
   m2
   5/f:
   m1
   5/f.base:
   a
   5/f.local:
   m1
   5/f.orig:
   m1
   5/f.other:
   m2
   5/g:
   m1
   5/g.base:
   a
   5/g.local:
   m1
   5/g.orig:
   m1
   5/g.other:
   m2
   6/g:
   m1
   6/g.base:
   a
   6/g.local:
   m1
   6/g.orig:
   m1
   6/g.other:
   m2
   7/f:
   m
   7/f.base:
   7/f.local:
   m
   7/f.orig:
   m
   7/f.other:
   m2
   8/f:
   m2
   $ cd ..

tests/test-sparse-merges.t

@@ -1,121 +1,121 b''
 test merging things outside of the sparse checkout
 
   $ hg init myrepo
   $ cd myrepo
   $ cat > .hg/hgrc <<EOF
   > [extensions]
   > sparse=
   > EOF
 
   $ echo foo > foo
   $ echo bar > bar
   $ hg add foo bar
   $ hg commit -m initial
 
   $ hg branch feature
   marked working directory as branch feature
   (branches are permanent and global, did you want a bookmark?)
   $ echo bar2 >> bar
   $ hg commit -m 'feature - bar2'
 
   $ hg update -q default
   $ hg debugsparse --exclude 'bar**'
 
   $ hg merge feature
   temporarily included 1 file(s) in the sparse checkout for merging
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
 Verify bar was merged temporarily
 
   $ ls
   bar
   foo
   $ hg status
   M bar
 
 Verify bar disappears automatically when the working copy becomes clean
 
   $ hg commit -m "merged"
   cleaned up 1 temporarily added file(s) from the sparse checkout
   $ hg status
   $ ls
   foo
 
   $ hg cat -r . bar
   bar
   bar2
 
 Test merging things outside of the sparse checkout that are not in the working
 copy
 
   $ hg strip -q -r . --config extensions.strip=
   $ hg up -q feature
   $ touch branchonly
   $ hg ci -Aqm 'add branchonly'
 
   $ hg up -q default
   $ hg debugsparse -X branchonly
   $ hg merge feature
   temporarily included 2 file(s) in the sparse checkout for merging
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ cd ..
 
 Tests merging a file which is modified in one branch and deleted in another and
 file is excluded from sparse checkout
 
   $ hg init ytest
   $ cd ytest
   $ echo "syntax: glob" >> .hgignore
   $ echo "*.orig" >> .hgignore
   $ hg ci -Aqm "added .hgignore"
   $ for ch in a d; do echo foo > $ch; hg ci -Aqm "added "$ch; done;
   $ cat >> .hg/hgrc <<EOF
   > [alias]
   > glog = log -GT "{rev}:{node|short} {desc}"
   > [extensions]
   > sparse =
   > EOF
 
   $ hg glog
   @  2:f29feff37cfc added d
   |
   o  1:617125d27d6b added a
   |
   o  0:53f3774ed939 added .hgignore
   
   $ hg rm d
   $ hg ci -m "removed d"
 
   $ hg up '.^'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg debugsparse --reset
   $ echo bar >> d
   $ hg ci -Am "added bar to d"
   created new head
 
   $ hg glog
   @  4:6527874a90e4 added bar to d
   |
   | o  3:372c8558de45 removed d
   |/
   o  2:f29feff37cfc added d
   |
   o  1:617125d27d6b added a
   |
   o  0:53f3774ed939 added .hgignore
   
   $ hg debugsparse --exclude "d"
   $ ls
   a
 
   $ hg merge
   temporarily included 1 file(s) in the sparse checkout for merging
-  file 'd' was deleted in local [working copy] but was modified in other [merge rev].
+  file 'd' was deleted in other [merge rev] but was modified in local [working copy].
   What do you want to do?
   use (c)hanged version, (d)elete, or leave (u)nresolved? u
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]