context: write dirstate out explicitly after marking files as clean

To detect change of a file without redundant comparison of file
content, dirstate recognizes a file as certainly clean, if:

  (1) it is already known as "normal",
  (2) dirstate entry for it has valid (= not "-1") timestamp, and
  (3) mode, size and timestamp of it on the filesystem are as same as
      ones expected in dirstate

This works as expected in many cases, but doesn't in the corner case
that changing a file keeps mode, size and timestamp of it on the
filesystem.

The timetable below shows steps in one of typical such situations:

  ---- ----------------------------------- ----------------
                                           timestamp of "f"
                                           ----------------
                                           dirstate   file-
  time          action                     mem  file  system
  ---- ----------------------------------- ---- ----- -----
  N                                              -1    ***
       - make file "f" clean                            N

       - execute 'hg foobar'
         - instantiate 'dirstate'           -1   -1
         - 'dirstate.normal("f")'           N    -1
           (e.g. via dirty check)
         - change "f", but keep size                    N
  N+1
         - release wlock
           - 'dirstate.write()'             N    N

       - 'hg status' shows "f" as "clean"   N    N      N
  ---- ----------------------------------- ---- ----- -----

The most important point is that 'dirstate.write()' is executed at N+1
or later. This causes writing dirstate timestamp N of "f" out
successfully. If it is executed at N, 'parsers.pack_dirstate()'
replaces timestamp N with "-1" before actual writing dirstate out.

Occasional test failure for unexpected file status is typical example
of this corner case. Batch execution with small working directory is
finished in no time, and rarely satisfies condition (2) above.

This issue can occur in cases below;

  - 'hg revert --rev REV' for revisions other than the parent
  - failure of 'merge.update()' before 'merge.recordupdates()'

The root cause of this issue is that files are changed without
flushing in-memory dirstate changes via 'repo.commit()' (even though
omitting 'dirstate.normallookup()' on changed files also causes this
issue).

To detect changes of files correctly, this patch writes in-memory
dirstate changes out explicitly after marking files as clean in
'workingctx._checklookup()', which is invoked via 'repo.status()'.

After this change, timetable is changed as below:

  ---- ----------------------------------- ----------------
                                           timestamp of "f"
                                           ----------------
                                           dirstate   file-
  time          action                     mem  file  system
  ---- ----------------------------------- ---- ----- -----
  N                                              -1    ***
       - make file "f" clean                            N

       - execute 'hg foobar'
         - instantiate 'dirstate'           -1   -1
         - 'dirstate.normal("f")'           N    -1
           (e.g. via dirty check)
       ----------------------------------- ---- ----- -----
         - 'dirsttate.write()'              -1   -1
       ----------------------------------- ---- ----- -----
         - change "f", but keep size                    N
  N+1
         - release wlock
           - 'dirstate.write()'             -1   -1

       - 'hg status'                        -1   -1      N
  ---- ----------------------------------- ---- ----- -----

To reproduce this issue in tests certainly, this patch emulates some
timing critical actions as below:

  - timestamp of "f" in '.hg/dirstate' is -1 at the beginning

    'hg debugrebuildstate' before command invocation ensures it.

  - make file "f" clean at N
  - change "f" at N

    'touch -t 200001010000' before and after command invocation
    changes mtime of "f" to "2000-01-01 00:00" (= N).

  - invoke 'dirstate.write()' via 'repo.status()' at N

    'fakedirstatewritetime.py' forces 'pack_dirstate()' to use
    "2000-01-01 00:00" as "now", only if 'pack_dirstate()' is invoked
    via 'workingctx._checklookup()'.

  - invoke 'dirstate.write()' via releasing wlock at N+1 (or "not at N")

    'pack_dirstate()' via releasing wlock uses actual timestamp at
    runtime as "now", and it should be different from the "2000-01-01
    00:00" of "f".

BTW, this patch also changes 'test-largefiles-misc.t', because adding
'dirstate.write()' makes recent dirstate changes visible to external
process.

mercurial/context.py

@@ -1,1919 +1,1923 b''
 # context.py - changeset and file context objects for mercurial
 #
 # Copyright 2006, 2007 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 node import nullid, nullrev, wdirid, short, hex, bin
 from i18n import _
 import mdiff, error, util, scmutil, subrepo, patch, encoding, phases
 import match as matchmod
 import os, errno, stat
 import obsolete as obsmod
 import repoview
 import fileset
 import revlog
 
 propertycache = util.propertycache
 
 # Phony node value to stand-in for new files in some uses of
 # manifests. Manifests support 21-byte hashes for nodes which are
 # dirty in the working copy.
 _newnode = '!' * 21
 
 class basectx(object):
     """A basectx object represents the common logic for its children:
     changectx: read-only context that is already present in the repo,
     workingctx: a context that represents the working directory and can
                 be committed,
     memctx: a context that represents changes in-memory and can also
             be committed."""
     def __new__(cls, repo, changeid='', *args, **kwargs):
         if isinstance(changeid, basectx):
             return changeid
 
         o = super(basectx, cls).__new__(cls)
 
         o._repo = repo
         o._rev = nullrev
         o._node = nullid
 
         return o
 
     def __str__(self):
         return short(self.node())
 
     def __int__(self):
         return self.rev()
 
     def __repr__(self):
         return "<%s %s>" % (type(self).__name__, str(self))
 
     def __eq__(self, other):
         try:
             return type(self) == type(other) and self._rev == other._rev
         except AttributeError:
             return False
 
     def __ne__(self, other):
         return not (self == other)
 
     def __contains__(self, key):
         return key in self._manifest
 
     def __getitem__(self, key):
         return self.filectx(key)
 
     def __iter__(self):
         return iter(self._manifest)
 
     def _manifestmatches(self, match, s):
         """generate a new manifest filtered by the match argument
 
         This method is for internal use only and mainly exists to provide an
         object oriented way for other contexts to customize the manifest
         generation.
         """
         return self.manifest().matches(match)
 
     def _matchstatus(self, other, match):
         """return match.always if match is none
 
         This internal method provides a way for child objects to override the
         match operator.
         """
         return match or matchmod.always(self._repo.root, self._repo.getcwd())
 
     def _buildstatus(self, other, s, match, listignored, listclean,
                      listunknown):
         """build a status with respect to another context"""
         # Load earliest manifest first for caching reasons. More specifically,
         # if you have revisions 1000 and 1001, 1001 is probably stored as a
         # delta against 1000. Thus, if you read 1000 first, we'll reconstruct
         # 1000 and cache it so that when you read 1001, we just need to apply a
         # delta to what's in the cache. So that's one full reconstruction + one
         # delta application.
         if self.rev() is not None and self.rev() < other.rev():
             self.manifest()
         mf1 = other._manifestmatches(match, s)
         mf2 = self._manifestmatches(match, s)
 
         modified, added = [], []
         removed = []
         clean = []
         deleted, unknown, ignored = s.deleted, s.unknown, s.ignored
         deletedset = set(deleted)
         d = mf1.diff(mf2, clean=listclean)
         for fn, value in d.iteritems():
             if fn in deletedset:
                 continue
             if value is None:
                 clean.append(fn)
                 continue
             (node1, flag1), (node2, flag2) = value
             if node1 is None:
                 added.append(fn)
             elif node2 is None:
                 removed.append(fn)
             elif node2 != _newnode:
                 # The file was not a new file in mf2, so an entry
                 # from diff is really a difference.
                 modified.append(fn)
             elif self[fn].cmp(other[fn]):
                 # node2 was newnode, but the working file doesn't
                 # match the one in mf1.
                 modified.append(fn)
             else:
                 clean.append(fn)
 
         if removed:
             # need to filter files if they are already reported as removed
             unknown = [fn for fn in unknown if fn not in mf1]
             ignored = [fn for fn in ignored if fn not in mf1]
             # if they're deleted, don't report them as removed
             removed = [fn for fn in removed if fn not in deletedset]
 
         return scmutil.status(modified, added, removed, deleted, unknown,
                               ignored, clean)
 
     @propertycache
     def substate(self):
         return subrepo.state(self, self._repo.ui)
 
     def subrev(self, subpath):
         return self.substate[subpath][1]
 
     def rev(self):
         return self._rev
     def node(self):
         return self._node
     def hex(self):
         return hex(self.node())
     def manifest(self):
         return self._manifest
     def repo(self):
         return self._repo
     def phasestr(self):
         return phases.phasenames[self.phase()]
     def mutable(self):
         return self.phase() > phases.public
 
     def getfileset(self, expr):
         return fileset.getfileset(self, expr)
 
     def obsolete(self):
         """True if the changeset is obsolete"""
         return self.rev() in obsmod.getrevs(self._repo, 'obsolete')
 
     def extinct(self):
         """True if the changeset is extinct"""
         return self.rev() in obsmod.getrevs(self._repo, 'extinct')
 
     def unstable(self):
         """True if the changeset is not obsolete but it's ancestor are"""
         return self.rev() in obsmod.getrevs(self._repo, 'unstable')
 
     def bumped(self):
         """True if the changeset try to be a successor of a public changeset
 
         Only non-public and non-obsolete changesets may be bumped.
         """
         return self.rev() in obsmod.getrevs(self._repo, 'bumped')
 
     def divergent(self):
         """Is a successors of a changeset with multiple possible successors set
 
         Only non-public and non-obsolete changesets may be divergent.
         """
         return self.rev() in obsmod.getrevs(self._repo, 'divergent')
 
     def troubled(self):
         """True if the changeset is either unstable, bumped or divergent"""
         return self.unstable() or self.bumped() or self.divergent()
 
     def troubles(self):
         """return the list of troubles affecting this changesets.
 
         Troubles are returned as strings. possible values are:
         - unstable,
         - bumped,
         - divergent.
         """
         troubles = []
         if self.unstable():
             troubles.append('unstable')
         if self.bumped():
             troubles.append('bumped')
         if self.divergent():
             troubles.append('divergent')
         return troubles
 
     def parents(self):
         """return contexts for each parent changeset"""
         return self._parents
 
     def p1(self):
         return self._parents[0]
 
     def p2(self):
         if len(self._parents) == 2:
             return self._parents[1]
         return changectx(self._repo, -1)
 
     def _fileinfo(self, path):
         if '_manifest' in self.__dict__:
             try:
                 return self._manifest[path], self._manifest.flags(path)
             except KeyError:
                 raise error.ManifestLookupError(self._node, path,
                                                 _('not found in manifest'))
         if '_manifestdelta' in self.__dict__ or path in self.files():
             if path in self._manifestdelta:
                 return (self._manifestdelta[path],
                         self._manifestdelta.flags(path))
         node, flag = self._repo.manifest.find(self._changeset[0], path)
         if not node:
             raise error.ManifestLookupError(self._node, path,
                                             _('not found in manifest'))
 
         return node, flag
 
     def filenode(self, path):
         return self._fileinfo(path)[0]
 
     def flags(self, path):
         try:
             return self._fileinfo(path)[1]
         except error.LookupError:
             return ''
 
     def sub(self, path):
         '''return a subrepo for the stored revision of path, never wdir()'''
         return subrepo.subrepo(self, path)
 
     def nullsub(self, path, pctx):
         return subrepo.nullsubrepo(self, path, pctx)
 
     def workingsub(self, path):
         '''return a subrepo for the stored revision, or wdir if this is a wdir
         context.
         '''
         return subrepo.subrepo(self, path, allowwdir=True)
 
     def match(self, pats=[], include=None, exclude=None, default='glob',
               listsubrepos=False, badfn=None):
         r = self._repo
         return matchmod.match(r.root, r.getcwd(), pats,
                               include, exclude, default,
                               auditor=r.auditor, ctx=self,
                               listsubrepos=listsubrepos, badfn=badfn)
 
     def diff(self, ctx2=None, match=None, **opts):
         """Returns a diff generator for the given contexts and matcher"""
         if ctx2 is None:
             ctx2 = self.p1()
         if ctx2 is not None:
             ctx2 = self._repo[ctx2]
         diffopts = patch.diffopts(self._repo.ui, opts)
         return patch.diff(self._repo, ctx2, self, match=match, opts=diffopts)
 
     def dirs(self):
         return self._manifest.dirs()
 
     def hasdir(self, dir):
         return self._manifest.hasdir(dir)
 
     def dirty(self, missing=False, merge=True, branch=True):
         return False
 
     def status(self, other=None, match=None, listignored=False,
                listclean=False, listunknown=False, listsubrepos=False):
         """return status of files between two nodes or node and working
         directory.
 
         If other is None, compare this node with working directory.
 
         returns (modified, added, removed, deleted, unknown, ignored, clean)
         """
 
         ctx1 = self
         ctx2 = self._repo[other]
 
         # This next code block is, admittedly, fragile logic that tests for
         # reversing the contexts and wouldn't need to exist if it weren't for
         # the fast (and common) code path of comparing the working directory
         # with its first parent.
         #
         # What we're aiming for here is the ability to call:
         #
         # workingctx.status(parentctx)
         #
         # If we always built the manifest for each context and compared those,
         # then we'd be done. But the special case of the above call means we
         # just copy the manifest of the parent.
         reversed = False
         if (not isinstance(ctx1, changectx)
             and isinstance(ctx2, changectx)):
             reversed = True
             ctx1, ctx2 = ctx2, ctx1
 
         match = ctx2._matchstatus(ctx1, match)
         r = scmutil.status([], [], [], [], [], [], [])
         r = ctx2._buildstatus(ctx1, r, match, listignored, listclean,
                               listunknown)
 
         if reversed:
             # Reverse added and removed. Clear deleted, unknown and ignored as
             # these make no sense to reverse.
             r = scmutil.status(r.modified, r.removed, r.added, [], [], [],
                                r.clean)
 
         if listsubrepos:
             for subpath, sub in scmutil.itersubrepos(ctx1, ctx2):
                 rev2 = ctx2.subrev(subpath)
                 try:
                     submatch = matchmod.narrowmatcher(subpath, match)
                     s = sub.status(rev2, match=submatch, ignored=listignored,
                                    clean=listclean, unknown=listunknown,
                                    listsubrepos=True)
                     for rfiles, sfiles in zip(r, s):
                         rfiles.extend("%s/%s" % (subpath, f) for f in sfiles)
                 except error.LookupError:
                     self._repo.ui.status(_("skipping missing "
                                            "subrepository: %s\n") % subpath)
 
         for l in r:
             l.sort()
 
         return r
 
 
 def makememctx(repo, parents, text, user, date, branch, files, store,
                editor=None, extra=None):
     def getfilectx(repo, memctx, path):
         data, mode, copied = store.getfile(path)
         if data is None:
             return None
         islink, isexec = mode
         return memfilectx(repo, path, data, islink=islink, isexec=isexec,
                                   copied=copied, memctx=memctx)
     if extra is None:
         extra = {}
     if branch:
         extra['branch'] = encoding.fromlocal(branch)
     ctx =  memctx(repo, parents, text, files, getfilectx, user,
                           date, extra, editor)
     return ctx
 
 class changectx(basectx):
     """A changecontext object makes access to data related to a particular
     changeset convenient. It represents a read-only context already present in
     the repo."""
     def __init__(self, repo, changeid=''):
         """changeid is a revision number, node, or tag"""
 
         # since basectx.__new__ already took care of copying the object, we
         # don't need to do anything in __init__, so we just exit here
         if isinstance(changeid, basectx):
             return
 
         if changeid == '':
             changeid = '.'
         self._repo = repo
 
         try:
             if isinstance(changeid, int):
                 self._node = repo.changelog.node(changeid)
                 self._rev = changeid
                 return
             if isinstance(changeid, long):
                 changeid = str(changeid)
             if changeid == 'null':
                 self._node = nullid
                 self._rev = nullrev
                 return
             if changeid == 'tip':
                 self._node = repo.changelog.tip()
                 self._rev = repo.changelog.rev(self._node)
                 return
             if changeid == '.' or changeid == repo.dirstate.p1():
                 # this is a hack to delay/avoid loading obsmarkers
                 # when we know that '.' won't be hidden
                 self._node = repo.dirstate.p1()
                 self._rev = repo.unfiltered().changelog.rev(self._node)
                 return
             if len(changeid) == 20:
                 try:
                     self._node = changeid
                     self._rev = repo.changelog.rev(changeid)
                     return
                 except error.FilteredRepoLookupError:
                     raise
                 except LookupError:
                     pass
 
             try:
                 r = int(changeid)
                 if str(r) != changeid:
                     raise ValueError
                 l = len(repo.changelog)
                 if r < 0:
                     r += l
                 if r < 0 or r >= l:
                     raise ValueError
                 self._rev = r
                 self._node = repo.changelog.node(r)
                 return
             except error.FilteredIndexError:
                 raise
             except (ValueError, OverflowError, IndexError):
                 pass
 
             if len(changeid) == 40:
                 try:
                     self._node = bin(changeid)
                     self._rev = repo.changelog.rev(self._node)
                     return
                 except error.FilteredLookupError:
                     raise
                 except (TypeError, LookupError):
                     pass
 
             # lookup bookmarks through the name interface
             try:
                 self._node = repo.names.singlenode(repo, changeid)
                 self._rev = repo.changelog.rev(self._node)
                 return
             except KeyError:
                 pass
             except error.FilteredRepoLookupError:
                 raise
             except error.RepoLookupError:
                 pass
 
             self._node = repo.unfiltered().changelog._partialmatch(changeid)
             if self._node is not None:
                 self._rev = repo.changelog.rev(self._node)
                 return
 
             # lookup failed
             # check if it might have come from damaged dirstate
             #
             # XXX we could avoid the unfiltered if we had a recognizable
             # exception for filtered changeset access
             if changeid in repo.unfiltered().dirstate.parents():
                 msg = _("working directory has unknown parent '%s'!")
                 raise error.Abort(msg % short(changeid))
             try:
                 if len(changeid) == 20:
                     changeid = hex(changeid)
             except TypeError:
                 pass
         except (error.FilteredIndexError, error.FilteredLookupError,
                 error.FilteredRepoLookupError):
             if repo.filtername.startswith('visible'):
                 msg = _("hidden revision '%s'") % changeid
                 hint = _('use --hidden to access hidden revisions')
                 raise error.FilteredRepoLookupError(msg, hint=hint)
             msg = _("filtered revision '%s' (not in '%s' subset)")
             msg %= (changeid, repo.filtername)
             raise error.FilteredRepoLookupError(msg)
         except IndexError:
             pass
         raise error.RepoLookupError(
             _("unknown revision '%s'") % changeid)
 
     def __hash__(self):
         try:
             return hash(self._rev)
         except AttributeError:
             return id(self)
 
     def __nonzero__(self):
         return self._rev != nullrev
 
     @propertycache
     def _changeset(self):
         return self._repo.changelog.read(self.rev())
 
     @propertycache
     def _manifest(self):
         return self._repo.manifest.read(self._changeset[0])
 
     @propertycache
     def _manifestdelta(self):
         return self._repo.manifest.readdelta(self._changeset[0])
 
     @propertycache
     def _parents(self):
         p = self._repo.changelog.parentrevs(self._rev)
         if p[1] == nullrev:
             p = p[:-1]
         return [changectx(self._repo, x) for x in p]
 
     def changeset(self):
         return self._changeset
     def manifestnode(self):
         return self._changeset[0]
 
     def user(self):
         return self._changeset[1]
     def date(self):
         return self._changeset[2]
     def files(self):
         return self._changeset[3]
     def description(self):
         return self._changeset[4]
     def branch(self):
         return encoding.tolocal(self._changeset[5].get("branch"))
     def closesbranch(self):
         return 'close' in self._changeset[5]
     def extra(self):
         return self._changeset[5]
     def tags(self):
         return self._repo.nodetags(self._node)
     def bookmarks(self):
         return self._repo.nodebookmarks(self._node)
     def phase(self):
         return self._repo._phasecache.phase(self._repo, self._rev)
     def hidden(self):
         return self._rev in repoview.filterrevs(self._repo, 'visible')
 
     def children(self):
         """return contexts for each child changeset"""
         c = self._repo.changelog.children(self._node)
         return [changectx(self._repo, x) for x in c]
 
     def ancestors(self):
         for a in self._repo.changelog.ancestors([self._rev]):
             yield changectx(self._repo, a)
 
     def descendants(self):
         for d in self._repo.changelog.descendants([self._rev]):
             yield changectx(self._repo, d)
 
     def filectx(self, path, fileid=None, filelog=None):
         """get a file context from this changeset"""
         if fileid is None:
             fileid = self.filenode(path)
         return filectx(self._repo, path, fileid=fileid,
                        changectx=self, filelog=filelog)
 
     def ancestor(self, c2, warn=False):
         """return the "best" ancestor context of self and c2
 
         If there are multiple candidates, it will show a message and check
         merge.preferancestor configuration before falling back to the
         revlog ancestor."""
         # deal with workingctxs
         n2 = c2._node
         if n2 is None:
             n2 = c2._parents[0]._node
         cahs = self._repo.changelog.commonancestorsheads(self._node, n2)
         if not cahs:
             anc = nullid
         elif len(cahs) == 1:
             anc = cahs[0]
         else:
             for r in self._repo.ui.configlist('merge', 'preferancestor'):
                 try:
                     ctx = changectx(self._repo, r)
                 except error.RepoLookupError:
                     continue
                 anc = ctx.node()
                 if anc in cahs:
                     break
             else:
                 anc = self._repo.changelog.ancestor(self._node, n2)
             if warn:
                 self._repo.ui.status(
                     (_("note: using %s as ancestor of %s and %s\n") %
                      (short(anc), short(self._node), short(n2))) +
                     ''.join(_("      alternatively, use --config "
                               "merge.preferancestor=%s\n") %
                             short(n) for n in sorted(cahs) if n != anc))
         return changectx(self._repo, anc)
 
     def descendant(self, other):
         """True if other is descendant of this changeset"""
         return self._repo.changelog.descendant(self._rev, other._rev)
 
     def walk(self, match):
         '''Generates matching file names.'''
 
         # Wrap match.bad method to have message with nodeid
         def bad(fn, msg):
             # The manifest doesn't know about subrepos, so don't complain about
             # paths into valid subrepos.
             if any(fn == s or fn.startswith(s + '/')
                    for s in self.substate):
                 return
             match.bad(fn, _('no such file in rev %s') % self)
 
         m = matchmod.badmatch(match, bad)
         return self._manifest.walk(m)
 
     def matches(self, match):
         return self.walk(match)
 
 class basefilectx(object):
     """A filecontext object represents the common logic for its children:
     filectx: read-only access to a filerevision that is already present
              in the repo,
     workingfilectx: a filecontext that represents files from the working
                     directory,
     memfilectx: a filecontext that represents files in-memory."""
     def __new__(cls, repo, path, *args, **kwargs):
         return super(basefilectx, cls).__new__(cls)
 
     @propertycache
     def _filelog(self):
         return self._repo.file(self._path)
 
     @propertycache
     def _changeid(self):
         if '_changeid' in self.__dict__:
             return self._changeid
         elif '_changectx' in self.__dict__:
             return self._changectx.rev()
         elif '_descendantrev' in self.__dict__:
             # this file context was created from a revision with a known
             # descendant, we can (lazily) correct for linkrev aliases
             return self._adjustlinkrev(self._path, self._filelog,
                                        self._filenode, self._descendantrev)
         else:
             return self._filelog.linkrev(self._filerev)
 
     @propertycache
     def _filenode(self):
         if '_fileid' in self.__dict__:
             return self._filelog.lookup(self._fileid)
         else:
             return self._changectx.filenode(self._path)
 
     @propertycache
     def _filerev(self):
         return self._filelog.rev(self._filenode)
 
     @propertycache
     def _repopath(self):
         return self._path
 
     def __nonzero__(self):
         try:
             self._filenode
             return True
         except error.LookupError:
             # file is missing
             return False
 
     def __str__(self):
         return "%s@%s" % (self.path(), self._changectx)
 
     def __repr__(self):
         return "<%s %s>" % (type(self).__name__, str(self))
 
     def __hash__(self):
         try:
             return hash((self._path, self._filenode))
         except AttributeError:
             return id(self)
 
     def __eq__(self, other):
         try:
             return (type(self) == type(other) and self._path == other._path
                     and self._filenode == other._filenode)
         except AttributeError:
             return False
 
     def __ne__(self, other):
         return not (self == other)
 
     def filerev(self):
         return self._filerev
     def filenode(self):
         return self._filenode
     def flags(self):
         return self._changectx.flags(self._path)
     def filelog(self):
         return self._filelog
     def rev(self):
         return self._changeid
     def linkrev(self):
         return self._filelog.linkrev(self._filerev)
     def node(self):
         return self._changectx.node()
     def hex(self):
         return self._changectx.hex()
     def user(self):
         return self._changectx.user()
     def date(self):
         return self._changectx.date()
     def files(self):
         return self._changectx.files()
     def description(self):
         return self._changectx.description()
     def branch(self):
         return self._changectx.branch()
     def extra(self):
         return self._changectx.extra()
     def phase(self):
         return self._changectx.phase()
     def phasestr(self):
         return self._changectx.phasestr()
     def manifest(self):
         return self._changectx.manifest()
     def changectx(self):
         return self._changectx
     def repo(self):
         return self._repo
 
     def path(self):
         return self._path
 
     def isbinary(self):
         try:
             return util.binary(self.data())
         except IOError:
             return False
     def isexec(self):
         return 'x' in self.flags()
     def islink(self):
         return 'l' in self.flags()
 
     def cmp(self, fctx):
         """compare with other file context
 
         returns True if different than fctx.
         """
         if (fctx._filerev is None
             and (self._repo._encodefilterpats
                  # if file data starts with '\1\n', empty metadata block is
                  # prepended, which adds 4 bytes to filelog.size().
                  or self.size() - 4 == fctx.size())
             or self.size() == fctx.size()):
             return self._filelog.cmp(self._filenode, fctx.data())
 
         return True
 
     def _adjustlinkrev(self, path, filelog, fnode, srcrev, inclusive=False):
         """return the first ancestor of <srcrev> introducing <fnode>
 
         If the linkrev of the file revision does not point to an ancestor of
         srcrev, we'll walk down the ancestors until we find one introducing
         this file revision.
 
         :repo: a localrepository object (used to access changelog and manifest)
         :path: the file path
         :fnode: the nodeid of the file revision
         :filelog: the filelog of this path
         :srcrev: the changeset revision we search ancestors from
         :inclusive: if true, the src revision will also be checked
         """
         repo = self._repo
         cl = repo.unfiltered().changelog
         ma = repo.manifest
         # fetch the linkrev
         fr = filelog.rev(fnode)
         lkr = filelog.linkrev(fr)
         # hack to reuse ancestor computation when searching for renames
         memberanc = getattr(self, '_ancestrycontext', None)
         iteranc = None
         if srcrev is None:
             # wctx case, used by workingfilectx during mergecopy
             revs = [p.rev() for p in self._repo[None].parents()]
             inclusive = True # we skipped the real (revless) source
         else:
             revs = [srcrev]
         if memberanc is None:
             memberanc = iteranc = cl.ancestors(revs, lkr,
                                                inclusive=inclusive)
         # check if this linkrev is an ancestor of srcrev
         if lkr not in memberanc:
             if iteranc is None:
                 iteranc = cl.ancestors(revs, lkr, inclusive=inclusive)
             for a in iteranc:
                 ac = cl.read(a) # get changeset data (we avoid object creation)
                 if path in ac[3]: # checking the 'files' field.
                     # The file has been touched, check if the content is
                     # similar to the one we search for.
                     if fnode == ma.readfast(ac[0]).get(path):
                         return a
             # In theory, we should never get out of that loop without a result.
             # But if manifest uses a buggy file revision (not children of the
             # one it replaces) we could. Such a buggy situation will likely
             # result is crash somewhere else at to some point.
         return lkr
 
     def introrev(self):
         """return the rev of the changeset which introduced this file revision
 
         This method is different from linkrev because it take into account the
         changeset the filectx was created from. It ensures the returned
         revision is one of its ancestors. This prevents bugs from
         'linkrev-shadowing' when a file revision is used by multiple
         changesets.
         """
         lkr = self.linkrev()
         attrs = vars(self)
         noctx = not ('_changeid' in attrs or '_changectx' in attrs)
         if noctx or self.rev() == lkr:
             return self.linkrev()
         return self._adjustlinkrev(self._path, self._filelog, self._filenode,
                                    self.rev(), inclusive=True)
 
     def _parentfilectx(self, path, fileid, filelog):
         """create parent filectx keeping ancestry info for _adjustlinkrev()"""
         fctx = filectx(self._repo, path, fileid=fileid, filelog=filelog)
         if '_changeid' in vars(self) or '_changectx' in vars(self):
             # If self is associated with a changeset (probably explicitly
             # fed), ensure the created filectx is associated with a
             # changeset that is an ancestor of self.changectx.
             # This lets us later use _adjustlinkrev to get a correct link.
             fctx._descendantrev = self.rev()
             fctx._ancestrycontext = getattr(self, '_ancestrycontext', None)
         elif '_descendantrev' in vars(self):
             # Otherwise propagate _descendantrev if we have one associated.
             fctx._descendantrev = self._descendantrev
             fctx._ancestrycontext = getattr(self, '_ancestrycontext', None)
         return fctx
 
     def parents(self):
         _path = self._path
         fl = self._filelog
         parents = self._filelog.parents(self._filenode)
         pl = [(_path, node, fl) for node in parents if node != nullid]
 
         r = fl.renamed(self._filenode)
         if r:
             # - In the simple rename case, both parent are nullid, pl is empty.
             # - In case of merge, only one of the parent is null id and should
             # be replaced with the rename information. This parent is -always-
             # the first one.
             #
             # As null id have always been filtered out in the previous list
             # comprehension, inserting to 0 will always result in "replacing
             # first nullid parent with rename information.
             pl.insert(0, (r[0], r[1], self._repo.file(r[0])))
 
         return [self._parentfilectx(path, fnode, l) for path, fnode, l in pl]
 
     def p1(self):
         return self.parents()[0]
 
     def p2(self):
         p = self.parents()
         if len(p) == 2:
             return p[1]
         return filectx(self._repo, self._path, fileid=-1, filelog=self._filelog)
 
     def annotate(self, follow=False, linenumber=None, diffopts=None):
         '''returns a list of tuples of (ctx, line) for each line
         in the file, where ctx is the filectx of the node where
         that line was last changed.
         This returns tuples of ((ctx, linenumber), line) for each line,
         if "linenumber" parameter is NOT "None".
         In such tuples, linenumber means one at the first appearance
         in the managed file.
         To reduce annotation cost,
         this returns fixed value(False is used) as linenumber,
         if "linenumber" parameter is "False".'''
 
         if linenumber is None:
             def decorate(text, rev):
                 return ([rev] * len(text.splitlines()), text)
         elif linenumber:
             def decorate(text, rev):
                 size = len(text.splitlines())
                 return ([(rev, i) for i in xrange(1, size + 1)], text)
         else:
             def decorate(text, rev):
                 return ([(rev, False)] * len(text.splitlines()), text)
 
         def pair(parent, child):
             blocks = mdiff.allblocks(parent[1], child[1], opts=diffopts,
                                      refine=True)
             for (a1, a2, b1, b2), t in blocks:
                 # Changed blocks ('!') or blocks made only of blank lines ('~')
                 # belong to the child.
                 if t == '=':
                     child[0][b1:b2] = parent[0][a1:a2]
             return child
 
         getlog = util.lrucachefunc(lambda x: self._repo.file(x))
 
         def parents(f):
             # Cut _descendantrev here to mitigate the penalty of lazy linkrev
             # adjustment. Otherwise, p._adjustlinkrev() would walk changelog
             # from the topmost introrev (= srcrev) down to p.linkrev() if it
             # isn't an ancestor of the srcrev.
             f._changeid
             pl = f.parents()
 
             # Don't return renamed parents if we aren't following.
             if not follow:
                 pl = [p for p in pl if p.path() == f.path()]
 
             # renamed filectx won't have a filelog yet, so set it
             # from the cache to save time
             for p in pl:
                 if not '_filelog' in p.__dict__:
                     p._filelog = getlog(p.path())
 
             return pl
 
         # use linkrev to find the first changeset where self appeared
         base = self
         introrev = self.introrev()
         if self.rev() != introrev:
             base = self.filectx(self.filenode(), changeid=introrev)
         if getattr(base, '_ancestrycontext', None) is None:
             cl = self._repo.changelog
             if introrev is None:
                 # wctx is not inclusive, but works because _ancestrycontext
                 # is used to test filelog revisions
                 ac = cl.ancestors([p.rev() for p in base.parents()],
                                   inclusive=True)
             else:
                 ac = cl.ancestors([introrev], inclusive=True)
             base._ancestrycontext = ac
 
         # This algorithm would prefer to be recursive, but Python is a
         # bit recursion-hostile. Instead we do an iterative
         # depth-first search.
 
         visit = [base]
         hist = {}
         pcache = {}
         needed = {base: 1}
         while visit:
             f = visit[-1]
             pcached = f in pcache
             if not pcached:
                 pcache[f] = parents(f)
 
             ready = True
             pl = pcache[f]
             for p in pl:
                 if p not in hist:
                     ready = False
                     visit.append(p)
                 if not pcached:
                     needed[p] = needed.get(p, 0) + 1
             if ready:
                 visit.pop()
                 reusable = f in hist
                 if reusable:
                     curr = hist[f]
                 else:
                     curr = decorate(f.data(), f)
                 for p in pl:
                     if not reusable:
                         curr = pair(hist[p], curr)
                     if needed[p] == 1:
                         del hist[p]
                         del needed[p]
                     else:
                         needed[p] -= 1
 
                 hist[f] = curr
                 pcache[f] = []
 
         return zip(hist[base][0], hist[base][1].splitlines(True))
 
     def ancestors(self, followfirst=False):
         visit = {}
         c = self
         if followfirst:
             cut = 1
         else:
             cut = None
 
         while True:
             for parent in c.parents()[:cut]:
                 visit[(parent.linkrev(), parent.filenode())] = parent
             if not visit:
                 break
             c = visit.pop(max(visit))
             yield c
 
 class filectx(basefilectx):
     """A filecontext object makes access to data related to a particular
        filerevision convenient."""
     def __init__(self, repo, path, changeid=None, fileid=None,
                  filelog=None, changectx=None):
         """changeid can be a changeset revision, node, or tag.
            fileid can be a file revision or node."""
         self._repo = repo
         self._path = path
 
         assert (changeid is not None
                 or fileid is not None
                 or changectx is not None), \
                 ("bad args: changeid=%r, fileid=%r, changectx=%r"
                  % (changeid, fileid, changectx))
 
         if filelog is not None:
             self._filelog = filelog
 
         if changeid is not None:
             self._changeid = changeid
         if changectx is not None:
             self._changectx = changectx
         if fileid is not None:
             self._fileid = fileid
 
     @propertycache
     def _changectx(self):
         try:
             return changectx(self._repo, self._changeid)
         except error.FilteredRepoLookupError:
             # Linkrev may point to any revision in the repository.  When the
             # repository is filtered this may lead to `filectx` trying to build
             # `changectx` for filtered revision. In such case we fallback to
             # creating `changectx` on the unfiltered version of the reposition.
             # This fallback should not be an issue because `changectx` from
             # `filectx` are not used in complex operations that care about
             # filtering.
             #
             # This fallback is a cheap and dirty fix that prevent several
             # crashes. It does not ensure the behavior is correct. However the
             # behavior was not correct before filtering either and "incorrect
             # behavior" is seen as better as "crash"
             #
             # Linkrevs have several serious troubles with filtering that are
             # complicated to solve. Proper handling of the issue here should be
             # considered when solving linkrev issue are on the table.
             return changectx(self._repo.unfiltered(), self._changeid)
 
     def filectx(self, fileid, changeid=None):
         '''opens an arbitrary revision of the file without
         opening a new filelog'''
         return filectx(self._repo, self._path, fileid=fileid,
                        filelog=self._filelog, changeid=changeid)
 
     def data(self):
         try:
             return self._filelog.read(self._filenode)
         except error.CensoredNodeError:
             if self._repo.ui.config("censor", "policy", "abort") == "ignore":
                 return ""
             raise util.Abort(_("censored node: %s") % short(self._filenode),
                              hint=_("set censor.policy to ignore errors"))
 
     def size(self):
         return self._filelog.size(self._filerev)
 
     def renamed(self):
         """check if file was actually renamed in this changeset revision
 
         If rename logged in file revision, we report copy for changeset only
         if file revisions linkrev points back to the changeset in question
         or both changeset parents contain different file revisions.
         """
 
         renamed = self._filelog.renamed(self._filenode)
         if not renamed:
             return renamed
 
         if self.rev() == self.linkrev():
             return renamed
 
         name = self.path()
         fnode = self._filenode
         for p in self._changectx.parents():
             try:
                 if fnode == p.filenode(name):
                     return None
             except error.LookupError:
                 pass
         return renamed
 
     def children(self):
         # hard for renames
         c = self._filelog.children(self._filenode)
         return [filectx(self._repo, self._path, fileid=x,
                         filelog=self._filelog) for x in c]
 
 class committablectx(basectx):
     """A committablectx object provides common functionality for a context that
     wants the ability to commit, e.g. workingctx or memctx."""
     def __init__(self, repo, text="", user=None, date=None, extra=None,
                  changes=None):
         self._repo = repo
         self._rev = None
         self._node = None
         self._text = text
         if date:
             self._date = util.parsedate(date)
         if user:
             self._user = user
         if changes:
             self._status = changes
 
         self._extra = {}
         if extra:
             self._extra = extra.copy()
         if 'branch' not in self._extra:
             try:
                 branch = encoding.fromlocal(self._repo.dirstate.branch())
             except UnicodeDecodeError:
                 raise util.Abort(_('branch name not in UTF-8!'))
             self._extra['branch'] = branch
         if self._extra['branch'] == '':
             self._extra['branch'] = 'default'
 
     def __str__(self):
         return str(self._parents[0]) + "+"
 
     def __nonzero__(self):
         return True
 
     def _buildflagfunc(self):
         # Create a fallback function for getting file flags when the
         # filesystem doesn't support them
 
         copiesget = self._repo.dirstate.copies().get
 
         if len(self._parents) < 2:
             # when we have one parent, it's easy: copy from parent
             man = self._parents[0].manifest()
             def func(f):
                 f = copiesget(f, f)
                 return man.flags(f)
         else:
             # merges are tricky: we try to reconstruct the unstored
             # result from the merge (issue1802)
             p1, p2 = self._parents
             pa = p1.ancestor(p2)
             m1, m2, ma = p1.manifest(), p2.manifest(), pa.manifest()
 
             def func(f):
                 f = copiesget(f, f) # may be wrong for merges with copies
                 fl1, fl2, fla = m1.flags(f), m2.flags(f), ma.flags(f)
                 if fl1 == fl2:
                     return fl1
                 if fl1 == fla:
                     return fl2
                 if fl2 == fla:
                     return fl1
                 return '' # punt for conflicts
 
         return func
 
     @propertycache
     def _flagfunc(self):
         return self._repo.dirstate.flagfunc(self._buildflagfunc)
 
     @propertycache
     def _manifest(self):
         """generate a manifest corresponding to the values in self._status
 
         This reuse the file nodeid from parent, but we append an extra letter
         when modified. Modified files get an extra 'm' while added files get
         an extra 'a'. This is used by manifests merge to see that files
         are different and by update logic to avoid deleting newly added files.
         """
 
         man1 = self._parents[0].manifest()
         man = man1.copy()
         if len(self._parents) > 1:
             man2 = self.p2().manifest()
             def getman(f):
                 if f in man1:
                     return man1
                 return man2
         else:
             getman = lambda f: man1
 
         copied = self._repo.dirstate.copies()
         ff = self._flagfunc
         for i, l in (("a", self._status.added), ("m", self._status.modified)):
             for f in l:
                 orig = copied.get(f, f)
                 man[f] = getman(orig).get(orig, nullid) + i
                 try:
                     man.setflag(f, ff(f))
                 except OSError:
                     pass
 
         for f in self._status.deleted + self._status.removed:
             if f in man:
                 del man[f]
 
         return man
 
     @propertycache
     def _status(self):
         return self._repo.status()
 
     @propertycache
     def _user(self):
         return self._repo.ui.username()
 
     @propertycache
     def _date(self):
         return util.makedate()
 
     def subrev(self, subpath):
         return None
 
     def manifestnode(self):
         return None
     def user(self):
         return self._user or self._repo.ui.username()
     def date(self):
         return self._date
     def description(self):
         return self._text
     def files(self):
         return sorted(self._status.modified + self._status.added +
                       self._status.removed)
 
     def modified(self):
         return self._status.modified
     def added(self):
         return self._status.added
     def removed(self):
         return self._status.removed
     def deleted(self):
         return self._status.deleted
     def branch(self):
         return encoding.tolocal(self._extra['branch'])
     def closesbranch(self):
         return 'close' in self._extra
     def extra(self):
         return self._extra
 
     def tags(self):
         return []
 
     def bookmarks(self):
         b = []
         for p in self.parents():
             b.extend(p.bookmarks())
         return b
 
     def phase(self):
         phase = phases.draft # default phase to draft
         for p in self.parents():
             phase = max(phase, p.phase())
         return phase
 
     def hidden(self):
         return False
 
     def children(self):
         return []
 
     def flags(self, path):
         if '_manifest' in self.__dict__:
             try:
                 return self._manifest.flags(path)
             except KeyError:
                 return ''
 
         try:
             return self._flagfunc(path)
         except OSError:
             return ''
 
     def ancestor(self, c2):
         """return the "best" ancestor context of self and c2"""
         return self._parents[0].ancestor(c2) # punt on two parents for now
 
     def walk(self, match):
         '''Generates matching file names.'''
         return sorted(self._repo.dirstate.walk(match, sorted(self.substate),
                                                True, False))
 
     def matches(self, match):
         return sorted(self._repo.dirstate.matches(match))
 
     def ancestors(self):
         for p in self._parents:
             yield p
         for a in self._repo.changelog.ancestors(
             [p.rev() for p in self._parents]):
             yield changectx(self._repo, a)
 
     def markcommitted(self, node):
         """Perform post-commit cleanup necessary after committing this ctx
 
         Specifically, this updates backing stores this working context
         wraps to reflect the fact that the changes reflected by this
         workingctx have been committed.  For example, it marks
         modified and added files as normal in the dirstate.
 
         """
 
         self._repo.dirstate.beginparentchange()
         for f in self.modified() + self.added():
             self._repo.dirstate.normal(f)
         for f in self.removed():
             self._repo.dirstate.drop(f)
         self._repo.dirstate.setparents(node)
         self._repo.dirstate.endparentchange()
 
 class workingctx(committablectx):
     """A workingctx object makes access to data related to
     the current working directory convenient.
     date - any valid date string or (unixtime, offset), or None.
     user - username string, or None.
     extra - a dictionary of extra values, or None.
     changes - a list of file lists as returned by localrepo.status()
                or None to use the repository status.
     """
     def __init__(self, repo, text="", user=None, date=None, extra=None,
                  changes=None):
         super(workingctx, self).__init__(repo, text, user, date, extra, changes)
 
     def __iter__(self):
         d = self._repo.dirstate
         for f in d:
             if d[f] != 'r':
                 yield f
 
     def __contains__(self, key):
         return self._repo.dirstate[key] not in "?r"
 
     def hex(self):
         return hex(wdirid)
 
     @propertycache
     def _parents(self):
         p = self._repo.dirstate.parents()
         if p[1] == nullid:
             p = p[:-1]
         return [changectx(self._repo, x) for x in p]
 
     def filectx(self, path, filelog=None):
         """get a file context from the working directory"""
         return workingfilectx(self._repo, path, workingctx=self,
                               filelog=filelog)
 
     def dirty(self, missing=False, merge=True, branch=True):
         "check whether a working directory is modified"
         # check subrepos first
         for s in sorted(self.substate):
             if self.sub(s).dirty():
                 return True
         # check current working dir
         return ((merge and self.p2()) or
                 (branch and self.branch() != self.p1().branch()) or
                 self.modified() or self.added() or self.removed() or
                 (missing and self.deleted()))
 
     def add(self, list, prefix=""):
         join = lambda f: os.path.join(prefix, f)
         wlock = self._repo.wlock()
         ui, ds = self._repo.ui, self._repo.dirstate
         try:
             rejected = []
             lstat = self._repo.wvfs.lstat
             for f in list:
                 scmutil.checkportable(ui, join(f))
                 try:
                     st = lstat(f)
                 except OSError:
                     ui.warn(_("%s does not exist!\n") % join(f))
                     rejected.append(f)
                     continue
                 if st.st_size > 10000000:
                     ui.warn(_("%s: up to %d MB of RAM may be required "
                               "to manage this file\n"
                               "(use 'hg revert %s' to cancel the "
                               "pending addition)\n")
                               % (f, 3 * st.st_size // 1000000, join(f)))
                 if not (stat.S_ISREG(st.st_mode) or stat.S_ISLNK(st.st_mode)):
                     ui.warn(_("%s not added: only files and symlinks "
                               "supported currently\n") % join(f))
                     rejected.append(f)
                 elif ds[f] in 'amn':
                     ui.warn(_("%s already tracked!\n") % join(f))
                 elif ds[f] == 'r':
                     ds.normallookup(f)
                 else:
                     ds.add(f)
             return rejected
         finally:
             wlock.release()
 
     def forget(self, files, prefix=""):
         join = lambda f: os.path.join(prefix, f)
         wlock = self._repo.wlock()
         try:
             rejected = []
             for f in files:
                 if f not in self._repo.dirstate:
                     self._repo.ui.warn(_("%s not tracked!\n") % join(f))
                     rejected.append(f)
                 elif self._repo.dirstate[f] != 'a':
                     self._repo.dirstate.remove(f)
                 else:
                     self._repo.dirstate.drop(f)
             return rejected
         finally:
             wlock.release()
 
     def undelete(self, list):
         pctxs = self.parents()
         wlock = self._repo.wlock()
         try:
             for f in list:
                 if self._repo.dirstate[f] != 'r':
                     self._repo.ui.warn(_("%s not removed!\n") % f)
                 else:
                     fctx = f in pctxs[0] and pctxs[0][f] or pctxs[1][f]
                     t = fctx.data()
                     self._repo.wwrite(f, t, fctx.flags())
                     self._repo.dirstate.normal(f)
         finally:
             wlock.release()
 
     def copy(self, source, dest):
         try:
             st = self._repo.wvfs.lstat(dest)
         except OSError as err:
             if err.errno != errno.ENOENT:
                 raise
             self._repo.ui.warn(_("%s does not exist!\n") % dest)
             return
         if not (stat.S_ISREG(st.st_mode) or stat.S_ISLNK(st.st_mode)):
             self._repo.ui.warn(_("copy failed: %s is not a file or a "
                                  "symbolic link\n") % dest)
         else:
             wlock = self._repo.wlock()
             try:
                 if self._repo.dirstate[dest] in '?':
                     self._repo.dirstate.add(dest)
                 elif self._repo.dirstate[dest] in 'r':
                     self._repo.dirstate.normallookup(dest)
                 self._repo.dirstate.copy(source, dest)
             finally:
                 wlock.release()
 
     def match(self, pats=[], include=None, exclude=None, default='glob',
               listsubrepos=False, badfn=None):
         r = self._repo
 
         # Only a case insensitive filesystem needs magic to translate user input
         # to actual case in the filesystem.
         if not util.checkcase(r.root):
             return matchmod.icasefsmatcher(r.root, r.getcwd(), pats, include,
                                            exclude, default, r.auditor, self,
                                            listsubrepos=listsubrepos,
                                            badfn=badfn)
         return matchmod.match(r.root, r.getcwd(), pats,
                               include, exclude, default,
                               auditor=r.auditor, ctx=self,
                               listsubrepos=listsubrepos, badfn=badfn)
 
     def _filtersuspectsymlink(self, files):
         if not files or self._repo.dirstate._checklink:
             return files
 
         # Symlink placeholders may get non-symlink-like contents
         # via user error or dereferencing by NFS or Samba servers,
         # so we filter out any placeholders that don't look like a
         # symlink
         sane = []
         for f in files:
             if self.flags(f) == 'l':
                 d = self[f].data()
                 if d == '' or len(d) >= 1024 or '\n' in d or util.binary(d):
                     self._repo.ui.debug('ignoring suspect symlink placeholder'
                                         ' "%s"\n' % f)
                     continue
             sane.append(f)
         return sane
 
     def _checklookup(self, files):
         # check for any possibly clean files
         if not files:
             return [], []
 
         modified = []
         fixup = []
         pctx = self._parents[0]
         # do a full compare of any files that might have changed
         for f in sorted(files):
             if (f not in pctx or self.flags(f) != pctx.flags(f)
                 or pctx[f].cmp(self[f])):
                 modified.append(f)
             else:
                 fixup.append(f)
 
         # update dirstate for files that are actually clean
         if fixup:
             try:
                 # updating the dirstate is optional
                 # so we don't wait on the lock
                 # wlock can invalidate the dirstate, so cache normal _after_
                 # taking the lock
                 wlock = self._repo.wlock(False)
                 normal = self._repo.dirstate.normal
                 try:
                     for f in fixup:
                         normal(f)
+                    # write changes out explicitly, because nesting
+                    # wlock at runtime may prevent 'wlock.release()'
+                    # below from doing so for subsequent changing files
+                    self._repo.dirstate.write()
                 finally:
                     wlock.release()
             except error.LockError:
                 pass
         return modified, fixup
 
     def _manifestmatches(self, match, s):
         """Slow path for workingctx
 
         The fast path is when we compare the working directory to its parent
         which means this function is comparing with a non-parent; therefore we
         need to build a manifest and return what matches.
         """
         mf = self._repo['.']._manifestmatches(match, s)
         for f in s.modified + s.added:
             mf[f] = _newnode
             mf.setflag(f, self.flags(f))
         for f in s.removed:
             if f in mf:
                 del mf[f]
         return mf
 
     def _dirstatestatus(self, match=None, ignored=False, clean=False,
                         unknown=False):
         '''Gets the status from the dirstate -- internal use only.'''
         listignored, listclean, listunknown = ignored, clean, unknown
         match = match or matchmod.always(self._repo.root, self._repo.getcwd())
         subrepos = []
         if '.hgsub' in self:
             subrepos = sorted(self.substate)
         cmp, s = self._repo.dirstate.status(match, subrepos, listignored,
                                             listclean, listunknown)
 
         # check for any possibly clean files
         if cmp:
             modified2, fixup = self._checklookup(cmp)
             s.modified.extend(modified2)
 
             # update dirstate for files that are actually clean
             if fixup and listclean:
                 s.clean.extend(fixup)
 
         if match.always():
             # cache for performance
             if s.unknown or s.ignored or s.clean:
                 # "_status" is cached with list*=False in the normal route
                 self._status = scmutil.status(s.modified, s.added, s.removed,
                                               s.deleted, [], [], [])
             else:
                 self._status = s
 
         return s
 
     def _buildstatus(self, other, s, match, listignored, listclean,
                      listunknown):
         """build a status with respect to another context
 
         This includes logic for maintaining the fast path of status when
         comparing the working directory against its parent, which is to skip
         building a new manifest if self (working directory) is not comparing
         against its parent (repo['.']).
         """
         s = self._dirstatestatus(match, listignored, listclean, listunknown)
         # Filter out symlinks that, in the case of FAT32 and NTFS filesystems,
         # might have accidentally ended up with the entire contents of the file
         # they are supposed to be linking to.
         s.modified[:] = self._filtersuspectsymlink(s.modified)
         if other != self._repo['.']:
             s = super(workingctx, self)._buildstatus(other, s, match,
                                                      listignored, listclean,
                                                      listunknown)
         return s
 
     def _matchstatus(self, other, match):
         """override the match method with a filter for directory patterns
 
         We use inheritance to customize the match.bad method only in cases of
         workingctx since it belongs only to the working directory when
         comparing against the parent changeset.
 
         If we aren't comparing against the working directory's parent, then we
         just use the default match object sent to us.
         """
         superself = super(workingctx, self)
         match = superself._matchstatus(other, match)
         if other != self._repo['.']:
             def bad(f, msg):
                 # 'f' may be a directory pattern from 'match.files()',
                 # so 'f not in ctx1' is not enough
                 if f not in other and not other.hasdir(f):
                     self._repo.ui.warn('%s: %s\n' %
                                        (self._repo.dirstate.pathto(f), msg))
             match.bad = bad
         return match
 
 class committablefilectx(basefilectx):
     """A committablefilectx provides common functionality for a file context
     that wants the ability to commit, e.g. workingfilectx or memfilectx."""
     def __init__(self, repo, path, filelog=None, ctx=None):
         self._repo = repo
         self._path = path
         self._changeid = None
         self._filerev = self._filenode = None
 
         if filelog is not None:
             self._filelog = filelog
         if ctx:
             self._changectx = ctx
 
     def __nonzero__(self):
         return True
 
     def linkrev(self):
         # linked to self._changectx no matter if file is modified or not
         return self.rev()
 
     def parents(self):
         '''return parent filectxs, following copies if necessary'''
         def filenode(ctx, path):
             return ctx._manifest.get(path, nullid)
 
         path = self._path
         fl = self._filelog
         pcl = self._changectx._parents
         renamed = self.renamed()
 
         if renamed:
             pl = [renamed + (None,)]
         else:
             pl = [(path, filenode(pcl[0], path), fl)]
 
         for pc in pcl[1:]:
             pl.append((path, filenode(pc, path), fl))
 
         return [self._parentfilectx(p, fileid=n, filelog=l)
                 for p, n, l in pl if n != nullid]
 
     def children(self):
         return []
 
 class workingfilectx(committablefilectx):
     """A workingfilectx object makes access to data related to a particular
        file in the working directory convenient."""
     def __init__(self, repo, path, filelog=None, workingctx=None):
         super(workingfilectx, self).__init__(repo, path, filelog, workingctx)
 
     @propertycache
     def _changectx(self):
         return workingctx(self._repo)
 
     def data(self):
         return self._repo.wread(self._path)
     def renamed(self):
         rp = self._repo.dirstate.copied(self._path)
         if not rp:
             return None
         return rp, self._changectx._parents[0]._manifest.get(rp, nullid)
 
     def size(self):
         return self._repo.wvfs.lstat(self._path).st_size
     def date(self):
         t, tz = self._changectx.date()
         try:
             return (int(self._repo.wvfs.lstat(self._path).st_mtime), tz)
         except OSError as err:
             if err.errno != errno.ENOENT:
                 raise
             return (t, tz)
 
     def cmp(self, fctx):
         """compare with other file context
 
         returns True if different than fctx.
         """
         # fctx should be a filectx (not a workingfilectx)
         # invert comparison to reuse the same code path
         return fctx.cmp(self)
 
     def remove(self, ignoremissing=False):
         """wraps unlink for a repo's working directory"""
         util.unlinkpath(self._repo.wjoin(self._path), ignoremissing)
 
     def write(self, data, flags):
         """wraps repo.wwrite"""
         self._repo.wwrite(self._path, data, flags)
 
 class workingcommitctx(workingctx):
     """A workingcommitctx object makes access to data related to
     the revision being committed convenient.
 
     This hides changes in the working directory, if they aren't
     committed in this context.
     """
     def __init__(self, repo, changes,
                  text="", user=None, date=None, extra=None):
         super(workingctx, self).__init__(repo, text, user, date, extra,
                                          changes)
 
     def _dirstatestatus(self, match=None, ignored=False, clean=False,
                         unknown=False):
         """Return matched files only in ``self._status``
 
         Uncommitted files appear "clean" via this context, even if
         they aren't actually so in the working directory.
         """
         match = match or matchmod.always(self._repo.root, self._repo.getcwd())
         if clean:
             clean = [f for f in self._manifest if f not in self._changedset]
         else:
             clean = []
         return scmutil.status([f for f in self._status.modified if match(f)],
                               [f for f in self._status.added if match(f)],
                               [f for f in self._status.removed if match(f)],
                               [], [], [], clean)
 
     @propertycache
     def _changedset(self):
         """Return the set of files changed in this context
         """
         changed = set(self._status.modified)
         changed.update(self._status.added)
         changed.update(self._status.removed)
         return changed
 
 class memctx(committablectx):
     """Use memctx to perform in-memory commits via localrepo.commitctx().
 
     Revision information is supplied at initialization time while
     related files data and is made available through a callback
     mechanism.  'repo' is the current localrepo, 'parents' is a
     sequence of two parent revisions identifiers (pass None for every
     missing parent), 'text' is the commit message and 'files' lists
     names of files touched by the revision (normalized and relative to
     repository root).
 
     filectxfn(repo, memctx, path) is a callable receiving the
     repository, the current memctx object and the normalized path of
     requested file, relative to repository root. It is fired by the
     commit function for every file in 'files', but calls order is
     undefined. If the file is available in the revision being
     committed (updated or added), filectxfn returns a memfilectx
     object. If the file was removed, filectxfn raises an
     IOError. Moved files are represented by marking the source file
     removed and the new file added with copy information (see
     memfilectx).
 
     user receives the committer name and defaults to current
     repository username, date is the commit date in any format
     supported by util.parsedate() and defaults to current date, extra
     is a dictionary of metadata or is left empty.
     """
 
     # Mercurial <= 3.1 expects the filectxfn to raise IOError for missing files.
     # Extensions that need to retain compatibility across Mercurial 3.1 can use
     # this field to determine what to do in filectxfn.
     _returnnoneformissingfiles = True
 
     def __init__(self, repo, parents, text, files, filectxfn, user=None,
                  date=None, extra=None, editor=False):
         super(memctx, self).__init__(repo, text, user, date, extra)
         self._rev = None
         self._node = None
         parents = [(p or nullid) for p in parents]
         p1, p2 = parents
         self._parents = [changectx(self._repo, p) for p in (p1, p2)]
         files = sorted(set(files))
         self._files = files
         self.substate = {}
 
         # if store is not callable, wrap it in a function
         if not callable(filectxfn):
             def getfilectx(repo, memctx, path):
                 fctx = filectxfn[path]
                 # this is weird but apparently we only keep track of one parent
                 # (why not only store that instead of a tuple?)
                 copied = fctx.renamed()
                 if copied:
                     copied = copied[0]
                 return memfilectx(repo, path, fctx.data(),
                                   islink=fctx.islink(), isexec=fctx.isexec(),
                                   copied=copied, memctx=memctx)
             self._filectxfn = getfilectx
         else:
             # "util.cachefunc" reduces invocation of possibly expensive
             # "filectxfn" for performance (e.g. converting from another VCS)
             self._filectxfn = util.cachefunc(filectxfn)
 
         if extra:
             self._extra = extra.copy()
         else:
             self._extra = {}
 
         if self._extra.get('branch', '') == '':
             self._extra['branch'] = 'default'
 
         if editor:
             self._text = editor(self._repo, self, [])
             self._repo.savecommitmessage(self._text)
 
     def filectx(self, path, filelog=None):
         """get a file context from the working directory
 
         Returns None if file doesn't exist and should be removed."""
         return self._filectxfn(self._repo, self, path)
 
     def commit(self):
         """commit context to the repo"""
         return self._repo.commitctx(self)
 
     @propertycache
     def _manifest(self):
         """generate a manifest based on the return values of filectxfn"""
 
         # keep this simple for now; just worry about p1
         pctx = self._parents[0]
         man = pctx.manifest().copy()
 
         for f in self._status.modified:
             p1node = nullid
             p2node = nullid
             p = pctx[f].parents() # if file isn't in pctx, check p2?
             if len(p) > 0:
                 p1node = p[0].node()
                 if len(p) > 1:
                     p2node = p[1].node()
             man[f] = revlog.hash(self[f].data(), p1node, p2node)
 
         for f in self._status.added:
             man[f] = revlog.hash(self[f].data(), nullid, nullid)
 
         for f in self._status.removed:
             if f in man:
                 del man[f]
 
         return man
 
     @propertycache
     def _status(self):
         """Calculate exact status from ``files`` specified at construction
         """
         man1 = self.p1().manifest()
         p2 = self._parents[1]
         # "1 < len(self._parents)" can't be used for checking
         # existence of the 2nd parent, because "memctx._parents" is
         # explicitly initialized by the list, of which length is 2.
         if p2.node() != nullid:
             man2 = p2.manifest()
             managing = lambda f: f in man1 or f in man2
         else:
             managing = lambda f: f in man1
 
         modified, added, removed = [], [], []
         for f in self._files:
             if not managing(f):
                 added.append(f)
             elif self[f]:
                 modified.append(f)
             else:
                 removed.append(f)
 
         return scmutil.status(modified, added, removed, [], [], [], [])
 
 class memfilectx(committablefilectx):
     """memfilectx represents an in-memory file to commit.
 
     See memctx and committablefilectx for more details.
     """
     def __init__(self, repo, path, data, islink=False,
                  isexec=False, copied=None, memctx=None):
         """
         path is the normalized file path relative to repository root.
         data is the file content as a string.
         islink is True if the file is a symbolic link.
         isexec is True if the file is executable.
         copied is the source file path if current file was copied in the
         revision being committed, or None."""
         super(memfilectx, self).__init__(repo, path, None, memctx)
         self._data = data
         self._flags = (islink and 'l' or '') + (isexec and 'x' or '')
         self._copied = None
         if copied:
             self._copied = (copied, nullid)
 
     def data(self):
         return self._data
     def size(self):
         return len(self.data())
     def flags(self):
         return self._flags
     def renamed(self):
         return self._copied
 
     def remove(self, ignoremissing=False):
         """wraps unlink for a repo's working directory"""
         # need to figure out what to do here
         del self._changectx[self._path]
 
     def write(self, data, flags):
         """wraps repo.wwrite"""
         self._data = data

tests/test-largefiles-misc.t

@@ -1,1093 +1,1089 b''
 This file contains testcases that tend to be related to special cases or less
 common commands affecting largefile.
 
 Each sections should be independent of each others.
 
   $ USERCACHE="$TESTTMP/cache"; export USERCACHE
   $ mkdir "${USERCACHE}"
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > largefiles=
   > purge=
   > rebase=
   > transplant=
   > [phases]
   > publish=False
   > [largefiles]
   > minsize=2
   > patterns=glob:**.dat
   > usercache=${USERCACHE}
   > [hooks]
   > precommit=sh -c "echo \\"Invoking status precommit hook\\"; hg status"
   > EOF
 
 
 
 Test copies and moves from a directory other than root (issue3516)
 =========================================================================
 
   $ hg init lf_cpmv
   $ cd lf_cpmv
   $ mkdir dira
   $ mkdir dira/dirb
   $ touch dira/dirb/largefile
   $ hg add --large dira/dirb/largefile
   $ hg commit -m "added"
   Invoking status precommit hook
   A dira/dirb/largefile
   $ cd dira
   $ hg cp dirb/largefile foo/largefile
 
 TODO: Ideally, this should mention the largefile, not the standin
   $ hg log -T '{rev}\n' --stat 'set:clean()'
   0
    .hglf/dira/dirb/largefile |  1 +
    1 files changed, 1 insertions(+), 0 deletions(-)
   
   $ hg ci -m "deep copy"
   Invoking status precommit hook
   A dira/foo/largefile
   $ find . | sort
   .
   ./dirb
   ./dirb/largefile
   ./foo
   ./foo/largefile
   $ hg mv foo/largefile baz/largefile
   $ hg ci -m "moved"
   Invoking status precommit hook
   A dira/baz/largefile
   R dira/foo/largefile
   $ find . | sort
   .
   ./baz
   ./baz/largefile
   ./dirb
   ./dirb/largefile
   $ cd ..
   $ hg mv dira dirc
   moving .hglf/dira/baz/largefile to .hglf/dirc/baz/largefile (glob)
   moving .hglf/dira/dirb/largefile to .hglf/dirc/dirb/largefile (glob)
   $ find * | sort
   dirc
   dirc/baz
   dirc/baz/largefile
   dirc/dirb
   dirc/dirb/largefile
 
   $ hg clone -q . ../fetch
   $ hg --config extensions.fetch= fetch ../fetch
   abort: uncommitted changes
   [255]
   $ hg up -qC
   $ cd ..
 
 Clone a local repository owned by another user
 ===================================================
 
 #if unix-permissions
 
 We have to simulate that here by setting $HOME and removing write permissions
   $ ORIGHOME="$HOME"
   $ mkdir alice
   $ HOME="`pwd`/alice"
   $ cd alice
   $ hg init pubrepo
   $ cd pubrepo
   $ dd if=/dev/zero bs=1k count=11k > a-large-file 2> /dev/null
   $ hg add --large a-large-file
   $ hg commit -m "Add a large file"
   Invoking status precommit hook
   A a-large-file
   $ cd ..
   $ chmod -R a-w pubrepo
   $ cd ..
   $ mkdir bob
   $ HOME="`pwd`/bob"
   $ cd bob
   $ hg clone --pull ../alice/pubrepo pubrepo
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   updating to branch default
   getting changed largefiles
   1 largefiles updated, 0 removed
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ..
   $ chmod -R u+w alice/pubrepo
   $ HOME="$ORIGHOME"
 
 #endif
 
 
 Symlink to a large largefile should behave the same as a symlink to a normal file
 =====================================================================================
 
 #if symlink
 
   $ hg init largesymlink
   $ cd largesymlink
   $ dd if=/dev/zero bs=1k count=10k of=largefile 2>/dev/null
   $ hg add --large largefile
   $ hg commit -m "commit a large file"
   Invoking status precommit hook
   A largefile
   $ ln -s largefile largelink
   $ hg add largelink
   $ hg commit -m "commit a large symlink"
   Invoking status precommit hook
   A largelink
   $ rm -f largelink
   $ hg up >/dev/null
   $ test -f largelink
   [1]
   $ test -L largelink
   [1]
   $ rm -f largelink # make next part of the test independent of the previous
   $ hg up -C >/dev/null
   $ test -f largelink
   $ test -L largelink
   $ cd ..
 
 #endif
 
 
 test for pattern matching on 'hg status':
 ==============================================
 
 
 to boost performance, largefiles checks whether specified patterns are
 related to largefiles in working directory (NOT to STANDIN) or not.
 
   $ hg init statusmatch
   $ cd statusmatch
 
   $ mkdir -p a/b/c/d
   $ echo normal > a/b/c/d/e.normal.txt
   $ hg add a/b/c/d/e.normal.txt
   $ echo large > a/b/c/d/e.large.txt
   $ hg add --large a/b/c/d/e.large.txt
   $ mkdir -p a/b/c/x
   $ echo normal > a/b/c/x/y.normal.txt
   $ hg add a/b/c/x/y.normal.txt
   $ hg commit -m 'add files'
   Invoking status precommit hook
   A a/b/c/d/e.large.txt
   A a/b/c/d/e.normal.txt
   A a/b/c/x/y.normal.txt
 
 (1) no pattern: no performance boost
   $ hg status -A
   C a/b/c/d/e.large.txt
   C a/b/c/d/e.normal.txt
   C a/b/c/x/y.normal.txt
 
 (2) pattern not related to largefiles: performance boost
   $ hg status -A a/b/c/x
   C a/b/c/x/y.normal.txt
 
 (3) pattern related to largefiles: no performance boost
   $ hg status -A a/b/c/d
   C a/b/c/d/e.large.txt
   C a/b/c/d/e.normal.txt
 
 (4) pattern related to STANDIN (not to largefiles): performance boost
   $ hg status -A .hglf/a
   C .hglf/a/b/c/d/e.large.txt
 
 (5) mixed case: no performance boost
   $ hg status -A a/b/c/x a/b/c/d
   C a/b/c/d/e.large.txt
   C a/b/c/d/e.normal.txt
   C a/b/c/x/y.normal.txt
 
 verify that largefiles doesn't break filesets
 
   $ hg log --rev . --exclude "set:binary()"
   changeset:   0:41bd42f10efa
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add files
   
 verify that large files in subrepos handled properly
   $ hg init subrepo
   $ echo "subrepo = subrepo" > .hgsub
   $ hg add .hgsub
   $ hg ci -m "add subrepo"
   Invoking status precommit hook
   A .hgsub
   ? .hgsubstate
   $ echo "rev 1" > subrepo/large.txt
   $ hg add --large subrepo/large.txt
   $ hg sum
   parent: 1:8ee150ea2e9c tip
    add subrepo
   branch: default
   commit: 1 subrepos
   update: (current)
   phases: 2 draft
   $ hg st
   $ hg st -S
   A subrepo/large.txt
   $ hg ci -S -m "commit top repo"
   committing subrepository subrepo
   Invoking status precommit hook
   A large.txt
   Invoking status precommit hook
   M .hgsubstate
 # No differences
   $ hg st -S
   $ hg sum
   parent: 2:ce4cd0c527a6 tip
    commit top repo
   branch: default
   commit: (clean)
   update: (current)
   phases: 3 draft
   $ echo "rev 2" > subrepo/large.txt
   $ hg st -S
   M subrepo/large.txt
   $ hg sum
   parent: 2:ce4cd0c527a6 tip
    commit top repo
   branch: default
   commit: 1 subrepos
   update: (current)
   phases: 3 draft
   $ hg ci -m "this commit should fail without -S"
   abort: uncommitted changes in subrepository 'subrepo'
   (use --subrepos for recursive commit)
   [255]
 
 Add a normal file to the subrepo, then test archiving
 
   $ echo 'normal file' > subrepo/normal.txt
   $ touch large.dat
   $ mv subrepo/large.txt subrepo/renamed-large.txt
   $ hg addremove -S --dry-run
   adding large.dat as a largefile
   removing subrepo/large.txt
   adding subrepo/normal.txt
   adding subrepo/renamed-large.txt
   $ hg status -S
   ! subrepo/large.txt
   ? large.dat
   ? subrepo/normal.txt
   ? subrepo/renamed-large.txt
 
   $ hg addremove --dry-run subrepo
   removing subrepo/large.txt (glob)
   adding subrepo/normal.txt (glob)
   adding subrepo/renamed-large.txt (glob)
   $ hg status -S
   ! subrepo/large.txt
   ? large.dat
   ? subrepo/normal.txt
   ? subrepo/renamed-large.txt
   $ cd ..
 
   $ hg -R statusmatch addremove --dry-run statusmatch/subrepo
   removing statusmatch/subrepo/large.txt (glob)
   adding statusmatch/subrepo/normal.txt (glob)
   adding statusmatch/subrepo/renamed-large.txt (glob)
   $ hg -R statusmatch status -S
   ! subrepo/large.txt
   ? large.dat
   ? subrepo/normal.txt
   ? subrepo/renamed-large.txt
 
   $ hg -R statusmatch addremove --dry-run -S
   adding large.dat as a largefile
   removing subrepo/large.txt
   adding subrepo/normal.txt
   adding subrepo/renamed-large.txt
   $ cd statusmatch
 
   $ mv subrepo/renamed-large.txt subrepo/large.txt
   $ hg addremove subrepo
   adding subrepo/normal.txt (glob)
   $ hg forget subrepo/normal.txt
 
   $ hg addremove -S
   adding large.dat as a largefile
   adding subrepo/normal.txt
   $ rm large.dat
 
   $ hg addremove subrepo
   $ hg addremove -S
   removing large.dat
 
 Lock in subrepo, otherwise the change isn't archived
 
   $ hg ci -S -m "add normal file to top level"
   committing subrepository subrepo
   Invoking status precommit hook
   M large.txt
   A normal.txt
   Invoking status precommit hook
   M .hgsubstate
   $ hg archive -S ../lf_subrepo_archive
   $ find ../lf_subrepo_archive | sort
   ../lf_subrepo_archive
   ../lf_subrepo_archive/.hg_archival.txt
   ../lf_subrepo_archive/.hgsub
   ../lf_subrepo_archive/.hgsubstate
   ../lf_subrepo_archive/a
   ../lf_subrepo_archive/a/b
   ../lf_subrepo_archive/a/b/c
   ../lf_subrepo_archive/a/b/c/d
   ../lf_subrepo_archive/a/b/c/d/e.large.txt
   ../lf_subrepo_archive/a/b/c/d/e.normal.txt
   ../lf_subrepo_archive/a/b/c/x
   ../lf_subrepo_archive/a/b/c/x/y.normal.txt
   ../lf_subrepo_archive/subrepo
   ../lf_subrepo_archive/subrepo/large.txt
   ../lf_subrepo_archive/subrepo/normal.txt
   $ cat ../lf_subrepo_archive/.hg_archival.txt
   repo: 41bd42f10efa43698cc02052ea0977771cba506d
   node: d56a95e6522858bc08a724c4fe2bdee066d1c30b
   branch: default
   latesttag: null
   latesttagdistance: 4
   changessincelatesttag: 4
 
 Test update with subrepos.
 
   $ hg update 0
   getting changed largefiles
   0 largefiles updated, 1 removed
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg status -S
   $ hg update tip
   getting changed largefiles
   1 largefiles updated, 0 removed
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg status -S
 # modify a large file
   $ echo "modified" > subrepo/large.txt
   $ hg st -S
   M subrepo/large.txt
 # update -C should revert the change.
   $ hg update -C
   getting changed largefiles
   1 largefiles updated, 0 removed
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg status -S
 
   $ hg forget -v subrepo/large.txt
   removing subrepo/large.txt (glob)
 
 Test reverting a forgotten file
   $ hg revert -R subrepo subrepo/large.txt
   $ hg status -SA subrepo/large.txt
   C subrepo/large.txt
 
   $ hg rm -v subrepo/large.txt
   removing subrepo/large.txt (glob)
   $ hg revert -R subrepo subrepo/large.txt
   $ rm subrepo/large.txt
   $ hg addremove -S
   removing subrepo/large.txt
   $ hg st -S
   R subrepo/large.txt
 
 Test archiving a revision that references a subrepo that is not yet
 cloned (see test-subrepo-recursion.t):
 
   $ hg clone -U . ../empty
   $ cd ../empty
   $ hg archive --subrepos -r tip ../archive.tar.gz
   cloning subrepo subrepo from $TESTTMP/statusmatch/subrepo
   $ cd ..
 
 
 
 
 
 
 Test addremove, forget and others
 ==============================================
 
 Test that addremove picks up largefiles prior to the initial commit (issue3541)
 
   $ hg init addrm2
   $ cd addrm2
   $ touch large.dat
   $ touch large2.dat
   $ touch normal
   $ hg add --large large.dat
   $ hg addremove -v
   adding large2.dat as a largefile
   adding normal
 
 Test that forgetting all largefiles reverts to islfilesrepo() == False
 (addremove will add *.dat as normal files now)
   $ hg forget large.dat
   $ hg forget large2.dat
   $ hg addremove -v
   adding large.dat
   adding large2.dat
 
 Test commit's addremove option prior to the first commit
   $ hg forget large.dat
   $ hg forget large2.dat
   $ hg add --large large.dat
   $ hg ci -Am "commit"
   adding large2.dat as a largefile
   Invoking status precommit hook
   A large.dat
   A large2.dat
   A normal
   $ find .hglf | sort
   .hglf
   .hglf/large.dat
   .hglf/large2.dat
 
 Test actions on largefiles using relative paths from subdir
 
   $ mkdir sub
   $ cd sub
   $ echo anotherlarge > anotherlarge
   $ hg add --large anotherlarge
   $ hg st
   A sub/anotherlarge
   $ hg st anotherlarge
   A anotherlarge
   $ hg commit -m anotherlarge anotherlarge
   Invoking status precommit hook
   A sub/anotherlarge
   $ hg log anotherlarge
   changeset:   1:9627a577c5e9
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     anotherlarge
   
   $ hg --debug log -T '{rev}: {desc}\n' ../sub/anotherlarge
   updated patterns: ['../.hglf/sub/../sub/anotherlarge', '../sub/anotherlarge']
   1: anotherlarge
 
   $ hg log -G anotherlarge
   @  changeset:   1:9627a577c5e9
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     anotherlarge
   |
 
   $ hg log glob:another*
   changeset:   1:9627a577c5e9
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     anotherlarge
   
   $ hg --debug log -T '{rev}: {desc}\n' -G glob:another*
   updated patterns: ['glob:../.hglf/sub/another*', 'glob:another*']
   @  1: anotherlarge
   |
 
 #if no-msys
   $ hg --debug log -T '{rev}: {desc}\n' 'glob:../.hglf/sub/another*' # no-msys
   updated patterns: ['glob:../.hglf/sub/another*']
   1: anotherlarge
 
   $ hg --debug log -G -T '{rev}: {desc}\n' 'glob:../.hglf/sub/another*' # no-msys
   updated patterns: ['glob:../.hglf/sub/another*']
   @  1: anotherlarge
   |
 #endif
 
   $ echo more >> anotherlarge
   $ hg st .
   M anotherlarge
   $ hg cat anotherlarge
   anotherlarge
   $ hg revert anotherlarge
   $ hg st
   ? sub/anotherlarge.orig
   $ cd ..
 
 Test glob logging from the root dir
   $ hg log glob:**another*
   changeset:   1:9627a577c5e9
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     anotherlarge
   
   $ hg log -G glob:**another*
   @  changeset:   1:9627a577c5e9
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     anotherlarge
   |
 
   $ cd ..
 
 Log from outer space
   $ hg --debug log -R addrm2 -T '{rev}: {desc}\n' 'addrm2/sub/anotherlarge'
   updated patterns: ['addrm2/.hglf/sub/anotherlarge', 'addrm2/sub/anotherlarge']
   1: anotherlarge
   $ hg --debug log -R addrm2 -T '{rev}: {desc}\n' 'addrm2/.hglf/sub/anotherlarge'
   updated patterns: ['addrm2/.hglf/sub/anotherlarge']
   1: anotherlarge
 
 
 Check error message while exchange
 =========================================================
 
 issue3651: summary/outgoing with largefiles shows "no remote repo"
 unexpectedly
 
   $ mkdir issue3651
   $ cd issue3651
 
   $ hg init src
   $ echo a > src/a
   $ hg -R src add --large src/a
   $ hg -R src commit -m '#0'
   Invoking status precommit hook
   A a
 
 check messages when no remote repository is specified:
 "no remote repo" route for "hg outgoing --large" is not tested here,
 because it can't be reproduced easily.
 
   $ hg init clone1
   $ hg -R clone1 -q pull src
   $ hg -R clone1 -q update
   $ hg -R clone1 paths | grep default
   [1]
 
   $ hg -R clone1 summary --large
   parent: 0:fc0bd45326d3 tip
    #0
   branch: default
   commit: (clean)
   update: (current)
   phases: 1 draft
   largefiles: (no remote repo)
 
 check messages when there is no files to upload:
 
   $ hg -q clone src clone2
   $ hg -R clone2 paths | grep default
   default = $TESTTMP/issue3651/src (glob)
 
   $ hg -R clone2 summary --large
   parent: 0:fc0bd45326d3 tip
    #0
   branch: default
   commit: (clean)
   update: (current)
   phases: 1 draft
   largefiles: (no files to upload)
   $ hg -R clone2 outgoing --large
   comparing with $TESTTMP/issue3651/src (glob)
   searching for changes
   no changes found
   largefiles: no files to upload
   [1]
 
   $ hg -R clone2 outgoing --large --graph --template "{rev}"
   comparing with $TESTTMP/issue3651/src (glob)
   searching for changes
   no changes found
   largefiles: no files to upload
 
 check messages when there are files to upload:
 
   $ echo b > clone2/b
   $ hg -R clone2 add --large clone2/b
   $ hg -R clone2 commit -m '#1'
   Invoking status precommit hook
   A b
   $ hg -R clone2 summary --large
   parent: 1:1acbe71ce432 tip
    #1
   branch: default
   commit: (clean)
   update: (current)
   phases: 2 draft
   largefiles: 1 entities for 1 files to upload
   $ hg -R clone2 outgoing --large
   comparing with $TESTTMP/issue3651/src (glob)
   searching for changes
   changeset:   1:1acbe71ce432
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     #1
   
   largefiles to upload (1 entities):
   b
   
   $ hg -R clone2 outgoing --large --graph --template "{rev}"
   comparing with $TESTTMP/issue3651/src (glob)
   searching for changes
   @  1
   
   largefiles to upload (1 entities):
   b
   
 
   $ cp clone2/b clone2/b1
   $ cp clone2/b clone2/b2
   $ hg -R clone2 add --large clone2/b1 clone2/b2
   $ hg -R clone2 commit -m '#2: add largefiles referring same entity'
   Invoking status precommit hook
   A b1
   A b2
   $ hg -R clone2 summary --large
   parent: 2:6095d0695d70 tip
    #2: add largefiles referring same entity
   branch: default
   commit: (clean)
   update: (current)
   phases: 3 draft
   largefiles: 1 entities for 3 files to upload
   $ hg -R clone2 outgoing --large -T "{rev}:{node|short}\n"
   comparing with $TESTTMP/issue3651/src (glob)
   searching for changes
   1:1acbe71ce432
   2:6095d0695d70
   largefiles to upload (1 entities):
   b
   b1
   b2
   
   $ hg -R clone2 cat -r 1 clone2/.hglf/b
   89e6c98d92887913cadf06b2adb97f26cde4849b
   $ hg -R clone2 outgoing --large -T "{rev}:{node|short}\n" --debug --config progress.debug=true
   comparing with $TESTTMP/issue3651/src (glob)
   query 1; heads
   searching for changes
   all remote heads known locally
   1:1acbe71ce432
   2:6095d0695d70
   finding outgoing largefiles: 0/2 revision (0.00%)
   finding outgoing largefiles: 1/2 revision (50.00%)
   largefiles to upload (1 entities):
   b
       89e6c98d92887913cadf06b2adb97f26cde4849b
   b1
       89e6c98d92887913cadf06b2adb97f26cde4849b
   b2
       89e6c98d92887913cadf06b2adb97f26cde4849b
   
 
   $ echo bbb > clone2/b
   $ hg -R clone2 commit -m '#3: add new largefile entity as existing file'
   Invoking status precommit hook
   M b
   $ echo bbbb > clone2/b
   $ hg -R clone2 commit -m '#4: add new largefile entity as existing file'
   Invoking status precommit hook
   M b
   $ cp clone2/b1 clone2/b
   $ hg -R clone2 commit -m '#5: refer existing largefile entity again'
   Invoking status precommit hook
   M b
   $ hg -R clone2 summary --large
   parent: 5:036794ea641c tip
    #5: refer existing largefile entity again
   branch: default
   commit: (clean)
   update: (current)
   phases: 6 draft
   largefiles: 3 entities for 3 files to upload
   $ hg -R clone2 outgoing --large -T "{rev}:{node|short}\n"
   comparing with $TESTTMP/issue3651/src (glob)
   searching for changes
   1:1acbe71ce432
   2:6095d0695d70
   3:7983dce246cc
   4:233f12ada4ae
   5:036794ea641c
   largefiles to upload (3 entities):
   b
   b1
   b2
   
   $ hg -R clone2 cat -r 3 clone2/.hglf/b
   c801c9cfe94400963fcb683246217d5db77f9a9a
   $ hg -R clone2 cat -r 4 clone2/.hglf/b
   13f9ed0898e315bf59dc2973fec52037b6f441a2
   $ hg -R clone2 outgoing --large -T "{rev}:{node|short}\n" --debug --config progress.debug=true
   comparing with $TESTTMP/issue3651/src (glob)
   query 1; heads
   searching for changes
   all remote heads known locally
   1:1acbe71ce432
   2:6095d0695d70
   3:7983dce246cc
   4:233f12ada4ae
   5:036794ea641c
   finding outgoing largefiles: 0/5 revision (0.00%)
   finding outgoing largefiles: 1/5 revision (20.00%)
   finding outgoing largefiles: 2/5 revision (40.00%)
   finding outgoing largefiles: 3/5 revision (60.00%)
   finding outgoing largefiles: 4/5 revision (80.00%)
   largefiles to upload (3 entities):
   b
       13f9ed0898e315bf59dc2973fec52037b6f441a2
       89e6c98d92887913cadf06b2adb97f26cde4849b
       c801c9cfe94400963fcb683246217d5db77f9a9a
   b1
       89e6c98d92887913cadf06b2adb97f26cde4849b
   b2
       89e6c98d92887913cadf06b2adb97f26cde4849b
   
 
 Pushing revision #1 causes uploading entity 89e6c98d9288, which is
 shared also by largefiles b1, b2 in revision #2 and b in revision #5.
 
 Then, entity 89e6c98d9288 is not treated as "outgoing entity" at "hg
 summary" and "hg outgoing", even though files in outgoing revision #2
 and #5 refer it.
 
   $ hg -R clone2 push -r 1 -q
   $ hg -R clone2 summary --large
   parent: 5:036794ea641c tip
    #5: refer existing largefile entity again
   branch: default
   commit: (clean)
   update: (current)
   phases: 6 draft
   largefiles: 2 entities for 1 files to upload
   $ hg -R clone2 outgoing --large -T "{rev}:{node|short}\n"
   comparing with $TESTTMP/issue3651/src (glob)
   searching for changes
   2:6095d0695d70
   3:7983dce246cc
   4:233f12ada4ae
   5:036794ea641c
   largefiles to upload (2 entities):
   b
   
   $ hg -R clone2 outgoing --large -T "{rev}:{node|short}\n" --debug --config progress.debug=true
   comparing with $TESTTMP/issue3651/src (glob)
   query 1; heads
   searching for changes
   all remote heads known locally
   2:6095d0695d70
   3:7983dce246cc
   4:233f12ada4ae
   5:036794ea641c
   finding outgoing largefiles: 0/4 revision (0.00%)
   finding outgoing largefiles: 1/4 revision (25.00%)
   finding outgoing largefiles: 2/4 revision (50.00%)
   finding outgoing largefiles: 3/4 revision (75.00%)
   largefiles to upload (2 entities):
   b
       13f9ed0898e315bf59dc2973fec52037b6f441a2
       c801c9cfe94400963fcb683246217d5db77f9a9a
   
 
   $ cd ..
 
 merge action 'd' for 'local renamed directory to d2/g' which has no filename
 ==================================================================================
 
   $ hg init merge-action
   $ cd merge-action
   $ touch l
   $ hg add --large l
   $ mkdir d1
   $ touch d1/f
   $ hg ci -Aqm0
   Invoking status precommit hook
   A d1/f
   A l
   $ echo > d1/f
   $ touch d1/g
   $ hg ci -Aqm1
   Invoking status precommit hook
   M d1/f
   A d1/g
   $ hg up -qr0
   $ hg mv d1 d2
   moving d1/f to d2/f (glob)
   $ hg ci -qm2
   Invoking status precommit hook
   A d2/f
   R d1/f
   $ hg merge
   merging d2/f and d1/f to d2/f
   1 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ cd ..
 
 
 Merge conflicts:
 =====================
 
   $ hg init merge
   $ cd merge
   $ echo 0 > f-different
   $ echo 0 > f-same
   $ echo 0 > f-unchanged-1
   $ echo 0 > f-unchanged-2
   $ hg add --large *
   $ hg ci -m0
   Invoking status precommit hook
   A f-different
   A f-same
   A f-unchanged-1
   A f-unchanged-2
   $ echo tmp1 > f-unchanged-1
   $ echo tmp1 > f-unchanged-2
   $ echo tmp1 > f-same
   $ hg ci -m1
   Invoking status precommit hook
   M f-same
   M f-unchanged-1
   M f-unchanged-2
   $ echo 2 > f-different
   $ echo 0 > f-unchanged-1
   $ echo 1 > f-unchanged-2
   $ echo 1 > f-same
   $ hg ci -m2
   Invoking status precommit hook
   M f-different
   M f-same
   M f-unchanged-1
   M f-unchanged-2
   $ hg up -qr0
   $ echo tmp2 > f-unchanged-1
   $ echo tmp2 > f-unchanged-2
   $ echo tmp2 > f-same
   $ hg ci -m3
   Invoking status precommit hook
   M f-same
   M f-unchanged-1
   M f-unchanged-2
   created new head
   $ echo 1 > f-different
   $ echo 1 > f-unchanged-1
   $ echo 0 > f-unchanged-2
   $ echo 1 > f-same
   $ hg ci -m4
   Invoking status precommit hook
   M f-different
   M f-same
   M f-unchanged-1
   M f-unchanged-2
   $ hg merge
   largefile f-different has a merge conflict
   ancestor was 09d2af8dd22201dd8d48e5dcfcaed281ff9422c7
   keep (l)ocal e5fa44f2b31c1fb553b6021e7360d07d5d91ff5e or
   take (o)ther 7448d8798a4380162d4b56f9b452e2f6f9e24e7a? l
   getting changed largefiles
   1 largefiles updated, 0 removed
   0 files updated, 4 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ cat f-different
   1
   $ cat f-same
   1
   $ cat f-unchanged-1
   1
   $ cat f-unchanged-2
   1
   $ cd ..
 
 Test largefile insulation (do not enabled a side effect
 ========================================================
 
 Check whether "largefiles" feature is supported only in repositories
 enabling largefiles extension.
 
   $ mkdir individualenabling
   $ cd individualenabling
 
   $ hg init enabledlocally
   $ echo large > enabledlocally/large
   $ hg -R enabledlocally add --large enabledlocally/large
   $ hg -R enabledlocally commit -m '#0'
   Invoking status precommit hook
   A large
 
   $ hg init notenabledlocally
   $ echo large > notenabledlocally/large
   $ hg -R notenabledlocally add --large notenabledlocally/large
   $ hg -R notenabledlocally commit -m '#0'
   Invoking status precommit hook
   A large
 
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > # disable globally
   > largefiles=!
   > EOF
   $ cat >> enabledlocally/.hg/hgrc <<EOF
   > [extensions]
   > # enable locally
   > largefiles=
   > EOF
   $ hg -R enabledlocally root
   $TESTTMP/individualenabling/enabledlocally (glob)
   $ hg -R notenabledlocally root
   abort: repository requires features unknown to this Mercurial: largefiles!
   (see http://mercurial.selenic.com/wiki/MissingRequirement for more information)
   [255]
 
   $ hg init push-dst
   $ hg -R enabledlocally push push-dst
   pushing to push-dst
   abort: required features are not supported in the destination: largefiles
   [255]
 
   $ hg init pull-src
   $ hg -R pull-src pull enabledlocally
   pulling from enabledlocally
   abort: required features are not supported in the destination: largefiles
   [255]
 
   $ hg clone enabledlocally clone-dst
   abort: repository requires features unknown to this Mercurial: largefiles!
   (see http://mercurial.selenic.com/wiki/MissingRequirement for more information)
   [255]
   $ test -d clone-dst
   [1]
   $ hg clone --pull enabledlocally clone-pull-dst
   abort: required features are not supported in the destination: largefiles
   [255]
   $ test -d clone-pull-dst
   [1]
 
 #if serve
 
 Test largefiles specific peer setup, when largefiles is enabled
 locally (issue4109)
 
   $ hg showconfig extensions | grep largefiles
   extensions.largefiles=!
   $ mkdir -p $TESTTMP/individualenabling/usercache
 
   $ hg serve -R enabledlocally -d -p $HGPORT --pid-file hg.pid
   $ cat hg.pid >> $DAEMON_PIDS
 
   $ hg init pull-dst
   $ cat > pull-dst/.hg/hgrc <<EOF
   > [extensions]
   > # enable locally
   > largefiles=
   > [largefiles]
   > # ignore system cache to force largefiles specific wire proto access
   > usercache=$TESTTMP/individualenabling/usercache
   > EOF
   $ hg -R pull-dst -q pull -u http://localhost:$HGPORT
 
   $ killdaemons.py
 #endif
 
 Test overridden functions work correctly even for repos disabling
 largefiles (issue4547)
 
   $ hg showconfig extensions | grep largefiles
   extensions.largefiles=!
 
 (test updating implied by clone)
 
   $ hg init enabled-but-no-largefiles
   $ echo normal1 > enabled-but-no-largefiles/normal1
   $ hg -R enabled-but-no-largefiles add enabled-but-no-largefiles/normal1
   $ hg -R enabled-but-no-largefiles commit -m '#0@enabled-but-no-largefiles'
   Invoking status precommit hook
   A normal1
   $ cat >> enabled-but-no-largefiles/.hg/hgrc <<EOF
   > [extensions]
   > # enable locally
   > largefiles=
   > EOF
   $ hg clone -q enabled-but-no-largefiles no-largefiles
 
-(test rebasing implied by pull: precommit while rebasing unexpectedly
-shows "normal3" as "?", because lfdirstate isn't yet written out at
-that time)
-
   $ echo normal2 > enabled-but-no-largefiles/normal2
   $ hg -R enabled-but-no-largefiles add enabled-but-no-largefiles/normal2
   $ hg -R enabled-but-no-largefiles commit -m '#1@enabled-but-no-largefiles'
   Invoking status precommit hook
   A normal2
 
   $ echo normal3 > no-largefiles/normal3
   $ hg -R no-largefiles add no-largefiles/normal3
   $ hg -R no-largefiles commit -m '#1@no-largefiles'
   Invoking status precommit hook
   A normal3
 
   $ hg -R no-largefiles -q pull --rebase
   Invoking status precommit hook
-  M normal3
+  A normal3
 
 (test reverting)
 
   $ hg init subrepo-root
   $ cat >> subrepo-root/.hg/hgrc <<EOF
   > [extensions]
   > # enable locally
   > largefiles=
   > EOF
   $ echo large > subrepo-root/large
   $ hg -R subrepo-root add --large subrepo-root/large
   $ hg clone -q no-largefiles subrepo-root/no-largefiles
   $ cat > subrepo-root/.hgsub <<EOF
   > no-largefiles = no-largefiles
   > EOF
   $ hg -R subrepo-root add subrepo-root/.hgsub
   $ hg -R subrepo-root commit -m '#0'
   Invoking status precommit hook
   A .hgsub
   A large
   ? .hgsubstate
   $ echo dirty >> subrepo-root/large
   $ echo dirty >> subrepo-root/no-largefiles/normal1
   $ hg -R subrepo-root status -S
   M large
   M no-largefiles/normal1
   $ hg -R subrepo-root revert --all
   reverting subrepo-root/.hglf/large (glob)
   reverting subrepo no-largefiles
   reverting subrepo-root/no-largefiles/normal1 (glob)
 
   $ cd ..
 
 
 Test "pull --rebase" when rebase is enabled before largefiles (issue3861)
 =========================================================================
 
   $ hg showconfig extensions | grep largefiles
   extensions.largefiles=!
 
   $ mkdir issue3861
   $ cd issue3861
   $ hg init src
   $ hg clone -q src dst
   $ echo a > src/a
   $ hg -R src commit -Aqm "#0"
   Invoking status precommit hook
   A a
 
   $ cat >> dst/.hg/hgrc <<EOF
   > [extensions]
   > largefiles=
   > EOF
   $ hg -R dst pull --rebase
   pulling from $TESTTMP/issue3861/src (glob)
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   nothing to rebase - working directory parent is already an ancestor of destination bf5e395ced2c
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ cd ..

tests/test-merge-tools.t

@@ -1,1003 +1,1030 b''
 test merge-tools configuration - mostly exercising filemerge.py
 
   $ unset HGMERGE # make sure HGMERGE doesn't interfere with the test
   $ hg init
 
 revision 0
 
   $ echo "revision 0" > f
   $ echo "space" >> f
   $ hg commit -Am "revision 0"
   adding f
 
 revision 1
 
   $ echo "revision 1" > f
   $ echo "space" >> f
   $ hg commit -Am "revision 1"
   $ hg update 0 > /dev/null
 
 revision 2
 
   $ echo "revision 2" > f
   $ echo "space" >> f
   $ hg commit -Am "revision 2"
   created new head
   $ hg update 0 > /dev/null
 
 revision 3 - simple to merge
 
   $ echo "revision 3" >> f
   $ hg commit -Am "revision 3"
   created new head
 
 revision 4 - hard to merge
 
   $ hg update 0 > /dev/null
   $ echo "revision 4" > f
   $ hg commit -Am "revision 4"
   created new head
 
   $ echo "[merge-tools]" > .hg/hgrc
 
   $ beforemerge() {
   >   cat .hg/hgrc
   >   echo "# hg update -C 1"
   >   hg update -C 1 > /dev/null
   > }
   $ aftermerge() {
   >   echo "# cat f"
   >   cat f
   >   echo "# hg stat"
   >   hg stat
   >   rm -f f.orig
   > }
 
 Tool selection
 
 default is internal merge:
 
   $ beforemerge
   [merge-tools]
   # hg update -C 1
 
 hg merge -r 2
 override $PATH to ensure hgmerge not visible; use $PYTHON in case we're
 running from a devel copy, not a temp installation
 
   $ PATH="$BINDIR" $PYTHON "$BINDIR"/hg merge -r 2
   merging f
   warning: conflicts during merge.
   merging f incomplete! (edit conflicts, 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 update -C .' to abandon
   [1]
   $ aftermerge
   # cat f
   <<<<<<< local: ef83787e2614  - test: revision 1
   revision 1
   =======
   revision 2
   >>>>>>> other: 0185f4e0cf02  - test: revision 2
   space
   # hg stat
   M f
   ? f.orig
 
 simplest hgrc using false for merge:
 
   $ echo "false.whatever=" >> .hg/hgrc
   $ beforemerge
   [merge-tools]
   false.whatever=
   # hg update -C 1
   $ hg merge -r 2
   merging f
   merging f failed!
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg update -C .' to abandon
   [1]
   $ aftermerge
   # cat f
   revision 1
   space
   # hg stat
   M f
   ? f.orig
 
 #if unix-permissions
 
 unexecutable file in $PATH shouldn't be found:
 
   $ echo "echo fail" > false
   $ hg up -qC 1
   $ PATH="`pwd`:$BINDIR" $PYTHON "$BINDIR"/hg merge -r 2
   merging f
   warning: conflicts during merge.
   merging f incomplete! (edit conflicts, 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 update -C .' to abandon
   [1]
   $ rm false
 
 #endif
 
 executable directory in $PATH shouldn't be found:
 
   $ mkdir false
   $ hg up -qC 1
   $ PATH="`pwd`:$BINDIR" $PYTHON "$BINDIR"/hg merge -r 2
   merging f
   warning: conflicts during merge.
   merging f incomplete! (edit conflicts, 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 update -C .' to abandon
   [1]
   $ rmdir false
 
 true with higher .priority gets precedence:
 
   $ echo "true.priority=1" >> .hg/hgrc
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   # hg update -C 1
   $ hg merge -r 2
   merging f
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ aftermerge
   # cat f
   revision 1
   space
   # hg stat
   M f
 
 unless lowered on command line:
 
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   # hg update -C 1
   $ hg merge -r 2 --config merge-tools.true.priority=-7
   merging f
   merging f failed!
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg update -C .' to abandon
   [1]
   $ aftermerge
   # cat f
   revision 1
   space
   # hg stat
   M f
   ? f.orig
 
 or false set higher on command line:
 
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   # hg update -C 1
   $ hg merge -r 2 --config merge-tools.false.priority=117
   merging f
   merging f failed!
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg update -C .' to abandon
   [1]
   $ aftermerge
   # cat f
   revision 1
   space
   # hg stat
   M f
   ? f.orig
 
 or true.executable not found in PATH:
 
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   # hg update -C 1
   $ hg merge -r 2 --config merge-tools.true.executable=nonexistentmergetool
   merging f
   merging f failed!
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg update -C .' to abandon
   [1]
   $ aftermerge
   # cat f
   revision 1
   space
   # hg stat
   M f
   ? f.orig
 
 or true.executable with bogus path:
 
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   # hg update -C 1
   $ hg merge -r 2 --config merge-tools.true.executable=/nonexistent/mergetool
   merging f
   merging f failed!
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg update -C .' to abandon
   [1]
   $ aftermerge
   # cat f
   revision 1
   space
   # hg stat
   M f
   ? f.orig
 
 but true.executable set to cat found in PATH works:
 
   $ echo "true.executable=cat" >> .hg/hgrc
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   true.executable=cat
   # hg update -C 1
   $ hg merge -r 2
   merging f
   revision 1
   space
   revision 0
   space
   revision 2
   space
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ aftermerge
   # cat f
   revision 1
   space
   # hg stat
   M f
 
 and true.executable set to cat with path works:
 
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   true.executable=cat
   # hg update -C 1
   $ hg merge -r 2 --config merge-tools.true.executable=cat
   merging f
   revision 1
   space
   revision 0
   space
   revision 2
   space
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ aftermerge
   # cat f
   revision 1
   space
   # hg stat
   M f
 
 #if unix-permissions
 
 environment variables in true.executable are handled:
 
   $ echo 'echo "custom merge tool"' > .hg/merge.sh
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   true.executable=cat
   # hg update -C 1
   $ hg --config merge-tools.true.executable='sh' \
   >    --config merge-tools.true.args=.hg/merge.sh \
   >    merge -r 2
   merging f
   custom merge tool
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ aftermerge
   # cat f
   revision 1
   space
   # hg stat
   M f
 
 #endif
 
 Tool selection and merge-patterns
 
 merge-patterns specifies new tool false:
 
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   true.executable=cat
   # hg update -C 1
   $ hg merge -r 2 --config merge-patterns.f=false
   merging f
   merging f failed!
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg update -C .' to abandon
   [1]
   $ aftermerge
   # cat f
   revision 1
   space
   # hg stat
   M f
   ? f.orig
 
 merge-patterns specifies executable not found in PATH and gets warning:
 
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   true.executable=cat
   # hg update -C 1
   $ hg merge -r 2 --config merge-patterns.f=true --config merge-tools.true.executable=nonexistentmergetool
   couldn't find merge tool true specified for f
   merging f
   merging f failed!
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg update -C .' to abandon
   [1]
   $ aftermerge
   # cat f
   revision 1
   space
   # hg stat
   M f
   ? f.orig
 
 merge-patterns specifies executable with bogus path and gets warning:
 
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   true.executable=cat
   # hg update -C 1
   $ hg merge -r 2 --config merge-patterns.f=true --config merge-tools.true.executable=/nonexistent/mergetool
   couldn't find merge tool true specified for f
   merging f
   merging f failed!
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg update -C .' to abandon
   [1]
   $ aftermerge
   # cat f
   revision 1
   space
   # hg stat
   M f
   ? f.orig
 
 ui.merge overrules priority
 
 ui.merge specifies false:
 
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   true.executable=cat
   # hg update -C 1
   $ hg merge -r 2 --config ui.merge=false
   merging f
   merging f failed!
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg update -C .' to abandon
   [1]
   $ aftermerge
   # cat f
   revision 1
   space
   # hg stat
   M f
   ? f.orig
 
 ui.merge specifies internal:fail:
 
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   true.executable=cat
   # hg update -C 1
   $ hg merge -r 2 --config ui.merge=internal:fail
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg update -C .' to abandon
   [1]
   $ aftermerge
   # cat f
   revision 1
   space
   # hg stat
   M f
 
 ui.merge specifies :local (without internal prefix):
 
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   true.executable=cat
   # hg update -C 1
   $ hg merge -r 2 --config ui.merge=:local
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ aftermerge
   # cat f
   revision 1
   space
   # hg stat
   M f
 
 ui.merge specifies internal:other:
 
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   true.executable=cat
   # hg update -C 1
   $ hg merge -r 2 --config ui.merge=internal:other
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ aftermerge
   # cat f
   revision 2
   space
   # hg stat
   M f
 
 ui.merge specifies internal:prompt:
 
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   true.executable=cat
   # hg update -C 1
   $ hg merge -r 2 --config ui.merge=internal:prompt
    no tool found to merge f
   keep (l)ocal or take (o)ther? l
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ aftermerge
   # cat f
   revision 1
   space
   # hg stat
   M f
 
 ui.merge specifies internal:dump:
 
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   true.executable=cat
   # hg update -C 1
   $ hg merge -r 2 --config ui.merge=internal:dump
   merging f
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg update -C .' to abandon
   [1]
   $ aftermerge
   # cat f
   revision 1
   space
   # hg stat
   M f
   ? f.base
   ? f.local
   ? f.orig
   ? f.other
 
 f.base:
 
   $ cat f.base
   revision 0
   space
 
 f.local:
 
   $ cat f.local
   revision 1
   space
 
 f.other:
 
   $ cat f.other
   revision 2
   space
   $ rm f.base f.local f.other
 
 ui.merge specifies internal:other but is overruled by pattern for false:
 
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   true.executable=cat
   # hg update -C 1
   $ hg merge -r 2 --config ui.merge=internal:other --config merge-patterns.f=false
   merging f
   merging f failed!
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg update -C .' to abandon
   [1]
   $ aftermerge
   # cat f
   revision 1
   space
   # hg stat
   M f
   ? f.orig
 
 Premerge
 
 ui.merge specifies internal:other but is overruled by --tool=false
 
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   true.executable=cat
   # hg update -C 1
   $ hg merge -r 2 --config ui.merge=internal:other --tool=false
   merging f
   merging f failed!
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg update -C .' to abandon
   [1]
   $ aftermerge
   # cat f
   revision 1
   space
   # hg stat
   M f
   ? f.orig
 
 HGMERGE specifies internal:other but is overruled by --tool=false
 
   $ HGMERGE=internal:other ; export HGMERGE
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   true.executable=cat
   # hg update -C 1
   $ hg merge -r 2 --tool=false
   merging f
   merging f failed!
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg update -C .' to abandon
   [1]
   $ aftermerge
   # cat f
   revision 1
   space
   # hg stat
   M f
   ? f.orig
 
   $ unset HGMERGE # make sure HGMERGE doesn't interfere with remaining tests
 
 update is a merge ...
 
+(this also tests that files reverted with '--rev REV' are treated as
+"modified", even if none of mode, size and timestamp of them isn't
+changed on the filesystem (see also issue4583))
+
+  $ cat >> $HGRCPATH <<EOF
+  > [fakedirstatewritetime]
+  > # emulate invoking dirstate.write() via repo.status()
+  > # at 2000-01-01 00:00
+  > fakenow = 200001010000
+  > EOF
+
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   true.executable=cat
   # hg update -C 1
   $ hg update -q 0
   $ f -s f
   f: size=17
   $ touch -t 200001010000 f
-  $ hg status f
+  $ hg debugrebuildstate
+  $ cat >> $HGRCPATH <<EOF
+  > [extensions]
+  > fakedirstatewritetime = $TESTDIR/fakedirstatewritetime.py
+  > EOF
   $ hg revert -q -r 1 .
+  $ cat >> $HGRCPATH <<EOF
+  > [extensions]
+  > fakedirstatewritetime = !
+  > EOF
   $ f -s f
   f: size=17
   $ touch -t 200001010000 f
   $ hg status f
   M f
   $ hg update -r 2
   merging f
   revision 1
   space
   revision 0
   space
   revision 2
   space
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   $ aftermerge
   # cat f
   revision 1
   space
   # hg stat
   M f
 
 update should also have --tool
 
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   true.executable=cat
   # hg update -C 1
   $ hg update -q 0
   $ f -s f
   f: size=17
   $ touch -t 200001010000 f
-  $ hg status f
+  $ hg debugrebuildstate
+  $ cat >> $HGRCPATH <<EOF
+  > [extensions]
+  > fakedirstatewritetime = $TESTDIR/fakedirstatewritetime.py
+  > EOF
   $ hg revert -q -r 1 .
+  $ cat >> $HGRCPATH <<EOF
+  > [extensions]
+  > fakedirstatewritetime = !
+  > EOF
   $ f -s f
   f: size=17
   $ touch -t 200001010000 f
   $ hg status f
   M f
   $ hg update -r 2 --tool false
   merging f
   merging f failed!
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges
   [1]
   $ aftermerge
   # cat f
   revision 1
   space
   # hg stat
   M f
   ? f.orig
 
 Default is silent simplemerge:
 
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   true.executable=cat
   # hg update -C 1
   $ hg merge -r 3
   merging f
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ aftermerge
   # cat f
   revision 1
   space
   revision 3
   # hg stat
   M f
 
 .premerge=True is same:
 
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   true.executable=cat
   # hg update -C 1
   $ hg merge -r 3 --config merge-tools.true.premerge=True
   merging f
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ aftermerge
   # cat f
   revision 1
   space
   revision 3
   # hg stat
   M f
 
 .premerge=False executes merge-tool:
 
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   true.executable=cat
   # hg update -C 1
   $ hg merge -r 3 --config merge-tools.true.premerge=False
   merging f
   revision 1
   space
   revision 0
   space
   revision 0
   space
   revision 3
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ aftermerge
   # cat f
   revision 1
   space
   # hg stat
   M f
 
 premerge=keep keeps conflict markers in:
 
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   true.executable=cat
   # hg update -C 1
   $ hg merge -r 4 --config merge-tools.true.premerge=keep
   merging f
   <<<<<<< local: ef83787e2614  - test: revision 1
   revision 1
   space
   =======
   revision 4
   >>>>>>> other: 81448d39c9a0 - test: revision 4
   revision 0
   space
   revision 4
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ aftermerge
   # cat f
   <<<<<<< local: ef83787e2614  - test: revision 1
   revision 1
   space
   =======
   revision 4
   >>>>>>> other: 81448d39c9a0 - test: revision 4
   # hg stat
   M f
 
 premerge=keep-merge3 keeps conflict markers with base content:
 
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   true.executable=cat
   # hg update -C 1
   $ hg merge -r 4 --config merge-tools.true.premerge=keep-merge3
   merging f
   <<<<<<< local: ef83787e2614  - test: revision 1
   revision 1
   space
   ||||||| base
   revision 0
   space
   =======
   revision 4
   >>>>>>> other: 81448d39c9a0 - test: revision 4
   revision 0
   space
   revision 4
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ aftermerge
   # cat f
   <<<<<<< local: ef83787e2614  - test: revision 1
   revision 1
   space
   ||||||| base
   revision 0
   space
   =======
   revision 4
   >>>>>>> other: 81448d39c9a0 - test: revision 4
   # hg stat
   M f
 
 
 Tool execution
 
 set tools.args explicit to include $base $local $other $output:
 
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   true.executable=cat
   # hg update -C 1
   $ hg merge -r 2 --config merge-tools.true.executable=head --config merge-tools.true.args='$base $local $other $output' \
   >   | sed 's,==> .* <==,==> ... <==,g'
   merging f
   ==> ... <==
   revision 0
   space
   
   ==> ... <==
   revision 1
   space
   
   ==> ... <==
   revision 2
   space
   
   ==> ... <==
   revision 1
   space
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ aftermerge
   # cat f
   revision 1
   space
   # hg stat
   M f
 
 Merge with "echo mergeresult > $local":
 
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   true.executable=cat
   # hg update -C 1
   $ hg merge -r 2 --config merge-tools.true.executable=echo --config merge-tools.true.args='mergeresult > $local'
   merging f
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ aftermerge
   # cat f
   mergeresult
   # hg stat
   M f
 
 - and $local is the file f:
 
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   true.executable=cat
   # hg update -C 1
   $ hg merge -r 2 --config merge-tools.true.executable=echo --config merge-tools.true.args='mergeresult > f'
   merging f
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ aftermerge
   # cat f
   mergeresult
   # hg stat
   M f
 
 Merge with "echo mergeresult > $output" - the variable is a bit magic:
 
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   true.executable=cat
   # hg update -C 1
   $ hg merge -r 2 --config merge-tools.true.executable=echo --config merge-tools.true.args='mergeresult > $output'
   merging f
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ aftermerge
   # cat f
   mergeresult
   # hg stat
   M f
 
 Merge using tool with a path that must be quoted:
 
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   true.executable=cat
   # hg update -C 1
   $ cat <<EOF > 'my merge tool'
   > cat "\$1" "\$2" "\$3" > "\$4"
   > EOF
   $ hg --config merge-tools.true.executable='sh' \
   >    --config merge-tools.true.args='"./my merge tool" $base $local $other $output' \
   >    merge -r 2
   merging f
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ rm -f 'my merge tool'
   $ aftermerge
   # cat f
   revision 0
   space
   revision 1
   space
   revision 2
   space
   # hg stat
   M f
 
 Issue3581: Merging a filename that needs to be quoted
 (This test doesn't work on Windows filesystems even on Linux, so check
 for Unix-like permission)
 
 #if unix-permissions
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   true.executable=cat
   # hg update -C 1
   $ echo "revision 5" > '"; exit 1; echo "'
   $ hg commit -Am "revision 5"
   adding "; exit 1; echo "
   warning: filename contains '"', which is reserved on Windows: '"; exit 1; echo "'
   $ hg update -C 1 > /dev/null
   $ echo "revision 6" > '"; exit 1; echo "'
   $ hg commit -Am "revision 6"
   adding "; exit 1; echo "
   warning: filename contains '"', which is reserved on Windows: '"; exit 1; echo "'
   created new head
   $ hg merge --config merge-tools.true.executable="true" -r 5
   merging "; exit 1; echo "
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg update -C 1 > /dev/null
 #endif
 
 Merge post-processing
 
 cat is a bad merge-tool and doesn't change:
 
   $ beforemerge
   [merge-tools]
   false.whatever=
   true.priority=1
   true.executable=cat
   # hg update -C 1
   $ hg merge -y -r 2 --config merge-tools.true.checkchanged=1
   merging f
   revision 1
   space
   revision 0
   space
   revision 2
   space
    output file f appears unchanged
   was merge successful (yn)? n
   merging f failed!
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg update -C .' to abandon
   [1]
   $ aftermerge
   # cat f
   revision 1
   space
   # hg stat
   M f
   ? f.orig
 
 #if symlink
 
 internal merge cannot handle symlinks and shouldn't try:
 
   $ hg update -q -C 1
   $ rm f
   $ ln -s symlink f
   $ hg commit -qm 'f is symlink'
   $ hg merge -r 2 --tool internal:merge
   merging f
   warning: internal :merge cannot merge symlinks for f
   merging f incomplete! (edit conflicts, 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 update -C .' to abandon
   [1]
 
 #endif

tests/test-merge1.t

@@ -1,209 +1,296 b''
   $ cat <<EOF > merge
   > import sys, os
   > 
   > try:
   >     import msvcrt
   >     msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
   >     msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY)
   > except ImportError:
   >     pass
   > 
   > print "merging for", os.path.basename(sys.argv[1])
   > EOF
   $ HGMERGE="python ../merge"; export HGMERGE
 
   $ hg init t
   $ cd t
   $ echo This is file a1 > a
   $ hg add a
   $ hg commit -m "commit #0"
   $ echo This is file b1 > b
   $ hg add b
   $ hg commit -m "commit #1"
 
   $ hg update 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
 Test interrupted updates by exploiting our non-handling of directory collisions
 
   $ mkdir b
   $ hg up
   abort: *: '$TESTTMP/t/b' (glob)
   [255]
   $ hg ci
   abort: last update was interrupted
   (use 'hg update' to get a consistent checkout)
   [255]
   $ hg sum
   parent: 0:538afb845929 
    commit #0
   branch: default
   commit: (interrupted update)
   update: 1 new changesets (update)
   phases: 2 draft
   $ rmdir b
   $ hg up
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg sum
   parent: 1:b8bb4a988f25 tip
    commit #1
   branch: default
   commit: (clean)
   update: (current)
   phases: 2 draft
 
 Prepare a basic merge
 
   $ hg up 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo This is file c1 > c
   $ hg add c
   $ hg commit -m "commit #2"
   created new head
   $ echo This is file b1 > b
 no merges expected
   $ hg merge -P 1
   changeset:   1:b8bb4a988f25
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit #1
   
   $ hg merge 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg diff --nodates
   diff -r 49035e18a8e6 b
   --- /dev/null
   +++ b/b
   @@ -0,0 +1,1 @@
   +This is file b1
   $ hg status
   M b
   $ cd ..; rm -r t
 
   $ hg init t
   $ cd t
   $ echo This is file a1 > a
   $ hg add a
   $ hg commit -m "commit #0"
   $ echo This is file b1 > b
   $ hg add b
   $ hg commit -m "commit #1"
 
   $ hg update 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo This is file c1 > c
   $ hg add c
   $ hg commit -m "commit #2"
   created new head
   $ echo This is file b2 > b
 merge should fail
   $ hg merge 1
   b: untracked file differs
   abort: untracked files in working directory differ from files in requested revision
   [255]
 merge of b expected
   $ hg merge -f 1
   merging b
   merging for b
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg diff --nodates
   diff -r 49035e18a8e6 b
   --- /dev/null
   +++ b/b
   @@ -0,0 +1,1 @@
   +This is file b2
   $ hg status
   M b
   $ cd ..; rm -r t
 
   $ hg init t
   $ cd t
   $ echo This is file a1 > a
   $ hg add a
   $ hg commit -m "commit #0"
   $ echo This is file b1 > b
   $ hg add b
   $ hg commit -m "commit #1"
   $ echo This is file b22 > b
   $ hg commit -m "commit #2"
   $ hg update 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo This is file c1 > c
   $ hg add c
   $ hg commit -m "commit #3"
   created new head
 
 Contents of b should be "this is file b1"
   $ cat b
   This is file b1
 
   $ echo This is file b22 > b
 merge fails
   $ hg merge 2
   abort: uncommitted changes
   (use 'hg status' to list changes)
   [255]
 merge expected!
   $ hg merge -f 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg diff --nodates
   diff -r 85de557015a8 b
   --- a/b
   +++ b/b
   @@ -1,1 +1,1 @@
   -This is file b1
   +This is file b22
   $ hg status
   M b
   $ cd ..; rm -r t
 
   $ hg init t
   $ cd t
   $ echo This is file a1 > a
   $ hg add a
   $ hg commit -m "commit #0"
   $ echo This is file b1 > b
   $ hg add b
   $ hg commit -m "commit #1"
   $ echo This is file b22 > b
   $ hg commit -m "commit #2"
   $ hg update 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo This is file c1 > c
   $ hg add c
   $ hg commit -m "commit #3"
   created new head
   $ echo This is file b33 > b
 merge of b should fail
   $ hg merge 2
   abort: uncommitted changes
   (use 'hg status' to list changes)
   [255]
 merge of b expected
   $ hg merge -f 2
   merging b
   merging for b
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg diff --nodates
   diff -r 85de557015a8 b
   --- a/b
   +++ b/b
   @@ -1,1 +1,1 @@
   -This is file b1
   +This is file b33
   $ hg status
   M b
 
 Test for issue2364
 
   $ hg up -qC .
   $ hg rm b
   $ hg ci -md
   $ hg revert -r -2 b
   $ hg up -q -- -2
 
+Test that updated files are treated as "modified", when
+'merge.update()' is aborted before 'merge.recordupdates()' (= parents
+aren't changed), even if none of mode, size and timestamp of them
+isn't changed on the filesystem (see also issue4583).
+
+  $ cat > $TESTTMP/abort.py <<EOF
+  > # emulate aborting before "recordupdates()". in this case, files
+  > # are changed without updating dirstate
+  > from mercurial import extensions, merge, util
+  > def applyupdates(orig, *args, **kwargs):
+  >     orig(*args, **kwargs)
+  >     raise util.Abort('intentional aborting')
+  > def extsetup(ui):
+  >     extensions.wrapfunction(merge, "applyupdates", applyupdates)
+  > EOF
+
+  $ cat >> .hg/hgrc <<EOF
+  > [fakedirstatewritetime]
+  > # emulate invoking dirstate.write() via repo.status()
+  > # at 2000-01-01 00:00
+  > fakenow = 200001010000
+  > EOF
+
+(file gotten from other revision)
+
+  $ hg update -q -C 2
+  $ echo 'THIS IS FILE B5' > b
+  $ hg commit -m 'commit #5'
+
+  $ hg update -q -C 3
+  $ cat b
+  This is file b1
+  $ touch -t 200001010000 b
+  $ hg debugrebuildstate
+
+  $ cat >> .hg/hgrc <<EOF
+  > [extensions]
+  > fakedirstatewritetime = $TESTDIR/fakedirstatewritetime.py
+  > abort = $TESTTMP/abort.py
+  > EOF
+  $ hg merge 5
+  abort: intentional aborting
+  [255]
+  $ cat >> .hg/hgrc <<EOF
+  > [extensions]
+  > fakedirstatewritetime = !
+  > abort = !
+  > EOF
+
+  $ cat b
+  THIS IS FILE B5
+  $ touch -t 200001010000 b
+  $ hg status -A b
+  M b
+
+(file merged from other revision)
+
+  $ hg update -q -C 3
+  $ echo 'this is file b6' > b
+  $ hg commit -m 'commit #6'
+  created new head
+
+  $ cat b
+  this is file b6
+  $ touch -t 200001010000 b
+  $ hg debugrebuildstate
+
+  $ cat >> .hg/hgrc <<EOF
+  > [extensions]
+  > fakedirstatewritetime = $TESTDIR/fakedirstatewritetime.py
+  > abort = $TESTTMP/abort.py
+  > EOF
+  $ hg merge --tool internal:other 5
+  abort: intentional aborting
+  [255]
+  $ cat >> .hg/hgrc <<EOF
+  > [extensions]
+  > fakedirstatewritetime = !
+  > abort = !
+  > EOF
+
+  $ cat b
+  THIS IS FILE B5
+  $ touch -t 200001010000 b
+  $ hg status -A b
+  M b
+
   $ cd ..

tests/test-revert.t

@@ -1,1028 +1,1068 b''
   $ hg init repo
   $ cd repo
   $ echo 123 > a
   $ echo 123 > c
   $ echo 123 > e
   $ hg add a c e
   $ hg commit -m "first" a c e
 
 nothing changed
 
   $ hg revert
   abort: no files or directories specified
   (use --all to revert all files)
   [255]
   $ hg revert --all
 
 Introduce some changes and revert them
 --------------------------------------
 
   $ echo 123 > b
 
   $ hg status
   ? b
   $ echo 12 > c
 
   $ hg status
   M c
   ? b
   $ hg add b
 
   $ hg status
   M c
   A b
   $ hg rm a
 
   $ hg status
   M c
   A b
   R a
 
 revert removal of a file
 
   $ hg revert a
   $ hg status
   M c
   A b
 
 revert addition of a file
 
   $ hg revert b
   $ hg status
   M c
   ? b
 
 revert modification of a file (--no-backup)
 
   $ hg revert --no-backup c
   $ hg status
   ? b
 
 revert deletion (! status) of a added file
 ------------------------------------------
 
   $ hg add b
 
   $ hg status b
   A b
   $ rm b
   $ hg status b
   ! b
   $ hg revert -v b
   forgetting b
   $ hg status b
   b: * (glob)
 
   $ ls
   a
   c
   e
 
 Test creation of backup (.orig) files
 -------------------------------------
 
   $ echo z > e
   $ hg revert --all -v
   saving current version of e as e.orig
   reverting e
 
 revert on clean file (no change)
 --------------------------------
 
   $ hg revert a
   no changes needed to a
 
 revert on an untracked file
 ---------------------------
 
   $ echo q > q
   $ hg revert q
   file not managed: q
   $ rm q
 
 revert on file that does not exists
 -----------------------------------
 
   $ hg revert notfound
   notfound: no such file in rev 334a9e57682c
   $ touch d
   $ hg add d
   $ hg rm a
   $ hg commit -m "second"
   $ echo z > z
   $ hg add z
   $ hg st
   A z
   ? e.orig
 
 revert to another revision (--rev)
 ----------------------------------
 
   $ hg revert --all -r0
   adding a
   removing d
   forgetting z
 
 revert explicitly to parent (--rev)
 -----------------------------------
 
   $ hg revert --all -rtip
   forgetting a
   undeleting d
   $ rm a *.orig
 
 revert to another revision (--rev) and exact match
 --------------------------------------------------
 
 exact match are more silent
 
   $ hg revert -r0 a
   $ hg st a
   A a
   $ hg rm d
   $ hg st d
   R d
 
 should keep d removed
 
   $ hg revert -r0 d
   no changes needed to d
   $ hg st d
   R d
 
   $ hg update -C
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 revert of exec bit
 ------------------
 
 #if execbit
   $ chmod +x c
   $ hg revert --all
   reverting c
 
   $ test -x c || echo non-executable
   non-executable
 
   $ chmod +x c
   $ hg commit -m exe
 
   $ chmod -x c
   $ hg revert --all
   reverting c
 
   $ test -x c && echo executable
   executable
 #endif
 
+Test that files reverted to other than the parent are treated as
+"modified", even if none of mode, size and timestamp of it isn't
+changed on the filesystem (see also issue4583).
+
+  $ echo 321 > e
+  $ hg diff --git
+  diff --git a/e b/e
+  --- a/e
+  +++ b/e
+  @@ -1,1 +1,1 @@
+  -123
+  +321
+  $ hg commit -m 'ambiguity from size'
+
+  $ cat e
+  321
+  $ touch -t 200001010000 e
+  $ hg debugrebuildstate
+
+  $ cat >> .hg/hgrc <<EOF
+  > [fakedirstatewritetime]
+  > # emulate invoking dirstate.write() via repo.status()
+  > # at 2000-01-01 00:00
+  > fakenow = 200001010000
+  > 
+  > [extensions]
+  > fakedirstatewritetime = $TESTDIR/fakedirstatewritetime.py
+  > EOF
+  $ hg revert -r 0 e
+  $ cat >> .hg/hgrc <<EOF
+  > [extensions]
+  > fakedirstatewritetime = !
+  > EOF
+
+  $ cat e
+  123
+  $ touch -t 200001010000 e
+  $ hg status -A e
+  M e
+
   $ cd ..
 
 
 Issue241: update and revert produces inconsistent repositories
 --------------------------------------------------------------
 
   $ hg init a
   $ cd a
   $ echo a >> a
   $ hg commit -A -d '1 0' -m a
   adding a
   $ echo a >> a
   $ hg commit -d '2 0' -m a
   $ hg update 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ mkdir b
   $ echo b > b/b
 
 call `hg revert` with no file specified
 ---------------------------------------
 
   $ hg revert -rtip
   abort: no files or directories specified
   (use --all to revert all files, or 'hg update 1' to update)
   [255]
 
 call `hg revert` with -I
 ---------------------------
 
   $ echo a >> a
   $ hg revert -I a
   reverting a
 
 call `hg revert` with -X
 ---------------------------
 
   $ echo a >> a
   $ hg revert -X d
   reverting a
 
 call `hg revert` with --all
 ---------------------------
 
   $ hg revert --all -rtip
   reverting a
   $ rm *.orig
 
 Issue332: confusing message when reverting directory
 ----------------------------------------------------
 
   $ hg ci -A -m b
   adding b/b
   created new head
   $ echo foobar > b/b
   $ mkdir newdir
   $ echo foo > newdir/newfile
   $ hg add newdir/newfile
   $ hg revert b newdir
   reverting b/b (glob)
   forgetting newdir/newfile (glob)
   $ echo foobar > b/b
   $ hg revert .
   reverting b/b (glob)
 
 
 reverting a rename target should revert the source
 --------------------------------------------------
 
   $ hg mv a newa
   $ hg revert newa
   $ hg st a newa
   ? newa
 
 Also true for move overwriting an existing file
 
   $ hg mv --force a b/b
   $ hg revert b/b
   $ hg status a b/b
 
   $ cd ..
 
   $ hg init ignored
   $ cd ignored
   $ echo '^ignored$' > .hgignore
   $ echo '^ignoreddir$' >> .hgignore
   $ echo '^removed$' >> .hgignore
 
   $ mkdir ignoreddir
   $ touch ignoreddir/file
   $ touch ignoreddir/removed
   $ touch ignored
   $ touch removed
 
 4 ignored files (we will add/commit everything)
 
   $ hg st -A -X .hgignore
   I ignored
   I ignoreddir/file
   I ignoreddir/removed
   I removed
   $ hg ci -qAm 'add files' ignored ignoreddir/file ignoreddir/removed removed
 
   $ echo >> ignored
   $ echo >> ignoreddir/file
   $ hg rm removed ignoreddir/removed
 
 should revert ignored* and undelete *removed
 --------------------------------------------
 
   $ hg revert -a --no-backup
   reverting ignored
   reverting ignoreddir/file (glob)
   undeleting ignoreddir/removed (glob)
   undeleting removed
   $ hg st -mardi
 
   $ hg up -qC
   $ echo >> ignored
   $ hg rm removed
 
 should silently revert the named files
 --------------------------------------
 
   $ hg revert --no-backup ignored removed
   $ hg st -mardi
 
 Reverting copy (issue3920)
 --------------------------
 
 someone set up us the copies
 
   $ rm .hgignore
   $ hg update -C
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg mv ignored allyour
   $ hg copy removed base
   $ hg commit -m rename
 
 copies and renames, you have no chance to survive make your time (issue3920)
 
   $ hg update '.^'
   1 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg revert -rtip -a
   adding allyour
   adding base
   removing ignored
   $ hg status -C
   A allyour
     ignored
   A base
     removed
   R ignored
 
 Test revert of a file added by one side of the merge
 ====================================================
 
 remove any pending change
 
   $ hg revert --all
   forgetting allyour
   forgetting base
   undeleting ignored
   $ hg purge --all --config extensions.purge=
 
 Adds a new commit
 
   $ echo foo > newadd
   $ hg add newadd
   $ hg commit -m 'other adds'
   created new head
 
 
 merge it with the other head
 
   $ hg merge # merge 1 into 2
   2 files updated, 0 files merged, 1 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg summary
   parent: 2:b8ec310b2d4e tip
    other adds
   parent: 1:f6180deb8fbe 
    rename
   branch: default
   commit: 2 modified, 1 removed (merge)
   update: (current)
   phases: 3 draft
 
 clarifies who added what
 
   $ hg status
   M allyour
   M base
   R ignored
   $ hg status --change 'p1()'
   A newadd
   $ hg status --change 'p2()'
   A allyour
   A base
   R ignored
 
 revert file added by p1() to p1() state
 -----------------------------------------
 
   $ hg revert -r 'p1()' 'glob:newad?'
   $ hg status
   M allyour
   M base
   R ignored
 
 revert file added by p1() to p2() state
 ------------------------------------------
 
   $ hg revert -r 'p2()' 'glob:newad?'
   removing newadd
   $ hg status
   M allyour
   M base
   R ignored
   R newadd
 
 revert file added by p2() to p2() state
 ------------------------------------------
 
   $ hg revert -r 'p2()' 'glob:allyou?'
   $ hg status
   M allyour
   M base
   R ignored
   R newadd
 
 revert file added by p2() to p1() state
 ------------------------------------------
 
   $ hg revert -r 'p1()' 'glob:allyou?'
   removing allyour
   $ hg status
   M base
   R allyour
   R ignored
   R newadd
 
 Systematic behavior validation of most possible cases
 =====================================================
 
 This section tests most of the possible combinations of revision states and
 working directory states. The number of possible cases is significant but they
 but they all have a slightly different handling. So this section commits to
 and testing all of them to allow safe refactoring of the revert code.
 
 A python script is used to generate a file history for each combination of
 states, on one side the content (or lack thereof) in two revisions, and
 on the other side, the content and "tracked-ness" of the working directory. The
 three states generated are:
 
 - a "base" revision
 - a "parent" revision
 - the working directory (based on "parent")
 
 The files generated have names of the form:
 
  <rev1-content>_<rev2-content>_<working-copy-content>-<tracked-ness>
 
 All known states are not tested yet. See inline documentation for details.
 Special cases from merge and rename are not tested by this section.
 
 Write the python script to disk
 -------------------------------
 
 check list of planned files
 
   $ python $TESTDIR/generate-working-copy-states.py filelist 2
   content1_content1_content1-tracked
   content1_content1_content1-untracked
   content1_content1_content3-tracked
   content1_content1_content3-untracked
   content1_content1_missing-tracked
   content1_content1_missing-untracked
   content1_content2_content1-tracked
   content1_content2_content1-untracked
   content1_content2_content2-tracked
   content1_content2_content2-untracked
   content1_content2_content3-tracked
   content1_content2_content3-untracked
   content1_content2_missing-tracked
   content1_content2_missing-untracked
   content1_missing_content1-tracked
   content1_missing_content1-untracked
   content1_missing_content3-tracked
   content1_missing_content3-untracked
   content1_missing_missing-tracked
   content1_missing_missing-untracked
   missing_content2_content2-tracked
   missing_content2_content2-untracked
   missing_content2_content3-tracked
   missing_content2_content3-untracked
   missing_content2_missing-tracked
   missing_content2_missing-untracked
   missing_missing_content3-tracked
   missing_missing_content3-untracked
   missing_missing_missing-tracked
   missing_missing_missing-untracked
 
 Script to make a simple text version of the content
 ---------------------------------------------------
 
   $ cat << EOF >> dircontent.py
   > # generate a simple text view of the directory for easy comparison
   > import os
   > files = os.listdir('.')
   > files.sort()
   > for filename in files:
   >     if os.path.isdir(filename):
   >         continue
   >     content = open(filename).read()
   >     print '%-6s %s' % (content.strip(), filename)
   > EOF
 
 Generate appropriate repo state
 -------------------------------
 
   $ hg init revert-ref
   $ cd revert-ref
 
 Generate base changeset
 
   $ python $TESTDIR/generate-working-copy-states.py state 2 1
   $ hg addremove --similarity 0
   adding content1_content1_content1-tracked
   adding content1_content1_content1-untracked
   adding content1_content1_content3-tracked
   adding content1_content1_content3-untracked
   adding content1_content1_missing-tracked
   adding content1_content1_missing-untracked
   adding content1_content2_content1-tracked
   adding content1_content2_content1-untracked
   adding content1_content2_content2-tracked
   adding content1_content2_content2-untracked
   adding content1_content2_content3-tracked
   adding content1_content2_content3-untracked
   adding content1_content2_missing-tracked
   adding content1_content2_missing-untracked
   adding content1_missing_content1-tracked
   adding content1_missing_content1-untracked
   adding content1_missing_content3-tracked
   adding content1_missing_content3-untracked
   adding content1_missing_missing-tracked
   adding content1_missing_missing-untracked
   $ hg status
   A content1_content1_content1-tracked
   A content1_content1_content1-untracked
   A content1_content1_content3-tracked
   A content1_content1_content3-untracked
   A content1_content1_missing-tracked
   A content1_content1_missing-untracked
   A content1_content2_content1-tracked
   A content1_content2_content1-untracked
   A content1_content2_content2-tracked
   A content1_content2_content2-untracked
   A content1_content2_content3-tracked
   A content1_content2_content3-untracked
   A content1_content2_missing-tracked
   A content1_content2_missing-untracked
   A content1_missing_content1-tracked
   A content1_missing_content1-untracked
   A content1_missing_content3-tracked
   A content1_missing_content3-untracked
   A content1_missing_missing-tracked
   A content1_missing_missing-untracked
   $ hg commit -m 'base'
 
 (create a simple text version of the content)
 
   $ python ../dircontent.py > ../content-base.txt
   $ cat ../content-base.txt
   content1 content1_content1_content1-tracked
   content1 content1_content1_content1-untracked
   content1 content1_content1_content3-tracked
   content1 content1_content1_content3-untracked
   content1 content1_content1_missing-tracked
   content1 content1_content1_missing-untracked
   content1 content1_content2_content1-tracked
   content1 content1_content2_content1-untracked
   content1 content1_content2_content2-tracked
   content1 content1_content2_content2-untracked
   content1 content1_content2_content3-tracked
   content1 content1_content2_content3-untracked
   content1 content1_content2_missing-tracked
   content1 content1_content2_missing-untracked
   content1 content1_missing_content1-tracked
   content1 content1_missing_content1-untracked
   content1 content1_missing_content3-tracked
   content1 content1_missing_content3-untracked
   content1 content1_missing_missing-tracked
   content1 content1_missing_missing-untracked
 
 Create parent changeset
 
   $ python $TESTDIR/generate-working-copy-states.py state 2 2
   $ hg addremove --similarity 0
   removing content1_missing_content1-tracked
   removing content1_missing_content1-untracked
   removing content1_missing_content3-tracked
   removing content1_missing_content3-untracked
   removing content1_missing_missing-tracked
   removing content1_missing_missing-untracked
   adding missing_content2_content2-tracked
   adding missing_content2_content2-untracked
   adding missing_content2_content3-tracked
   adding missing_content2_content3-untracked
   adding missing_content2_missing-tracked
   adding missing_content2_missing-untracked
   $ hg status
   M content1_content2_content1-tracked
   M content1_content2_content1-untracked
   M content1_content2_content2-tracked
   M content1_content2_content2-untracked
   M content1_content2_content3-tracked
   M content1_content2_content3-untracked
   M content1_content2_missing-tracked
   M content1_content2_missing-untracked
   A missing_content2_content2-tracked
   A missing_content2_content2-untracked
   A missing_content2_content3-tracked
   A missing_content2_content3-untracked
   A missing_content2_missing-tracked
   A missing_content2_missing-untracked
   R content1_missing_content1-tracked
   R content1_missing_content1-untracked
   R content1_missing_content3-tracked
   R content1_missing_content3-untracked
   R content1_missing_missing-tracked
   R content1_missing_missing-untracked
   $ hg commit -m 'parent'
 
 (create a simple text version of the content)
 
   $ python ../dircontent.py > ../content-parent.txt
   $ cat ../content-parent.txt
   content1 content1_content1_content1-tracked
   content1 content1_content1_content1-untracked
   content1 content1_content1_content3-tracked
   content1 content1_content1_content3-untracked
   content1 content1_content1_missing-tracked
   content1 content1_content1_missing-untracked
   content2 content1_content2_content1-tracked
   content2 content1_content2_content1-untracked
   content2 content1_content2_content2-tracked
   content2 content1_content2_content2-untracked
   content2 content1_content2_content3-tracked
   content2 content1_content2_content3-untracked
   content2 content1_content2_missing-tracked
   content2 content1_content2_missing-untracked
   content2 missing_content2_content2-tracked
   content2 missing_content2_content2-untracked
   content2 missing_content2_content3-tracked
   content2 missing_content2_content3-untracked
   content2 missing_content2_missing-tracked
   content2 missing_content2_missing-untracked
 
 Setup working directory
 
   $ python $TESTDIR/generate-working-copy-states.py state 2 wc
   $ hg addremove --similarity 0
   adding content1_missing_content1-tracked
   adding content1_missing_content1-untracked
   adding content1_missing_content3-tracked
   adding content1_missing_content3-untracked
   adding content1_missing_missing-tracked
   adding content1_missing_missing-untracked
   adding missing_missing_content3-tracked
   adding missing_missing_content3-untracked
   adding missing_missing_missing-tracked
   adding missing_missing_missing-untracked
   $ hg forget *_*_*-untracked
   $ rm *_*_missing-*
   $ hg status
   M content1_content1_content3-tracked
   M content1_content2_content1-tracked
   M content1_content2_content3-tracked
   M missing_content2_content3-tracked
   A content1_missing_content1-tracked
   A content1_missing_content3-tracked
   A missing_missing_content3-tracked
   R content1_content1_content1-untracked
   R content1_content1_content3-untracked
   R content1_content1_missing-untracked
   R content1_content2_content1-untracked
   R content1_content2_content2-untracked
   R content1_content2_content3-untracked
   R content1_content2_missing-untracked
   R missing_content2_content2-untracked
   R missing_content2_content3-untracked
   R missing_content2_missing-untracked
   ! content1_content1_missing-tracked
   ! content1_content2_missing-tracked
   ! content1_missing_missing-tracked
   ! missing_content2_missing-tracked
   ! missing_missing_missing-tracked
   ? content1_missing_content1-untracked
   ? content1_missing_content3-untracked
   ? missing_missing_content3-untracked
 
   $ hg status --rev 'desc("base")'
   M content1_content1_content3-tracked
   M content1_content2_content2-tracked
   M content1_content2_content3-tracked
   M content1_missing_content3-tracked
   A missing_content2_content2-tracked
   A missing_content2_content3-tracked
   A missing_missing_content3-tracked
   R content1_content1_content1-untracked
   R content1_content1_content3-untracked
   R content1_content1_missing-untracked
   R content1_content2_content1-untracked
   R content1_content2_content2-untracked
   R content1_content2_content3-untracked
   R content1_content2_missing-untracked
   R content1_missing_content1-untracked
   R content1_missing_content3-untracked
   R content1_missing_missing-untracked
   ! content1_content1_missing-tracked
   ! content1_content2_missing-tracked
   ! content1_missing_missing-tracked
   ! missing_content2_missing-tracked
   ! missing_missing_missing-tracked
   ? missing_missing_content3-untracked
 
 (create a simple text version of the content)
 
   $ python ../dircontent.py > ../content-wc.txt
   $ cat ../content-wc.txt
   content1 content1_content1_content1-tracked
   content1 content1_content1_content1-untracked
   content3 content1_content1_content3-tracked
   content3 content1_content1_content3-untracked
   content1 content1_content2_content1-tracked
   content1 content1_content2_content1-untracked
   content2 content1_content2_content2-tracked
   content2 content1_content2_content2-untracked
   content3 content1_content2_content3-tracked
   content3 content1_content2_content3-untracked
   content1 content1_missing_content1-tracked
   content1 content1_missing_content1-untracked
   content3 content1_missing_content3-tracked
   content3 content1_missing_content3-untracked
   content2 missing_content2_content2-tracked
   content2 missing_content2_content2-untracked
   content3 missing_content2_content3-tracked
   content3 missing_content2_content3-untracked
   content3 missing_missing_content3-tracked
   content3 missing_missing_content3-untracked
 
   $ cd ..
 
 Test revert --all to parent content
 -----------------------------------
 
 (setup from reference repo)
 
   $ cp -r revert-ref revert-parent-all
   $ cd revert-parent-all
 
 check revert output
 
   $ hg revert --all
   undeleting content1_content1_content1-untracked
   reverting content1_content1_content3-tracked
   undeleting content1_content1_content3-untracked
   reverting content1_content1_missing-tracked
   undeleting content1_content1_missing-untracked
   reverting content1_content2_content1-tracked
   undeleting content1_content2_content1-untracked
   undeleting content1_content2_content2-untracked
   reverting content1_content2_content3-tracked
   undeleting content1_content2_content3-untracked
   reverting content1_content2_missing-tracked
   undeleting content1_content2_missing-untracked
   forgetting content1_missing_content1-tracked
   forgetting content1_missing_content3-tracked
   forgetting content1_missing_missing-tracked
   undeleting missing_content2_content2-untracked
   reverting missing_content2_content3-tracked
   undeleting missing_content2_content3-untracked
   reverting missing_content2_missing-tracked
   undeleting missing_content2_missing-untracked
   forgetting missing_missing_content3-tracked
   forgetting missing_missing_missing-tracked
 
 Compare resulting directory with revert target.
 
 The diff is filtered to include change only. The only difference should be
 additional `.orig` backup file when applicable.
 
   $ python ../dircontent.py > ../content-parent-all.txt
   $ cd ..
   $ diff -U 0 -- content-parent.txt content-parent-all.txt | grep _
   +content3 content1_content1_content3-tracked.orig
   +content3 content1_content1_content3-untracked.orig
   +content1 content1_content2_content1-tracked.orig
   +content1 content1_content2_content1-untracked.orig
   +content3 content1_content2_content3-tracked.orig
   +content3 content1_content2_content3-untracked.orig
   +content1 content1_missing_content1-tracked
   +content1 content1_missing_content1-untracked
   +content3 content1_missing_content3-tracked
   +content3 content1_missing_content3-untracked
   +content3 missing_content2_content3-tracked.orig
   +content3 missing_content2_content3-untracked.orig
   +content3 missing_missing_content3-tracked
   +content3 missing_missing_content3-untracked
 
 Test revert --all to "base" content
 -----------------------------------
 
 (setup from reference repo)
 
   $ cp -r revert-ref revert-base-all
   $ cd revert-base-all
 
 check revert output
 
   $ hg revert --all --rev 'desc(base)'
   undeleting content1_content1_content1-untracked
   reverting content1_content1_content3-tracked
   undeleting content1_content1_content3-untracked
   reverting content1_content1_missing-tracked
   undeleting content1_content1_missing-untracked
   undeleting content1_content2_content1-untracked
   reverting content1_content2_content2-tracked
   undeleting content1_content2_content2-untracked
   reverting content1_content2_content3-tracked
   undeleting content1_content2_content3-untracked
   reverting content1_content2_missing-tracked
   undeleting content1_content2_missing-untracked
   adding content1_missing_content1-untracked
   reverting content1_missing_content3-tracked
   adding content1_missing_content3-untracked
   reverting content1_missing_missing-tracked
   adding content1_missing_missing-untracked
   removing missing_content2_content2-tracked
   removing missing_content2_content3-tracked
   removing missing_content2_missing-tracked
   forgetting missing_missing_content3-tracked
   forgetting missing_missing_missing-tracked
 
 Compare resulting directory with revert target.
 
 The diff is filtered to include change only. The only difference should be
 additional `.orig` backup file when applicable.
 
   $ python ../dircontent.py > ../content-base-all.txt
   $ cd ..
   $ diff -U 0 -- content-base.txt content-base-all.txt | grep _
   +content3 content1_content1_content3-tracked.orig
   +content3 content1_content1_content3-untracked.orig
   +content2 content1_content2_content2-untracked.orig
   +content3 content1_content2_content3-tracked.orig
   +content3 content1_content2_content3-untracked.orig
   +content3 content1_missing_content3-tracked.orig
   +content3 content1_missing_content3-untracked.orig
   +content2 missing_content2_content2-untracked
   +content3 missing_content2_content3-tracked.orig
   +content3 missing_content2_content3-untracked
   +content3 missing_missing_content3-tracked
   +content3 missing_missing_content3-untracked
 
 Test revert to parent content with explicit file name
 -----------------------------------------------------
 
 (setup from reference repo)
 
   $ cp -r revert-ref revert-parent-explicit
   $ cd revert-parent-explicit
 
 revert all files individually and check the output
 (output is expected to be different than in the --all case)
 
   $ for file in `python $TESTDIR/generate-working-copy-states.py filelist 2`; do
   >   echo '### revert for:' $file;
   >   hg revert $file;
   >   echo
   > done
   ### revert for: content1_content1_content1-tracked
   no changes needed to content1_content1_content1-tracked
   
   ### revert for: content1_content1_content1-untracked
   
   ### revert for: content1_content1_content3-tracked
   
   ### revert for: content1_content1_content3-untracked
   
   ### revert for: content1_content1_missing-tracked
   
   ### revert for: content1_content1_missing-untracked
   
   ### revert for: content1_content2_content1-tracked
   
   ### revert for: content1_content2_content1-untracked
   
   ### revert for: content1_content2_content2-tracked
   no changes needed to content1_content2_content2-tracked
   
   ### revert for: content1_content2_content2-untracked
   
   ### revert for: content1_content2_content3-tracked
   
   ### revert for: content1_content2_content3-untracked
   
   ### revert for: content1_content2_missing-tracked
   
   ### revert for: content1_content2_missing-untracked
   
   ### revert for: content1_missing_content1-tracked
   
   ### revert for: content1_missing_content1-untracked
   file not managed: content1_missing_content1-untracked
   
   ### revert for: content1_missing_content3-tracked
   
   ### revert for: content1_missing_content3-untracked
   file not managed: content1_missing_content3-untracked
   
   ### revert for: content1_missing_missing-tracked
   
   ### revert for: content1_missing_missing-untracked
   content1_missing_missing-untracked: no such file in rev * (glob)
   
   ### revert for: missing_content2_content2-tracked
   no changes needed to missing_content2_content2-tracked
   
   ### revert for: missing_content2_content2-untracked
   
   ### revert for: missing_content2_content3-tracked
   
   ### revert for: missing_content2_content3-untracked
   
   ### revert for: missing_content2_missing-tracked
   
   ### revert for: missing_content2_missing-untracked
   
   ### revert for: missing_missing_content3-tracked
   
   ### revert for: missing_missing_content3-untracked
   file not managed: missing_missing_content3-untracked
   
   ### revert for: missing_missing_missing-tracked
   
   ### revert for: missing_missing_missing-untracked
   missing_missing_missing-untracked: no such file in rev * (glob)
   
 
 check resulting directory against the --all run
 (There should be no difference)
 
   $ python ../dircontent.py > ../content-parent-explicit.txt
   $ cd ..
   $ diff -U 0 -- content-parent-all.txt content-parent-explicit.txt | grep _
   [1]
 
 Test revert to "base" content with explicit file name
 -----------------------------------------------------
 
 (setup from reference repo)
 
   $ cp -r revert-ref revert-base-explicit
   $ cd revert-base-explicit
 
 revert all files individually and check the output
 (output is expected to be different than in the --all case)
 
   $ for file in `python $TESTDIR/generate-working-copy-states.py filelist 2`; do
   >   echo '### revert for:' $file;
   >   hg revert $file --rev 'desc(base)';
   >   echo
   > done
   ### revert for: content1_content1_content1-tracked
   no changes needed to content1_content1_content1-tracked
   
   ### revert for: content1_content1_content1-untracked
   
   ### revert for: content1_content1_content3-tracked
   
   ### revert for: content1_content1_content3-untracked
   
   ### revert for: content1_content1_missing-tracked
   
   ### revert for: content1_content1_missing-untracked
   
   ### revert for: content1_content2_content1-tracked
   no changes needed to content1_content2_content1-tracked
   
   ### revert for: content1_content2_content1-untracked
   
   ### revert for: content1_content2_content2-tracked
   
   ### revert for: content1_content2_content2-untracked
   
   ### revert for: content1_content2_content3-tracked
   
   ### revert for: content1_content2_content3-untracked
   
   ### revert for: content1_content2_missing-tracked
   
   ### revert for: content1_content2_missing-untracked
   
   ### revert for: content1_missing_content1-tracked
   no changes needed to content1_missing_content1-tracked
   
   ### revert for: content1_missing_content1-untracked
   
   ### revert for: content1_missing_content3-tracked
   
   ### revert for: content1_missing_content3-untracked
   
   ### revert for: content1_missing_missing-tracked
   
   ### revert for: content1_missing_missing-untracked
   
   ### revert for: missing_content2_content2-tracked
   
   ### revert for: missing_content2_content2-untracked
   no changes needed to missing_content2_content2-untracked
   
   ### revert for: missing_content2_content3-tracked
   
   ### revert for: missing_content2_content3-untracked
   no changes needed to missing_content2_content3-untracked
   
   ### revert for: missing_content2_missing-tracked
   
   ### revert for: missing_content2_missing-untracked
   no changes needed to missing_content2_missing-untracked
   
   ### revert for: missing_missing_content3-tracked
   
   ### revert for: missing_missing_content3-untracked
   file not managed: missing_missing_content3-untracked
   
   ### revert for: missing_missing_missing-tracked
   
   ### revert for: missing_missing_missing-untracked
   missing_missing_missing-untracked: no such file in rev * (glob)
   
 
 check resulting directory against the --all run
 (There should be no difference)
 
   $ python ../dircontent.py > ../content-base-explicit.txt
   $ cd ..
   $ diff -U 0 -- content-base-all.txt content-base-explicit.txt | grep _
   [1]

tests/test-subrepo.t

@@ -1,1739 +1,1757 b''
 Let commit recurse into subrepos by default to match pre-2.0 behavior:
 
   $ echo "[ui]" >> $HGRCPATH
   $ echo "commitsubrepos = Yes" >> $HGRCPATH
 
   $ hg init t
   $ cd t
 
 first revision, no sub
 
   $ echo a > a
   $ hg ci -Am0
   adding a
 
 add first sub
 
   $ echo s = s > .hgsub
   $ hg add .hgsub
   $ hg init s
   $ echo a > s/a
 
 Issue2232: committing a subrepo without .hgsub
 
   $ hg ci -mbad s
   abort: can't commit subrepos without .hgsub
   [255]
 
   $ hg -R s add s/a
   $ hg files -S
   .hgsub
   a
   s/a (glob)
 
   $ hg -R s ci -Ams0
   $ hg sum
   parent: 0:f7b1eb17ad24 tip
    0
   branch: default
   commit: 1 added, 1 subrepos
   update: (current)
   phases: 1 draft
   $ hg ci -m1
 
 test handling .hgsubstate "added" explicitly.
 
   $ hg parents --template '{node}\n{files}\n'
   7cf8cfea66e410e8e3336508dfeec07b3192de51
   .hgsub .hgsubstate
   $ hg rollback -q
   $ hg add .hgsubstate
   $ hg ci -m1
   $ hg parents --template '{node}\n{files}\n'
   7cf8cfea66e410e8e3336508dfeec07b3192de51
   .hgsub .hgsubstate
 
 Revert subrepo and test subrepo fileset keyword:
 
   $ echo b > s/a
   $ hg revert --dry-run "set:subrepo('glob:s*')"
   reverting subrepo s
   reverting s/a (glob)
   $ cat s/a
   b
   $ hg revert "set:subrepo('glob:s*')"
   reverting subrepo s
   reverting s/a (glob)
   $ cat s/a
   a
   $ rm s/a.orig
 
 Revert subrepo with no backup. The "reverting s/a" line is gone since
 we're really running 'hg update' in the subrepo:
 
   $ echo b > s/a
   $ hg revert --no-backup s
   reverting subrepo s
 
 Issue2022: update -C
 
   $ echo b > s/a
   $ hg sum
   parent: 1:7cf8cfea66e4 tip
    1
   branch: default
   commit: 1 subrepos
   update: (current)
   phases: 2 draft
   $ hg co -C 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg sum
   parent: 1:7cf8cfea66e4 tip
    1
   branch: default
   commit: (clean)
   update: (current)
   phases: 2 draft
 
 commands that require a clean repo should respect subrepos
 
   $ echo b >> s/a
   $ hg backout tip
   abort: uncommitted changes in subrepository 's'
   [255]
   $ hg revert -C -R s s/a
 
 add sub sub
 
   $ echo ss = ss > s/.hgsub
   $ hg init s/ss
   $ echo a > s/ss/a
   $ hg -R s add s/.hgsub
   $ hg -R s/ss add s/ss/a
   $ hg sum
   parent: 1:7cf8cfea66e4 tip
    1
   branch: default
   commit: 1 subrepos
   update: (current)
   phases: 2 draft
   $ hg ci -m2
   committing subrepository s
   committing subrepository s/ss (glob)
   $ hg sum
   parent: 2:df30734270ae tip
    2
   branch: default
   commit: (clean)
   update: (current)
   phases: 3 draft
 
 test handling .hgsubstate "modified" explicitly.
 
   $ hg parents --template '{node}\n{files}\n'
   df30734270ae757feb35e643b7018e818e78a9aa
   .hgsubstate
   $ hg rollback -q
   $ hg status -A .hgsubstate
   M .hgsubstate
   $ hg ci -m2
   $ hg parents --template '{node}\n{files}\n'
   df30734270ae757feb35e643b7018e818e78a9aa
   .hgsubstate
 
 bump sub rev (and check it is ignored by ui.commitsubrepos)
 
   $ echo b > s/a
   $ hg -R s ci -ms1
   $ hg --config ui.commitsubrepos=no ci -m3
 
 leave sub dirty (and check ui.commitsubrepos=no aborts the commit)
 
   $ echo c > s/a
   $ hg --config ui.commitsubrepos=no ci -m4
   abort: uncommitted changes in subrepository 's'
   (use --subrepos for recursive commit)
   [255]
   $ hg id
   f6affe3fbfaa+ tip
   $ hg -R s ci -mc
   $ hg id
   f6affe3fbfaa+ tip
   $ echo d > s/a
   $ hg ci -m4
   committing subrepository s
   $ hg tip -R s
   changeset:   4:02dcf1d70411
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     4
   
 
 check caching
 
   $ hg co 0
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg debugsub
 
 restore
 
   $ hg co
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg debugsub
   path s
    source   s
    revision 02dcf1d704118aee3ee306ccfa1910850d5b05ef
 
 new branch for merge tests
 
   $ hg co 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo t = t >> .hgsub
   $ hg init t
   $ echo t > t/t
   $ hg -R t add t
   adding t/t (glob)
 
 5
 
   $ hg ci -m5 # add sub
   committing subrepository t
   created new head
   $ echo t2 > t/t
 
 6
 
   $ hg st -R s
   $ hg ci -m6 # change sub
   committing subrepository t
   $ hg debugsub
   path s
    source   s
    revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
   path t
    source   t
    revision 6747d179aa9a688023c4b0cad32e4c92bb7f34ad
   $ echo t3 > t/t
 
 7
 
   $ hg ci -m7 # change sub again for conflict test
   committing subrepository t
   $ hg rm .hgsub
 
 8
 
   $ hg ci -m8 # remove sub
 
 test handling .hgsubstate "removed" explicitly.
 
   $ hg parents --template '{node}\n{files}\n'
   96615c1dad2dc8e3796d7332c77ce69156f7b78e
   .hgsub .hgsubstate
   $ hg rollback -q
   $ hg remove .hgsubstate
   $ hg ci -m8
   $ hg parents --template '{node}\n{files}\n'
   96615c1dad2dc8e3796d7332c77ce69156f7b78e
   .hgsub .hgsubstate
 
 merge tests
 
   $ hg co -C 3
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge 5 # test adding
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg debugsub
   path s
    source   s
    revision fc627a69481fcbe5f1135069e8a3881c023e4cf5
   path t
    source   t
    revision 60ca1237c19474e7a3978b0dc1ca4e6f36d51382
   $ hg ci -m9
   created new head
   $ hg merge 6 --debug # test change
     searching for copies back to rev 2
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 1f14a2e2d3ec, local: f0d2028bf86d+, remote: 1831e14459c4
    .hgsubstate: versions differ -> m
   subrepo merge f0d2028bf86d+ 1831e14459c4 1f14a2e2d3ec
     subrepo t: other changed, get t:6747d179aa9a688023c4b0cad32e4c92bb7f34ad:hg
   getting subrepo t
   resolving manifests
    branchmerge: False, force: False, partial: False
    ancestor: 60ca1237c194, local: 60ca1237c194+, remote: 6747d179aa9a
    t: remote is newer -> g
   getting t
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg debugsub
   path s
    source   s
    revision fc627a69481fcbe5f1135069e8a3881c023e4cf5
   path t
    source   t
    revision 6747d179aa9a688023c4b0cad32e4c92bb7f34ad
   $ echo conflict > t/t
   $ hg ci -m10
   committing subrepository t
   $ HGMERGE=internal:merge hg merge --debug 7 # test conflict
     searching for copies back to rev 2
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 1831e14459c4, local: e45c8b14af55+, remote: f94576341bcf
    .hgsubstate: versions differ -> m
   subrepo merge e45c8b14af55+ f94576341bcf 1831e14459c4
     subrepo t: both sides changed 
    subrepository t diverged (local revision: 20a0db6fbf6c, remote revision: 7af322bc1198)
   (M)erge, keep (l)ocal or keep (r)emote? m
   merging subrepo t
     searching for copies back to rev 2
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 6747d179aa9a, local: 20a0db6fbf6c+, remote: 7af322bc1198
    preserving t for resolve of t
    t: versions differ -> m
   picked tool 'internal:merge' for t (binary False symlink False)
   merging t
   my t@20a0db6fbf6c+ other t@7af322bc1198 ancestor t@6747d179aa9a
   warning: conflicts during merge.
   merging t incomplete! (edit conflicts, 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 update -C .' to abandon
     subrepo t: merge with t:7af322bc1198a32402fe903e0b7ebcfc5c9bf8f4:hg
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
 should conflict
 
   $ cat t/t
   <<<<<<< local: 20a0db6fbf6c - test: 10
   conflict
   =======
   t3
   >>>>>>> other: 7af322bc1198  - test: 7
 
 11: remove subrepo t
 
   $ hg co -C 5
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg revert -r 4 .hgsub # remove t
   $ hg ci -m11
   created new head
   $ hg debugsub
   path s
    source   s
    revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
 
 local removed, remote changed, keep changed
 
   $ hg merge 6
    remote changed subrepository t which local removed
   use (c)hanged version or (d)elete? c
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 BROKEN: should include subrepo t
   $ hg debugsub
   path s
    source   s
    revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
   $ cat .hgsubstate
   e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   6747d179aa9a688023c4b0cad32e4c92bb7f34ad t
   $ hg ci -m 'local removed, remote changed, keep changed'
 BROKEN: should include subrepo t
   $ hg debugsub
   path s
    source   s
    revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
 BROKEN: should include subrepo t
   $ cat .hgsubstate
   e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   $ cat t/t
   t2
 
 local removed, remote changed, keep removed
 
   $ hg co -C 11
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge --config ui.interactive=true 6 <<EOF
   > d
   > EOF
    remote changed subrepository t which local removed
   use (c)hanged version or (d)elete? d
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg debugsub
   path s
    source   s
    revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
   $ cat .hgsubstate
   e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   $ hg ci -m 'local removed, remote changed, keep removed'
   created new head
   $ hg debugsub
   path s
    source   s
    revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
   $ cat .hgsubstate
   e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
 
 local changed, remote removed, keep changed
 
   $ hg co -C 6
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge 11
    local changed subrepository t which remote removed
   use (c)hanged version or (d)elete? c
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 BROKEN: should include subrepo t
   $ hg debugsub
   path s
    source   s
    revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
 BROKEN: should include subrepo t
   $ cat .hgsubstate
   e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   $ hg ci -m 'local changed, remote removed, keep changed'
   created new head
 BROKEN: should include subrepo t
   $ hg debugsub
   path s
    source   s
    revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
 BROKEN: should include subrepo t
   $ cat .hgsubstate
   e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   $ cat t/t
   t2
 
 local changed, remote removed, keep removed
 
   $ hg co -C 6
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge --config ui.interactive=true 11 <<EOF
   > d
   > EOF
    local changed subrepository t which remote removed
   use (c)hanged version or (d)elete? d
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg debugsub
   path s
    source   s
    revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
   $ cat .hgsubstate
   e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   $ hg ci -m 'local changed, remote removed, keep removed'
   created new head
   $ hg debugsub
   path s
    source   s
    revision e4ece1bf43360ddc8f6a96432201a37b7cd27ae4
   $ cat .hgsubstate
   e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
 
 clean up to avoid having to fix up the tests below
 
   $ hg co -C 10
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > strip=
   > EOF
   $ hg strip -r 11:15
   saved backup bundle to $TESTTMP/t/.hg/strip-backup/*-backup.hg (glob)
 
 clone
 
   $ cd ..
   $ hg clone t tc
   updating to branch default
   cloning subrepo s from $TESTTMP/t/s
   cloning subrepo s/ss from $TESTTMP/t/s/ss (glob)
   cloning subrepo t from $TESTTMP/t/t
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd tc
   $ hg debugsub
   path s
    source   s
    revision fc627a69481fcbe5f1135069e8a3881c023e4cf5
   path t
    source   t
    revision 20a0db6fbf6c3d2836e6519a642ae929bfc67c0e
 
 push
 
   $ echo bah > t/t
   $ hg ci -m11
   committing subrepository t
   $ hg push
   pushing to $TESTTMP/t (glob)
   no changes made to subrepo s/ss since last push to $TESTTMP/t/s/ss (glob)
   no changes made to subrepo s since last push to $TESTTMP/t/s
   pushing subrepo t to $TESTTMP/t/t
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
 push -f
 
   $ echo bah > s/a
   $ hg ci -m12
   committing subrepository s
   $ hg push
   pushing to $TESTTMP/t (glob)
   no changes made to subrepo s/ss since last push to $TESTTMP/t/s/ss (glob)
   pushing subrepo s to $TESTTMP/t/s
   searching for changes
   abort: push creates new remote head 12a213df6fa9! (in subrepo s)
   (merge or see "hg help push" for details about pushing new heads)
   [255]
   $ hg push -f
   pushing to $TESTTMP/t (glob)
   pushing subrepo s/ss to $TESTTMP/t/s/ss (glob)
   searching for changes
   no changes found
   pushing subrepo s to $TESTTMP/t/s
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (+1 heads)
   pushing subrepo t to $TESTTMP/t/t
   searching for changes
   no changes found
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
 check that unmodified subrepos are not pushed
 
   $ hg clone . ../tcc
   updating to branch default
   cloning subrepo s from $TESTTMP/tc/s
   cloning subrepo s/ss from $TESTTMP/tc/s/ss (glob)
   cloning subrepo t from $TESTTMP/tc/t
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 the subrepos on the new clone have nothing to push to its source
 
   $ hg push -R ../tcc .
   pushing to .
   no changes made to subrepo s/ss since last push to s/ss (glob)
   no changes made to subrepo s since last push to s
   no changes made to subrepo t since last push to t
   searching for changes
   no changes found
   [1]
 
 the subrepos on the source do not have a clean store versus the clone target
 because they were never explicitly pushed to the source
 
   $ hg push ../tcc
   pushing to ../tcc
   pushing subrepo s/ss to ../tcc/s/ss (glob)
   searching for changes
   no changes found
   pushing subrepo s to ../tcc/s
   searching for changes
   no changes found
   pushing subrepo t to ../tcc/t
   searching for changes
   no changes found
   searching for changes
   no changes found
   [1]
 
 after push their stores become clean
 
   $ hg push ../tcc
   pushing to ../tcc
   no changes made to subrepo s/ss since last push to ../tcc/s/ss (glob)
   no changes made to subrepo s since last push to ../tcc/s
   no changes made to subrepo t since last push to ../tcc/t
   searching for changes
   no changes found
   [1]
 
 updating a subrepo to a different revision or changing
 its working directory does not make its store dirty
 
   $ hg -R s update '.^'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg push
   pushing to $TESTTMP/t (glob)
   no changes made to subrepo s/ss since last push to $TESTTMP/t/s/ss (glob)
   no changes made to subrepo s since last push to $TESTTMP/t/s
   no changes made to subrepo t since last push to $TESTTMP/t/t
   searching for changes
   no changes found
   [1]
   $ echo foo >> s/a
   $ hg push
   pushing to $TESTTMP/t (glob)
   no changes made to subrepo s/ss since last push to $TESTTMP/t/s/ss (glob)
   no changes made to subrepo s since last push to $TESTTMP/t/s
   no changes made to subrepo t since last push to $TESTTMP/t/t
   searching for changes
   no changes found
   [1]
   $ hg -R s update -C tip
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 committing into a subrepo makes its store (but not its parent's store) dirty
 
   $ echo foo >> s/ss/a
   $ hg -R s/ss commit -m 'test dirty store detection'
 
   $ hg out -S -r `hg log -r tip -T "{node|short}"`
   comparing with $TESTTMP/t (glob)
   searching for changes
   no changes found
   comparing with $TESTTMP/t/s
   searching for changes
   no changes found
   comparing with $TESTTMP/t/s/ss
   searching for changes
   changeset:   1:79ea5566a333
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     test dirty store detection
   
   comparing with $TESTTMP/t/t
   searching for changes
   no changes found
 
   $ hg push
   pushing to $TESTTMP/t (glob)
   pushing subrepo s/ss to $TESTTMP/t/s/ss (glob)
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   no changes made to subrepo s since last push to $TESTTMP/t/s
   no changes made to subrepo t since last push to $TESTTMP/t/t
   searching for changes
   no changes found
   [1]
 
 a subrepo store may be clean versus one repo but not versus another
 
   $ hg push
   pushing to $TESTTMP/t (glob)
   no changes made to subrepo s/ss since last push to $TESTTMP/t/s/ss (glob)
   no changes made to subrepo s since last push to $TESTTMP/t/s
   no changes made to subrepo t since last push to $TESTTMP/t/t
   searching for changes
   no changes found
   [1]
   $ hg push ../tcc
   pushing to ../tcc
   pushing subrepo s/ss to ../tcc/s/ss (glob)
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   no changes made to subrepo s since last push to ../tcc/s
   no changes made to subrepo t since last push to ../tcc/t
   searching for changes
   no changes found
   [1]
 
 update
 
   $ cd ../t
   $ hg up -C # discard our earlier merge
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo blah > t/t
   $ hg ci -m13
   committing subrepository t
 
 backout calls revert internally with minimal opts, which should not raise
 KeyError
 
   $ hg backout ".^"
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   changeset c373c8102e68 backed out, don't forget to commit.
 
   $ hg up -C # discard changes
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 pull
 
   $ cd ../tc
   $ hg pull
   pulling from $TESTTMP/t (glob)
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   (run 'hg update' to get a working copy)
 
 should pull t
 
   $ hg incoming -S -r `hg log -r tip -T "{node|short}"`
   comparing with $TESTTMP/t (glob)
   no changes found
   comparing with $TESTTMP/t/s
   searching for changes
   no changes found
   comparing with $TESTTMP/t/s/ss
   searching for changes
   no changes found
   comparing with $TESTTMP/t/t
   searching for changes
   changeset:   5:52c0adc0515a
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     13
   
 
   $ hg up
   pulling subrepo t from $TESTTMP/t/t
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat t/t
   blah
 
 bogus subrepo path aborts
 
   $ echo 'bogus=[boguspath' >> .hgsub
   $ hg ci -m 'bogus subrepo path'
   abort: missing ] in subrepo source
   [255]
 
 Issue1986: merge aborts when trying to merge a subrepo that
 shouldn't need merging
 
 # subrepo layout
 #
 #   o   5 br
 #  /|
 # o |   4 default
 # | |
 # | o   3 br
 # |/|
 # o |   2 default
 # | |
 # | o   1 br
 # |/
 # o     0 default
 
   $ cd ..
   $ rm -rf sub
   $ hg init main
   $ cd main
   $ hg init s
   $ cd s
   $ echo a > a
   $ hg ci -Am1
   adding a
   $ hg branch br
   marked working directory as branch br
   (branches are permanent and global, did you want a bookmark?)
   $ echo a >> a
   $ hg ci -m1
   $ hg up default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo b > b
   $ hg ci -Am1
   adding b
   $ hg up br
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg merge tip
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m1
   $ hg up 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo c > c
   $ hg ci -Am1
   adding c
   $ hg up 3
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg merge 4
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m1
 
 # main repo layout:
 #
 #   * <-- try to merge default into br again
 # .`|
 # . o   5 br      --> substate = 5
 # . |
 # o |   4 default --> substate = 4
 # | |
 # | o   3 br      --> substate = 2
 # |/|
 # o |   2 default --> substate = 2
 # | |
 # | o   1 br      --> substate = 3
 # |/
 # o     0 default --> substate = 2
 
   $ cd ..
   $ echo 's = s' > .hgsub
   $ hg -R s up 2
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg ci -Am1
   adding .hgsub
   $ hg branch br
   marked working directory as branch br
   (branches are permanent and global, did you want a bookmark?)
   $ echo b > b
   $ hg -R s up 3
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg ci -Am1
   adding b
   $ hg up default
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo c > c
   $ hg ci -Am1
   adding c
   $ hg up 1
   2 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg merge 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m1
   $ hg up 2
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg -R s up 4
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo d > d
   $ hg ci -Am1
   adding d
   $ hg up 3
   2 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg -R s up 5
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo e > e
   $ hg ci -Am1
   adding e
 
   $ hg up 5
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge 4    # try to merge default into br again
    subrepository s diverged (local revision: f8f13b33206e, remote revision: a3f9062a4f88)
   (M)erge, keep (l)ocal or keep (r)emote? m
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ cd ..
 
 test subrepo delete from .hgsubstate
 
   $ hg init testdelete
   $ mkdir testdelete/nested testdelete/nested2
   $ hg init testdelete/nested
   $ hg init testdelete/nested2
   $ echo test > testdelete/nested/foo
   $ echo test > testdelete/nested2/foo
   $ hg -R testdelete/nested add
   adding testdelete/nested/foo (glob)
   $ hg -R testdelete/nested2 add
   adding testdelete/nested2/foo (glob)
   $ hg -R testdelete/nested ci -m test
   $ hg -R testdelete/nested2 ci -m test
   $ echo nested = nested > testdelete/.hgsub
   $ echo nested2 = nested2 >> testdelete/.hgsub
   $ hg -R testdelete add
   adding testdelete/.hgsub (glob)
   $ hg -R testdelete ci -m "nested 1 & 2 added"
   $ echo nested = nested > testdelete/.hgsub
   $ hg -R testdelete ci -m "nested 2 deleted"
   $ cat testdelete/.hgsubstate
   bdf5c9a3103743d900b12ae0db3ffdcfd7b0d878 nested
   $ hg -R testdelete remove testdelete/.hgsub
   $ hg -R testdelete ci -m ".hgsub deleted"
   $ cat testdelete/.hgsubstate
   bdf5c9a3103743d900b12ae0db3ffdcfd7b0d878 nested
 
 test repository cloning
 
   $ mkdir mercurial mercurial2
   $ hg init nested_absolute
   $ echo test > nested_absolute/foo
   $ hg -R nested_absolute add
   adding nested_absolute/foo (glob)
   $ hg -R nested_absolute ci -mtest
   $ cd mercurial
   $ hg init nested_relative
   $ echo test2 > nested_relative/foo2
   $ hg -R nested_relative add
   adding nested_relative/foo2 (glob)
   $ hg -R nested_relative ci -mtest2
   $ hg init main
   $ echo "nested_relative = ../nested_relative" > main/.hgsub
   $ echo "nested_absolute = `pwd`/nested_absolute" >> main/.hgsub
   $ hg -R main add
   adding main/.hgsub (glob)
   $ hg -R main ci -m "add subrepos"
   $ cd ..
   $ hg clone mercurial/main mercurial2/main
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat mercurial2/main/nested_absolute/.hg/hgrc \
   >     mercurial2/main/nested_relative/.hg/hgrc
   [paths]
   default = $TESTTMP/mercurial/nested_absolute
   [paths]
   default = $TESTTMP/mercurial/nested_relative
   $ rm -rf mercurial mercurial2
 
 Issue1977: multirepo push should fail if subrepo push fails
 
   $ hg init repo
   $ hg init repo/s
   $ echo a > repo/s/a
   $ hg -R repo/s ci -Am0
   adding a
   $ echo s = s > repo/.hgsub
   $ hg -R repo ci -Am1
   adding .hgsub
   $ hg clone repo repo2
   updating to branch default
   cloning subrepo s from $TESTTMP/repo/s
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -q -R repo2 pull -u
   $ echo 1 > repo2/s/a
   $ hg -R repo2/s ci -m2
   $ hg -q -R repo2/s push
   $ hg -R repo2/s up -C 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 2 > repo2/s/b
   $ hg -R repo2/s ci -m3 -A
   adding b
   created new head
   $ hg -R repo2 ci -m3
   $ hg -q -R repo2 push
   abort: push creates new remote head cc505f09a8b2! (in subrepo s)
   (merge or see "hg help push" for details about pushing new heads)
   [255]
   $ hg -R repo update
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 test if untracked file is not overwritten
 
+(this also tests that updated .hgsubstate is treated as "modified",
+when 'merge.update()' is aborted before 'merge.recordupdates()', even
+if none of mode, size and timestamp of it isn't changed on the
+filesystem (see also issue4583))
+
   $ echo issue3276_ok > repo/s/b
   $ hg -R repo2 push -f -q
   $ touch -t 200001010000 repo/.hgsubstate
-  $ hg -R repo status --config debug.dirstate.delaywrite=2 repo/.hgsubstate
+
+  $ cat >> repo/.hg/hgrc <<EOF
+  > [fakedirstatewritetime]
+  > # emulate invoking dirstate.write() via repo.status()
+  > # at 2000-01-01 00:00
+  > fakenow = 200001010000
+  > 
+  > [extensions]
+  > fakedirstatewritetime = $TESTDIR/fakedirstatewritetime.py
+  > EOF
   $ hg -R repo update
   b: untracked file differs
   abort: untracked files in working directory differ from files in requested revision (in subrepo s)
   [255]
+  $ cat >> repo/.hg/hgrc <<EOF
+  > [extensions]
+  > fakedirstatewritetime = !
+  > EOF
 
   $ cat repo/s/b
   issue3276_ok
   $ rm repo/s/b
   $ touch -t 200001010000 repo/.hgsubstate
   $ hg -R repo revert --all
   reverting repo/.hgsubstate (glob)
   reverting subrepo s
   $ hg -R repo update
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat repo/s/b
   2
   $ rm -rf repo2 repo
 
 
 Issue1852 subrepos with relative paths always push/pull relative to default
 
 Prepare a repo with subrepo
 
   $ hg init issue1852a
   $ cd issue1852a
   $ hg init sub/repo
   $ echo test > sub/repo/foo
   $ hg -R sub/repo add sub/repo/foo
   $ echo sub/repo = sub/repo > .hgsub
   $ hg add .hgsub
   $ hg ci -mtest
   committing subrepository sub/repo (glob)
   $ echo test >> sub/repo/foo
   $ hg ci -mtest
   committing subrepository sub/repo (glob)
   $ hg cat sub/repo/foo
   test
   test
   $ mkdir -p tmp/sub/repo
   $ hg cat -r 0 --output tmp/%p_p sub/repo/foo
   $ cat tmp/sub/repo/foo_p
   test
   $ mv sub/repo sub_
   $ hg cat sub/repo/baz
   skipping missing subrepository: sub/repo
   [1]
   $ rm -rf sub/repo
   $ mv sub_ sub/repo
   $ cd ..
 
 Create repo without default path, pull top repo, and see what happens on update
 
   $ hg init issue1852b
   $ hg -R issue1852b pull issue1852a
   pulling from issue1852a
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 3 changes to 2 files
   (run 'hg update' to get a working copy)
   $ hg -R issue1852b update
   abort: default path for subrepository not found (in subrepo sub/repo) (glob)
   [255]
 
 Ensure a full traceback, not just the SubrepoAbort part
 
   $ hg -R issue1852b update --traceback 2>&1 | grep 'raise util\.Abort'
       raise util.Abort(_("default path for subrepository not found"))
 
 Pull -u now doesn't help
 
   $ hg -R issue1852b pull -u issue1852a
   pulling from issue1852a
   searching for changes
   no changes found
 
 Try the same, but with pull -u
 
   $ hg init issue1852c
   $ hg -R issue1852c pull -r0 -u issue1852a
   pulling from issue1852a
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
   cloning subrepo sub/repo from issue1852a/sub/repo (glob)
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Try to push from the other side
 
   $ hg -R issue1852a push `pwd`/issue1852c
   pushing to $TESTTMP/issue1852c (glob)
   pushing subrepo sub/repo to $TESTTMP/issue1852c/sub/repo (glob)
   searching for changes
   no changes found
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
 Incoming and outgoing should not use the default path:
 
   $ hg clone -q issue1852a issue1852d
   $ hg -R issue1852d outgoing --subrepos issue1852c
   comparing with issue1852c
   searching for changes
   no changes found
   comparing with issue1852c/sub/repo
   searching for changes
   no changes found
   [1]
   $ hg -R issue1852d incoming --subrepos issue1852c
   comparing with issue1852c
   searching for changes
   no changes found
   comparing with issue1852c/sub/repo
   searching for changes
   no changes found
   [1]
 
 Check that merge of a new subrepo doesn't write the uncommitted state to
 .hgsubstate (issue4622)
 
   $ hg init issue1852a/addedsub
   $ echo zzz > issue1852a/addedsub/zz.txt
   $ hg -R issue1852a/addedsub ci -Aqm "initial ZZ"
 
   $ hg clone issue1852a/addedsub issue1852d/addedsub
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ echo def > issue1852a/sub/repo/foo
   $ hg -R issue1852a ci -SAm 'tweaked subrepo'
   adding tmp/sub/repo/foo_p
   committing subrepository sub/repo (glob)
 
   $ echo 'addedsub = addedsub' >> issue1852d/.hgsub
   $ echo xyz > issue1852d/sub/repo/foo
   $ hg -R issue1852d pull -u
   pulling from $TESTTMP/issue1852a (glob)
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
    subrepository sub/repo diverged (local revision: f42d5c7504a8, remote revision: 46cd4aac504c)
   (M)erge, keep (l)ocal or keep (r)emote? m
   pulling subrepo sub/repo from $TESTTMP/issue1852a/sub/repo (glob)
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
    subrepository sources for sub/repo differ (glob)
   use (l)ocal source (f42d5c7504a8) or (r)emote source (46cd4aac504c)? l
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat issue1852d/.hgsubstate
   f42d5c7504a811dda50f5cf3e5e16c3330b87172 sub/repo
 
 Check status of files when none of them belong to the first
 subrepository:
 
   $ hg init subrepo-status
   $ cd subrepo-status
   $ hg init subrepo-1
   $ hg init subrepo-2
   $ cd subrepo-2
   $ touch file
   $ hg add file
   $ cd ..
   $ echo subrepo-1 = subrepo-1 > .hgsub
   $ echo subrepo-2 = subrepo-2 >> .hgsub
   $ hg add .hgsub
   $ hg ci -m 'Added subrepos'
   committing subrepository subrepo-2
   $ hg st subrepo-2/file
 
 Check that share works with subrepo
   $ hg --config extensions.share= share . ../shared
   updating working directory
   cloning subrepo subrepo-2 from $TESTTMP/subrepo-status/subrepo-2
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ test -f ../shared/subrepo-1/.hg/sharedpath
   [1]
   $ hg -R ../shared in
   abort: repository default not found!
   [255]
   $ hg -R ../shared/subrepo-2 showconfig paths
   paths.default=$TESTTMP/subrepo-status/subrepo-2
   $ hg -R ../shared/subrepo-1 sum --remote
   parent: -1:000000000000 tip (empty repository)
   branch: default
   commit: (clean)
   update: (current)
   remote: (synced)
 
 Check hg update --clean
   $ cd $TESTTMP/t
   $ rm -r t/t.orig
   $ hg status -S --all
   C .hgsub
   C .hgsubstate
   C a
   C s/.hgsub
   C s/.hgsubstate
   C s/a
   C s/ss/a
   C t/t
   $ echo c1 > s/a
   $ cd s
   $ echo c1 > b
   $ echo c1 > c
   $ hg add b
   $ cd ..
   $ hg status -S
   M s/a
   A s/b
   ? s/c
   $ hg update -C
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg status -S
   ? s/b
   ? s/c
 
 Sticky subrepositories, no changes
   $ cd $TESTTMP/t
   $ hg id
   925c17564ef8 tip
   $ hg -R s id
   12a213df6fa9 tip
   $ hg -R t id
   52c0adc0515a tip
   $ hg update 11
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id
   365661e5936a
   $ hg -R s id
   fc627a69481f
   $ hg -R t id
   e95bcfa18a35
 
 Sticky subrepositories, file changes
   $ touch s/f1
   $ touch t/f1
   $ hg add -S s/f1
   $ hg add -S t/f1
   $ hg id
   365661e5936a+
   $ hg -R s id
   fc627a69481f+
   $ hg -R t id
   e95bcfa18a35+
   $ hg update tip
    subrepository s diverged (local revision: fc627a69481f, remote revision: 12a213df6fa9)
   (M)erge, keep (l)ocal or keep (r)emote? m
    subrepository sources for s differ
   use (l)ocal source (fc627a69481f) or (r)emote source (12a213df6fa9)? l
    subrepository t diverged (local revision: e95bcfa18a35, remote revision: 52c0adc0515a)
   (M)erge, keep (l)ocal or keep (r)emote? m
    subrepository sources for t differ
   use (l)ocal source (e95bcfa18a35) or (r)emote source (52c0adc0515a)? l
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id
   925c17564ef8+ tip
   $ hg -R s id
   fc627a69481f+
   $ hg -R t id
   e95bcfa18a35+
   $ hg update --clean tip
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Sticky subrepository, revision updates
   $ hg id
   925c17564ef8 tip
   $ hg -R s id
   12a213df6fa9 tip
   $ hg -R t id
   52c0adc0515a tip
   $ cd s
   $ hg update -r -2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ../t
   $ hg update -r 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ..
   $ hg update 10
    subrepository s diverged (local revision: 12a213df6fa9, remote revision: fc627a69481f)
   (M)erge, keep (l)ocal or keep (r)emote? m
    subrepository t diverged (local revision: 52c0adc0515a, remote revision: 20a0db6fbf6c)
   (M)erge, keep (l)ocal or keep (r)emote? m
    subrepository sources for t differ (in checked out version)
   use (l)ocal source (7af322bc1198) or (r)emote source (20a0db6fbf6c)? l
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id
   e45c8b14af55+
   $ hg -R s id
   02dcf1d70411
   $ hg -R t id
   7af322bc1198
 
 Sticky subrepository, file changes and revision updates
   $ touch s/f1
   $ touch t/f1
   $ hg add -S s/f1
   $ hg add -S t/f1
   $ hg id
   e45c8b14af55+
   $ hg -R s id
   02dcf1d70411+
   $ hg -R t id
   7af322bc1198+
   $ hg update tip
    subrepository s diverged (local revision: 12a213df6fa9, remote revision: 12a213df6fa9)
   (M)erge, keep (l)ocal or keep (r)emote? m
    subrepository sources for s differ
   use (l)ocal source (02dcf1d70411) or (r)emote source (12a213df6fa9)? l
    subrepository t diverged (local revision: 52c0adc0515a, remote revision: 52c0adc0515a)
   (M)erge, keep (l)ocal or keep (r)emote? m
    subrepository sources for t differ
   use (l)ocal source (7af322bc1198) or (r)emote source (52c0adc0515a)? l
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id
   925c17564ef8+ tip
   $ hg -R s id
   02dcf1d70411+
   $ hg -R t id
   7af322bc1198+
 
 Sticky repository, update --clean
   $ hg update --clean tip
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id
   925c17564ef8 tip
   $ hg -R s id
   12a213df6fa9 tip
   $ hg -R t id
   52c0adc0515a tip
 
 Test subrepo already at intended revision:
   $ cd s
   $ hg update fc627a69481f
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ..
   $ hg update 11
    subrepository s diverged (local revision: 12a213df6fa9, remote revision: fc627a69481f)
   (M)erge, keep (l)ocal or keep (r)emote? m
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id -n
   11+
   $ hg -R s id
   fc627a69481f
   $ hg -R t id
   e95bcfa18a35
 
 Test that removing .hgsubstate doesn't break anything:
 
   $ hg rm -f .hgsubstate
   $ hg ci -mrm
   nothing changed
   [1]
   $ hg log -vr tip
   changeset:   13:925c17564ef8
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files:       .hgsubstate
   description:
   13
   
   
 
 Test that removing .hgsub removes .hgsubstate:
 
   $ hg rm .hgsub
   $ hg ci -mrm2
   created new head
   $ hg log -vr tip
   changeset:   14:2400bccd50af
   tag:         tip
   parent:      11:365661e5936a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files:       .hgsub .hgsubstate
   description:
   rm2
   
   
 Test issue3153: diff -S with deleted subrepos
 
   $ hg diff --nodates -S -c .
   diff -r 365661e5936a -r 2400bccd50af .hgsub
   --- a/.hgsub
   +++ /dev/null
   @@ -1,2 +0,0 @@
   -s = s
   -t = t
   diff -r 365661e5936a -r 2400bccd50af .hgsubstate
   --- a/.hgsubstate
   +++ /dev/null
   @@ -1,2 +0,0 @@
   -fc627a69481fcbe5f1135069e8a3881c023e4cf5 s
   -e95bcfa18a358dc4936da981ebf4147b4cad1362 t
 
 Test behavior of add for explicit path in subrepo:
   $ cd ..
   $ hg init explicit
   $ cd explicit
   $ echo s = s > .hgsub
   $ hg add .hgsub
   $ hg init s
   $ hg ci -m0
 Adding with an explicit path in a subrepo adds the file
   $ echo c1 > f1
   $ echo c2 > s/f2
   $ hg st -S
   ? f1
   ? s/f2
   $ hg add s/f2
   $ hg st -S
   A s/f2
   ? f1
   $ hg ci -R s -m0
   $ hg ci -Am1
   adding f1
 Adding with an explicit path in a subrepo with -S has the same behavior
   $ echo c3 > f3
   $ echo c4 > s/f4
   $ hg st -S
   ? f3
   ? s/f4
   $ hg add -S s/f4
   $ hg st -S
   A s/f4
   ? f3
   $ hg ci -R s -m1
   $ hg ci -Ama2
   adding f3
 Adding without a path or pattern silently ignores subrepos
   $ echo c5 > f5
   $ echo c6 > s/f6
   $ echo c7 > s/f7
   $ hg st -S
   ? f5
   ? s/f6
   ? s/f7
   $ hg add
   adding f5
   $ hg st -S
   A f5
   ? s/f6
   ? s/f7
   $ hg ci -R s -Am2
   adding f6
   adding f7
   $ hg ci -m3
 Adding without a path or pattern with -S also adds files in subrepos
   $ echo c8 > f8
   $ echo c9 > s/f9
   $ echo c10 > s/f10
   $ hg st -S
   ? f8
   ? s/f10
   ? s/f9
   $ hg add -S
   adding f8
   adding s/f10 (glob)
   adding s/f9 (glob)
   $ hg st -S
   A f8
   A s/f10
   A s/f9
   $ hg ci -R s -m3
   $ hg ci -m4
 Adding with a pattern silently ignores subrepos
   $ echo c11 > fm11
   $ echo c12 > fn12
   $ echo c13 > s/fm13
   $ echo c14 > s/fn14
   $ hg st -S
   ? fm11
   ? fn12
   ? s/fm13
   ? s/fn14
   $ hg add 'glob:**fm*'
   adding fm11
   $ hg st -S
   A fm11
   ? fn12
   ? s/fm13
   ? s/fn14
   $ hg ci -R s -Am4
   adding fm13
   adding fn14
   $ hg ci -Am5
   adding fn12
 Adding with a pattern with -S also adds matches in subrepos
   $ echo c15 > fm15
   $ echo c16 > fn16
   $ echo c17 > s/fm17
   $ echo c18 > s/fn18
   $ hg st -S
   ? fm15
   ? fn16
   ? s/fm17
   ? s/fn18
   $ hg add -S 'glob:**fm*'
   adding fm15
   adding s/fm17 (glob)
   $ hg st -S
   A fm15
   A s/fm17
   ? fn16
   ? s/fn18
   $ hg ci -R s -Am5
   adding fn18
   $ hg ci -Am6
   adding fn16
 
 Test behavior of forget for explicit path in subrepo:
 Forgetting an explicit path in a subrepo untracks the file
   $ echo c19 > s/f19
   $ hg add s/f19
   $ hg st -S
   A s/f19
   $ hg forget s/f19
   $ hg st -S
   ? s/f19
   $ rm s/f19
   $ cd ..
 
 Courtesy phases synchronisation to publishing server does not block the push
 (issue3781)
 
   $ cp -r main issue3781
   $ cp -r main issue3781-dest
   $ cd issue3781-dest/s
   $ hg phase tip # show we have draft changeset
   5: draft
   $ chmod a-w .hg/store/phaseroots # prevent phase push
   $ cd ../../issue3781
   $ cat >> .hg/hgrc << EOF
   > [paths]
   > default=../issue3781-dest/
   > EOF
   $ hg push --config experimental.bundle2-exp=False
   pushing to $TESTTMP/issue3781-dest (glob)
   pushing subrepo s to $TESTTMP/issue3781-dest/s
   searching for changes
   no changes found
   searching for changes
   no changes found
   [1]
 # clean the push cache
   $ rm s/.hg/cache/storehash/*
   $ hg push --config experimental.bundle2-exp=True
   pushing to $TESTTMP/issue3781-dest (glob)
   pushing subrepo s to $TESTTMP/issue3781-dest/s
   searching for changes
   no changes found
   searching for changes
   no changes found
   [1]
   $ cd ..
 
 Test phase choice for newly created commit with "phases.subrepochecks"
 configuration
 
   $ cd t
   $ hg update -q -r 12
 
   $ cat >> s/ss/.hg/hgrc <<EOF
   > [phases]
   > new-commit = secret
   > EOF
   $ cat >> s/.hg/hgrc <<EOF
   > [phases]
   > new-commit = draft
   > EOF
   $ echo phasecheck1 >> s/ss/a
   $ hg -R s commit -S --config phases.checksubrepos=abort -m phasecheck1
   committing subrepository ss
   transaction abort!
   rollback completed
   abort: can't commit in draft phase conflicting secret from subrepository ss
   [255]
   $ echo phasecheck2 >> s/ss/a
   $ hg -R s commit -S --config phases.checksubrepos=ignore -m phasecheck2
   committing subrepository ss
   $ hg -R s/ss phase tip
   3: secret
   $ hg -R s phase tip
   6: draft
   $ echo phasecheck3 >> s/ss/a
   $ hg -R s commit -S -m phasecheck3
   committing subrepository ss
   warning: changes are committed in secret phase from subrepository ss
   $ hg -R s/ss phase tip
   4: secret
   $ hg -R s phase tip
   7: secret
 
   $ cat >> t/.hg/hgrc <<EOF
   > [phases]
   > new-commit = draft
   > EOF
   $ cat >> .hg/hgrc <<EOF
   > [phases]
   > new-commit = public
   > EOF
   $ echo phasecheck4 >>   s/ss/a
   $ echo phasecheck4 >>   t/t
   $ hg commit -S -m phasecheck4
   committing subrepository s
   committing subrepository s/ss (glob)
   warning: changes are committed in secret phase from subrepository ss
   committing subrepository t
   warning: changes are committed in secret phase from subrepository s
   created new head
   $ hg -R s/ss phase tip
   5: secret
   $ hg -R s phase tip
   8: secret
   $ hg -R t phase tip
   6: draft
   $ hg phase tip
   15: secret
 
   $ cd ..
 
 
 Test that commit --secret works on both repo and subrepo (issue4182)
 
   $ cd main
   $ echo secret >> b
   $ echo secret >> s/b
   $ hg commit --secret --subrepo -m "secret"
   committing subrepository s
   $ hg phase -r .
   6: secret
   $ cd s
   $ hg phase -r .
   6: secret
   $ cd ../../
 
 Test "subrepos" template keyword
 
   $ cd t
   $ hg update -q 15
   $ cat > .hgsub <<EOF
   > s = s
   > EOF
   $ hg commit -m "16"
   warning: changes are committed in secret phase from subrepository s
 
 (addition of ".hgsub" itself)
 
   $ hg diff --nodates -c 1 .hgsubstate
   diff -r f7b1eb17ad24 -r 7cf8cfea66e4 .hgsubstate
   --- /dev/null
   +++ b/.hgsubstate
   @@ -0,0 +1,1 @@
   +e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   $ hg log -r 1 --template "{p1node|short} {p2node|short}\n{subrepos % '{subrepo}\n'}"
   f7b1eb17ad24 000000000000
   s
 
 (modification of existing entry)
 
   $ hg diff --nodates -c 2 .hgsubstate
   diff -r 7cf8cfea66e4 -r df30734270ae .hgsubstate
   --- a/.hgsubstate
   +++ b/.hgsubstate
   @@ -1,1 +1,1 @@
   -e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   +dc73e2e6d2675eb2e41e33c205f4bdab4ea5111d s
   $ hg log -r 2 --template "{p1node|short} {p2node|short}\n{subrepos % '{subrepo}\n'}"
   7cf8cfea66e4 000000000000
   s
 
 (addition of entry)
 
   $ hg diff --nodates -c 5 .hgsubstate
   diff -r 7cf8cfea66e4 -r 1f14a2e2d3ec .hgsubstate
   --- a/.hgsubstate
   +++ b/.hgsubstate
   @@ -1,1 +1,2 @@
    e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   +60ca1237c19474e7a3978b0dc1ca4e6f36d51382 t
   $ hg log -r 5 --template "{p1node|short} {p2node|short}\n{subrepos % '{subrepo}\n'}"
   7cf8cfea66e4 000000000000
   t
 
 (removal of existing entry)
 
   $ hg diff --nodates -c 16 .hgsubstate
   diff -r 8bec38d2bd0b -r f2f70bc3d3c9 .hgsubstate
   --- a/.hgsubstate
   +++ b/.hgsubstate
   @@ -1,2 +1,1 @@
    0731af8ca9423976d3743119d0865097c07bdc1b s
   -e202dc79b04c88a636ea8913d9182a1346d9b3dc t
   $ hg log -r 16 --template "{p1node|short} {p2node|short}\n{subrepos % '{subrepo}\n'}"
   8bec38d2bd0b 000000000000
   t
 
 (merging)
 
   $ hg diff --nodates -c 9 .hgsubstate
   diff -r f6affe3fbfaa -r f0d2028bf86d .hgsubstate
   --- a/.hgsubstate
   +++ b/.hgsubstate
   @@ -1,1 +1,2 @@
    fc627a69481fcbe5f1135069e8a3881c023e4cf5 s
   +60ca1237c19474e7a3978b0dc1ca4e6f36d51382 t
   $ hg log -r 9 --template "{p1node|short} {p2node|short}\n{subrepos % '{subrepo}\n'}"
   f6affe3fbfaa 1f14a2e2d3ec
   t
 
 (removal of ".hgsub" itself)
 
   $ hg diff --nodates -c 8 .hgsubstate
   diff -r f94576341bcf -r 96615c1dad2d .hgsubstate
   --- a/.hgsubstate
   +++ /dev/null
   @@ -1,2 +0,0 @@
   -e4ece1bf43360ddc8f6a96432201a37b7cd27ae4 s
   -7af322bc1198a32402fe903e0b7ebcfc5c9bf8f4 t
   $ hg log -r 8 --template "{p1node|short} {p2node|short}\n{subrepos % '{subrepo}\n'}"
   f94576341bcf 000000000000
 
 Test that '[paths]' is configured correctly at subrepo creation
 
   $ cd $TESTTMP/tc
   $ cat > .hgsub <<EOF
   > # to clear bogus subrepo path 'bogus=[boguspath'
   > s = s
   > t = t
   > EOF
   $ hg update -q --clean null
   $ rm -rf s t
   $ cat >> .hg/hgrc <<EOF
   > [paths]
   > default-push = /foo/bar
   > EOF
   $ hg update -q
   $ cat s/.hg/hgrc
   [paths]
   default = $TESTTMP/t/s
   default-push = /foo/bar/s
   $ cat s/ss/.hg/hgrc
   [paths]
   default = $TESTTMP/t/s/ss
   default-push = /foo/bar/s/ss
   $ cat t/.hg/hgrc
   [paths]
   default = $TESTTMP/t/t
   default-push = /foo/bar/t
 
   $ cd $TESTTMP/t
   $ hg up -qC 0
   $ echo 'bar' > bar.txt
   $ hg ci -Am 'branch before subrepo add'
   adding bar.txt
   created new head
   $ hg merge -r "first(subrepo('s'))"
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg status -S -X '.hgsub*'
   A s/a
   ? s/b
   ? s/c
   ? s/f1
   $ hg status -S --rev 'p2()'
   A bar.txt
   ? s/b
   ? s/c
   ? s/f1
   $ hg diff -S -X '.hgsub*' --nodates
   diff -r 000000000000 s/a
   --- /dev/null
   +++ b/s/a
   @@ -0,0 +1,1 @@
   +a
   $ hg diff -S --rev 'p2()' --nodates
   diff -r 7cf8cfea66e4 bar.txt
   --- /dev/null
   +++ b/bar.txt
   @@ -0,0 +1,1 @@
   +bar
 
   $ cd ..