filemerge: default change/delete conflicts to 'leave unresolved' (BC)

It makes far more sense to leave these conflicts unresolved and kick back to
the user than to just assume that the local version be chosen. There are almost
certainly buggy scripts and applications using Mercurial in the wild that do
merges or rebases non-interactively, and then assume that if the operation
succeeded there's nothing the user needs to pay attention to.

(This wasn't possible earlier because there was no way to re-resolve
change/delete conflicts -- but now it is.)

mercurial/filemerge.py

@@ -1,686 +1,686 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 filecmp
 import os
 import re
 import tempfile
 
 from .i18n import _
 from .node import nullid, short
 
 from . import (
     cmdutil,
     error,
     match,
     simplemerge,
     tagmerge,
     templatekw,
     templater,
     util,
 )
 
 def _toolstr(ui, tool, part, default=""):
     return ui.config("merge-tools", tool + "." + part, default)
 
 def _toolbool(ui, tool, part, default=False):
     return ui.configbool("merge-tools", tool + "." + part, default)
 
 def _toollist(ui, tool, part, default=[]):
     return ui.configlist("merge-tools", tool + "." + part, default)
 
 internals = {}
 # Merge tools to document.
 internalsdoc = {}
 
 # internal tool merge types
 nomerge = None
 mergeonly = 'mergeonly'  # just the full merge, no premerge
 fullmerge = 'fullmerge'  # both premerge and merge
 
 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 internaltool(name, mergetype, onfailure=None, precheck=None):
     '''return a decorator for populating internal merge tool table'''
     def decorator(func):
         fullname = ':' + name
         func.__doc__ = "``%s``\n" % fullname + func.__doc__.strip()
         internals[fullname] = func
         internals['internal:' + name] = func
         internalsdoc[fullname] = func
         func.mergetype = mergetype
         func.onfailure = onfailure
         func.precheck = precheck
         return func
     return decorator
 
 def _findtool(ui, tool):
     if tool in internals:
         return tool
     return findexternaltool(ui, tool)
 
 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 = util.findexe(p + _toolstr(ui, tool, "regappend"))
             if p:
                 return p
     exe = _toolstr(ui, tool, "executable", tool)
     return util.findexe(util.expandpath(exe))
 
 def _picktool(repo, ui, path, binary, symlink, changedelete):
     def supportscd(tool):
         return tool in internals and internals[tool].mergetype == nomerge
 
     def check(tool, pat, symlink, binary, changedelete):
         tmsg = tool
         if pat:
             tmsg += " specified for " + 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 _toolbool(ui, tool, "symlink"):
             ui.warn(_("tool %s can't handle symlinks\n") % tmsg)
         elif binary and not _toolbool(ui, tool, "binary"):
             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 util.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, util.shellquote(toolpath))
             else:
                 # mimic HGMERGE if given tool not found
                 return (force, force)
 
     # HGMERGE takes next precedence
     hgmerge = os.environ.get("HGMERGE")
     if hgmerge:
         if changedelete and not supportscd(hgmerge):
             return ":prompt", None
         else:
             return (hgmerge, hgmerge)
 
     # then patterns
     for pat, tool in ui.configitems("merge-patterns"):
         mf = match.match(repo.root, '', [pat])
         if mf(path) and check(tool, pat, symlink, False, changedelete):
             toolpath = _findtool(ui, tool)
             return (tool, util.shellquote(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", "0"))
         if _toolbool(ui, t, "disabled", False):
             disabled.add(t)
     names = tools.keys()
     tools = sorted([(-p, t) for t, p in tools.items() if t 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 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, util.shellquote(toolpath))
 
     # internal merge or prompt as last resort
     if symlink or binary or changedelete:
         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, origfile):
     "Convert EOL markers in a file to match origfile"
     tostyle = _eoltype(util.readfile(origfile))
     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):
     """Asks the user which of the local or the other version to keep as
     the merged version."""
     ui = repo.ui
     fd = fcd.path()
 
     try:
         if fco.isabsent():
             index = ui.promptchoice(
                 _("local changed %s which remote deleted\n"
                   "use (c)hanged version, (d)elete, or leave (u)nresolved?"
-                  "$$ &Changed $$ &Delete $$ &Unresolved") % fd, 0)
+                  "$$ &Changed $$ &Delete $$ &Unresolved") % fd, 2)
             choice = ['local', 'other', 'unresolved'][index]
         elif fcd.isabsent():
             index = ui.promptchoice(
                 _("remote changed %s which local deleted\n"
                   "use (c)hanged version, leave (d)eleted, or "
                   "leave (u)nresolved?"
-                  "$$ &Changed $$ &Deleted $$ &Unresolved") % fd, 0)
+                  "$$ &Changed $$ &Deleted $$ &Unresolved") % fd, 2)
             choice = ['other', 'local', 'unresolved'][index]
         else:
             index = ui.promptchoice(
                 _("no tool found to merge %s\n"
                   "keep (l)ocal, take (o)ther, or leave (u)nresolved?"
                   "$$ &Local $$ &Other $$ &Unresolved") % fd, 2)
             choice = ['local', 'other', 'unresolved'][index]
 
         if choice == 'other':
             return _iother(repo, mynode, orig, fcd, fco, fca, toolconf)
         elif choice == 'local':
             return _ilocal(repo, mynode, orig, fcd, fco, fca, toolconf)
         elif choice == 'unresolved':
             return _ifail(repo, mynode, orig, fcd, fco, fca, toolconf)
     except error.ResponseExpected:
         ui.write("\n")
         return _ifail(repo, mynode, orig, fcd, fco, fca, toolconf)
 
 @internaltool('local', nomerge)
 def _ilocal(repo, mynode, orig, fcd, fco, fca, toolconf):
     """Uses the local version of files as the merged version."""
     return 0, fcd.isabsent()
 
 @internaltool('other', nomerge)
 def _iother(repo, mynode, orig, fcd, fco, fca, toolconf):
     """Uses the other version of files as the merged version."""
     if fco.isabsent():
         # local changed, remote deleted -- 'deleted' picked
         repo.wvfs.unlinkpath(fcd.path())
         deleted = True
     else:
         repo.wwrite(fcd.path(), fco.data(), fco.flags())
         deleted = False
     return 0, deleted
 
 @internaltool('fail', nomerge)
 def _ifail(repo, mynode, orig, fcd, fco, fca, toolconf):
     """
     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():
         repo.wwrite(fcd.path(), fco.data(), fco.flags())
     return 1, False
 
 def _premerge(repo, fcd, fco, fca, toolconf, files, labels=None):
     tool, toolpath, binary, symlink = toolconf
     if symlink or fcd.isabsent() or fco.isabsent():
         return 1
     a, b, c, 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, a, b, c, quiet=True, label=labels)
         if not r:
             ui.debug(" premerge successful\n")
             return 0
         if premerge not in validkeep:
             util.copyfile(back, a) # restore from backup and try again
     return 1 # continue merging
 
 def _mergecheck(repo, mynode, orig, fcd, fco, fca, toolconf):
     tool, toolpath, binary, symlink = 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."""
     a, b, c, back = files
 
     ui = repo.ui
 
     r = simplemerge.simplemerge(ui, a, b, c, 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 = toolconf
     a, b, c, back = files
     r = simplemerge.simplemerge(repo.ui, a, b, c, 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 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 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)
 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``."""
     a, b, c, back = files
 
     fd = fcd.path()
 
     util.copyfile(a, a + ".local")
     repo.wwrite(fd + ".other", fco.data(), fco.flags())
     repo.wwrite(fd + ".base", fca.data(), fca.flags())
     return False, 1, False
 
 def _xmerge(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels=None):
     tool, toolpath, binary, symlink = 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
     a, b, c, back = files
     out = ""
     env = {'HG_FILE': fcd.path(),
            'HG_MY_NODE': short(mynode),
            'HG_OTHER_NODE': str(fco.changectx()),
            'HG_BASE_NODE': str(fca.changectx()),
            'HG_MY_ISLINK': 'l' in fcd.flags(),
            'HG_OTHER_ISLINK': 'l' in fco.flags(),
            'HG_BASE_ISLINK': 'l' in fca.flags(),
            }
 
     ui = repo.ui
 
     args = _toolstr(ui, tool, "args", '$local $base $other')
     if "$output" in args:
         out, a = a, back # read input from backup, write to original
     replace = {'local': a, 'base': b, 'other': c, 'output': out}
     args = util.interpolate(r'\$', replace, args,
                             lambda s: util.shellquote(util.localpath(s)))
     cmd = toolpath + ' ' + args
     repo.ui.debug('launching merge tool: %s\n' % cmd)
     r = ui.system(cmd, cwd=repo.root, environ=env)
     repo.ui.debug('merge tool returned: %s\n' % r)
     return True, r, False
 
 def _formatconflictmarker(repo, 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 = templatekw.keywords.copy()
     props['templ'] = template
     props['ctx'] = ctx
     props['repo'] = repo
     templateresult = template('conflictmarker', **props)
 
     label = ('%s:' % label).ljust(pad + 1)
     mark = '%s %s' % (label, templater.stringify(templateresult))
 
     if mark:
         mark = mark.splitlines()[0] # split for safety
 
     # 8 for the prefix of conflict marker lines (e.g. '<<<<<<< ')
     return util.ellipsis(mark, 80 - 8)
 
 _defaultconflictmarker = ('{node|short} ' +
     '{ifeq(tags, "tip", "", "{tags} ")}' +
     '{if(bookmarks, "{bookmarks} ")}' +
     '{ifeq(branch, "default", "", "{branch} ")}' +
     '- {author|user}: {desc|firstline}')
 
 _defaultconflictlabels = ['local', 'other']
 
 def _formatlabels(repo, fcd, fco, fca, labels):
     """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', _defaultconflictmarker)
     tmpl = templater.templater(None, cache={'conflictmarker': template})
 
     pad = max(len(l) for l in labels)
 
     newlabels = [_formatconflictmarker(repo, cd, tmpl, labels[0], pad),
                  _formatconflictmarker(repo, co, tmpl, labels[1], pad)]
     if len(labels) > 2:
         newlabels.append(_formatconflictmarker(repo, ca, tmpl, labels[2], pad))
     return newlabels
 
 def _filemerge(premerge, repo, 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."""
 
     def temp(prefix, ctx):
         pre = "%s~%s." % (os.path.basename(ctx.path()), prefix)
         (fd, name) = tempfile.mkstemp(prefix=pre)
         data = repo.wwritedata(ctx.path(), ctx.data())
         f = os.fdopen(fd, "wb")
         f.write(data)
         f.close()
         return name
 
     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)
     if tool in internals and tool.startswith('internal:'):
         # normalize to new-style names (':merge' etc)
         tool = tool[len('internal'):]
     ui.debug("picked tool '%s' for %s (binary %s symlink %s changedelete %s)\n"
              % (tool, fd, binary, symlink, changedelete))
 
     if tool in internals:
         func = internals[tool]
         mergetype = func.mergetype
         onfailure = func.onfailure
         precheck = func.precheck
     else:
         func = _xmerge
         mergetype = fullmerge
         onfailure = _("merging %s failed!\n")
         precheck = None
 
     toolconf = tool, toolpath, binary, symlink
 
     if mergetype == nomerge:
         r, deleted = func(repo, mynode, orig, fcd, fco, fca, toolconf)
         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:
             ui.warn(onfailure % fd)
         return True, 1, False
 
     a = repo.wjoin(fd)
     b = temp("base", fca)
     c = temp("other", fco)
     if not fcd.isabsent():
         back = cmdutil.origpath(ui, repo, a)
         if premerge:
             util.copyfile(a, back)
     else:
         back = None
     files = (a, b, c, back)
 
     r = 1
     try:
         markerstyle = ui.config('ui', 'mergemarkers', 'basic')
         if not labels:
             labels = _defaultconflictlabels
         if markerstyle != 'basic':
             labels = _formatlabels(repo, fcd, fco, fca, labels)
 
         if premerge and mergetype == fullmerge:
             r = _premerge(repo, fcd, fco, fca, toolconf, files, labels=labels)
             # 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=labels)
 
         if needcheck:
             r = _check(r, ui, tool, fcd, files)
 
         if r:
             if onfailure:
                 ui.warn(onfailure % fd)
 
         return True, r, deleted
     finally:
         if not r and back is not None:
             util.unlink(back)
         util.unlink(b)
         util.unlink(c)
 
 def _check(r, ui, tool, fcd, files):
     fd = fcd.path()
     a, b, c, back = files
 
     if not r and (_toolbool(ui, tool, "checkconflicts") or
                   'conflicts' in _toollist(ui, tool, "check")):
         if re.search("^(<<<<<<< .*|=======|>>>>>>> .*)$", fcd.data(),
                      re.MULTILINE):
             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 filecmp.cmp(a, 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(a, back)
 
     return r
 
 def premerge(repo, mynode, orig, fcd, fco, fca, labels=None):
     return _filemerge(True, repo, mynode, orig, fcd, fco, fca, labels=labels)
 
 def filemerge(repo, mynode, orig, fcd, fco, fca, labels=None):
     return _filemerge(False, repo, mynode, orig, fcd, fco, fca, labels=labels)
 
 # tell hggettext to extract docstrings from these functions:
 i18nfunctions = internals.values()

tests/test-merge-changedelete.t

@@ -1,988 +1,992 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
   local changed file1 which remote deleted
-  use (c)hanged version, (d)elete, or leave (u)nresolved? c
+  use (c)hanged version, (d)elete, or leave (u)nresolved? u
   remote changed file2 which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  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, 2 files merged, 0 files removed, 1 files unresolved
+  0 files updated, 0 files merged, 0 files removed, 3 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg update -C .' to abandon
   [1]
 
   $ status
   --- status ---
   M file2
   M file3
   C file1
   --- resolve --list ---
-  R file1
-  R file2
+  U file1
+  U file2
   U file3
   --- debugmergestate ---
   * version 2 records
   local: 13910f48cf7bdb2a0ba6e24b4900e4fdd5739dd4
   other: 10f9a0a634e82080907e62f075ab119cbc565ea6
-  file: file1 (record type "C", state "r", hash 60b27f004e454aca81b0480209cce5081ec52390)
+  file: file1 (record type "C", state "u", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node b8e02f6433738021a065f94175c7cd23db5f05be)
     other path: file1 (node null)
-  file: file2 (record type "C", state "r", hash null)
+  file: file2 (record type "C", state "u", hash null)
     local path: file2 (flags "")
     ancestor path: file2 (node 5d9299349fc01ddd25d0070d149b124d8f10411e)
     other path: file2 (node e7c1328648519852e723de86c0c0525acd779257)
   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
   <<<<<<< local: 13910f48cf7b - test: changed file1, removed file2, changed file3
   changed2
   =======
   changed1
   >>>>>>> other: 10f9a0a634e8  - test: removed file1, changed file2, changed file3
 
 
 Interactive merge:
 
   $ hg co -C
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
   $ hg merge --config ui.interactive=true <<EOF
   > c
   > d
   > EOF
   local changed file1 which remote deleted
   use (c)hanged version, (d)elete, or leave (u)nresolved? c
   remote changed file2 which local deleted
   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 update -C .' 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
   file: file1 (record type "C", state "r", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node b8e02f6433738021a065f94175c7cd23db5f05be)
     other path: file1 (node null)
   file: file2 (record type "C", state "r", hash null)
     local path: file2 (flags "")
     ancestor path: file2 (node 5d9299349fc01ddd25d0070d149b124d8f10411e)
     other path: file2 (node e7c1328648519852e723de86c0c0525acd779257)
   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
   <<<<<<< local: 13910f48cf7b - test: changed file1, removed file2, changed file3
   changed2
   =======
   changed1
   >>>>>>> other: 10f9a0a634e8  - test: removed file1, changed file2, changed file3
 
 
 Interactive merge with bad input:
 
   $ hg co -C
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg merge --config ui.interactive=true <<EOF
   > foo
   > bar
   > d
   > baz
   > c
   > EOF
   local changed file1 which remote deleted
   use (c)hanged version, (d)elete, or leave (u)nresolved? foo
   unrecognized response
   local changed file1 which remote deleted
   use (c)hanged version, (d)elete, or leave (u)nresolved? bar
   unrecognized response
   local changed file1 which remote deleted
   use (c)hanged version, (d)elete, or leave (u)nresolved? d
   remote changed file2 which local deleted
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? baz
   unrecognized response
   remote changed file2 which local deleted
   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 update -C .' 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
   file: file1 (record type "C", state "r", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node b8e02f6433738021a065f94175c7cd23db5f05be)
     other path: file1 (node null)
   file: file2 (record type "C", state "r", hash null)
     local path: file2 (flags "")
     ancestor path: file2 (node 5d9299349fc01ddd25d0070d149b124d8f10411e)
     other path: file2 (node e7c1328648519852e723de86c0c0525acd779257)
   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
   <<<<<<< local: 13910f48cf7b - test: changed file1, removed file2, changed file3
   changed2
   =======
   changed1
   >>>>>>> other: 10f9a0a634e8  - test: removed file1, changed file2, changed file3
 
 
 Interactive merge with not enough input:
 
   $ hg co -C
   2 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
   $ hg merge --config ui.interactive=true <<EOF
   > d
   > EOF
   local changed file1 which remote deleted
   use (c)hanged version, (d)elete, or leave (u)nresolved? d
   remote changed file2 which local deleted
   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 update -C .' 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
   file: file1 (record type "C", state "r", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node b8e02f6433738021a065f94175c7cd23db5f05be)
     other path: file1 (node null)
   file: file2 (record type "C", state "u", hash null)
     local path: file2 (flags "")
     ancestor path: file2 (node 5d9299349fc01ddd25d0070d149b124d8f10411e)
     other path: file2 (node e7c1328648519852e723de86c0c0525acd779257)
   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
   <<<<<<< local: 13910f48cf7b - test: changed file1, removed file2, changed file3
   changed2
   =======
   changed1
   >>>>>>> other: 10f9a0a634e8  - test: removed file1, changed file2, changed file3
 
 Choose local versions of files
 
   $ hg co -C
   2 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
   $ 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
   file: file1 (record type "C", state "r", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node b8e02f6433738021a065f94175c7cd23db5f05be)
     other path: file1 (node null)
   file: file2 (record type "C", state "r", hash null)
     local path: file2 (flags "")
     ancestor path: file2 (node 5d9299349fc01ddd25d0070d149b124d8f10411e)
     other path: file2 (node e7c1328648519852e723de86c0c0525acd779257)
   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
 
   $ 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
   file: file1 (record type "C", state "r", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node b8e02f6433738021a065f94175c7cd23db5f05be)
     other path: file1 (node null)
   file: file2 (record type "C", state "r", hash null)
     local path: file2 (flags "")
     ancestor path: file2 (node 5d9299349fc01ddd25d0070d149b124d8f10411e)
     other path: file2 (node e7c1328648519852e723de86c0c0525acd779257)
   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
 
   $ 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 update -C .' 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
   file: file1 (record type "C", state "u", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node b8e02f6433738021a065f94175c7cd23db5f05be)
     other path: file1 (node null)
   file: file2 (record type "C", state "u", hash null)
     local path: file2 (flags "")
     ancestor path: file2 (node 5d9299349fc01ddd25d0070d149b124d8f10411e)
     other path: file2 (node e7c1328648519852e723de86c0c0525acd779257)
   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
 
   $ hg merge --config ui.interactive=True --tool :prompt
   local changed file1 which remote deleted
   use (c)hanged version, (d)elete, or leave (u)nresolved? 
   remote changed file2 which local deleted
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? 
   no tool found to merge file3
   keep (l)ocal, take (o)ther, or leave (u)nresolved? 
   0 files updated, 0 files merged, 0 files removed, 3 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg update -C .' 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
   file: file1 (record type "C", state "u", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node b8e02f6433738021a065f94175c7cd23db5f05be)
     other path: file1 (node null)
   file: file2 (record type "C", state "u", hash null)
     local path: file2 (flags "")
     ancestor path: file2 (node 5d9299349fc01ddd25d0070d149b124d8f10411e)
     other path: file2 (node e7c1328648519852e723de86c0c0525acd779257)
   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
 
   $ hg merge --tool :prompt
   local changed file1 which remote deleted
-  use (c)hanged version, (d)elete, or leave (u)nresolved? c
+  use (c)hanged version, (d)elete, or leave (u)nresolved? u
   remote changed file2 which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   no tool found to merge file3
   keep (l)ocal, take (o)ther, or leave (u)nresolved? u
-  0 files updated, 2 files merged, 0 files removed, 1 files unresolved
+  0 files updated, 0 files merged, 0 files removed, 3 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg update -C .' to abandon
   [1]
   $ status
   --- status ---
   M file2
   M file3
   C file1
   --- resolve --list ---
-  R file1
-  R file2
+  U file1
+  U file2
   U file3
   --- debugmergestate ---
   * version 2 records
   local: 13910f48cf7bdb2a0ba6e24b4900e4fdd5739dd4
   other: 10f9a0a634e82080907e62f075ab119cbc565ea6
-  file: file1 (record type "C", state "r", hash 60b27f004e454aca81b0480209cce5081ec52390)
+  file: file1 (record type "C", state "u", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node b8e02f6433738021a065f94175c7cd23db5f05be)
     other path: file1 (node null)
-  file: file2 (record type "C", state "r", hash null)
+  file: file2 (record type "C", state "u", hash null)
     local path: file2 (flags "")
     ancestor path: file2 (node 5d9299349fc01ddd25d0070d149b124d8f10411e)
     other path: file2 (node e7c1328648519852e723de86c0c0525acd779257)
   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
 
   $ hg merge --tool :merge3
   local changed file1 which remote deleted
-  use (c)hanged version, (d)elete, or leave (u)nresolved? c
+  use (c)hanged version, (d)elete, or leave (u)nresolved? u
   remote changed file2 which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  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, 2 files merged, 0 files removed, 1 files unresolved
+  0 files updated, 0 files merged, 0 files removed, 3 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg update -C .' to abandon
   [1]
   $ status
   --- status ---
   M file2
   M file3
   C file1
   --- resolve --list ---
-  R file1
-  R file2
+  U file1
+  U file2
   U file3
   --- debugmergestate ---
   * version 2 records
   local: 13910f48cf7bdb2a0ba6e24b4900e4fdd5739dd4
   other: 10f9a0a634e82080907e62f075ab119cbc565ea6
-  file: file1 (record type "C", state "r", hash 60b27f004e454aca81b0480209cce5081ec52390)
+  file: file1 (record type "C", state "u", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node b8e02f6433738021a065f94175c7cd23db5f05be)
     other path: file1 (node null)
-  file: file2 (record type "C", state "r", hash null)
+  file: file2 (record type "C", state "u", hash null)
     local path: file2 (flags "")
     ancestor path: file2 (node 5d9299349fc01ddd25d0070d149b124d8f10411e)
     other path: file2 (node e7c1328648519852e723de86c0c0525acd779257)
   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
   <<<<<<< local: 13910f48cf7b - test: changed file1, removed file2, changed file3
   changed2
   ||||||| base
   =======
   changed1
   >>>>>>> other: 10f9a0a634e8  - test: removed file1, changed file2, changed file3
 
 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 ===
   local changed file1 which remote deleted
   use (c)hanged version, (d)elete, or leave (u)nresolved? 
   remote changed file2 which local deleted
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? 
   no tool found to merge file3
   keep (l)ocal, take (o)ther, 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 ===
   local changed file1 which remote deleted
   use (c)hanged version, (d)elete, or leave (u)nresolved? 
   remote changed file2 which local deleted
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? 
   no tool found to merge file3
   keep (l)ocal, take (o)ther, 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 ===
   local changed file1 which remote deleted
   use (c)hanged version, (d)elete, or leave (u)nresolved? 
   remote changed file2 which local deleted
   use (c)hanged version, leave (d)eleted, or leave (u)nresolved? 
   no tool found to merge file3
   keep (l)ocal, take (o)ther, 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)
   
 
 
 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
   local changed file1 which remote deleted
-  use (c)hanged version, (d)elete, or leave (u)nresolved? c
+  use (c)hanged version, (d)elete, or leave (u)nresolved? u
   remote changed file2 which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
-  1 files updated, 2 files merged, 0 files removed, 0 files unresolved
+  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 ---
-  R file1
-  R file2
+  U file1
+  U file2
   --- debugmergestate ---
   * version 2 records
   local: ab57bf49aa276a22d35a473592d4c34b5abc3eff
   other: 10f9a0a634e82080907e62f075ab119cbc565ea6
-  file: file1 (record type "C", state "r", hash 60b27f004e454aca81b0480209cce5081ec52390)
+  file: file1 (record type "C", state "u", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node b8e02f6433738021a065f94175c7cd23db5f05be)
     other path: file1 (node null)
-  file: file2 (record type "C", state "r", hash null)
+  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
   file: file1 (record type "C", state "r", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node b8e02f6433738021a065f94175c7cd23db5f05be)
     other path: file1 (node null)
   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
   file: file1 (record type "C", state "r", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node b8e02f6433738021a065f94175c7cd23db5f05be)
     other path: file1 (node null)
   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
   file: file1 (record type "C", state "u", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node b8e02f6433738021a065f94175c7cd23db5f05be)
     other path: file1 (node null)
   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
   local changed file1 which remote deleted
   use (c)hanged version, (d)elete, or leave (u)nresolved? 
   remote changed file2 which local deleted
   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
   file: file1 (record type "C", state "u", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node b8e02f6433738021a065f94175c7cd23db5f05be)
     other path: file1 (node null)
   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
   local changed file1 which remote deleted
-  use (c)hanged version, (d)elete, or leave (u)nresolved? c
+  use (c)hanged version, (d)elete, or leave (u)nresolved? u
   remote changed file2 which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
-  1 files updated, 2 files merged, 0 files removed, 0 files unresolved
+  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 ---
-  R file1
-  R file2
+  U file1
+  U file2
   --- debugmergestate ---
   * version 2 records
   local: ab57bf49aa276a22d35a473592d4c34b5abc3eff
   other: 10f9a0a634e82080907e62f075ab119cbc565ea6
-  file: file1 (record type "C", state "r", hash 60b27f004e454aca81b0480209cce5081ec52390)
+  file: file1 (record type "C", state "u", hash 60b27f004e454aca81b0480209cce5081ec52390)
     local path: file1 (flags "")
     ancestor path: file1 (node b8e02f6433738021a065f94175c7cd23db5f05be)
     other path: file1 (node null)
-  file: file2 (record type "C", state "r", hash null)
+  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 ===
   local changed file1 which remote deleted
   use (c)hanged version, (d)elete, or leave (u)nresolved? 
   remote changed file2 which local deleted
   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 ===
   local changed file1 which remote deleted
   use (c)hanged version, (d)elete, or leave (u)nresolved? 
   remote changed file2 which local deleted
   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 ===
   local changed file1 which remote deleted
   use (c)hanged version, (d)elete, or leave (u)nresolved? 
   remote changed file2 which local deleted
   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,782 +1,782 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")'
   local changed content1_missing_content1_content4-tracked which remote deleted
-  use (c)hanged version, (d)elete, or leave (u)nresolved? c
+  use (c)hanged version, (d)elete, or leave (u)nresolved? u
   local changed content1_missing_content3_content3-tracked which remote deleted
-  use (c)hanged version, (d)elete, or leave (u)nresolved? c
+  use (c)hanged version, (d)elete, or leave (u)nresolved? u
   local changed content1_missing_content3_content4-tracked which remote deleted
-  use (c)hanged version, (d)elete, or leave (u)nresolved? c
+  use (c)hanged version, (d)elete, or leave (u)nresolved? u
   local changed content1_missing_missing_content4-tracked which remote deleted
-  use (c)hanged version, (d)elete, or leave (u)nresolved? c
+  use (c)hanged version, (d)elete, or leave (u)nresolved? u
   remote changed content1_content2_content1_content1-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   remote changed content1_content2_content1_content2-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   remote changed content1_content2_content1_content4-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   remote changed content1_content2_content1_missing-tracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   remote changed content1_content2_content1_missing-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   remote changed content1_content2_content2_content1-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   remote changed content1_content2_content2_content2-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   remote changed content1_content2_content2_content4-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   remote changed content1_content2_content2_missing-tracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   remote changed content1_content2_content2_missing-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   remote changed content1_content2_content3_content1-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   remote changed content1_content2_content3_content2-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   remote changed content1_content2_content3_content3-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   remote changed content1_content2_content3_content4-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   remote changed content1_content2_content3_missing-tracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   remote changed content1_content2_content3_missing-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   remote changed content1_content2_missing_content1-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   remote changed content1_content2_missing_content2-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   remote changed content1_content2_missing_content4-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   remote changed content1_content2_missing_missing-tracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   remote changed content1_content2_missing_missing-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  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, 28 files merged, 8 files removed, 10 files unresolved
+  18 files updated, 3 files merged, 8 files removed, 35 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg update -C .' to abandon
   [1]
 
 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
-  R content1_content2_content1_content1-untracked
-  R content1_content2_content1_content2-untracked
+  U content1_content2_content1_content1-untracked
+  U content1_content2_content1_content2-untracked
   U content1_content2_content1_content4-tracked
-  R content1_content2_content1_content4-untracked
-  R content1_content2_content1_missing-tracked
-  R content1_content2_content1_missing-untracked
+  U content1_content2_content1_content4-untracked
+  U content1_content2_content1_missing-tracked
+  U content1_content2_content1_missing-untracked
   R content1_content2_content2_content1-tracked
-  R content1_content2_content2_content1-untracked
-  R content1_content2_content2_content2-untracked
+  U content1_content2_content2_content1-untracked
+  U content1_content2_content2_content2-untracked
   U content1_content2_content2_content4-tracked
-  R content1_content2_content2_content4-untracked
-  R content1_content2_content2_missing-tracked
-  R content1_content2_content2_missing-untracked
+  U content1_content2_content2_content4-untracked
+  U content1_content2_content2_missing-tracked
+  U content1_content2_content2_missing-untracked
   R content1_content2_content3_content1-tracked
-  R content1_content2_content3_content1-untracked
-  R content1_content2_content3_content2-untracked
+  U content1_content2_content3_content1-untracked
+  U content1_content2_content3_content2-untracked
   U content1_content2_content3_content3-tracked
-  R content1_content2_content3_content3-untracked
+  U content1_content2_content3_content3-untracked
   U content1_content2_content3_content4-tracked
-  R content1_content2_content3_content4-untracked
-  R content1_content2_content3_missing-tracked
-  R content1_content2_content3_missing-untracked
+  U content1_content2_content3_content4-untracked
+  U content1_content2_content3_missing-tracked
+  U content1_content2_content3_missing-untracked
   R content1_content2_missing_content1-tracked
-  R content1_content2_missing_content1-untracked
-  R content1_content2_missing_content2-untracked
+  U content1_content2_missing_content1-untracked
+  U content1_content2_missing_content2-untracked
   U content1_content2_missing_content4-tracked
-  R content1_content2_missing_content4-untracked
-  R content1_content2_missing_missing-tracked
-  R content1_content2_missing_missing-untracked
-  R content1_missing_content1_content4-tracked
-  R content1_missing_content3_content3-tracked
-  R content1_missing_content3_content4-tracked
-  R content1_missing_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
   <<<<<<< local: 0447570f1af6 - test: local
   content4
   ||||||| base
   content1
   =======
   content2
   >>>>>>> other: 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
   <<<<<<< local: 0447570f1af6 - test: local
   content4
   ||||||| base
   content1
   =======
   content2
   >>>>>>> other: 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
   <<<<<<< local: 0447570f1af6 - test: local
   content3
   ||||||| base
   content1
   =======
   content2
   >>>>>>> other: 85100b8c675b  - test: remote
   
   M content1_content2_content3_content3-untracked
   content2
   
   M content1_content2_content3_content4-tracked
   <<<<<<< local: 0447570f1af6 - test: local
   content4
   ||||||| base
   content1
   =======
   content2
   >>>>>>> other: 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
   <<<<<<< local: 0447570f1af6 - test: local
   content4
   ||||||| base
   content1
   =======
   content2
   >>>>>>> other: 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
   <<<<<<< local: 0447570f1af6 - test: local
   content4
   ||||||| base
   =======
   content2
   >>>>>>> other: 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
   <<<<<<< local: 0447570f1af6 - test: local
   content3
   ||||||| base
   =======
   content2
   >>>>>>> other: 85100b8c675b  - test: remote
   
   M missing_content2_content3_content3-untracked
   content2
   
   M missing_content2_content3_content4-tracked
   <<<<<<< local: 0447570f1af6 - test: local
   content4
   ||||||| base
   =======
   content2
   >>>>>>> other: 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
   <<<<<<< local: 0447570f1af6 - test: local
   content4
   ||||||| base
   =======
   content2
   >>>>>>> other: 85100b8c675b  - test: remote
   
   M missing_content2_missing_content4-untracked
   <<<<<<< local: 0447570f1af6 - test: local
   content4
   ||||||| base
   =======
   content2
   >>>>>>> other: 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
   remote changed content1_content2_content1_content1-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   remote changed content1_content2_content1_content2-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   merging content1_content2_content1_content4-tracked
   remote changed content1_content2_content1_content4-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   remote changed content1_content2_content1_missing-tracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   remote changed content1_content2_content1_missing-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   merging content1_content2_content2_content1-tracked
   remote changed content1_content2_content2_content1-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   remote changed content1_content2_content2_content2-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   merging content1_content2_content2_content4-tracked
   remote changed content1_content2_content2_content4-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   remote changed content1_content2_content2_missing-tracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   remote changed content1_content2_content2_missing-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   merging content1_content2_content3_content1-tracked
   remote changed content1_content2_content3_content1-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   remote changed content1_content2_content3_content2-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   merging content1_content2_content3_content3-tracked
   remote changed content1_content2_content3_content3-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   merging content1_content2_content3_content4-tracked
   remote changed content1_content2_content3_content4-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   remote changed content1_content2_content3_missing-tracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   remote changed content1_content2_content3_missing-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   merging content1_content2_missing_content1-tracked
   remote changed content1_content2_missing_content1-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   remote changed content1_content2_missing_content2-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   merging content1_content2_missing_content4-tracked
   remote changed content1_content2_missing_content4-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   remote changed content1_content2_missing_missing-tracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   remote changed content1_content2_missing_missing-untracked which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   local changed content1_missing_content1_content4-tracked which remote deleted
-  use (c)hanged version, (d)elete, or leave (u)nresolved? c
+  use (c)hanged version, (d)elete, or leave (u)nresolved? u
   local changed content1_missing_content3_content3-tracked which remote deleted
-  use (c)hanged version, (d)elete, or leave (u)nresolved? c
+  use (c)hanged version, (d)elete, or leave (u)nresolved? u
   local changed content1_missing_content3_content4-tracked which remote deleted
-  use (c)hanged version, (d)elete, or leave (u)nresolved? c
+  use (c)hanged version, (d)elete, or leave (u)nresolved? u
   local changed content1_missing_missing_content4-tracked which remote deleted
-  use (c)hanged version, (d)elete, or leave (u)nresolved? c
+  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

tests/test-merge-remove.t

@@ -1,114 +1,115 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
   remote changed bar which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
   merging foo1 and foo to foo1
-  0 files updated, 2 files merged, 0 files removed, 0 files unresolved
-  (branch merge, don't forget to commit)
+  0 files updated, 1 files merged, 0 files removed, 1 files unresolved
+  use 'hg resolve' to retry unresolved file merges or 'hg update -C .' to abandon
+  [1]
   $ cat bar
   bleh
   $ hg st
   M bar
   M foo1

tests/test-rename-merge2.t

@@ -1,1055 +1,1057 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
    a: remote unchanged -> k
    b: remote copied from a -> m (premerge)
   picked tool 'python ../merge' for b (binary False symlink False changedelete False)
   merging a and b to b
   my b@e300d1c794ec+ other b@4ce40f5aca24 ancestor a@924404dff337
    premerge successful
    rev: versions differ -> m (premerge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   merging rev
   my rev@e300d1c794ec+ other rev@4ce40f5aca24 ancestor rev@924404dff337
    rev: versions differ -> m (merge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   my rev@e300d1c794ec+ other rev@4ce40f5aca24 ancestor rev@924404dff337
   launching merge tool: python ../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 'python ../merge' for b (binary False symlink False changedelete False)
   merging b and a to b
   my b@86a2aa42fc76+ other a@f4db7e329e71 ancestor a@924404dff337
    premerge successful
    rev: versions differ -> m (premerge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   merging rev
   my rev@86a2aa42fc76+ other rev@f4db7e329e71 ancestor rev@924404dff337
    rev: versions differ -> m (merge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   my rev@86a2aa42fc76+ other rev@f4db7e329e71 ancestor rev@924404dff337
   launching merge tool: python ../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
    b: remote moved from a -> m (premerge)
   picked tool 'python ../merge' for b (binary False symlink False changedelete False)
   merging a and b to b
   my b@e300d1c794ec+ other b@bdb19105162a ancestor a@924404dff337
    premerge successful
    rev: versions differ -> m (premerge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   merging rev
   my rev@e300d1c794ec+ other rev@bdb19105162a ancestor rev@924404dff337
    rev: versions differ -> m (merge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   my rev@e300d1c794ec+ other rev@bdb19105162a ancestor rev@924404dff337
   launching merge tool: python ../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
    b: local copied/moved from a -> m (premerge)
   picked tool 'python ../merge' for b (binary False symlink False changedelete False)
   merging b and a to b
   my b@02963e448370+ other a@f4db7e329e71 ancestor a@924404dff337
    premerge successful
    rev: versions differ -> m (premerge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   merging rev
   my rev@02963e448370+ other rev@f4db7e329e71 ancestor rev@924404dff337
    rev: versions differ -> m (merge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   my rev@02963e448370+ other rev@f4db7e329e71 ancestor rev@924404dff337
   launching merge tool: python ../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 'python ../merge' for rev (binary False symlink False changedelete False)
   merging rev
   my rev@94b33a1b7f2d+ other rev@4ce40f5aca24 ancestor rev@924404dff337
    rev: versions differ -> m (merge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   my rev@94b33a1b7f2d+ other rev@4ce40f5aca24 ancestor rev@924404dff337
   launching merge tool: python ../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
    rev: versions differ -> m (premerge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   merging rev
   my rev@86a2aa42fc76+ other rev@97c705ade336 ancestor rev@924404dff337
    rev: versions differ -> m (merge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   my rev@86a2aa42fc76+ other rev@97c705ade336 ancestor rev@924404dff337
   launching merge tool: python ../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 'python ../merge' for rev (binary False symlink False changedelete False)
   merging rev
   my rev@94b33a1b7f2d+ other rev@bdb19105162a ancestor rev@924404dff337
    rev: versions differ -> m (merge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   my rev@94b33a1b7f2d+ other rev@bdb19105162a ancestor rev@924404dff337
   launching merge tool: python ../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
    rev: versions differ -> m (premerge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   merging rev
   my rev@02963e448370+ other rev@97c705ade336 ancestor rev@924404dff337
    rev: versions differ -> m (merge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   my rev@02963e448370+ other rev@97c705ade336 ancestor rev@924404dff337
   launching merge tool: python ../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
    b: both renamed from a -> m (premerge)
   picked tool 'python ../merge' for b (binary False symlink False changedelete False)
   merging b
   my b@62e7bf090eba+ other b@49b6d8032493 ancestor a@924404dff337
    rev: versions differ -> m (premerge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   merging rev
   my rev@62e7bf090eba+ other rev@49b6d8032493 ancestor rev@924404dff337
    b: both renamed from a -> m (merge)
   picked tool 'python ../merge' for b (binary False symlink False changedelete False)
   my b@62e7bf090eba+ other b@49b6d8032493 ancestor a@924404dff337
   launching merge tool: python ../merge *$TESTTMP/t/t/b* * * (glob)
   merge tool returned: 0
    rev: versions differ -> m (merge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   my rev@62e7bf090eba+ other rev@49b6d8032493 ancestor rev@924404dff337
   launching merge tool: python ../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 'python ../merge' for rev (binary False symlink False changedelete False)
   merging rev
   my rev@02963e448370+ other rev@fe905ef2c33e ancestor rev@924404dff337
    rev: versions differ -> m (merge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   my rev@02963e448370+ other rev@fe905ef2c33e ancestor rev@924404dff337
   launching merge tool: python ../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
    b: both created -> m (premerge)
   picked tool 'python ../merge' for b (binary False symlink False changedelete False)
   merging b
   my b@86a2aa42fc76+ other b@af30c7647fc7 ancestor b@000000000000
    rev: versions differ -> m (premerge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   merging rev
   my rev@86a2aa42fc76+ other rev@af30c7647fc7 ancestor rev@924404dff337
    b: both created -> m (merge)
   picked tool 'python ../merge' for b (binary False symlink False changedelete False)
   my b@86a2aa42fc76+ other b@af30c7647fc7 ancestor b@000000000000
   launching merge tool: python ../merge *$TESTTMP/t/t/b* * * (glob)
   merge tool returned: 0
    rev: versions differ -> m (merge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   my rev@86a2aa42fc76+ other rev@af30c7647fc7 ancestor rev@924404dff337
   launching merge tool: python ../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
    b: both created -> m (premerge)
   picked tool 'python ../merge' for b (binary False symlink False changedelete False)
   merging b
   my b@59318016310c+ other b@bdb19105162a ancestor b@000000000000
    rev: versions differ -> m (premerge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   merging rev
   my rev@59318016310c+ other rev@bdb19105162a ancestor rev@924404dff337
    b: both created -> m (merge)
   picked tool 'python ../merge' for b (binary False symlink False changedelete False)
   my b@59318016310c+ other b@bdb19105162a ancestor b@000000000000
   launching merge tool: python ../merge *$TESTTMP/t/t/b* * * (glob)
   merge tool returned: 0
    rev: versions differ -> m (merge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   my rev@59318016310c+ other rev@bdb19105162a ancestor rev@924404dff337
   launching merge tool: python ../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 'python ../merge' for b (binary False symlink False changedelete False)
   merging b
   my b@86a2aa42fc76+ other b@8dbce441892a ancestor b@000000000000
    rev: versions differ -> m (premerge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   merging rev
   my rev@86a2aa42fc76+ other rev@8dbce441892a ancestor rev@924404dff337
    b: both created -> m (merge)
   picked tool 'python ../merge' for b (binary False symlink False changedelete False)
   my b@86a2aa42fc76+ other b@8dbce441892a ancestor b@000000000000
   launching merge tool: python ../merge *$TESTTMP/t/t/b* * * (glob)
   merge tool returned: 0
    rev: versions differ -> m (merge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   my rev@86a2aa42fc76+ other rev@8dbce441892a ancestor rev@924404dff337
   launching merge tool: python ../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
    b: both created -> m (premerge)
   picked tool 'python ../merge' for b (binary False symlink False changedelete False)
   merging b
   my b@59318016310c+ other b@bdb19105162a ancestor b@000000000000
    rev: versions differ -> m (premerge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   merging rev
   my rev@59318016310c+ other rev@bdb19105162a ancestor rev@924404dff337
    b: both created -> m (merge)
   picked tool 'python ../merge' for b (binary False symlink False changedelete False)
   my b@59318016310c+ other b@bdb19105162a ancestor b@000000000000
   launching merge tool: python ../merge *$TESTTMP/t/t/b* * * (glob)
   merge tool returned: 0
    rev: versions differ -> m (merge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   my rev@59318016310c+ other rev@bdb19105162a ancestor rev@924404dff337
   launching merge tool: python ../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 'python ../merge' for b (binary False symlink False changedelete False)
   merging b
   my b@86a2aa42fc76+ other b@8dbce441892a ancestor b@000000000000
    rev: versions differ -> m (premerge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   merging rev
   my rev@86a2aa42fc76+ other rev@8dbce441892a ancestor rev@924404dff337
    b: both created -> m (merge)
   picked tool 'python ../merge' for b (binary False symlink False changedelete False)
   my b@86a2aa42fc76+ other b@8dbce441892a ancestor b@000000000000
   launching merge tool: python ../merge *$TESTTMP/t/t/b* * * (glob)
   merge tool returned: 0
    rev: versions differ -> m (merge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   my rev@86a2aa42fc76+ other rev@8dbce441892a ancestor rev@924404dff337
   launching merge tool: python ../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
    a: remote unchanged -> k
    b: both created -> m (premerge)
   picked tool 'python ../merge' for b (binary False symlink False changedelete False)
   merging b
   my b@0b76e65c8289+ other b@4ce40f5aca24 ancestor b@000000000000
    rev: versions differ -> m (premerge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   merging rev
   my rev@0b76e65c8289+ other rev@4ce40f5aca24 ancestor rev@924404dff337
    b: both created -> m (merge)
   picked tool 'python ../merge' for b (binary False symlink False changedelete False)
   my b@0b76e65c8289+ other b@4ce40f5aca24 ancestor b@000000000000
   launching merge tool: python ../merge *$TESTTMP/t/t/b* * * (glob)
   merge tool returned: 0
    rev: versions differ -> m (merge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   my rev@0b76e65c8289+ other rev@4ce40f5aca24 ancestor rev@924404dff337
   launching merge tool: python ../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
    a: prompt deleted/changed -> m (premerge)
   picked tool ':prompt' for a (binary False symlink False changedelete True)
   remote changed a which local deleted
-  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? c
+  use (c)hanged version, leave (d)eleted, or leave (u)nresolved? u
    b: both created -> m (premerge)
   picked tool 'python ../merge' for b (binary False symlink False changedelete False)
   merging b
   my b@02963e448370+ other b@8dbce441892a ancestor b@000000000000
    rev: versions differ -> m (premerge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   merging rev
   my rev@02963e448370+ other rev@8dbce441892a ancestor rev@924404dff337
    b: both created -> m (merge)
   picked tool 'python ../merge' for b (binary False symlink False changedelete False)
   my b@02963e448370+ other b@8dbce441892a ancestor b@000000000000
   launching merge tool: python ../merge *$TESTTMP/t/t/b* * * (glob)
   merge tool returned: 0
    rev: versions differ -> m (merge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   my rev@02963e448370+ other rev@8dbce441892a ancestor rev@924404dff337
   launching merge tool: python ../merge *$TESTTMP/t/t/rev* * * (glob)
   merge tool returned: 0
-  0 files updated, 3 files merged, 0 files removed, 0 files unresolved
-  (branch merge, don't forget to commit)
+  0 files updated, 2 files merged, 0 files removed, 1 files unresolved
+  use 'hg resolve' to retry unresolved file merges or 'hg update -C .' 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
    a: prompt changed/deleted -> m (premerge)
   picked tool ':prompt' for a (binary False symlink False changedelete True)
   local changed a which remote deleted
-  use (c)hanged version, (d)elete, or leave (u)nresolved? c
+  use (c)hanged version, (d)elete, or leave (u)nresolved? u
    b: both created -> m (premerge)
   picked tool 'python ../merge' for b (binary False symlink False changedelete False)
   merging b
   my b@0b76e65c8289+ other b@bdb19105162a ancestor b@000000000000
    rev: versions differ -> m (premerge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   merging rev
   my rev@0b76e65c8289+ other rev@bdb19105162a ancestor rev@924404dff337
    b: both created -> m (merge)
   picked tool 'python ../merge' for b (binary False symlink False changedelete False)
   my b@0b76e65c8289+ other b@bdb19105162a ancestor b@000000000000
   launching merge tool: python ../merge *$TESTTMP/t/t/b* * * (glob)
   merge tool returned: 0
    rev: versions differ -> m (merge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   my rev@0b76e65c8289+ other rev@bdb19105162a ancestor rev@924404dff337
   launching merge tool: python ../merge *$TESTTMP/t/t/rev* * * (glob)
   merge tool returned: 0
-  0 files updated, 3 files merged, 0 files removed, 0 files unresolved
-  (branch merge, don't forget to commit)
+  0 files updated, 2 files merged, 0 files removed, 1 files unresolved
+  use 'hg resolve' to retry unresolved file merges or 'hg update -C .' 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
    b: remote moved from a -> m (premerge)
   picked tool 'python ../merge' for b (binary False symlink False changedelete False)
   merging a and b to b
   my b@e300d1c794ec+ other b@49b6d8032493 ancestor a@924404dff337
    rev: versions differ -> m (premerge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   merging rev
   my rev@e300d1c794ec+ other rev@49b6d8032493 ancestor rev@924404dff337
    b: remote moved from a -> m (merge)
   picked tool 'python ../merge' for b (binary False symlink False changedelete False)
   my b@e300d1c794ec+ other b@49b6d8032493 ancestor a@924404dff337
   launching merge tool: python ../merge *$TESTTMP/t/t/b* * * (glob)
   merge tool returned: 0
    rev: versions differ -> m (merge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   my rev@e300d1c794ec+ other rev@49b6d8032493 ancestor rev@924404dff337
   launching merge tool: python ../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
    b: local copied/moved from a -> m (premerge)
   picked tool 'python ../merge' for b (binary False symlink False changedelete False)
   merging b and a to b
   my b@62e7bf090eba+ other a@f4db7e329e71 ancestor a@924404dff337
    rev: versions differ -> m (premerge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   merging rev
   my rev@62e7bf090eba+ other rev@f4db7e329e71 ancestor rev@924404dff337
    b: local copied/moved from a -> m (merge)
   picked tool 'python ../merge' for b (binary False symlink False changedelete False)
   my b@62e7bf090eba+ other a@f4db7e329e71 ancestor a@924404dff337
   launching merge tool: python ../merge *$TESTTMP/t/t/b* * * (glob)
   merge tool returned: 0
    rev: versions differ -> m (merge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   my rev@62e7bf090eba+ other rev@f4db7e329e71 ancestor rev@924404dff337
   launching merge tool: python ../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 'python ../merge' for b (binary False symlink False changedelete False)
   merging b and a to b
   my b@02963e448370+ other a@2b958612230f ancestor a@924404dff337
    premerge successful
    rev: versions differ -> m (premerge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   merging rev
   my rev@02963e448370+ other rev@2b958612230f ancestor rev@924404dff337
    rev: versions differ -> m (merge)
   picked tool 'python ../merge' for rev (binary False symlink False changedelete False)
   my rev@02963e448370+ other rev@2b958612230f ancestor rev@924404dff337
   launching merge tool: python ../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 ..