copies: print debug information about copies per side/branch

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

mercurial/copies.py

@@ -1,1150 +1,1151 b''
 # copies.py - copy detection for Mercurial
 #
 # Copyright 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 collections
 import multiprocessing
 import os
 
 from .i18n import _
 
 
 from .revlogutils.flagutil import REVIDX_SIDEDATA
 
 from . import (
     error,
     match as matchmod,
     node,
     pathutil,
     pycompat,
     util,
 )
 
 from .revlogutils import sidedata as sidedatamod
 
 from .utils import stringutil
 
 
 def _filter(src, dst, t):
     """filters out invalid copies after chaining"""
 
     # When _chain()'ing copies in 'a' (from 'src' via some other commit 'mid')
     # with copies in 'b' (from 'mid' to 'dst'), we can get the different cases
     # in the following table (not including trivial cases). For example, case 2
     # is where a file existed in 'src' and remained under that name in 'mid' and
     # then was renamed between 'mid' and 'dst'.
     #
     # case src mid dst result
     #   1   x   y   -    -
     #   2   x   y   y   x->y
     #   3   x   y   x    -
     #   4   x   y   z   x->z
     #   5   -   x   y    -
     #   6   x   x   y   x->y
     #
     # _chain() takes care of chaining the copies in 'a' and 'b', but it
     # cannot tell the difference between cases 1 and 2, between 3 and 4, or
     # between 5 and 6, so it includes all cases in its result.
     # Cases 1, 3, and 5 are then removed by _filter().
 
     for k, v in list(t.items()):
         # remove copies from files that didn't exist
         if v not in src:
             del t[k]
         # remove criss-crossed copies
         elif k in src and v in dst:
             del t[k]
         # remove copies to files that were then removed
         elif k not in dst:
             del t[k]
 
 
 def _chain(prefix, suffix):
     """chain two sets of copies 'prefix' and 'suffix'"""
     result = prefix.copy()
     for key, value in pycompat.iteritems(suffix):
         result[key] = prefix.get(value, value)
     return result
 
 
 def _tracefile(fctx, am, basemf):
     """return file context that is the ancestor of fctx present in ancestor
     manifest am
 
     Note: we used to try and stop after a given limit, however checking if that
     limit is reached turned out to be very expensive. we are better off
     disabling that feature."""
 
     for f in fctx.ancestors():
         path = f.path()
         if am.get(path, None) == f.filenode():
             return path
         if basemf and basemf.get(path, None) == f.filenode():
             return path
 
 
 def _dirstatecopies(repo, match=None):
     ds = repo.dirstate
     c = ds.copies().copy()
     for k in list(c):
         if ds[k] not in b'anm' or (match and not match(k)):
             del c[k]
     return c
 
 
 def _computeforwardmissing(a, b, match=None):
     """Computes which files are in b but not a.
     This is its own function so extensions can easily wrap this call to see what
     files _forwardcopies is about to process.
     """
     ma = a.manifest()
     mb = b.manifest()
     return mb.filesnotin(ma, match=match)
 
 
 def usechangesetcentricalgo(repo):
     """Checks if we should use changeset-centric copy algorithms"""
     if repo.filecopiesmode == b'changeset-sidedata':
         return True
     readfrom = repo.ui.config(b'experimental', b'copies.read-from')
     changesetsource = (b'changeset-only', b'compatibility')
     return readfrom in changesetsource
 
 
 def _committedforwardcopies(a, b, base, match):
     """Like _forwardcopies(), but b.rev() cannot be None (working copy)"""
     # files might have to be traced back to the fctx parent of the last
     # one-side-only changeset, but not further back than that
     repo = a._repo
 
     if usechangesetcentricalgo(repo):
         return _changesetforwardcopies(a, b, match)
 
     debug = repo.ui.debugflag and repo.ui.configbool(b'devel', b'debug.copies')
     dbg = repo.ui.debug
     if debug:
         dbg(b'debug.copies:    looking into rename from %s to %s\n' % (a, b))
     am = a.manifest()
     basemf = None if base is None else base.manifest()
 
     # find where new files came from
     # we currently don't try to find where old files went, too expensive
     # this means we can miss a case like 'hg rm b; hg cp a b'
     cm = {}
 
     # Computing the forward missing is quite expensive on large manifests, since
     # it compares the entire manifests. We can optimize it in the common use
     # case of computing what copies are in a commit versus its parent (like
     # during a rebase or histedit). Note, we exclude merge commits from this
     # optimization, since the ctx.files() for a merge commit is not correct for
     # this comparison.
     forwardmissingmatch = match
     if b.p1() == a and b.p2().node() == node.nullid:
         filesmatcher = matchmod.exact(b.files())
         forwardmissingmatch = matchmod.intersectmatchers(match, filesmatcher)
     missing = _computeforwardmissing(a, b, match=forwardmissingmatch)
 
     ancestrycontext = a._repo.changelog.ancestors([b.rev()], inclusive=True)
 
     if debug:
         dbg(b'debug.copies:      missing files to search: %d\n' % len(missing))
 
     for f in sorted(missing):
         if debug:
             dbg(b'debug.copies:        tracing file: %s\n' % f)
         fctx = b[f]
         fctx._ancestrycontext = ancestrycontext
 
         if debug:
             start = util.timer()
         opath = _tracefile(fctx, am, basemf)
         if opath:
             if debug:
                 dbg(b'debug.copies:          rename of: %s\n' % opath)
             cm[f] = opath
         if debug:
             dbg(
                 b'debug.copies:          time: %f seconds\n'
                 % (util.timer() - start)
             )
     return cm
 
 
 def _revinfogetter(repo):
     """return a function that return multiple data given a <rev>"i
 
     * p1: revision number of first parent
     * p2: revision number of first parent
     * p1copies: mapping of copies from p1
     * p2copies: mapping of copies from p2
     * removed: a list of removed files
     """
     cl = repo.changelog
     parents = cl.parentrevs
 
     if repo.filecopiesmode == b'changeset-sidedata':
         changelogrevision = cl.changelogrevision
         flags = cl.flags
 
         # A small cache to avoid doing the work twice for merges
         #
         # In the vast majority of cases, if we ask information for a revision
         # about 1 parent, we'll later ask it for the other. So it make sense to
         # keep the information around when reaching the first parent of a merge
         # and dropping it after it was provided for the second parents.
         #
         # It exists cases were only one parent of the merge will be walked. It
         # happens when the "destination" the copy tracing is descendant from a
         # new root, not common with the "source". In that case, we will only walk
         # through merge parents that are descendant of changesets common
         # between "source" and "destination".
         #
         # With the current case implementation if such changesets have a copy
         # information, we'll keep them in memory until the end of
         # _changesetforwardcopies. We don't expect the case to be frequent
         # enough to matters.
         #
         # In addition, it would be possible to reach pathological case, were
         # many first parent are met before any second parent is reached. In
         # that case the cache could grow. If this even become an issue one can
         # safely introduce a maximum cache size. This would trade extra CPU/IO
         # time to save memory.
         merge_caches = {}
 
         def revinfo(rev):
             p1, p2 = parents(rev)
             if flags(rev) & REVIDX_SIDEDATA:
                 e = merge_caches.pop(rev, None)
                 if e is not None:
                     return e
                 c = changelogrevision(rev)
                 p1copies = c.p1copies
                 p2copies = c.p2copies
                 removed = c.filesremoved
                 if p1 != node.nullrev and p2 != node.nullrev:
                     # XXX some case we over cache, IGNORE
                     merge_caches[rev] = (p1, p2, p1copies, p2copies, removed)
             else:
                 p1copies = {}
                 p2copies = {}
                 removed = []
             return p1, p2, p1copies, p2copies, removed
 
     else:
 
         def revinfo(rev):
             p1, p2 = parents(rev)
             ctx = repo[rev]
             p1copies, p2copies = ctx._copies
             removed = ctx.filesremoved()
             return p1, p2, p1copies, p2copies, removed
 
     return revinfo
 
 
 def _changesetforwardcopies(a, b, match):
     if a.rev() in (node.nullrev, b.rev()):
         return {}
 
     repo = a.repo().unfiltered()
     children = {}
     revinfo = _revinfogetter(repo)
 
     cl = repo.changelog
     missingrevs = cl.findmissingrevs(common=[a.rev()], heads=[b.rev()])
     mrset = set(missingrevs)
     roots = set()
     for r in missingrevs:
         for p in cl.parentrevs(r):
             if p == node.nullrev:
                 continue
             if p not in children:
                 children[p] = [r]
             else:
                 children[p].append(r)
             if p not in mrset:
                 roots.add(p)
     if not roots:
         # no common revision to track copies from
         return {}
     min_root = min(roots)
 
     from_head = set(
         cl.reachableroots(min_root, [b.rev()], list(roots), includepath=True)
     )
 
     iterrevs = set(from_head)
     iterrevs &= mrset
     iterrevs.update(roots)
     iterrevs.remove(b.rev())
     revs = sorted(iterrevs)
     return _combinechangesetcopies(revs, children, b.rev(), revinfo, match)
 
 
 def _combinechangesetcopies(revs, children, targetrev, revinfo, match):
     """combine the copies information for each item of iterrevs
 
     revs: sorted iterable of revision to visit
     children: a {parent: [children]} mapping.
     targetrev: the final copies destination revision (not in iterrevs)
     revinfo(rev): a function that return (p1, p2, p1copies, p2copies, removed)
     match: a matcher
 
     It returns the aggregated copies information for `targetrev`.
     """
     all_copies = {}
     alwaysmatch = match.always()
     for r in revs:
         copies = all_copies.pop(r, None)
         if copies is None:
             # this is a root
             copies = {}
         for i, c in enumerate(children[r]):
             p1, p2, p1copies, p2copies, removed = revinfo(c)
             if r == p1:
                 parent = 1
                 childcopies = p1copies
             else:
                 assert r == p2
                 parent = 2
                 childcopies = p2copies
             if not alwaysmatch:
                 childcopies = {
                     dst: src for dst, src in childcopies.items() if match(dst)
                 }
             newcopies = copies
             if childcopies:
                 newcopies = _chain(newcopies, childcopies)
                 # _chain makes a copies, we can avoid doing so in some
                 # simple/linear cases.
                 assert newcopies is not copies
             for f in removed:
                 if f in newcopies:
                     if newcopies is copies:
                         # copy on write to avoid affecting potential other
                         # branches.  when there are no other branches, this
                         # could be avoided.
                         newcopies = copies.copy()
                     del newcopies[f]
             othercopies = all_copies.get(c)
             if othercopies is None:
                 all_copies[c] = newcopies
             else:
                 # we are the second parent to work on c, we need to merge our
                 # work with the other.
                 #
                 # Unlike when copies are stored in the filelog, we consider
                 # it a copy even if the destination already existed on the
                 # other branch. It's simply too expensive to check if the
                 # file existed in the manifest.
                 #
                 # In case of conflict, parent 1 take precedence over parent 2.
                 # This is an arbitrary choice made anew when implementing
                 # changeset based copies. It was made without regards with
                 # potential filelog related behavior.
                 if parent == 1:
                     othercopies.update(newcopies)
                 else:
                     newcopies.update(othercopies)
                     all_copies[c] = newcopies
     return all_copies[targetrev]
 
 
 def _forwardcopies(a, b, base=None, match=None):
     """find {dst@b: src@a} copy mapping where a is an ancestor of b"""
 
     if base is None:
         base = a
     match = a.repo().narrowmatch(match)
     # check for working copy
     if b.rev() is None:
         cm = _committedforwardcopies(a, b.p1(), base, match)
         # combine copies from dirstate if necessary
         copies = _chain(cm, _dirstatecopies(b._repo, match))
     else:
         copies = _committedforwardcopies(a, b, base, match)
     return copies
 
 
 def _backwardrenames(a, b, match):
     if a._repo.ui.config(b'experimental', b'copytrace') == b'off':
         return {}
 
     # Even though we're not taking copies into account, 1:n rename situations
     # can still exist (e.g. hg cp a b; hg mv a c). In those cases we
     # arbitrarily pick one of the renames.
     # We don't want to pass in "match" here, since that would filter
     # the destination by it. Since we're reversing the copies, we want
     # to filter the source instead.
     f = _forwardcopies(b, a)
     r = {}
     for k, v in sorted(pycompat.iteritems(f)):
         if match and not match(v):
             continue
         # remove copies
         if v in a:
             continue
         r[v] = k
     return r
 
 
 def pathcopies(x, y, match=None):
     """find {dst@y: src@x} copy mapping for directed compare"""
     repo = x._repo
     debug = repo.ui.debugflag and repo.ui.configbool(b'devel', b'debug.copies')
     if debug:
         repo.ui.debug(
             b'debug.copies: searching copies from %s to %s\n' % (x, y)
         )
     if x == y or not x or not y:
         return {}
     a = y.ancestor(x)
     if a == x:
         if debug:
             repo.ui.debug(b'debug.copies: search mode: forward\n')
         if y.rev() is None and x == y.p1():
             # short-circuit to avoid issues with merge states
             return _dirstatecopies(repo, match)
         copies = _forwardcopies(x, y, match=match)
     elif a == y:
         if debug:
             repo.ui.debug(b'debug.copies: search mode: backward\n')
         copies = _backwardrenames(x, y, match=match)
     else:
         if debug:
             repo.ui.debug(b'debug.copies: search mode: combined\n')
         base = None
         if a.rev() != node.nullrev:
             base = x
         copies = _chain(
             _backwardrenames(x, a, match=match),
             _forwardcopies(a, y, base, match=match),
         )
     _filter(x, y, copies)
     return copies
 
 
 def mergecopies(repo, c1, c2, base):
     """
     Finds moves and copies between context c1 and c2 that are relevant for
     merging. 'base' will be used as the merge base.
 
     Copytracing is used in commands like rebase, merge, unshelve, etc to merge
     files that were moved/ copied in one merge parent and modified in another.
     For example:
 
     o          ---> 4 another commit
     |
     |   o      ---> 3 commit that modifies a.txt
     |  /
     o /        ---> 2 commit that moves a.txt to b.txt
     |/
     o          ---> 1 merge base
 
     If we try to rebase revision 3 on revision 4, since there is no a.txt in
     revision 4, and if user have copytrace disabled, we prints the following
     message:
 
     ```other changed <file> which local deleted```
 
     Returns five dicts: "copy", "movewithdir", "diverge", "renamedelete" and
     "dirmove".
 
     "copy" is a mapping from destination name -> source name,
     where source is in c1 and destination is in c2 or vice-versa.
 
     "movewithdir" is a mapping from source name -> destination name,
     where the file at source present in one context but not the other
     needs to be moved to destination by the merge process, because the
     other context moved the directory it is in.
 
     "diverge" is a mapping of source name -> list of destination names
     for divergent renames.
 
     "renamedelete" is a mapping of source name -> list of destination
     names for files deleted in c1 that were renamed in c2 or vice-versa.
 
     "dirmove" is a mapping of detected source dir -> destination dir renames.
     This is needed for handling changes to new files previously grafted into
     renamed directories.
 
     This function calls different copytracing algorithms based on config.
     """
     # avoid silly behavior for update from empty dir
     if not c1 or not c2 or c1 == c2:
         return {}, {}, {}, {}, {}
 
     narrowmatch = c1.repo().narrowmatch()
 
     # avoid silly behavior for parent -> working dir
     if c2.node() is None and c1.node() == repo.dirstate.p1():
         return _dirstatecopies(repo, narrowmatch), {}, {}, {}, {}
 
     copytracing = repo.ui.config(b'experimental', b'copytrace')
     if stringutil.parsebool(copytracing) is False:
         # stringutil.parsebool() returns None when it is unable to parse the
         # value, so we should rely on making sure copytracing is on such cases
         return {}, {}, {}, {}, {}
 
     if usechangesetcentricalgo(repo):
         # The heuristics don't make sense when we need changeset-centric algos
         return _fullcopytracing(repo, c1, c2, base)
 
     # Copy trace disabling is explicitly below the node == p1 logic above
     # because the logic above is required for a simple copy to be kept across a
     # rebase.
     if copytracing == b'heuristics':
         # Do full copytracing if only non-public revisions are involved as
         # that will be fast enough and will also cover the copies which could
         # be missed by heuristics
         if _isfullcopytraceable(repo, c1, base):
             return _fullcopytracing(repo, c1, c2, base)
         return _heuristicscopytracing(repo, c1, c2, base)
     else:
         return _fullcopytracing(repo, c1, c2, base)
 
 
 def _isfullcopytraceable(repo, c1, base):
     """ Checks that if base, source and destination are all no-public branches,
     if yes let's use the full copytrace algorithm for increased capabilities
     since it will be fast enough.
 
     `experimental.copytrace.sourcecommitlimit` can be used to set a limit for
     number of changesets from c1 to base such that if number of changesets are
     more than the limit, full copytracing algorithm won't be used.
     """
     if c1.rev() is None:
         c1 = c1.p1()
     if c1.mutable() and base.mutable():
         sourcecommitlimit = repo.ui.configint(
             b'experimental', b'copytrace.sourcecommitlimit'
         )
         commits = len(repo.revs(b'%d::%d', base.rev(), c1.rev()))
         return commits < sourcecommitlimit
     return False
 
 
 def _checksinglesidecopies(
     src, dsts1, m1, m2, mb, c2, base, copy, renamedelete
 ):
     if src not in m2:
         # deleted on side 2
         if src not in m1:
             # renamed on side 1, deleted on side 2
             renamedelete[src] = dsts1
     elif m2[src] != mb[src]:
         if not _related(c2[src], base[src]):
             return
         # modified on side 2
         for dst in dsts1:
             if dst not in m2:
                 # dst not added on side 2 (handle as regular
                 # "both created" case in manifestmerge otherwise)
                 copy[dst] = src
 
 
 def _fullcopytracing(repo, c1, c2, base):
     """ The full copytracing algorithm which finds all the new files that were
     added from merge base up to the top commit and for each file it checks if
     this file was copied from another file.
 
     This is pretty slow when a lot of changesets are involved but will track all
     the copies.
     """
     m1 = c1.manifest()
     m2 = c2.manifest()
     mb = base.manifest()
 
     copies1 = pathcopies(base, c1)
     copies2 = pathcopies(base, c2)
 
     if not (copies1 or copies2):
         return {}, {}, {}, {}, {}
 
     inversecopies1 = {}
     inversecopies2 = {}
     for dst, src in copies1.items():
         inversecopies1.setdefault(src, []).append(dst)
     for dst, src in copies2.items():
         inversecopies2.setdefault(src, []).append(dst)
 
     copy1 = {}
     copy2 = {}
     diverge = {}
     renamedelete1 = {}
     renamedelete2 = {}
     allsources = set(inversecopies1) | set(inversecopies2)
     for src in allsources:
         dsts1 = inversecopies1.get(src)
         dsts2 = inversecopies2.get(src)
         if dsts1 and dsts2:
             # copied/renamed on both sides
             if src not in m1 and src not in m2:
                 # renamed on both sides
                 dsts1 = set(dsts1)
                 dsts2 = set(dsts2)
                 # If there's some overlap in the rename destinations, we
                 # consider it not divergent. For example, if side 1 copies 'a'
                 # to 'b' and 'c' and deletes 'a', and side 2 copies 'a' to 'c'
                 # and 'd' and deletes 'a'.
                 if dsts1 & dsts2:
                     for dst in dsts1 & dsts2:
                         copy1[dst] = src
                         copy2[dst] = src
                 else:
                     diverge[src] = sorted(dsts1 | dsts2)
             elif src in m1 and src in m2:
                 # copied on both sides
                 dsts1 = set(dsts1)
                 dsts2 = set(dsts2)
                 for dst in dsts1 & dsts2:
                     copy1[dst] = src
                     copy2[dst] = src
             # TODO: Handle cases where it was renamed on one side and copied
             # on the other side
         elif dsts1:
             # copied/renamed only on side 1
             _checksinglesidecopies(
                 src, dsts1, m1, m2, mb, c2, base, copy1, renamedelete1
             )
         elif dsts2:
             # copied/renamed only on side 2
             _checksinglesidecopies(
                 src, dsts2, m2, m1, mb, c1, base, copy2, renamedelete2
             )
 
     # find interesting file sets from manifests
     addedinm1 = m1.filesnotin(mb, repo.narrowmatch())
     addedinm2 = m2.filesnotin(mb, repo.narrowmatch())
     u1 = sorted(addedinm1 - addedinm2)
     u2 = sorted(addedinm2 - addedinm1)
 
     header = b"  unmatched files in %s"
     if u1:
         repo.ui.debug(b"%s:\n   %s\n" % (header % b'local', b"\n   ".join(u1)))
     if u2:
         repo.ui.debug(b"%s:\n   %s\n" % (header % b'other', b"\n   ".join(u2)))
 
-    fullcopy = copies1.copy()
-    fullcopy.update(copies2)
-
     if repo.ui.debugflag:
         renamedeleteset = set()
         divergeset = set()
         for dsts in diverge.values():
             divergeset.update(dsts)
         for dsts in renamedelete1.values():
             renamedeleteset.update(dsts)
         for dsts in renamedelete2.values():
             renamedeleteset.update(dsts)
 
         repo.ui.debug(
             b"  all copies found (* = to merge, ! = divergent, "
             b"% = renamed and deleted):\n"
         )
-        for f in sorted(fullcopy):
-            note = b""
-            if f in copy1 or f in copy2:
-                note += b"*"
-            if f in divergeset:
-                note += b"!"
-            if f in renamedeleteset:
-                note += b"%"
-            repo.ui.debug(
-                b"   src: '%s' -> dst: '%s' %s\n" % (fullcopy[f], f, note)
-            )
+        for side, copies in ((b"local", copies1), (b"remote", copies2)):
+            if not copies:
+                continue
+            repo.ui.debug(b"   on %s side:\n" % side)
+            for f in sorted(copies):
+                note = b""
+                if f in copy1 or f in copy2:
+                    note += b"*"
+                if f in divergeset:
+                    note += b"!"
+                if f in renamedeleteset:
+                    note += b"%"
+                repo.ui.debug(
+                    b"    src: '%s' -> dst: '%s' %s\n" % (copies[f], f, note)
+                )
         del renamedeleteset
         del divergeset
 
     repo.ui.debug(b"  checking for directory renames\n")
 
     dirmove1, movewithdir2 = _dir_renames(repo, c1, copy1, copies1, u2)
     dirmove2, movewithdir1 = _dir_renames(repo, c2, copy2, copies2, u1)
 
     copy1.update(copy2)
     renamedelete1.update(renamedelete2)
     movewithdir1.update(movewithdir2)
     dirmove1.update(dirmove2)
 
     return copy1, movewithdir1, diverge, renamedelete1, dirmove1
 
 
 def _dir_renames(repo, ctx, copy, fullcopy, addedfiles):
     """Finds moved directories and files that should move with them.
 
     ctx: the context for one of the sides
     copy: files copied on the same side (as ctx)
     fullcopy: files copied on the same side (as ctx), including those that
               merge.manifestmerge() won't care about
     addedfiles: added files on the other side (compared to ctx)
     """
     # generate a directory move map
     d = ctx.dirs()
     invalid = set()
     dirmove = {}
 
     # examine each file copy for a potential directory move, which is
     # when all the files in a directory are moved to a new directory
     for dst, src in pycompat.iteritems(fullcopy):
         dsrc, ddst = pathutil.dirname(src), pathutil.dirname(dst)
         if dsrc in invalid:
             # already seen to be uninteresting
             continue
         elif dsrc in d and ddst in d:
             # directory wasn't entirely moved locally
             invalid.add(dsrc)
         elif dsrc in dirmove and dirmove[dsrc] != ddst:
             # files from the same directory moved to two different places
             invalid.add(dsrc)
         else:
             # looks good so far
             dirmove[dsrc] = ddst
 
     for i in invalid:
         if i in dirmove:
             del dirmove[i]
     del d, invalid
 
     if not dirmove:
         return {}, {}
 
     dirmove = {k + b"/": v + b"/" for k, v in pycompat.iteritems(dirmove)}
 
     for d in dirmove:
         repo.ui.debug(
             b"   discovered dir src: '%s' -> dst: '%s'\n" % (d, dirmove[d])
         )
 
     movewithdir = {}
     # check unaccounted nonoverlapping files against directory moves
     for f in addedfiles:
         if f not in fullcopy:
             for d in dirmove:
                 if f.startswith(d):
                     # new file added in a directory that was moved, move it
                     df = dirmove[d] + f[len(d) :]
                     if df not in copy:
                         movewithdir[f] = df
                         repo.ui.debug(
                             b"   pending file src: '%s' -> dst: '%s'\n"
                             % (f, df)
                         )
                     break
 
     return dirmove, movewithdir
 
 
 def _heuristicscopytracing(repo, c1, c2, base):
     """ Fast copytracing using filename heuristics
 
     Assumes that moves or renames are of following two types:
 
     1) Inside a directory only (same directory name but different filenames)
     2) Move from one directory to another
                     (same filenames but different directory names)
 
     Works only when there are no merge commits in the "source branch".
     Source branch is commits from base up to c2 not including base.
 
     If merge is involved it fallbacks to _fullcopytracing().
 
     Can be used by setting the following config:
 
         [experimental]
         copytrace = heuristics
 
     In some cases the copy/move candidates found by heuristics can be very large
     in number and that will make the algorithm slow. The number of possible
     candidates to check can be limited by using the config
     `experimental.copytrace.movecandidateslimit` which defaults to 100.
     """
 
     if c1.rev() is None:
         c1 = c1.p1()
     if c2.rev() is None:
         c2 = c2.p1()
 
     copies = {}
 
     changedfiles = set()
     m1 = c1.manifest()
     if not repo.revs(b'%d::%d', base.rev(), c2.rev()):
         # If base is not in c2 branch, we switch to fullcopytracing
         repo.ui.debug(
             b"switching to full copytracing as base is not "
             b"an ancestor of c2\n"
         )
         return _fullcopytracing(repo, c1, c2, base)
 
     ctx = c2
     while ctx != base:
         if len(ctx.parents()) == 2:
             # To keep things simple let's not handle merges
             repo.ui.debug(b"switching to full copytracing because of merges\n")
             return _fullcopytracing(repo, c1, c2, base)
         changedfiles.update(ctx.files())
         ctx = ctx.p1()
 
     cp = _forwardcopies(base, c2)
     for dst, src in pycompat.iteritems(cp):
         if src in m1:
             copies[dst] = src
 
     # file is missing if it isn't present in the destination, but is present in
     # the base and present in the source.
     # Presence in the base is important to exclude added files, presence in the
     # source is important to exclude removed files.
     filt = lambda f: f not in m1 and f in base and f in c2
     missingfiles = [f for f in changedfiles if filt(f)]
 
     if missingfiles:
         basenametofilename = collections.defaultdict(list)
         dirnametofilename = collections.defaultdict(list)
 
         for f in m1.filesnotin(base.manifest()):
             basename = os.path.basename(f)
             dirname = os.path.dirname(f)
             basenametofilename[basename].append(f)
             dirnametofilename[dirname].append(f)
 
         for f in missingfiles:
             basename = os.path.basename(f)
             dirname = os.path.dirname(f)
             samebasename = basenametofilename[basename]
             samedirname = dirnametofilename[dirname]
             movecandidates = samebasename + samedirname
             # f is guaranteed to be present in c2, that's why
             # c2.filectx(f) won't fail
             f2 = c2.filectx(f)
             # we can have a lot of candidates which can slow down the heuristics
             # config value to limit the number of candidates moves to check
             maxcandidates = repo.ui.configint(
                 b'experimental', b'copytrace.movecandidateslimit'
             )
 
             if len(movecandidates) > maxcandidates:
                 repo.ui.status(
                     _(
                         b"skipping copytracing for '%s', more "
                         b"candidates than the limit: %d\n"
                     )
                     % (f, len(movecandidates))
                 )
                 continue
 
             for candidate in movecandidates:
                 f1 = c1.filectx(candidate)
                 if _related(f1, f2):
                     # if there are a few related copies then we'll merge
                     # changes into all of them. This matches the behaviour
                     # of upstream copytracing
                     copies[candidate] = f
 
     return copies, {}, {}, {}, {}
 
 
 def _related(f1, f2):
     """return True if f1 and f2 filectx have a common ancestor
 
     Walk back to common ancestor to see if the two files originate
     from the same file. Since workingfilectx's rev() is None it messes
     up the integer comparison logic, hence the pre-step check for
     None (f1 and f2 can only be workingfilectx's initially).
     """
 
     if f1 == f2:
         return True  # a match
 
     g1, g2 = f1.ancestors(), f2.ancestors()
     try:
         f1r, f2r = f1.linkrev(), f2.linkrev()
 
         if f1r is None:
             f1 = next(g1)
         if f2r is None:
             f2 = next(g2)
 
         while True:
             f1r, f2r = f1.linkrev(), f2.linkrev()
             if f1r > f2r:
                 f1 = next(g1)
             elif f2r > f1r:
                 f2 = next(g2)
             else:  # f1 and f2 point to files in the same linkrev
                 return f1 == f2  # true if they point to the same file
     except StopIteration:
         return False
 
 
 def graftcopies(wctx, ctx, base):
     """reproduce copies between base and ctx in the wctx
 
     Unlike mergecopies(), this function will only consider copies between base
     and ctx; it will ignore copies between base and wctx. Also unlike
     mergecopies(), this function will apply copies to the working copy (instead
     of just returning information about the copies). That makes it cheaper
     (especially in the common case of base==ctx.p1()) and useful also when
     experimental.copytrace=off.
 
     merge.update() will have already marked most copies, but it will only
     mark copies if it thinks the source files are related (see
     merge._related()). It will also not mark copies if the file wasn't modified
     on the local side. This function adds the copies that were "missed"
     by merge.update().
     """
     new_copies = pathcopies(base, ctx)
     _filter(wctx.p1(), wctx, new_copies)
     for dst, src in pycompat.iteritems(new_copies):
         wctx[dst].markcopied(src)
 
 
 def computechangesetfilesadded(ctx):
     """return the list of files added in a changeset
     """
     added = []
     for f in ctx.files():
         if not any(f in p for p in ctx.parents()):
             added.append(f)
     return added
 
 
 def computechangesetfilesremoved(ctx):
     """return the list of files removed in a changeset
     """
     removed = []
     for f in ctx.files():
         if f not in ctx:
             removed.append(f)
     return removed
 
 
 def computechangesetcopies(ctx):
     """return the copies data for a changeset
 
     The copies data are returned as a pair of dictionnary (p1copies, p2copies).
 
     Each dictionnary are in the form: `{newname: oldname}`
     """
     p1copies = {}
     p2copies = {}
     p1 = ctx.p1()
     p2 = ctx.p2()
     narrowmatch = ctx._repo.narrowmatch()
     for dst in ctx.files():
         if not narrowmatch(dst) or dst not in ctx:
             continue
         copied = ctx[dst].renamed()
         if not copied:
             continue
         src, srcnode = copied
         if src in p1 and p1[src].filenode() == srcnode:
             p1copies[dst] = src
         elif src in p2 and p2[src].filenode() == srcnode:
             p2copies[dst] = src
     return p1copies, p2copies
 
 
 def encodecopies(files, copies):
     items = []
     for i, dst in enumerate(files):
         if dst in copies:
             items.append(b'%d\0%s' % (i, copies[dst]))
     if len(items) != len(copies):
         raise error.ProgrammingError(
             b'some copy targets missing from file list'
         )
     return b"\n".join(items)
 
 
 def decodecopies(files, data):
     try:
         copies = {}
         if not data:
             return copies
         for l in data.split(b'\n'):
             strindex, src = l.split(b'\0')
             i = int(strindex)
             dst = files[i]
             copies[dst] = src
         return copies
     except (ValueError, IndexError):
         # Perhaps someone had chosen the same key name (e.g. "p1copies") and
         # used different syntax for the value.
         return None
 
 
 def encodefileindices(files, subset):
     subset = set(subset)
     indices = []
     for i, f in enumerate(files):
         if f in subset:
             indices.append(b'%d' % i)
     return b'\n'.join(indices)
 
 
 def decodefileindices(files, data):
     try:
         subset = []
         if not data:
             return subset
         for strindex in data.split(b'\n'):
             i = int(strindex)
             if i < 0 or i >= len(files):
                 return None
             subset.append(files[i])
         return subset
     except (ValueError, IndexError):
         # Perhaps someone had chosen the same key name (e.g. "added") and
         # used different syntax for the value.
         return None
 
 
 def _getsidedata(srcrepo, rev):
     ctx = srcrepo[rev]
     filescopies = computechangesetcopies(ctx)
     filesadded = computechangesetfilesadded(ctx)
     filesremoved = computechangesetfilesremoved(ctx)
     sidedata = {}
     if any([filescopies, filesadded, filesremoved]):
         sortedfiles = sorted(ctx.files())
         p1copies, p2copies = filescopies
         p1copies = encodecopies(sortedfiles, p1copies)
         p2copies = encodecopies(sortedfiles, p2copies)
         filesadded = encodefileindices(sortedfiles, filesadded)
         filesremoved = encodefileindices(sortedfiles, filesremoved)
         if p1copies:
             sidedata[sidedatamod.SD_P1COPIES] = p1copies
         if p2copies:
             sidedata[sidedatamod.SD_P2COPIES] = p2copies
         if filesadded:
             sidedata[sidedatamod.SD_FILESADDED] = filesadded
         if filesremoved:
             sidedata[sidedatamod.SD_FILESREMOVED] = filesremoved
     return sidedata
 
 
 def getsidedataadder(srcrepo, destrepo):
     use_w = srcrepo.ui.configbool(b'experimental', b'worker.repository-upgrade')
     if pycompat.iswindows or not use_w:
         return _get_simple_sidedata_adder(srcrepo, destrepo)
     else:
         return _get_worker_sidedata_adder(srcrepo, destrepo)
 
 
 def _sidedata_worker(srcrepo, revs_queue, sidedata_queue, tokens):
     """The function used by worker precomputing sidedata
 
     It read an input queue containing revision numbers
     It write in an output queue containing (rev, <sidedata-map>)
 
     The `None` input value is used as a stop signal.
 
     The `tokens` semaphore is user to avoid having too many unprocessed
     entries. The workers needs to acquire one token before fetching a task.
     They will be released by the consumer of the produced data.
     """
     tokens.acquire()
     rev = revs_queue.get()
     while rev is not None:
         data = _getsidedata(srcrepo, rev)
         sidedata_queue.put((rev, data))
         tokens.acquire()
         rev = revs_queue.get()
     # processing of `None` is completed, release the token.
     tokens.release()
 
 
 BUFF_PER_WORKER = 50
 
 
 def _get_worker_sidedata_adder(srcrepo, destrepo):
     """The parallel version of the sidedata computation
 
     This code spawn a pool of worker that precompute a buffer of sidedata
     before we actually need them"""
     # avoid circular import copies -> scmutil -> worker -> copies
     from . import worker
 
     nbworkers = worker._numworkers(srcrepo.ui)
 
     tokens = multiprocessing.BoundedSemaphore(nbworkers * BUFF_PER_WORKER)
     revsq = multiprocessing.Queue()
     sidedataq = multiprocessing.Queue()
 
     assert srcrepo.filtername is None
     # queue all tasks beforehand, revision numbers are small and it make
     # synchronisation simpler
     #
     # Since the computation for each node can be quite expensive, the overhead
     # of using a single queue is not revelant. In practice, most computation
     # are fast but some are very expensive and dominate all the other smaller
     # cost.
     for r in srcrepo.changelog.revs():
         revsq.put(r)
     # queue the "no more tasks" markers
     for i in range(nbworkers):
         revsq.put(None)
 
     allworkers = []
     for i in range(nbworkers):
         args = (srcrepo, revsq, sidedataq, tokens)
         w = multiprocessing.Process(target=_sidedata_worker, args=args)
         allworkers.append(w)
         w.start()
 
     # dictionnary to store results for revision higher than we one we are
     # looking for. For example, if we need the sidedatamap for 42, and 43 is
     # received, when shelve 43 for later use.
     staging = {}
 
     def sidedata_companion(revlog, rev):
         sidedata = {}
         if util.safehasattr(revlog, b'filteredrevs'):  # this is a changelog
             # Is the data previously shelved ?
             sidedata = staging.pop(rev, None)
             if sidedata is None:
                 # look at the queued result until we find the one we are lookig
                 # for (shelve the other ones)
                 r, sidedata = sidedataq.get()
                 while r != rev:
                     staging[r] = sidedata
                     r, sidedata = sidedataq.get()
             tokens.release()
         return False, (), sidedata
 
     return sidedata_companion
 
 
 def _get_simple_sidedata_adder(srcrepo, destrepo):
     """The simple version of the sidedata computation
 
     It just compute it in the same thread on request"""
 
     def sidedatacompanion(revlog, rev):
         sidedata = {}
         if util.safehasattr(revlog, 'filteredrevs'):  # this is a changelog
             sidedata = _getsidedata(srcrepo, rev)
         return False, (), sidedata
 
     return sidedatacompanion
 
 
 def getsidedataremover(srcrepo, destrepo):
     def sidedatacompanion(revlog, rev):
         f = ()
         if util.safehasattr(revlog, 'filteredrevs'):  # this is a changelog
             if revlog.flags(rev) & REVIDX_SIDEDATA:
                 f = (
                     sidedatamod.SD_P1COPIES,
                     sidedatamod.SD_P2COPIES,
                     sidedatamod.SD_FILESADDED,
                     sidedatamod.SD_FILESREMOVED,
                 )
         return False, f, {}
 
     return sidedatacompanion

tests/test-copy-move-merge.t

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

tests/test-double-merge.t

@@ -1,65 +1,66 b''
   $ hg init repo
   $ cd repo
 
   $ echo line 1 > foo
   $ hg ci -qAm 'add foo'
 
 copy foo to bar and change both files
   $ hg cp foo bar
   $ echo line 2-1 >> foo
   $ echo line 2-2 >> bar
   $ hg ci -m 'cp foo bar; change both'
 
 in another branch, change foo in a way that doesn't conflict with
 the other changes
   $ hg up -qC 0
   $ echo line 0 > foo
   $ hg cat foo >> foo
   $ hg ci -m 'change foo'
   created new head
 
 we get conflicts that shouldn't be there
   $ hg merge -P
   changeset:   1:484bf6903104
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     cp foo bar; change both
   
   $ hg merge --debug
     unmatched files in other:
      bar
     all copies found (* = to merge, ! = divergent, % = renamed and deleted):
-     src: 'foo' -> dst: 'bar' *
+     on remote side:
+      src: 'foo' -> dst: 'bar' *
     checking for directory renames
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: e6dc8efe11cc, local: 6a0df1dad128+, remote: 484bf6903104
    preserving foo for resolve of bar
    preserving foo for resolve of foo
   starting 4 threads for background file closing (?)
    bar: remote copied from foo -> m (premerge)
   picked tool ':merge' for bar (binary False symlink False changedelete False)
   merging foo and bar to bar
   my bar@6a0df1dad128+ other bar@484bf6903104 ancestor foo@e6dc8efe11cc
    premerge successful
    foo: versions differ -> m (premerge)
   picked tool ':merge' for foo (binary False symlink False changedelete False)
   merging foo
   my foo@6a0df1dad128+ other foo@484bf6903104 ancestor foo@e6dc8efe11cc
    premerge successful
   0 files updated, 2 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
 contents of foo
   $ cat foo
   line 0
   line 1
   line 2-1
 
 contents of bar
   $ cat bar
   line 0
   line 1
   line 2-2
 
   $ cd ..

tests/test-graft.t

@@ -1,906 +1,912 b''
   $ cat >> $HGRCPATH <<EOF
   > [extdiff]
   > # for portability:
   > pdiff = sh "$RUNTESTDIR/pdiff"
   > EOF
 
 Create a repo with some stuff in it:
 
   $ hg init a
   $ cd a
   $ echo a > a
   $ echo a > d
   $ echo a > e
   $ hg ci -qAm0
   $ echo b > a
   $ hg ci -m1 -u bar
   $ hg mv a b
   $ hg ci -m2
   $ hg cp b c
   $ hg ci -m3 -u baz
   $ echo b > d
   $ echo f > e
   $ hg ci -m4
   $ hg up -q 3
   $ echo b > e
   $ hg branch -q stable
   $ hg ci -m5
   $ hg merge -q default --tool internal:local # for conflicts in e, choose 5 and ignore 4
   $ hg branch -q default
   $ hg ci -m6
   $ hg phase --public 3
   $ hg phase --force --secret 6
 
   $ hg log -G --template '{author}@{rev}.{phase}: {desc}\n'
   @    [e-mail]: 6
   |\
   | o  [e-mail]: 5
   | |
   o |  [e-mail]: 4
   |/
   o  [e-mail]: 3
   |
   o  [e-mail]: 2
   |
   o  [e-mail]: 1
   |
   o  [e-mail]: 0
   
 Test --base for grafting the merge of 4 from the perspective of 5, thus only getting the change to d
 
   $ hg up -cqr 3
   $ hg graft -r 6 --base 5
   grafting 6:25a2b029d3ae "6" (tip)
   merging e
   $ hg st --change .
   M d
 
   $ hg -q strip . --config extensions.strip=
 
 Test --base for collapsing changesets 2 and 3, thus getting both b and c
 
   $ hg up -cqr 0
   $ hg graft -r 3 --base 1
   grafting 3:4c60f11aa304 "3"
   merging a and b to b
   merging a and c to c
   $ hg st --change .
   A b
   A c
   R a
 
   $ hg -q strip . --config extensions.strip=
 
 Specifying child as --base revision fails safely (perhaps slightly confusing, but consistent)
 
   $ hg graft -r 2 --base 3
   grafting 2:5c095ad7e90f "2"
   note: possible conflict - c was deleted and renamed to:
    a
   note: graft of 2:5c095ad7e90f created no changes to commit
 
 Can't continue without starting:
 
   $ hg -q up -cr tip
   $ hg rm -q e
   $ hg graft --continue
   abort: no graft in progress
   [255]
   $ hg revert -r . -q e
 
 Need to specify a rev:
 
   $ hg graft
   abort: no revisions specified
   [255]
 
 Can't graft ancestor:
 
   $ hg graft 1 2
   skipping ancestor revision 1:5d205f8b35b6
   skipping ancestor revision 2:5c095ad7e90f
   [255]
 
 Specify revisions with -r:
 
   $ hg graft -r 1 -r 2
   skipping ancestor revision 1:5d205f8b35b6
   skipping ancestor revision 2:5c095ad7e90f
   [255]
 
   $ hg graft -r 1 2
   warning: inconsistent use of --rev might give unexpected revision ordering!
   skipping ancestor revision 2:5c095ad7e90f
   skipping ancestor revision 1:5d205f8b35b6
   [255]
 
 Conflicting date/user options:
 
   $ hg up -q 0
   $ hg graft -U --user foo 2
   abort: cannot specify both --user and --currentuser
   [255]
   $ hg graft -D --date '0 0' 2
   abort: cannot specify both --date and --currentdate
   [255]
 
 Can't graft with dirty wd:
 
   $ hg up -q 0
   $ echo foo > a
   $ hg graft 1
   abort: uncommitted changes
   [255]
   $ hg revert a
 
 Graft a rename:
 (this also tests that editor is invoked if '--edit' is specified)
 
   $ hg status --rev "2^1" --rev 2
   A b
   R a
   $ HGEDITOR=cat hg graft 2 -u foo --edit
   grafting 2:5c095ad7e90f "2"
   merging a and b to b
   2
   
   
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: foo
   HG: branch 'default'
   HG: added b
   HG: removed a
   $ hg export tip --git
   # HG changeset patch
   # User foo
   # Date 0 0
   #      Thu Jan 01 00:00:00 1970 +0000
   # Node ID ef0ef43d49e79e81ddafdc7997401ba0041efc82
   # Parent  68795b066622ca79a25816a662041d8f78f3cd9e
   2
   
   diff --git a/a b/b
   rename from a
   rename to b
 
 Look for extra:source
 
   $ hg log --debug -r tip
   changeset:   7:ef0ef43d49e79e81ddafdc7997401ba0041efc82
   tag:         tip
   phase:       draft
   parent:      0:68795b066622ca79a25816a662041d8f78f3cd9e
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    7:e59b6b228f9cbf9903d5e9abf996e083a1f533eb
   user:        foo
   date:        Thu Jan 01 00:00:00 1970 +0000
   files+:      b
   files-:      a
   extra:       branch=default
   extra:       source=5c095ad7e90f871700f02dd1fa5012cb4498a2d4
   description:
   2
   
   
 
 Graft out of order, skipping a merge and a duplicate
 (this also tests that editor is not invoked if '--edit' is not specified)
 
   $ hg graft 1 5 4 3 'merge()' 2 -n
   skipping ungraftable merge revision 6
   skipping revision 2:5c095ad7e90f (already grafted to 7:ef0ef43d49e7)
   grafting 1:5d205f8b35b6 "1"
   grafting 5:97f8bfe72746 "5"
   grafting 4:9c233e8e184d "4"
   grafting 3:4c60f11aa304 "3"
 
   $ HGEDITOR=cat hg graft 1 5 'merge()' 2 --debug
   skipping ungraftable merge revision 6
   scanning for duplicate grafts
   skipping revision 2:5c095ad7e90f (already grafted to 7:ef0ef43d49e7)
   grafting 1:5d205f8b35b6 "1"
     unmatched files in local:
      b
     all copies found (* = to merge, ! = divergent, % = renamed and deleted):
-     src: 'a' -> dst: 'b' *
+     on local side:
+      src: 'a' -> dst: 'b' *
     checking for directory renames
   resolving manifests
    branchmerge: True, force: True, partial: False
    ancestor: 68795b066622, local: ef0ef43d49e7+, remote: 5d205f8b35b6
    preserving b for resolve of b
   starting 4 threads for background file closing (?)
    b: local copied/moved from a -> m (premerge)
   picked tool ':merge' for b (binary False symlink False changedelete False)
   merging b and a to b
   my b@ef0ef43d49e7+ other a@5d205f8b35b6 ancestor a@68795b066622
    premerge successful
   committing files:
   b
   committing manifest
   committing changelog
   updating the branch cache
   grafting 5:97f8bfe72746 "5"
     all copies found (* = to merge, ! = divergent, % = renamed and deleted):
-     src: 'c' -> dst: 'b' 
+     on local side:
+      src: 'c' -> dst: 'b' 
     checking for directory renames
   resolving manifests
    branchmerge: True, force: True, partial: False
    ancestor: 4c60f11aa304, local: 6b9e5368ca4e+, remote: 97f8bfe72746
    e: remote is newer -> g
   getting e
   committing files:
   e
   committing manifest
   committing changelog
   updating the branch cache
   $ HGEDITOR=cat hg graft 4 3 --log --debug
   scanning for duplicate grafts
   grafting 4:9c233e8e184d "4"
     all copies found (* = to merge, ! = divergent, % = renamed and deleted):
-     src: 'c' -> dst: 'b' 
+     on local side:
+      src: 'c' -> dst: 'b' 
     checking for directory renames
   resolving manifests
    branchmerge: True, force: True, partial: False
    ancestor: 4c60f11aa304, local: 1905859650ec+, remote: 9c233e8e184d
    preserving e for resolve of e
    d: remote is newer -> g
   getting d
    e: versions differ -> m (premerge)
   picked tool ':merge' for e (binary False symlink False changedelete False)
   merging e
   my e@1905859650ec+ other e@9c233e8e184d ancestor e@4c60f11aa304
    e: versions differ -> m (merge)
   picked tool ':merge' for e (binary False symlink False changedelete False)
   my e@1905859650ec+ other e@9c233e8e184d ancestor e@4c60f11aa304
   warning: conflicts while merging e! (edit, then use 'hg resolve --mark')
   abort: unresolved conflicts, can't continue
   (use 'hg resolve' and 'hg graft --continue')
   [255]
 
 Summary should mention graft:
 
   $ hg summary |grep graft
   commit: 2 modified, 2 unknown, 1 unresolved (graft in progress)
 
 Using status to get more context
 
   $ hg status --verbose
   M d
   M e
   ? a.orig
   ? e.orig
   # The repository is in an unfinished *graft* state.
   
   # Unresolved merge conflicts:
   # 
   #     e
   # 
   # To mark files as resolved:  hg resolve --mark FILE
   
   # To continue:    hg graft --continue
   # To abort:       hg graft --abort
   # To stop:        hg graft --stop
   
 
 Commit while interrupted should fail:
 
   $ hg ci -m 'commit interrupted graft'
   abort: graft in progress
   (use 'hg graft --continue' or 'hg graft --stop' to stop)
   [255]
 
 Abort the graft and try committing:
 
   $ hg up -C .
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo c >> e
   $ hg ci -mtest
 
   $ hg strip . --config extensions.strip=
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/a/.hg/strip-backup/*-backup.hg (glob)
 
 Graft again:
 
   $ hg graft 1 5 4 3 'merge()' 2
   skipping ungraftable merge revision 6
   skipping revision 2:5c095ad7e90f (already grafted to 7:ef0ef43d49e7)
   skipping revision 1:5d205f8b35b6 (already grafted to 8:6b9e5368ca4e)
   skipping revision 5:97f8bfe72746 (already grafted to 9:1905859650ec)
   grafting 4:9c233e8e184d "4"
   merging e
   warning: conflicts while merging e! (edit, then use 'hg resolve --mark')
   abort: unresolved conflicts, can't continue
   (use 'hg resolve' and 'hg graft --continue')
   [255]
 
 Continue without resolve should fail:
 
   $ hg graft -c
   grafting 4:9c233e8e184d "4"
   abort: unresolved merge conflicts (see 'hg help resolve')
   [255]
 
 Fix up:
 
   $ echo b > e
   $ hg resolve -m e
   (no more unresolved files)
   continue: hg graft --continue
 
 Continue with a revision should fail:
 
   $ hg graft -c 6
   abort: can't specify --continue and revisions
   [255]
 
   $ hg graft -c -r 6
   abort: can't specify --continue and revisions
   [255]
 
 Continue for real, clobber usernames
 
   $ hg graft -c -U
   grafting 4:9c233e8e184d "4"
   grafting 3:4c60f11aa304 "3"
 
 Compare with original:
 
   $ hg diff -r 6
   $ hg status --rev 0:. -C
   M d
   M e
   A b
     a
   A c
     a
   R a
 
 View graph:
 
   $ hg log -G --template '{author}@{rev}.{phase}: {desc}\n'
   @  [e-mail]: 3
   |
   o  [e-mail]: 4
   |
   o  [e-mail]: 5
   |
   o  [e-mail]: 1
   |
   o  [e-mail]: 2
   |
   | o    [e-mail]: 6
   | |\
   | | o  [e-mail]: 5
   | | |
   | o |  [e-mail]: 4
   | |/
   | o  [e-mail]: 3
   | |
   | o  [e-mail]: 2
   | |
   | o  [e-mail]: 1
   |/
   o  [e-mail]: 0
   
 Graft again onto another branch should preserve the original source
   $ hg up -q 0
   $ echo 'g'>g
   $ hg add g
   $ hg ci -m 7
   created new head
   $ hg graft 7
   grafting 7:ef0ef43d49e7 "2"
 
   $ hg log -r 7 --template '{rev}:{node}\n'
   7:ef0ef43d49e79e81ddafdc7997401ba0041efc82
   $ hg log -r 2 --template '{rev}:{node}\n'
   2:5c095ad7e90f871700f02dd1fa5012cb4498a2d4
 
   $ hg log --debug -r tip
   changeset:   13:7a4785234d87ec1aa420ed6b11afe40fa73e12a9
   tag:         tip
   phase:       draft
   parent:      12:b592ea63bb0c19a6c5c44685ee29a2284f9f1b8f
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    13:dc313617b8c32457c0d589e0dbbedfe71f3cd637
   user:        foo
   date:        Thu Jan 01 00:00:00 1970 +0000
   files+:      b
   files-:      a
   extra:       branch=default
   extra:       intermediate-source=ef0ef43d49e79e81ddafdc7997401ba0041efc82
   extra:       source=5c095ad7e90f871700f02dd1fa5012cb4498a2d4
   description:
   2
   
   
 Disallow grafting an already grafted cset onto its original branch
   $ hg up -q 6
   $ hg graft 7
   skipping already grafted revision 7:ef0ef43d49e7 (was grafted from 2:5c095ad7e90f)
   [255]
 
   $ hg pdiff --config extensions.extdiff= --patch -r 2 -r 13
   --- */hg-5c095ad7e90f.patch	* (glob)
   +++ */hg-7a4785234d87.patch	* (glob)
   @@ -1,18 +1,18 @@
    # HG changeset patch
   -# User test
   +# User foo
    # Date 0 0
    #      Thu Jan 01 00:00:00 1970 +0000
   -# Node ID 5c095ad7e90f871700f02dd1fa5012cb4498a2d4
   -# Parent  5d205f8b35b66bc36375c9534ffd3237730e8f04
   +# Node ID 7a4785234d87ec1aa420ed6b11afe40fa73e12a9
   +# Parent  b592ea63bb0c19a6c5c44685ee29a2284f9f1b8f
    2
    
   -diff -r 5d205f8b35b6 -r 5c095ad7e90f a
   +diff -r b592ea63bb0c -r 7a4785234d87 a
    --- a/a	Thu Jan 01 00:00:00 1970 +0000
    +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    @@ -1,1 +0,0 @@
   --b
   -diff -r 5d205f8b35b6 -r 5c095ad7e90f b
   +-a
   +diff -r b592ea63bb0c -r 7a4785234d87 b
    --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    +++ b/b	Thu Jan 01 00:00:00 1970 +0000
    @@ -0,0 +1,1 @@
   -+b
   ++a
   [1]
 
   $ hg pdiff --config extensions.extdiff= --patch -r 2 -r 13 -X .
   --- */hg-5c095ad7e90f.patch	* (glob)
   +++ */hg-7a4785234d87.patch	* (glob)
   @@ -1,8 +1,8 @@
    # HG changeset patch
   -# User test
   +# User foo
    # Date 0 0
    #      Thu Jan 01 00:00:00 1970 +0000
   -# Node ID 5c095ad7e90f871700f02dd1fa5012cb4498a2d4
   -# Parent  5d205f8b35b66bc36375c9534ffd3237730e8f04
   +# Node ID 7a4785234d87ec1aa420ed6b11afe40fa73e12a9
   +# Parent  b592ea63bb0c19a6c5c44685ee29a2284f9f1b8f
    2
    
   [1]
 
 Disallow grafting already grafted csets with the same origin onto each other
   $ hg up -q 13
   $ hg graft 2
   skipping revision 2:5c095ad7e90f (already grafted to 13:7a4785234d87)
   [255]
   $ hg graft 7
   skipping already grafted revision 7:ef0ef43d49e7 (13:7a4785234d87 also has origin 2:5c095ad7e90f)
   [255]
 
   $ hg up -q 7
   $ hg graft 2
   skipping revision 2:5c095ad7e90f (already grafted to 7:ef0ef43d49e7)
   [255]
   $ hg graft tip
   skipping already grafted revision 13:7a4785234d87 (7:ef0ef43d49e7 also has origin 2:5c095ad7e90f)
   [255]
 
 Graft with --log
 
   $ hg up -Cq 1
   $ hg graft 3 --log -u foo
   grafting 3:4c60f11aa304 "3"
   $ hg log --template '{rev}:{node|short} {parents} {desc}\n' -r tip
   14:0c921c65ef1e 1:5d205f8b35b6  3
   (grafted from 4c60f11aa304a54ae1c199feb94e7fc771e51ed8)
 
 Resolve conflicted graft
   $ hg up -q 0
   $ echo b > a
   $ hg ci -m 8
   created new head
   $ echo c > a
   $ hg ci -m 9
   $ hg graft 1 --tool internal:fail
   grafting 1:5d205f8b35b6 "1"
   abort: unresolved conflicts, can't continue
   (use 'hg resolve' and 'hg graft --continue')
   [255]
   $ hg resolve --all
   merging a
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   [1]
   $ cat a
   <<<<<<< local: aaa4406d4f0a - test: 9
   c
   =======
   b
   >>>>>>> graft: 5d205f8b35b6 - bar: 1
   $ echo b > a
   $ hg resolve -m a
   (no more unresolved files)
   continue: hg graft --continue
   $ hg graft -c
   grafting 1:5d205f8b35b6 "1"
   $ hg export tip --git
   # HG changeset patch
   # User bar
   # Date 0 0
   #      Thu Jan 01 00:00:00 1970 +0000
   # Node ID f67661df0c4804d301f064f332b57e7d5ddaf2be
   # Parent  aaa4406d4f0ae9befd6e58c82ec63706460cbca6
   1
   
   diff --git a/a b/a
   --- a/a
   +++ b/a
   @@ -1,1 +1,1 @@
   -c
   +b
 
 Resolve conflicted graft with rename
   $ echo c > a
   $ hg ci -m 10
   $ hg graft 2 --tool internal:fail
   grafting 2:5c095ad7e90f "2"
   abort: unresolved conflicts, can't continue
   (use 'hg resolve' and 'hg graft --continue')
   [255]
   $ hg resolve --all
   merging a and b to b
   (no more unresolved files)
   continue: hg graft --continue
   $ hg graft -c
   grafting 2:5c095ad7e90f "2"
   $ hg export tip --git
   # HG changeset patch
   # User test
   # Date 0 0
   #      Thu Jan 01 00:00:00 1970 +0000
   # Node ID 9627f653b421c61fc1ea4c4e366745070fa3d2bc
   # Parent  ee295f490a40b97f3d18dd4c4f1c8936c233b612
   2
   
   diff --git a/a b/b
   rename from a
   rename to b
 
 Test simple origin(), with and without args
   $ hg log -r 'origin()'
   changeset:   1:5d205f8b35b6
   user:        bar
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1
   
   changeset:   2:5c095ad7e90f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2
   
   changeset:   3:4c60f11aa304
   user:        baz
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     3
   
   changeset:   4:9c233e8e184d
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     4
   
   changeset:   5:97f8bfe72746
   branch:      stable
   parent:      3:4c60f11aa304
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     5
   
   $ hg log -r 'origin(7)'
   changeset:   2:5c095ad7e90f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2
   
 Now transplant a graft to test following through copies
   $ hg up -q 0
   $ hg branch -q dev
   $ hg ci -qm "dev branch"
   $ hg --config extensions.transplant= transplant -q 7
   $ hg log -r 'origin(.)'
   changeset:   2:5c095ad7e90f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2
   
 Test that the graft and transplant markers in extra are converted, allowing
 origin() to still work.  Note that these recheck the immediately preceeding two
 tests.
   $ hg --quiet --config extensions.convert= --config convert.hg.saverev=True convert . ../converted
 
 The graft case
   $ hg -R ../converted log -r 7 --template "{rev}: {node}\n{join(extras, '\n')}\n"
   7: 7ae846e9111fc8f57745634250c7b9ac0a60689b
   branch=default
   convert_revision=ef0ef43d49e79e81ddafdc7997401ba0041efc82
   source=e0213322b2c1a5d5d236c74e79666441bee67a7d
   $ hg -R ../converted log -r 'origin(7)'
   changeset:   2:e0213322b2c1
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2
   
 Test that template correctly expands more than one 'extra' (issue4362), and that
 'intermediate-source' is converted.
   $ hg -R ../converted log -r 13 --template "{extras % ' Extra: {extra}\n'}"
    Extra: branch=default
    Extra: convert_revision=7a4785234d87ec1aa420ed6b11afe40fa73e12a9
    Extra: intermediate-source=7ae846e9111fc8f57745634250c7b9ac0a60689b
    Extra: source=e0213322b2c1a5d5d236c74e79666441bee67a7d
 
 The transplant case
   $ hg -R ../converted log -r tip --template "{rev}: {node}\n{join(extras, '\n')}\n"
   21: fbb6c5cc81002f2b4b49c9d731404688bcae5ade
   branch=dev
   convert_revision=7e61b508e709a11d28194a5359bc3532d910af21
   transplant_source=z\xe8F\xe9\x11\x1f\xc8\xf5wEcBP\xc7\xb9\xac\n`h\x9b
   $ hg -R ../converted log -r 'origin(tip)'
   changeset:   2:e0213322b2c1
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2
   
 
 Test simple destination
   $ hg log -r 'destination()'
   changeset:   7:ef0ef43d49e7
   parent:      0:68795b066622
   user:        foo
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2
   
   changeset:   8:6b9e5368ca4e
   user:        bar
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1
   
   changeset:   9:1905859650ec
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     5
   
   changeset:   10:52dc0b4c6907
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     4
   
   changeset:   11:882b35362a6b
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     3
   
   changeset:   13:7a4785234d87
   user:        foo
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2
   
   changeset:   14:0c921c65ef1e
   parent:      1:5d205f8b35b6
   user:        foo
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     3
   
   changeset:   17:f67661df0c48
   user:        bar
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1
   
   changeset:   19:9627f653b421
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2
   
   changeset:   21:7e61b508e709
   branch:      dev
   tag:         tip
   user:        foo
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2
   
   $ hg log -r 'destination(2)'
   changeset:   7:ef0ef43d49e7
   parent:      0:68795b066622
   user:        foo
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2
   
   changeset:   13:7a4785234d87
   user:        foo
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2
   
   changeset:   19:9627f653b421
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2
   
   changeset:   21:7e61b508e709
   branch:      dev
   tag:         tip
   user:        foo
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2
   
 Transplants of grafts can find a destination...
   $ hg log -r 'destination(7)'
   changeset:   21:7e61b508e709
   branch:      dev
   tag:         tip
   user:        foo
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2
   
 ... grafts of grafts unfortunately can't
   $ hg graft -q 13 --debug
   scanning for duplicate grafts
   grafting 13:7a4785234d87 "2"
     all copies found (* = to merge, ! = divergent, % = renamed and deleted):
-     src: 'a' -> dst: 'b' *
+     on local side:
+      src: 'a' -> dst: 'b' *
+     on remote side:
+      src: 'a' -> dst: 'b' *
     checking for directory renames
   resolving manifests
    branchmerge: True, force: True, partial: False
    ancestor: b592ea63bb0c, local: 7e61b508e709+, remote: 7a4785234d87
   starting 4 threads for background file closing (?)
   note: graft of 13:7a4785234d87 created no changes to commit
   $ hg log -r 'destination(13)'
 All copies of a cset
   $ hg log -r 'origin(13) or destination(origin(13))'
   changeset:   2:5c095ad7e90f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2
   
   changeset:   7:ef0ef43d49e7
   parent:      0:68795b066622
   user:        foo
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2
   
   changeset:   13:7a4785234d87
   user:        foo
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2
   
   changeset:   19:9627f653b421
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2
   
   changeset:   21:7e61b508e709
   branch:      dev
   tag:         tip
   user:        foo
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2
   
 
 graft skips ancestors
 
   $ hg graft 21 3
   skipping ancestor revision 21:7e61b508e709
   grafting 3:4c60f11aa304 "3"
   merging b and c to c
 
 graft with --force (still doesn't graft merges)
 
   $ hg graft 19 0 6
   skipping ungraftable merge revision 6
   skipping ancestor revision 0:68795b066622
   grafting 19:9627f653b421 "2"
   merging b
   note: graft of 19:9627f653b421 created no changes to commit
   $ hg graft 19 0 6 --force
   skipping ungraftable merge revision 6
   grafting 19:9627f653b421 "2"
   merging b
   note: graft of 19:9627f653b421 created no changes to commit
   grafting 0:68795b066622 "0"
 
 graft --force after backout
 
   $ echo abc > a
   $ hg ci -m 24
   $ hg backout 24
   reverting a
   changeset 25:71c4e63d4f98 backs out changeset 24:2e7ea477be26
   $ hg graft 24
   skipping ancestor revision 24:2e7ea477be26
   [255]
   $ hg graft 24 --force
   grafting 24:2e7ea477be26 "24"
   merging a
   $ cat a
   abc
 
 graft --continue after --force
 
   $ echo def > a
   $ hg ci -m 27
   $ hg graft 24 --force --tool internal:fail
   grafting 24:2e7ea477be26 "24"
   abort: unresolved conflicts, can't continue
   (use 'hg resolve' and 'hg graft --continue')
   [255]
   $ hg resolve --all
   merging a
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   [1]
   $ echo abc > a
   $ hg resolve -m a
   (no more unresolved files)
   continue: hg graft --continue
   $ hg graft -c
   grafting 24:2e7ea477be26 "24"
   $ cat a
   abc
 
 Continue testing same origin policy, using revision numbers from test above
 but do some destructive editing of the repo:
 
   $ hg up -qC 7
   $ hg tag -l -r 13 tmp
   $ hg --config extensions.strip= strip 2
   saved backup bundle to $TESTTMP/a/.hg/strip-backup/5c095ad7e90f-d323a1e4-backup.hg
   $ hg graft tmp
   skipping already grafted revision 8:7a4785234d87 (2:ef0ef43d49e7 also has unknown origin 5c095ad7e90f)
   [255]
 
 Empty graft
 
   $ hg up -qr 22
   $ hg tag -f something
   $ hg graft -qr 23
   $ hg graft -f 23
   grafting 23:72d9c7c75bcc "24"
   note: graft of 23:72d9c7c75bcc created no changes to commit
 
   $ cd ..
 
 Graft to duplicate a commit
 
   $ hg init graftsibling
   $ cd graftsibling
   $ touch a
   $ hg commit -qAm a
   $ touch b
   $ hg commit -qAm b
   $ hg log -G -T '{rev}\n'
   @  1
   |
   o  0
   
   $ hg up -q 0
   $ hg graft -r 1
   grafting 1:0e067c57feba "b" (tip)
   $ hg log -G -T '{rev}\n'
   @  2
   |
   | o  1
   |/
   o  0
   
 Graft to duplicate a commit twice
 
   $ hg up -q 0
   $ hg graft -r 2
   grafting 2:044ec77f6389 "b" (tip)
   $ hg log -G -T '{rev}\n'
   @  3
   |
   | o  2
   |/
   | o  1
   |/
   o  0
   

tests/test-issue672.t

@@ -1,96 +1,99 b''
 https://bz.mercurial-scm.org/672
 
 # 0-2-4
 #  \ \ \
 #   1-3-5
 #
 # rename in #1, content change in #4.
 
   $ hg init
 
   $ touch 1
   $ touch 2
   $ hg commit -Am init  # 0
   adding 1
   adding 2
 
   $ hg rename 1 1a
   $ hg commit -m rename # 1
 
   $ hg co -C 0
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
   $ echo unrelated >> 2
   $ hg ci -m unrelated1 # 2
   created new head
 
   $ hg merge --debug 1
     unmatched files in other:
      1a
     all copies found (* = to merge, ! = divergent, % = renamed and deleted):
-     src: '1' -> dst: '1a' 
+     on remote side:
+      src: '1' -> dst: '1a' 
     checking for directory renames
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 81f4b099af3d, local: c64f439569a9+, remote: c12dcd37c90a
    1: other deleted -> r
   removing 1
    1a: remote created -> g
   getting 1a
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ hg ci -m merge1 # 3
 
   $ hg co -C 2
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
   $ echo hello >> 1
   $ hg ci -m unrelated2 # 4
   created new head
 
   $ hg co -C 3
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
   $ hg merge -y --debug 4
     unmatched files in local:
      1a
     all copies found (* = to merge, ! = divergent, % = renamed and deleted):
-     src: '1' -> dst: '1a' *
+     on local side:
+      src: '1' -> dst: '1a' *
     checking for directory renames
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: c64f439569a9, local: f4a9cff3cd0b+, remote: 746e9549ea96
    preserving 1a for resolve of 1a
   starting 4 threads for background file closing (?)
    1a: local copied/moved from 1 -> m (premerge)
   picked tool ':merge' for 1a (binary False symlink False changedelete False)
   merging 1a and 1 to 1a
   my 1a@f4a9cff3cd0b+ other 1@746e9549ea96 ancestor 1@c64f439569a9
    premerge successful
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ hg co -C 4
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
   $ hg merge -y --debug 3
     unmatched files in other:
      1a
     all copies found (* = to merge, ! = divergent, % = renamed and deleted):
-     src: '1' -> dst: '1a' *
+     on remote side:
+      src: '1' -> dst: '1a' *
     checking for directory renames
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: c64f439569a9, local: 746e9549ea96+, remote: f4a9cff3cd0b
    preserving 1 for resolve of 1a
   removing 1
   starting 4 threads for background file closing (?)
    1a: remote moved from 1 -> m (premerge)
   picked tool ':merge' for 1a (binary False symlink False changedelete False)
   merging 1 and 1a to 1a
   my 1a@746e9549ea96+ other 1a@f4a9cff3cd0b ancestor 1@c64f439569a9
    premerge successful
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 

tests/test-merge-criss-cross.t

@@ -1,445 +1,446 b''
 Criss cross merging
 
   $ hg init criss-cross
   $ cd criss-cross
   $ echo '0 base' > f1
   $ echo '0 base' > f2
   $ hg ci -Aqm '0 base'
 
   $ echo '1 first change' > f1
   $ hg ci -m '1 first change f1'
 
   $ hg up -qr0
   $ echo '2 first change' > f2
   $ hg ci -qm '2 first change f2'
 
   $ hg merge -qr 1
   $ hg ci -m '3 merge'
 
   $ hg up -qr2
   $ hg merge -qr1
   $ hg ci -qm '4 merge'
 
   $ echo '5 second change' > f1
   $ hg ci -m '5 second change f1'
 
   $ hg up -r3
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo '6 second change' > f2
   $ hg ci -m '6 second change f2'
 
   $ hg log -G
   @  changeset:   6:3b08d01b0ab5
   |  tag:         tip
   |  parent:      3:cf89f02107e5
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     6 second change f2
   |
   | o  changeset:   5:adfe50279922
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     5 second change f1
   | |
   | o    changeset:   4:7d3e55501ae6
   | |\   parent:      2:40663881a6dd
   | | |  parent:      1:0f6b37dbe527
   | | |  user:        test
   | | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | | |  summary:     4 merge
   | | |
   o---+  changeset:   3:cf89f02107e5
   | | |  parent:      2:40663881a6dd
   |/ /   parent:      1:0f6b37dbe527
   | |    user:        test
   | |    date:        Thu Jan 01 00:00:00 1970 +0000
   | |    summary:     3 merge
   | |
   | o  changeset:   2:40663881a6dd
   | |  parent:      0:40494bf2444c
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     2 first change f2
   | |
   o |  changeset:   1:0f6b37dbe527
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     1 first change f1
   |
   o  changeset:   0:40494bf2444c
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     0 base
   
 
   $ hg merge -v --debug --tool internal:dump 5 --config merge.preferancestor='!'
   note: using 0f6b37dbe527 as ancestor of 3b08d01b0ab5 and adfe50279922
         alternatively, use --config merge.preferancestor=40663881a6dd
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 0f6b37dbe527, local: 3b08d01b0ab5+, remote: adfe50279922
    preserving f2 for resolve of f2
    f1: remote is newer -> g
   getting f1
    f2: versions differ -> m (premerge)
   picked tool ':dump' for f2 (binary False symlink False changedelete False)
   merging f2
   my f2@3b08d01b0ab5+ other f2@adfe50279922 ancestor f2@0f6b37dbe527
    f2: versions differ -> m (merge)
   picked tool ':dump' for f2 (binary False symlink False changedelete False)
   my f2@3b08d01b0ab5+ other f2@adfe50279922 ancestor f2@0f6b37dbe527
   1 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
 
   $ f --dump *
   f1:
   >>>
   5 second change
   <<<
   f2:
   >>>
   6 second change
   <<<
   f2.base:
   >>>
   0 base
   <<<
   f2.local:
   >>>
   6 second change
   <<<
   f2.orig:
   >>>
   6 second change
   <<<
   f2.other:
   >>>
   2 first change
   <<<
 
   $ hg up -qC .
   $ hg merge -v --tool internal:dump 5 --config merge.preferancestor="null 40663881 3b08d"
   note: using 40663881a6dd as ancestor of 3b08d01b0ab5 and adfe50279922
         alternatively, use --config merge.preferancestor=0f6b37dbe527
   resolving manifests
   merging f1
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
 
 Redo merge with merge.preferancestor="*" to enable bid merge
 
   $ rm f*
   $ hg up -qC .
   $ hg merge -v --debug --tool internal:dump 5 --config merge.preferancestor="*"
   note: merging 3b08d01b0ab5+ and adfe50279922 using bids from ancestors 0f6b37dbe527 and 40663881a6dd
   
   calculating bids for ancestor 0f6b37dbe527
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 0f6b37dbe527, local: 3b08d01b0ab5+, remote: adfe50279922
    f1: remote is newer -> g
    f2: versions differ -> m
   
   calculating bids for ancestor 40663881a6dd
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 40663881a6dd, local: 3b08d01b0ab5+, remote: adfe50279922
    f1: versions differ -> m
    f2: remote unchanged -> k
   
   auction for merging merge bids
    f1: picking 'get' action
    f2: picking 'keep' action
   end of auction
   
    f1: remote is newer -> g
   getting f1
    f2: remote unchanged -> k
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ f --dump *
   f1:
   >>>
   5 second change
   <<<
   f2:
   >>>
   6 second change
   <<<
 
 
 The other way around:
 
   $ hg up -C -r5
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge -v --debug --config merge.preferancestor="*"
   note: merging adfe50279922+ and 3b08d01b0ab5 using bids from ancestors 0f6b37dbe527 and 40663881a6dd
   
   calculating bids for ancestor 0f6b37dbe527
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 0f6b37dbe527, local: adfe50279922+, remote: 3b08d01b0ab5
    f1: remote unchanged -> k
    f2: versions differ -> m
   
   calculating bids for ancestor 40663881a6dd
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 40663881a6dd, local: adfe50279922+, remote: 3b08d01b0ab5
    f1: versions differ -> m
    f2: remote is newer -> g
   
   auction for merging merge bids
    f1: picking 'keep' action
    f2: picking 'get' action
   end of auction
   
    f2: remote is newer -> g
   getting f2
    f1: remote unchanged -> k
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ f --dump *
   f1:
   >>>
   5 second change
   <<<
   f2:
   >>>
   6 second change
   <<<
 
 Verify how the output looks and and how verbose it is:
 
   $ hg up -qC
   $ hg merge
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ hg up -qC tip
   $ hg merge -v
   note: merging 3b08d01b0ab5+ and adfe50279922 using bids from ancestors 0f6b37dbe527 and 40663881a6dd
   
   calculating bids for ancestor 0f6b37dbe527
   resolving manifests
   
   calculating bids for ancestor 40663881a6dd
   resolving manifests
   
   auction for merging merge bids
    f1: picking 'get' action
    f2: picking 'keep' action
   end of auction
   
   getting f1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ hg up -qC
   $ hg merge -v --debug --config merge.preferancestor="*"
   note: merging 3b08d01b0ab5+ and adfe50279922 using bids from ancestors 0f6b37dbe527 and 40663881a6dd
   
   calculating bids for ancestor 0f6b37dbe527
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 0f6b37dbe527, local: 3b08d01b0ab5+, remote: adfe50279922
    f1: remote is newer -> g
    f2: versions differ -> m
   
   calculating bids for ancestor 40663881a6dd
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 40663881a6dd, local: 3b08d01b0ab5+, remote: adfe50279922
    f1: versions differ -> m
    f2: remote unchanged -> k
   
   auction for merging merge bids
    f1: picking 'get' action
    f2: picking 'keep' action
   end of auction
   
    f1: remote is newer -> g
   getting f1
    f2: remote unchanged -> k
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
 Test the greatest common ancestor returning multiple changesets
 
   $ hg log -r 'heads(commonancestors(head()))'
   changeset:   1:0f6b37dbe527
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1 first change f1
   
   changeset:   2:40663881a6dd
   parent:      0:40494bf2444c
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2 first change f2
   
 
   $ cd ..
 
 http://stackoverflow.com/questions/9350005/how-do-i-specify-a-merge-base-to-use-in-a-hg-merge/9430810
 
   $ hg init ancestor-merging
   $ cd ancestor-merging
   $ echo a > x
   $ hg commit -A -m a x
   $ hg update -q 0
   $ echo b >> x
   $ hg commit -m b
   $ hg update -q 0
   $ echo c >> x
   $ hg commit -qm c
   $ hg update -q 1
   $ hg merge -q --tool internal:local 2
   $ echo c >> x
   $ hg commit -m bc
   $ hg update -q 2
   $ hg merge -q --tool internal:local 1
   $ echo b >> x
   $ hg commit -qm cb
 
   $ hg merge --config merge.preferancestor='!'
   note: using 70008a2163f6 as ancestor of 0d355fdef312 and 4b8b546a3eef
         alternatively, use --config merge.preferancestor=b211bbc6eb3c
   merging x
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ cat x
   a
   c
   b
   c
 
   $ hg up -qC .
 
   $ hg merge --config merge.preferancestor=b211bbc6eb3c
   note: using b211bbc6eb3c as ancestor of 0d355fdef312 and 4b8b546a3eef
         alternatively, use --config merge.preferancestor=70008a2163f6
   merging x
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ cat x
   a
   b
   c
   b
 
   $ hg up -qC .
 
   $ hg merge -v --config merge.preferancestor="*"
   note: merging 0d355fdef312+ and 4b8b546a3eef using bids from ancestors 70008a2163f6 and b211bbc6eb3c
   
   calculating bids for ancestor 70008a2163f6
   resolving manifests
   
   calculating bids for ancestor b211bbc6eb3c
   resolving manifests
   
   auction for merging merge bids
    x: multiple bids for merge action:
     versions differ -> m
     versions differ -> m
    x: ambiguous merge - picked m action
   end of auction
   
   merging x
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ cat x
   a
   c
   b
   c
 
 Verify that the old context ancestor works with / despite preferancestor:
 
   $ hg log -r 'ancestor(head())' --config merge.preferancestor=1 -T '{rev}\n'
   1
   $ hg log -r 'ancestor(head())' --config merge.preferancestor=2 -T '{rev}\n'
   2
   $ hg log -r 'ancestor(head())' --config merge.preferancestor=3 -T '{rev}\n'
   1
   $ hg log -r 'ancestor(head())' --config merge.preferancestor='1337 * - 2' -T '{rev}\n'
   2
 
   $ cd ..
 
   $ hg init issue5020
   $ cd issue5020
 
   $ echo a > noop
   $ hg ci -qAm initial
 
   $ echo b > noop
   $ hg ci -qAm 'uninteresting change'
 
   $ hg up -q 0
   $ mkdir d1
   $ echo a > d1/a
   $ echo b > d1/b
   $ hg ci -qAm 'add d1/a and d1/b'
 
   $ hg merge -q 1
   $ hg rm d1/a
   $ hg mv -q d1 d2
   $ hg ci -qm 'merge while removing d1/a and moving d1/b to d2/b'
 
   $ hg up -q 1
   $ hg merge -q 2
   $ hg ci -qm 'merge (no changes while merging)'
   $ hg log -G -T '{rev}:{node|short} {desc}'
   @    4:c0ef19750a22 merge (no changes while merging)
   |\
   +---o  3:6ca01f7342b9 merge while removing d1/a and moving d1/b to d2/b
   | |/
   | o  2:154e6000f54e add d1/a and d1/b
   | |
   o |  1:11b5b303e36c uninteresting change
   |/
   o  0:7b54db1ebf33 initial
   
   $ hg merge 3 --debug
   note: merging c0ef19750a22+ and 6ca01f7342b9 using bids from ancestors 11b5b303e36c and 154e6000f54e
   
   calculating bids for ancestor 11b5b303e36c
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 11b5b303e36c, local: c0ef19750a22+, remote: 6ca01f7342b9
    d2/b: remote created -> g
   
   calculating bids for ancestor 154e6000f54e
     unmatched files in other:
      d2/b
     all copies found (* = to merge, ! = divergent, % = renamed and deleted):
-     src: 'd1/b' -> dst: 'd2/b' 
+     on remote side:
+      src: 'd1/b' -> dst: 'd2/b' 
     checking for directory renames
      discovered dir src: 'd1/' -> dst: 'd2/'
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 154e6000f54e, local: c0ef19750a22+, remote: 6ca01f7342b9
    d1/a: other deleted -> r
    d1/b: other deleted -> r
    d2/b: remote created -> g
   
   auction for merging merge bids
    d1/a: consensus for r
    d1/b: consensus for r
    d2/b: consensus for g
   end of auction
   
    d1/a: other deleted -> r
   removing d1/a
    d1/b: other deleted -> r
   removing d1/b
    d2/b: remote created -> g
   getting d2/b
   1 files updated, 0 files merged, 2 files removed, 0 files unresolved
   (branch merge, don't forget to commit)

tests/test-rename-dir-merge.t

@@ -1,294 +1,296 b''
   $ hg init t
   $ cd t
 
   $ mkdir a
   $ echo foo > a/a
   $ echo bar > a/b
   $ hg ci -Am "0"
   adding a/a
   adding a/b
 
   $ hg co -C 0
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg mv a b
   moving a/a to b/a
   moving a/b to b/b
   $ hg ci -m "1 mv a/ b/"
 
   $ hg co -C 0
   2 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ echo baz > a/c
   $ echo quux > a/d
   $ hg add a/c
   $ hg ci -m "2 add a/c"
   created new head
 
   $ hg merge --debug 1
     unmatched files in local:
      a/c
     unmatched files in other:
      b/a
      b/b
     all copies found (* = to merge, ! = divergent, % = renamed and deleted):
-     src: 'a/a' -> dst: 'b/a' 
-     src: 'a/b' -> dst: 'b/b' 
+     on remote side:
+      src: 'a/a' -> dst: 'b/a' 
+      src: 'a/b' -> dst: 'b/b' 
     checking for directory renames
      discovered dir src: 'a/' -> dst: 'b/'
      pending file src: 'a/c' -> dst: 'b/c'
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: f9b20c0d4c51, local: ce36d17b18fb+, remote: 397f8b00a740
    a/a: other deleted -> r
   removing a/a
    a/b: other deleted -> r
   removing a/b
    b/a: remote created -> g
   getting b/a
    b/b: remote created -> g
   getting b/b
    b/c: remote directory rename - move from a/c -> dm
   moving a/c to b/c
   3 files updated, 0 files merged, 2 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ echo a/* b/*
   a/d b/a b/b b/c
   $ hg st -C
   M b/a
   M b/b
   A b/c
     a/c
   R a/a
   R a/b
   R a/c
   ? a/d
   $ hg ci -m "3 merge 2+1"
   $ hg debugrename b/c
   b/c renamed from a/c:354ae8da6e890359ef49ade27b68bbc361f3ca88
 
   $ hg co -C 1
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg merge --debug 2
     unmatched files in local:
      b/a
      b/b
     unmatched files in other:
      a/c
     all copies found (* = to merge, ! = divergent, % = renamed and deleted):
-     src: 'a/a' -> dst: 'b/a' 
-     src: 'a/b' -> dst: 'b/b' 
+     on local side:
+      src: 'a/a' -> dst: 'b/a' 
+      src: 'a/b' -> dst: 'b/b' 
     checking for directory renames
      discovered dir src: 'a/' -> dst: 'b/'
      pending file src: 'a/c' -> dst: 'b/c'
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: f9b20c0d4c51, local: 397f8b00a740+, remote: ce36d17b18fb
   starting 4 threads for background file closing (?)
    b/c: local directory rename - get from a/c -> dg
   getting a/c to b/c
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ echo a/* b/*
   a/d b/a b/b b/c
   $ hg st -C
   A b/c
     a/c
   ? a/d
   $ hg ci -m "4 merge 1+2"
   created new head
   $ hg debugrename b/c
   b/c renamed from a/c:354ae8da6e890359ef49ade27b68bbc361f3ca88
 
 Local directory rename with conflicting file added in remote source directory
 and untracked in local target directory.
 
   $ hg co -qC 1
   $ echo target > b/c
   $ hg merge 2
   b/c: untracked file differs
   abort: untracked files in working directory differ from files in requested revision
   [255]
   $ cat b/c
   target
 but it should succeed if the content matches
   $ hg cat -r 2 a/c > b/c
   $ hg merge 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg st -C
   A b/c
     a/c
   ? a/d
 
 Local directory rename with conflicting file added in remote source directory
 and committed in local target directory.
 
   $ hg co -qC 1
   $ echo target > b/c
   $ hg add b/c
   $ hg commit -qm 'new file in target directory'
   $ hg merge 2
   merging b/c and a/c to b/c
   warning: conflicts while merging b/c! (edit, then use 'hg resolve --mark')
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
   $ hg st -A
   M b/c
     a/c
   ? a/d
   ? b/c.orig
   C b/a
   C b/b
   $ cat b/c
   <<<<<<< working copy: f1c50ca4f127 - test: new file in target directory
   target
   =======
   baz
   >>>>>>> merge rev:    ce36d17b18fb - test: 2 add a/c
   $ rm b/c.orig
 
 Remote directory rename with conflicting file added in remote target directory
 and committed in local source directory.
 
   $ hg co -qC 2
   $ hg st -A
   ? a/d
   C a/a
   C a/b
   C a/c
   $ hg merge 5
   merging a/c and b/c to b/c
   warning: conflicts while merging b/c! (edit, then use 'hg resolve --mark')
   2 files updated, 0 files merged, 2 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
   $ hg st -A
   M b/a
   M b/b
   M b/c
     a/c
   R a/a
   R a/b
   R a/c
   ? a/d
   ? b/c.orig
   $ cat b/c
   <<<<<<< working copy: ce36d17b18fb - test: 2 add a/c
   baz
   =======
   target
   >>>>>>> merge rev:    f1c50ca4f127 - test: new file in target directory
 
 Second scenario with two repos:
 
   $ cd ..
   $ hg init r1
   $ cd r1
   $ mkdir a
   $ echo foo > a/f
   $ hg add a
   adding a/f
   $ hg ci -m "a/f == foo"
   $ cd ..
 
   $ hg clone r1 r2
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd r2
   $ hg mv a b
   moving a/f to b/f
   $ echo foo1 > b/f
   $ hg ci -m" a -> b, b/f == foo1"
   $ cd ..
 
   $ cd r1
   $ mkdir a/aa
   $ echo bar > a/aa/g
   $ hg add a/aa
   adding a/aa/g
   $ hg ci -m "a/aa/g"
   $ hg pull ../r2
   pulling from ../r2
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (+1 heads)
   new changesets 7d51ed18da25
   1 local changesets published
   (run 'hg heads' to see heads, 'hg merge' to merge)
 
   $ hg merge
   2 files updated, 0 files merged, 1 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ hg st -C
   M b/f
   A b/aa/g
     a/aa/g
   R a/aa/g
   R a/f
 
   $ cd ..
 
 Test renames to separate directories
 
   $ hg init a
   $ cd a
   $ mkdir a
   $ touch a/s
   $ touch a/t
   $ hg ci -Am0
   adding a/s
   adding a/t
 
 Add more files
 
   $ touch a/s2
   $ touch a/t2
   $ hg ci -Am1
   adding a/s2
   adding a/t2
 
 Do moves on a branch
 
   $ hg up 0
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ mkdir s
   $ mkdir t
   $ hg mv a/s s
   $ hg mv a/t t
   $ hg ci -Am2
   created new head
   $ hg st --copies --change .
   A s/s
     a/s
   A t/t
     a/t
   R a/s
   R a/t
 
 Merge shouldn't move s2, t2
 
   $ hg merge
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg st --copies
   M a/s2
   M a/t2
 
 Try the merge in the other direction. It may or may not be appropriate for
 status to list copies here.
 
   $ hg up -C 1
   4 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg merge
   2 files updated, 0 files merged, 2 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg st --copies
   M s/s
   M t/t
   R a/s
   R a/t

tests/test-rename-merge1.t

@@ -1,256 +1,262 b''
   $ hg init
 
   $ echo "[merge]" >> .hg/hgrc
   $ echo "followcopies = 1" >> .hg/hgrc
 
   $ echo foo > a
   $ echo foo > a2
   $ hg add a a2
   $ hg ci -m "start"
 
   $ hg mv a b
   $ hg mv a2 b2
   $ hg ci -m "rename"
 
   $ hg co 0
   2 files updated, 0 files merged, 2 files removed, 0 files unresolved
 
   $ echo blahblah > a
   $ echo blahblah > a2
   $ hg mv a2 c2
   $ hg ci -m "modify"
   created new head
 
   $ hg merge -y --debug
     unmatched files in local:
      c2
     unmatched files in other:
      b
      b2
     all copies found (* = to merge, ! = divergent, % = renamed and deleted):
-     src: 'a' -> dst: 'b' *
-     src: 'a2' -> dst: 'b2' !
-     src: 'a2' -> dst: 'c2' !
+     on local side:
+      src: 'a2' -> dst: 'c2' !
+     on remote side:
+      src: 'a' -> dst: 'b' *
+      src: 'a2' -> dst: 'b2' !
     checking for directory renames
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: af1939970a1c, local: 044f8520aeeb+, remote: 85c198ef2f6c
   note: possible conflict - a2 was renamed multiple times to:
    b2
    c2
    preserving a for resolve of b
   removing a
    b2: remote created -> g
   getting b2
    b: remote moved from a -> m (premerge)
   picked tool ':merge' for b (binary False symlink False changedelete False)
   merging a and b to b
   my b@044f8520aeeb+ other b@85c198ef2f6c ancestor a@af1939970a1c
    premerge successful
   1 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ hg status -AC
   M b
     a
   M b2
   R a
   C c2
 
   $ cat b
   blahblah
 
   $ hg ci -m "merge"
 
   $ hg debugindex b
      rev linkrev nodeid       p1           p2
        0       1 57eacc201a7f 000000000000 000000000000
        1       3 4727ba907962 000000000000 57eacc201a7f
 
   $ hg debugrename b
   b renamed from a:dd03b83622e78778b403775d0d074b9ac7387a66
 
 This used to trigger a "divergent renames" warning, despite no renames
 
   $ hg cp b b3
   $ hg cp b b4
   $ hg ci -A -m 'copy b twice'
   $ hg up '.^'
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg up
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg rm b3 b4
   $ hg ci -m 'clean up a bit of our mess'
 
 We'd rather not warn on divergent renames done in the same changeset (issue2113)
 
   $ hg cp b b3
   $ hg mv b b4
   $ hg ci -A -m 'divergent renames in same changeset'
   $ hg up '.^'
   1 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg up
   2 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
 Check for issue2642
 
   $ hg init t
   $ cd t
 
   $ echo c0 > f1
   $ hg ci -Aqm0
 
   $ hg up null -q
   $ echo c1 > f1 # backport
   $ hg ci -Aqm1
   $ hg mv f1 f2
   $ hg ci -qm2
 
   $ hg up 0 -q
   $ hg merge 1 -q --tool internal:local
   $ hg ci -qm3
 
   $ hg merge 2
   merging f1 and f2 to f2
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ cat f2
   c0
 
   $ cd ..
 
 Check for issue2089
 
   $ hg init repo2089
   $ cd repo2089
 
   $ echo c0 > f1
   $ hg ci -Aqm0
 
   $ hg up null -q
   $ echo c1 > f1
   $ hg ci -Aqm1
 
   $ hg up 0 -q
   $ hg merge 1 -q --tool internal:local
   $ echo c2 > f1
   $ hg ci -qm2
 
   $ hg up 1 -q
   $ hg mv f1 f2
   $ hg ci -Aqm3
 
   $ hg up 2 -q
   $ hg merge 3
   merging f1 and f2 to f2
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ cat f2
   c2
 
   $ cd ..
 
 Check for issue3074
 
   $ hg init repo3074
   $ cd repo3074
   $ echo foo > file
   $ hg add file
   $ hg commit -m "added file"
   $ hg mv file newfile
   $ hg commit -m "renamed file"
   $ hg update 0
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg rm file
   $ hg commit -m "deleted file"
   created new head
   $ hg merge --debug
     unmatched files in other:
      newfile
     all copies found (* = to merge, ! = divergent, % = renamed and deleted):
-     src: 'file' -> dst: 'newfile' %
+     on remote side:
+      src: 'file' -> dst: 'newfile' %
     checking for directory renames
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 19d7f95df299, local: 0084274f6b67+, remote: 5d32493049f0
   note: possible conflict - file was deleted and renamed to:
    newfile
    newfile: remote created -> g
   getting newfile
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg status
   M newfile
   $ cd ..
 
 Create x and y, then modify y and rename x to z on one side of merge, and
 modify x and rename y to z on the other side.
   $ hg init conflicting-target
   $ cd conflicting-target
   $ echo x > x
   $ echo y > y
   $ hg ci -Aqm 'add x and y'
   $ hg mv x z
   $ echo foo >> y
   $ hg ci -qm 'modify y, rename x to z'
   $ hg co -q 0
   $ hg mv y z
   $ echo foo >> x
   $ hg ci -qm 'modify x, rename y to z'
 # We should probably tell the user about the conflicting rename sources.
 # Depending on which side they pick, we should take that rename and get
 # the changes to the source from the other side. The unchanged file should
 # remain.
 # we should not get the prompts about modify/delete conflicts
   $ hg merge --debug 1 -t :merge3
     all copies found (* = to merge, ! = divergent, % = renamed and deleted):
-     src: 'x' -> dst: 'z' 
+     on local side:
+      src: 'y' -> dst: 'z' 
+     on remote side:
+      src: 'x' -> dst: 'z' 
     checking for directory renames
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 5151c134577e, local: 07fcbc9a74ed+, remote: f21419739508
    preserving x for resolve of x
    preserving z for resolve of z
   starting 4 threads for background file closing (?)
    x: prompt changed/deleted -> m (premerge)
   picked tool ':prompt' for x (binary False symlink False changedelete True)
   file 'x' was deleted in other [merge rev] but was modified in local [working copy].
   You can use (c)hanged version, (d)elete, or leave (u)nresolved.
   What do you want to do? u
    y: prompt deleted/changed -> m (premerge)
   picked tool ':prompt' for y (binary False symlink False changedelete True)
   file 'y' was deleted in local [working copy] but was modified in other [merge rev].
   You can use (c)hanged version, leave (d)eleted, or leave (u)nresolved.
   What do you want to do? u
    z: both created -> m (premerge)
   picked tool ':merge3' for z (binary False symlink False changedelete False)
   merging z
   my z@07fcbc9a74ed+ other z@f21419739508 ancestor z@000000000000
    z: both created -> m (merge)
   picked tool ':merge3' for z (binary False symlink False changedelete False)
   my z@07fcbc9a74ed+ other z@f21419739508 ancestor z@000000000000
   warning: conflicts while merging z! (edit, then use 'hg resolve --mark')
   0 files updated, 0 files merged, 0 files removed, 3 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
   $ ls
   x
   y
   z
   z.orig
   $ cat x
   x
   foo
   $ cat y
   y
   foo
 # 'z' should have had the added 'foo' line
   $ cat z
   <<<<<<< working copy: 07fcbc9a74ed - test: modify x, rename y to z
   y
   ||||||| base
   =======
   x
   >>>>>>> merge rev:    f21419739508 - test: modify y, rename x to z

tests/test-rename-merge2.t

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