errors: add config that lets user get more detailed exit codes

This adds an experimental config that lets the user get more detailed
exit codes. For example, there will be a specific error code for
input/user errors. This is part of
https://www.mercurial-scm.org/wiki/ErrorCategoriesPlan. I've made the
config part of tweakdefaults.

I've made the config enabled by default in tests. My reasoning is that
we want to see that each specific error case gives the right exit code
and we don't want to duplicate all error cases in the entire test
suite. It also makes it easy to grep the `.t` files for `[255]` to
find which cases we have left to fix. The logic for the current exit
codes is quite simple, so I'm not too worried about regressions
there. I've added a test case specifically for the "legacy" exit
codes.

I've set the detailed exit status only for the case of
`InterventionRequired` and `SystemExit` for now (the cases where we
currently return something other than 255), just to show that it
works.

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

mercurial/configitems.py

@@ -1,1609 +1,1612 b''
 # configitems.py - centralized declaration of configuration option
 #
 #  Copyright 2017 Pierre-Yves David <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import functools
 import re
 
 from . import (
     encoding,
     error,
 )
 
 
 def loadconfigtable(ui, extname, configtable):
     """update config item known to the ui with the extension ones"""
     for section, items in sorted(configtable.items()):
         knownitems = ui._knownconfig.setdefault(section, itemregister())
         knownkeys = set(knownitems)
         newkeys = set(items)
         for key in sorted(knownkeys & newkeys):
             msg = b"extension '%s' overwrite config item '%s.%s'"
             msg %= (extname, section, key)
             ui.develwarn(msg, config=b'warn-config')
 
         knownitems.update(items)
 
 
 class configitem(object):
     """represent a known config item
 
     :section: the official config section where to find this item,
        :name: the official name within the section,
     :default: default value for this item,
     :alias: optional list of tuples as alternatives,
     :generic: this is a generic definition, match name using regular expression.
     """
 
     def __init__(
         self,
         section,
         name,
         default=None,
         alias=(),
         generic=False,
         priority=0,
         experimental=False,
     ):
         self.section = section
         self.name = name
         self.default = default
         self.alias = list(alias)
         self.generic = generic
         self.priority = priority
         self.experimental = experimental
         self._re = None
         if generic:
             self._re = re.compile(self.name)
 
 
 class itemregister(dict):
     """A specialized dictionary that can handle wild-card selection"""
 
     def __init__(self):
         super(itemregister, self).__init__()
         self._generics = set()
 
     def update(self, other):
         super(itemregister, self).update(other)
         self._generics.update(other._generics)
 
     def __setitem__(self, key, item):
         super(itemregister, self).__setitem__(key, item)
         if item.generic:
             self._generics.add(item)
 
     def get(self, key):
         baseitem = super(itemregister, self).get(key)
         if baseitem is not None and not baseitem.generic:
             return baseitem
 
         # search for a matching generic item
         generics = sorted(self._generics, key=(lambda x: (x.priority, x.name)))
         for item in generics:
             # we use 'match' instead of 'search' to make the matching simpler
             # for people unfamiliar with regular expression. Having the match
             # rooted to the start of the string will produce less surprising
             # result for user writing simple regex for sub-attribute.
             #
             # For example using "color\..*" match produces an unsurprising
             # result, while using search could suddenly match apparently
             # unrelated configuration that happens to contains "color."
             # anywhere. This is a tradeoff where we favor requiring ".*" on
             # some match to avoid the need to prefix most pattern with "^".
             # The "^" seems more error prone.
             if item._re.match(key):
                 return item
 
         return None
 
 
 coreitems = {}
 
 
 def _register(configtable, *args, **kwargs):
     item = configitem(*args, **kwargs)
     section = configtable.setdefault(item.section, itemregister())
     if item.name in section:
         msg = b"duplicated config item registration for '%s.%s'"
         raise error.ProgrammingError(msg % (item.section, item.name))
     section[item.name] = item
 
 
 # special value for case where the default is derived from other values
 dynamicdefault = object()
 
 # Registering actual config items
 
 
 def getitemregister(configtable):
     f = functools.partial(_register, configtable)
     # export pseudo enum as configitem.*
     f.dynamicdefault = dynamicdefault
     return f
 
 
 coreconfigitem = getitemregister(coreitems)
 
 
 def _registerdiffopts(section, configprefix=b''):
     coreconfigitem(
         section, configprefix + b'nodates', default=False,
     )
     coreconfigitem(
         section, configprefix + b'showfunc', default=False,
     )
     coreconfigitem(
         section, configprefix + b'unified', default=None,
     )
     coreconfigitem(
         section, configprefix + b'git', default=False,
     )
     coreconfigitem(
         section, configprefix + b'ignorews', default=False,
     )
     coreconfigitem(
         section, configprefix + b'ignorewsamount', default=False,
     )
     coreconfigitem(
         section, configprefix + b'ignoreblanklines', default=False,
     )
     coreconfigitem(
         section, configprefix + b'ignorewseol', default=False,
     )
     coreconfigitem(
         section, configprefix + b'nobinary', default=False,
     )
     coreconfigitem(
         section, configprefix + b'noprefix', default=False,
     )
     coreconfigitem(
         section, configprefix + b'word-diff', default=False,
     )
 
 
 coreconfigitem(
     b'alias', b'.*', default=dynamicdefault, generic=True,
 )
 coreconfigitem(
     b'auth', b'cookiefile', default=None,
 )
 _registerdiffopts(section=b'annotate')
 # bookmarks.pushing: internal hack for discovery
 coreconfigitem(
     b'bookmarks', b'pushing', default=list,
 )
 # bundle.mainreporoot: internal hack for bundlerepo
 coreconfigitem(
     b'bundle', b'mainreporoot', default=b'',
 )
 coreconfigitem(
     b'censor', b'policy', default=b'abort', experimental=True,
 )
 coreconfigitem(
     b'chgserver', b'idletimeout', default=3600,
 )
 coreconfigitem(
     b'chgserver', b'skiphash', default=False,
 )
 coreconfigitem(
     b'cmdserver', b'log', default=None,
 )
 coreconfigitem(
     b'cmdserver', b'max-log-files', default=7,
 )
 coreconfigitem(
     b'cmdserver', b'max-log-size', default=b'1 MB',
 )
 coreconfigitem(
     b'cmdserver', b'max-repo-cache', default=0, experimental=True,
 )
 coreconfigitem(
     b'cmdserver', b'message-encodings', default=list,
 )
 coreconfigitem(
     b'cmdserver',
     b'track-log',
     default=lambda: [b'chgserver', b'cmdserver', b'repocache'],
 )
 coreconfigitem(
     b'cmdserver', b'shutdown-on-interrupt', default=True,
 )
 coreconfigitem(
     b'color', b'.*', default=None, generic=True,
 )
 coreconfigitem(
     b'color', b'mode', default=b'auto',
 )
 coreconfigitem(
     b'color', b'pagermode', default=dynamicdefault,
 )
 coreconfigitem(
     b'command-templates',
     b'graphnode',
     default=None,
     alias=[(b'ui', b'graphnodetemplate')],
 )
 coreconfigitem(
     b'command-templates', b'log', default=None, alias=[(b'ui', b'logtemplate')],
 )
 coreconfigitem(
     b'command-templates',
     b'mergemarker',
     default=(
         b'{node|short} '
         b'{ifeq(tags, "tip", "", '
         b'ifeq(tags, "", "", "{tags} "))}'
         b'{if(bookmarks, "{bookmarks} ")}'
         b'{ifeq(branch, "default", "", "{branch} ")}'
         b'- {author|user}: {desc|firstline}'
     ),
     alias=[(b'ui', b'mergemarkertemplate')],
 )
 coreconfigitem(
     b'command-templates',
     b'pre-merge-tool-output',
     default=None,
     alias=[(b'ui', b'pre-merge-tool-output-template')],
 )
 coreconfigitem(
     b'command-templates', b'oneline-summary', default=None,
 )
 coreconfigitem(
     b'command-templates',
     b'oneline-summary.*',
     default=dynamicdefault,
     generic=True,
 )
 _registerdiffopts(section=b'commands', configprefix=b'commit.interactive.')
 coreconfigitem(
     b'commands', b'commit.post-status', default=False,
 )
 coreconfigitem(
     b'commands', b'grep.all-files', default=False, experimental=True,
 )
 coreconfigitem(
     b'commands', b'merge.require-rev', default=False,
 )
 coreconfigitem(
     b'commands', b'push.require-revs', default=False,
 )
 coreconfigitem(
     b'commands', b'resolve.confirm', default=False,
 )
 coreconfigitem(
     b'commands', b'resolve.explicit-re-merge', default=False,
 )
 coreconfigitem(
     b'commands', b'resolve.mark-check', default=b'none',
 )
 _registerdiffopts(section=b'commands', configprefix=b'revert.interactive.')
 coreconfigitem(
     b'commands', b'show.aliasprefix', default=list,
 )
 coreconfigitem(
     b'commands', b'status.relative', default=False,
 )
 coreconfigitem(
     b'commands', b'status.skipstates', default=[], experimental=True,
 )
 coreconfigitem(
     b'commands', b'status.terse', default=b'',
 )
 coreconfigitem(
     b'commands', b'status.verbose', default=False,
 )
 coreconfigitem(
     b'commands', b'update.check', default=None,
 )
 coreconfigitem(
     b'commands', b'update.requiredest', default=False,
 )
 coreconfigitem(
     b'committemplate', b'.*', default=None, generic=True,
 )
 coreconfigitem(
     b'convert', b'bzr.saverev', default=True,
 )
 coreconfigitem(
     b'convert', b'cvsps.cache', default=True,
 )
 coreconfigitem(
     b'convert', b'cvsps.fuzz', default=60,
 )
 coreconfigitem(
     b'convert', b'cvsps.logencoding', default=None,
 )
 coreconfigitem(
     b'convert', b'cvsps.mergefrom', default=None,
 )
 coreconfigitem(
     b'convert', b'cvsps.mergeto', default=None,
 )
 coreconfigitem(
     b'convert', b'git.committeractions', default=lambda: [b'messagedifferent'],
 )
 coreconfigitem(
     b'convert', b'git.extrakeys', default=list,
 )
 coreconfigitem(
     b'convert', b'git.findcopiesharder', default=False,
 )
 coreconfigitem(
     b'convert', b'git.remoteprefix', default=b'remote',
 )
 coreconfigitem(
     b'convert', b'git.renamelimit', default=400,
 )
 coreconfigitem(
     b'convert', b'git.saverev', default=True,
 )
 coreconfigitem(
     b'convert', b'git.similarity', default=50,
 )
 coreconfigitem(
     b'convert', b'git.skipsubmodules', default=False,
 )
 coreconfigitem(
     b'convert', b'hg.clonebranches', default=False,
 )
 coreconfigitem(
     b'convert', b'hg.ignoreerrors', default=False,
 )
 coreconfigitem(
     b'convert', b'hg.preserve-hash', default=False,
 )
 coreconfigitem(
     b'convert', b'hg.revs', default=None,
 )
 coreconfigitem(
     b'convert', b'hg.saverev', default=False,
 )
 coreconfigitem(
     b'convert', b'hg.sourcename', default=None,
 )
 coreconfigitem(
     b'convert', b'hg.startrev', default=None,
 )
 coreconfigitem(
     b'convert', b'hg.tagsbranch', default=b'default',
 )
 coreconfigitem(
     b'convert', b'hg.usebranchnames', default=True,
 )
 coreconfigitem(
     b'convert', b'ignoreancestorcheck', default=False, experimental=True,
 )
 coreconfigitem(
     b'convert', b'localtimezone', default=False,
 )
 coreconfigitem(
     b'convert', b'p4.encoding', default=dynamicdefault,
 )
 coreconfigitem(
     b'convert', b'p4.startrev', default=0,
 )
 coreconfigitem(
     b'convert', b'skiptags', default=False,
 )
 coreconfigitem(
     b'convert', b'svn.debugsvnlog', default=True,
 )
 coreconfigitem(
     b'convert', b'svn.trunk', default=None,
 )
 coreconfigitem(
     b'convert', b'svn.tags', default=None,
 )
 coreconfigitem(
     b'convert', b'svn.branches', default=None,
 )
 coreconfigitem(
     b'convert', b'svn.startrev', default=0,
 )
 coreconfigitem(
     b'debug', b'dirstate.delaywrite', default=0,
 )
 coreconfigitem(
     b'defaults', b'.*', default=None, generic=True,
 )
 coreconfigitem(
     b'devel', b'all-warnings', default=False,
 )
 coreconfigitem(
     b'devel', b'bundle2.debug', default=False,
 )
 coreconfigitem(
     b'devel', b'bundle.delta', default=b'',
 )
 coreconfigitem(
     b'devel', b'cache-vfs', default=None,
 )
 coreconfigitem(
     b'devel', b'check-locks', default=False,
 )
 coreconfigitem(
     b'devel', b'check-relroot', default=False,
 )
 coreconfigitem(
     b'devel', b'default-date', default=None,
 )
 coreconfigitem(
     b'devel', b'deprec-warn', default=False,
 )
 coreconfigitem(
     b'devel', b'disableloaddefaultcerts', default=False,
 )
 coreconfigitem(
     b'devel', b'warn-empty-changegroup', default=False,
 )
 coreconfigitem(
     b'devel', b'legacy.exchange', default=list,
 )
 coreconfigitem(
     b'devel', b'persistent-nodemap', default=False,
 )
 coreconfigitem(
     b'devel', b'servercafile', default=b'',
 )
 coreconfigitem(
     b'devel', b'serverexactprotocol', default=b'',
 )
 coreconfigitem(
     b'devel', b'serverrequirecert', default=False,
 )
 coreconfigitem(
     b'devel', b'strip-obsmarkers', default=True,
 )
 coreconfigitem(
     b'devel', b'warn-config', default=None,
 )
 coreconfigitem(
     b'devel', b'warn-config-default', default=None,
 )
 coreconfigitem(
     b'devel', b'user.obsmarker', default=None,
 )
 coreconfigitem(
     b'devel', b'warn-config-unknown', default=None,
 )
 coreconfigitem(
     b'devel', b'debug.copies', default=False,
 )
 coreconfigitem(
     b'devel', b'debug.extensions', default=False,
 )
 coreconfigitem(
     b'devel', b'debug.repo-filters', default=False,
 )
 coreconfigitem(
     b'devel', b'debug.peer-request', default=False,
 )
 coreconfigitem(
     b'devel', b'discovery.randomize', default=True,
 )
 _registerdiffopts(section=b'diff')
 coreconfigitem(
     b'email', b'bcc', default=None,
 )
 coreconfigitem(
     b'email', b'cc', default=None,
 )
 coreconfigitem(
     b'email', b'charsets', default=list,
 )
 coreconfigitem(
     b'email', b'from', default=None,
 )
 coreconfigitem(
     b'email', b'method', default=b'smtp',
 )
 coreconfigitem(
     b'email', b'reply-to', default=None,
 )
 coreconfigitem(
     b'email', b'to', default=None,
 )
 coreconfigitem(
     b'experimental', b'archivemetatemplate', default=dynamicdefault,
 )
 coreconfigitem(
     b'experimental', b'auto-publish', default=b'publish',
 )
 coreconfigitem(
     b'experimental', b'bundle-phases', default=False,
 )
 coreconfigitem(
     b'experimental', b'bundle2-advertise', default=True,
 )
 coreconfigitem(
     b'experimental', b'bundle2-output-capture', default=False,
 )
 coreconfigitem(
     b'experimental', b'bundle2.pushback', default=False,
 )
 coreconfigitem(
     b'experimental', b'bundle2lazylocking', default=False,
 )
 coreconfigitem(
     b'experimental', b'bundlecomplevel', default=None,
 )
 coreconfigitem(
     b'experimental', b'bundlecomplevel.bzip2', default=None,
 )
 coreconfigitem(
     b'experimental', b'bundlecomplevel.gzip', default=None,
 )
 coreconfigitem(
     b'experimental', b'bundlecomplevel.none', default=None,
 )
 coreconfigitem(
     b'experimental', b'bundlecomplevel.zstd', default=None,
 )
 coreconfigitem(
     b'experimental', b'changegroup3', default=False,
 )
 coreconfigitem(
     b'experimental', b'cleanup-as-archived', default=False,
 )
 coreconfigitem(
     b'experimental', b'clientcompressionengines', default=list,
 )
 coreconfigitem(
     b'experimental', b'copytrace', default=b'on',
 )
 coreconfigitem(
     b'experimental', b'copytrace.movecandidateslimit', default=100,
 )
 coreconfigitem(
     b'experimental', b'copytrace.sourcecommitlimit', default=100,
 )
 coreconfigitem(
     b'experimental', b'copies.read-from', default=b"filelog-only",
 )
 coreconfigitem(
     b'experimental', b'copies.write-to', default=b'filelog-only',
 )
 coreconfigitem(
     b'experimental', b'crecordtest', default=None,
 )
 coreconfigitem(
     b'experimental', b'directaccess', default=False,
 )
 coreconfigitem(
     b'experimental', b'directaccess.revnums', default=False,
 )
 coreconfigitem(
     b'experimental', b'editortmpinhg', default=False,
 )
 coreconfigitem(
     b'experimental', b'evolution', default=list,
 )
 coreconfigitem(
     b'experimental',
     b'evolution.allowdivergence',
     default=False,
     alias=[(b'experimental', b'allowdivergence')],
 )
 coreconfigitem(
     b'experimental', b'evolution.allowunstable', default=None,
 )
 coreconfigitem(
     b'experimental', b'evolution.createmarkers', default=None,
 )
 coreconfigitem(
     b'experimental',
     b'evolution.effect-flags',
     default=True,
     alias=[(b'experimental', b'effect-flags')],
 )
 coreconfigitem(
     b'experimental', b'evolution.exchange', default=None,
 )
 coreconfigitem(
     b'experimental', b'evolution.bundle-obsmarker', default=False,
 )
 coreconfigitem(
     b'experimental', b'log.topo', default=False,
 )
 coreconfigitem(
     b'experimental', b'evolution.report-instabilities', default=True,
 )
 coreconfigitem(
     b'experimental', b'evolution.track-operation', default=True,
 )
 # repo-level config to exclude a revset visibility
 #
 # The target use case is to use `share` to expose different subset of the same
 # repository, especially server side. See also `server.view`.
 coreconfigitem(
     b'experimental', b'extra-filter-revs', default=None,
 )
 coreconfigitem(
     b'experimental', b'maxdeltachainspan', default=-1,
 )
 # tracks files which were undeleted (merge might delete them but we explicitly
 # kept/undeleted them) and creates new filenodes for them
 coreconfigitem(
     b'experimental', b'merge-track-salvaged', default=False,
 )
 coreconfigitem(
     b'experimental', b'mergetempdirprefix', default=None,
 )
 coreconfigitem(
     b'experimental', b'mmapindexthreshold', default=None,
 )
 coreconfigitem(
     b'experimental', b'narrow', default=False,
 )
 coreconfigitem(
     b'experimental', b'nonnormalparanoidcheck', default=False,
 )
 coreconfigitem(
     b'experimental', b'exportableenviron', default=list,
 )
 coreconfigitem(
     b'experimental', b'extendedheader.index', default=None,
 )
 coreconfigitem(
     b'experimental', b'extendedheader.similarity', default=False,
 )
 coreconfigitem(
     b'experimental', b'graphshorten', default=False,
 )
 coreconfigitem(
     b'experimental', b'graphstyle.parent', default=dynamicdefault,
 )
 coreconfigitem(
     b'experimental', b'graphstyle.missing', default=dynamicdefault,
 )
 coreconfigitem(
     b'experimental', b'graphstyle.grandparent', default=dynamicdefault,
 )
 coreconfigitem(
     b'experimental', b'hook-track-tags', default=False,
 )
 coreconfigitem(
     b'experimental', b'httppeer.advertise-v2', default=False,
 )
 coreconfigitem(
     b'experimental', b'httppeer.v2-encoder-order', default=None,
 )
 coreconfigitem(
     b'experimental', b'httppostargs', default=False,
 )
 coreconfigitem(b'experimental', b'nointerrupt', default=False)
 coreconfigitem(b'experimental', b'nointerrupt-interactiveonly', default=True)
 
 coreconfigitem(
     b'experimental', b'obsmarkers-exchange-debug', default=False,
 )
 coreconfigitem(
     b'experimental', b'remotenames', default=False,
 )
 coreconfigitem(
     b'experimental', b'removeemptydirs', default=True,
 )
 coreconfigitem(
     b'experimental', b'revert.interactive.select-to-keep', default=False,
 )
 coreconfigitem(
     b'experimental', b'revisions.prefixhexnode', default=False,
 )
 coreconfigitem(
     b'experimental', b'revlogv2', default=None,
 )
 coreconfigitem(
     b'experimental', b'revisions.disambiguatewithin', default=None,
 )
 coreconfigitem(
     b'experimental', b'rust.index', default=False,
 )
 coreconfigitem(
     b'experimental', b'server.filesdata.recommended-batch-size', default=50000,
 )
 coreconfigitem(
     b'experimental',
     b'server.manifestdata.recommended-batch-size',
     default=100000,
 )
 coreconfigitem(
     b'experimental', b'server.stream-narrow-clones', default=False,
 )
 coreconfigitem(
     b'experimental', b'single-head-per-branch', default=False,
 )
 coreconfigitem(
     b'experimental',
     b'single-head-per-branch:account-closed-heads',
     default=False,
 )
 coreconfigitem(
     b'experimental', b'sshserver.support-v2', default=False,
 )
 coreconfigitem(
     b'experimental', b'sparse-read', default=False,
 )
 coreconfigitem(
     b'experimental', b'sparse-read.density-threshold', default=0.50,
 )
 coreconfigitem(
     b'experimental', b'sparse-read.min-gap-size', default=b'65K',
 )
 coreconfigitem(
     b'experimental', b'treemanifest', default=False,
 )
 coreconfigitem(
     b'experimental', b'update.atomic-file', default=False,
 )
 coreconfigitem(
     b'experimental', b'sshpeer.advertise-v2', default=False,
 )
 coreconfigitem(
     b'experimental', b'web.apiserver', default=False,
 )
 coreconfigitem(
     b'experimental', b'web.api.http-v2', default=False,
 )
 coreconfigitem(
     b'experimental', b'web.api.debugreflect', default=False,
 )
 coreconfigitem(
     b'experimental', b'worker.wdir-get-thread-safe', default=False,
 )
 coreconfigitem(
     b'experimental', b'worker.repository-upgrade', default=False,
 )
 coreconfigitem(
     b'experimental', b'xdiff', default=False,
 )
 coreconfigitem(
     b'extensions', b'.*', default=None, generic=True,
 )
 coreconfigitem(
     b'extdata', b'.*', default=None, generic=True,
 )
 coreconfigitem(
     b'format', b'bookmarks-in-store', default=False,
 )
 coreconfigitem(
     b'format', b'chunkcachesize', default=None, experimental=True,
 )
 coreconfigitem(
     b'format', b'dotencode', default=True,
 )
 coreconfigitem(
     b'format', b'generaldelta', default=False, experimental=True,
 )
 coreconfigitem(
     b'format', b'manifestcachesize', default=None, experimental=True,
 )
 coreconfigitem(
     b'format', b'maxchainlen', default=dynamicdefault, experimental=True,
 )
 coreconfigitem(
     b'format', b'obsstore-version', default=None,
 )
 coreconfigitem(
     b'format', b'sparse-revlog', default=True,
 )
 coreconfigitem(
     b'format',
     b'revlog-compression',
     default=lambda: [b'zlib'],
     alias=[(b'experimental', b'format.compression')],
 )
 coreconfigitem(
     b'format', b'usefncache', default=True,
 )
 coreconfigitem(
     b'format', b'usegeneraldelta', default=True,
 )
 coreconfigitem(
     b'format', b'usestore', default=True,
 )
 # Right now, the only efficient implement of the nodemap logic is in Rust, so
 # the persistent nodemap feature needs to stay experimental as long as the Rust
 # extensions are an experimental feature.
 coreconfigitem(
     b'format', b'use-persistent-nodemap', default=False, experimental=True
 )
 coreconfigitem(
     b'format',
     b'exp-use-copies-side-data-changeset',
     default=False,
     experimental=True,
 )
 coreconfigitem(
     b'format', b'exp-use-side-data', default=False, experimental=True,
 )
 coreconfigitem(
     b'format', b'exp-share-safe', default=False, experimental=True,
 )
 coreconfigitem(
     b'format', b'internal-phase', default=False, experimental=True,
 )
 coreconfigitem(
     b'fsmonitor', b'warn_when_unused', default=True,
 )
 coreconfigitem(
     b'fsmonitor', b'warn_update_file_count', default=50000,
 )
 coreconfigitem(
     b'fsmonitor', b'warn_update_file_count_rust', default=400000,
 )
 coreconfigitem(
     b'help', br'hidden-command\..*', default=False, generic=True,
 )
 coreconfigitem(
     b'help', br'hidden-topic\..*', default=False, generic=True,
 )
 coreconfigitem(
     b'hooks', b'.*', default=dynamicdefault, generic=True,
 )
 coreconfigitem(
     b'hgweb-paths', b'.*', default=list, generic=True,
 )
 coreconfigitem(
     b'hostfingerprints', b'.*', default=list, generic=True,
 )
 coreconfigitem(
     b'hostsecurity', b'ciphers', default=None,
 )
 coreconfigitem(
     b'hostsecurity', b'minimumprotocol', default=dynamicdefault,
 )
 coreconfigitem(
     b'hostsecurity',
     b'.*:minimumprotocol$',
     default=dynamicdefault,
     generic=True,
 )
 coreconfigitem(
     b'hostsecurity', b'.*:ciphers$', default=dynamicdefault, generic=True,
 )
 coreconfigitem(
     b'hostsecurity', b'.*:fingerprints$', default=list, generic=True,
 )
 coreconfigitem(
     b'hostsecurity', b'.*:verifycertsfile$', default=None, generic=True,
 )
 
 coreconfigitem(
     b'http_proxy', b'always', default=False,
 )
 coreconfigitem(
     b'http_proxy', b'host', default=None,
 )
 coreconfigitem(
     b'http_proxy', b'no', default=list,
 )
 coreconfigitem(
     b'http_proxy', b'passwd', default=None,
 )
 coreconfigitem(
     b'http_proxy', b'user', default=None,
 )
 
 coreconfigitem(
     b'http', b'timeout', default=None,
 )
 
 coreconfigitem(
     b'logtoprocess', b'commandexception', default=None,
 )
 coreconfigitem(
     b'logtoprocess', b'commandfinish', default=None,
 )
 coreconfigitem(
     b'logtoprocess', b'command', default=None,
 )
 coreconfigitem(
     b'logtoprocess', b'develwarn', default=None,
 )
 coreconfigitem(
     b'logtoprocess', b'uiblocked', default=None,
 )
 coreconfigitem(
     b'merge', b'checkunknown', default=b'abort',
 )
 coreconfigitem(
     b'merge', b'checkignored', default=b'abort',
 )
 coreconfigitem(
     b'experimental', b'merge.checkpathconflicts', default=False,
 )
 coreconfigitem(
     b'merge', b'followcopies', default=True,
 )
 coreconfigitem(
     b'merge', b'on-failure', default=b'continue',
 )
 coreconfigitem(
     b'merge', b'preferancestor', default=lambda: [b'*'], experimental=True,
 )
 coreconfigitem(
     b'merge', b'strict-capability-check', default=False,
 )
 coreconfigitem(
     b'merge-tools', b'.*', default=None, generic=True,
 )
 coreconfigitem(
     b'merge-tools',
     br'.*\.args$',
     default=b"$local $base $other",
     generic=True,
     priority=-1,
 )
 coreconfigitem(
     b'merge-tools', br'.*\.binary$', default=False, generic=True, priority=-1,
 )
 coreconfigitem(
     b'merge-tools', br'.*\.check$', default=list, generic=True, priority=-1,
 )
 coreconfigitem(
     b'merge-tools',
     br'.*\.checkchanged$',
     default=False,
     generic=True,
     priority=-1,
 )
 coreconfigitem(
     b'merge-tools',
     br'.*\.executable$',
     default=dynamicdefault,
     generic=True,
     priority=-1,
 )
 coreconfigitem(
     b'merge-tools', br'.*\.fixeol$', default=False, generic=True, priority=-1,
 )
 coreconfigitem(
     b'merge-tools', br'.*\.gui$', default=False, generic=True, priority=-1,
 )
 coreconfigitem(
     b'merge-tools',
     br'.*\.mergemarkers$',
     default=b'basic',
     generic=True,
     priority=-1,
 )
 coreconfigitem(
     b'merge-tools',
     br'.*\.mergemarkertemplate$',
     default=dynamicdefault,  # take from command-templates.mergemarker
     generic=True,
     priority=-1,
 )
 coreconfigitem(
     b'merge-tools', br'.*\.priority$', default=0, generic=True, priority=-1,
 )
 coreconfigitem(
     b'merge-tools',
     br'.*\.premerge$',
     default=dynamicdefault,
     generic=True,
     priority=-1,
 )
 coreconfigitem(
     b'merge-tools', br'.*\.symlink$', default=False, generic=True, priority=-1,
 )
 coreconfigitem(
     b'pager', b'attend-.*', default=dynamicdefault, generic=True,
 )
 coreconfigitem(
     b'pager', b'ignore', default=list,
 )
 coreconfigitem(
     b'pager', b'pager', default=dynamicdefault,
 )
 coreconfigitem(
     b'patch', b'eol', default=b'strict',
 )
 coreconfigitem(
     b'patch', b'fuzz', default=2,
 )
 coreconfigitem(
     b'paths', b'default', default=None,
 )
 coreconfigitem(
     b'paths', b'default-push', default=None,
 )
 coreconfigitem(
     b'paths', b'.*', default=None, generic=True,
 )
 coreconfigitem(
     b'phases', b'checksubrepos', default=b'follow',
 )
 coreconfigitem(
     b'phases', b'new-commit', default=b'draft',
 )
 coreconfigitem(
     b'phases', b'publish', default=True,
 )
 coreconfigitem(
     b'profiling', b'enabled', default=False,
 )
 coreconfigitem(
     b'profiling', b'format', default=b'text',
 )
 coreconfigitem(
     b'profiling', b'freq', default=1000,
 )
 coreconfigitem(
     b'profiling', b'limit', default=30,
 )
 coreconfigitem(
     b'profiling', b'nested', default=0,
 )
 coreconfigitem(
     b'profiling', b'output', default=None,
 )
 coreconfigitem(
     b'profiling', b'showmax', default=0.999,
 )
 coreconfigitem(
     b'profiling', b'showmin', default=dynamicdefault,
 )
 coreconfigitem(
     b'profiling', b'showtime', default=True,
 )
 coreconfigitem(
     b'profiling', b'sort', default=b'inlinetime',
 )
 coreconfigitem(
     b'profiling', b'statformat', default=b'hotpath',
 )
 coreconfigitem(
     b'profiling', b'time-track', default=dynamicdefault,
 )
 coreconfigitem(
     b'profiling', b'type', default=b'stat',
 )
 coreconfigitem(
     b'progress', b'assume-tty', default=False,
 )
 coreconfigitem(
     b'progress', b'changedelay', default=1,
 )
 coreconfigitem(
     b'progress', b'clear-complete', default=True,
 )
 coreconfigitem(
     b'progress', b'debug', default=False,
 )
 coreconfigitem(
     b'progress', b'delay', default=3,
 )
 coreconfigitem(
     b'progress', b'disable', default=False,
 )
 coreconfigitem(
     b'progress', b'estimateinterval', default=60.0,
 )
 coreconfigitem(
     b'progress',
     b'format',
     default=lambda: [b'topic', b'bar', b'number', b'estimate'],
 )
 coreconfigitem(
     b'progress', b'refresh', default=0.1,
 )
 coreconfigitem(
     b'progress', b'width', default=dynamicdefault,
 )
 coreconfigitem(
     b'pull', b'confirm', default=False,
 )
 coreconfigitem(
     b'push', b'pushvars.server', default=False,
 )
 coreconfigitem(
     b'rewrite',
     b'backup-bundle',
     default=True,
     alias=[(b'ui', b'history-editing-backup')],
 )
 coreconfigitem(
     b'rewrite', b'update-timestamp', default=False,
 )
 coreconfigitem(
     b'rewrite', b'empty-successor', default=b'skip', experimental=True,
 )
 coreconfigitem(
     b'storage', b'new-repo-backend', default=b'revlogv1', experimental=True,
 )
 coreconfigitem(
     b'storage',
     b'revlog.optimize-delta-parent-choice',
     default=True,
     alias=[(b'format', b'aggressivemergedeltas')],
 )
 # experimental as long as rust is experimental (or a C version is implemented)
 coreconfigitem(
     b'storage', b'revlog.nodemap.mmap', default=True, experimental=True
 )
 # experimental as long as format.use-persistent-nodemap is.
 coreconfigitem(
     b'storage', b'revlog.nodemap.mode', default=b'compat', experimental=True
 )
 coreconfigitem(
     b'storage', b'revlog.reuse-external-delta', default=True,
 )
 coreconfigitem(
     b'storage', b'revlog.reuse-external-delta-parent', default=None,
 )
 coreconfigitem(
     b'storage', b'revlog.zlib.level', default=None,
 )
 coreconfigitem(
     b'storage', b'revlog.zstd.level', default=None,
 )
 coreconfigitem(
     b'server', b'bookmarks-pushkey-compat', default=True,
 )
 coreconfigitem(
     b'server', b'bundle1', default=True,
 )
 coreconfigitem(
     b'server', b'bundle1gd', default=None,
 )
 coreconfigitem(
     b'server', b'bundle1.pull', default=None,
 )
 coreconfigitem(
     b'server', b'bundle1gd.pull', default=None,
 )
 coreconfigitem(
     b'server', b'bundle1.push', default=None,
 )
 coreconfigitem(
     b'server', b'bundle1gd.push', default=None,
 )
 coreconfigitem(
     b'server',
     b'bundle2.stream',
     default=True,
     alias=[(b'experimental', b'bundle2.stream')],
 )
 coreconfigitem(
     b'server', b'compressionengines', default=list,
 )
 coreconfigitem(
     b'server', b'concurrent-push-mode', default=b'check-related',
 )
 coreconfigitem(
     b'server', b'disablefullbundle', default=False,
 )
 coreconfigitem(
     b'server', b'maxhttpheaderlen', default=1024,
 )
 coreconfigitem(
     b'server', b'pullbundle', default=False,
 )
 coreconfigitem(
     b'server', b'preferuncompressed', default=False,
 )
 coreconfigitem(
     b'server', b'streamunbundle', default=False,
 )
 coreconfigitem(
     b'server', b'uncompressed', default=True,
 )
 coreconfigitem(
     b'server', b'uncompressedallowsecret', default=False,
 )
 coreconfigitem(
     b'server', b'view', default=b'served',
 )
 coreconfigitem(
     b'server', b'validate', default=False,
 )
 coreconfigitem(
     b'server', b'zliblevel', default=-1,
 )
 coreconfigitem(
     b'server', b'zstdlevel', default=3,
 )
 coreconfigitem(
     b'share', b'pool', default=None,
 )
 coreconfigitem(
     b'share', b'poolnaming', default=b'identity',
 )
 coreconfigitem(
     b'shelve', b'maxbackups', default=10,
 )
 coreconfigitem(
     b'smtp', b'host', default=None,
 )
 coreconfigitem(
     b'smtp', b'local_hostname', default=None,
 )
 coreconfigitem(
     b'smtp', b'password', default=None,
 )
 coreconfigitem(
     b'smtp', b'port', default=dynamicdefault,
 )
 coreconfigitem(
     b'smtp', b'tls', default=b'none',
 )
 coreconfigitem(
     b'smtp', b'username', default=None,
 )
 coreconfigitem(
     b'sparse', b'missingwarning', default=True, experimental=True,
 )
 coreconfigitem(
     b'subrepos',
     b'allowed',
     default=dynamicdefault,  # to make backporting simpler
 )
 coreconfigitem(
     b'subrepos', b'hg:allowed', default=dynamicdefault,
 )
 coreconfigitem(
     b'subrepos', b'git:allowed', default=dynamicdefault,
 )
 coreconfigitem(
     b'subrepos', b'svn:allowed', default=dynamicdefault,
 )
 coreconfigitem(
     b'templates', b'.*', default=None, generic=True,
 )
 coreconfigitem(
     b'templateconfig', b'.*', default=dynamicdefault, generic=True,
 )
 coreconfigitem(
     b'trusted', b'groups', default=list,
 )
 coreconfigitem(
     b'trusted', b'users', default=list,
 )
 coreconfigitem(
     b'ui', b'_usedassubrepo', default=False,
 )
 coreconfigitem(
     b'ui', b'allowemptycommit', default=False,
 )
 coreconfigitem(
     b'ui', b'archivemeta', default=True,
 )
 coreconfigitem(
     b'ui', b'askusername', default=False,
 )
 coreconfigitem(
     b'ui', b'available-memory', default=None,
 )
 
 coreconfigitem(
     b'ui', b'clonebundlefallback', default=False,
 )
 coreconfigitem(
     b'ui', b'clonebundleprefers', default=list,
 )
 coreconfigitem(
     b'ui', b'clonebundles', default=True,
 )
 coreconfigitem(
     b'ui', b'color', default=b'auto',
 )
 coreconfigitem(
     b'ui', b'commitsubrepos', default=False,
 )
 coreconfigitem(
     b'ui', b'debug', default=False,
 )
 coreconfigitem(
     b'ui', b'debugger', default=None,
 )
 coreconfigitem(
     b'ui', b'editor', default=dynamicdefault,
 )
 coreconfigitem(
+    b'ui', b'detailed-exit-code', default=False, experimental=True,
+)
+coreconfigitem(
     b'ui', b'fallbackencoding', default=None,
 )
 coreconfigitem(
     b'ui', b'forcecwd', default=None,
 )
 coreconfigitem(
     b'ui', b'forcemerge', default=None,
 )
 coreconfigitem(
     b'ui', b'formatdebug', default=False,
 )
 coreconfigitem(
     b'ui', b'formatjson', default=False,
 )
 coreconfigitem(
     b'ui', b'formatted', default=None,
 )
 coreconfigitem(
     b'ui', b'interactive', default=None,
 )
 coreconfigitem(
     b'ui', b'interface', default=None,
 )
 coreconfigitem(
     b'ui', b'interface.chunkselector', default=None,
 )
 coreconfigitem(
     b'ui', b'large-file-limit', default=10000000,
 )
 coreconfigitem(
     b'ui', b'logblockedtimes', default=False,
 )
 coreconfigitem(
     b'ui', b'merge', default=None,
 )
 coreconfigitem(
     b'ui', b'mergemarkers', default=b'basic',
 )
 coreconfigitem(
     b'ui', b'message-output', default=b'stdio',
 )
 coreconfigitem(
     b'ui', b'nontty', default=False,
 )
 coreconfigitem(
     b'ui', b'origbackuppath', default=None,
 )
 coreconfigitem(
     b'ui', b'paginate', default=True,
 )
 coreconfigitem(
     b'ui', b'patch', default=None,
 )
 coreconfigitem(
     b'ui', b'portablefilenames', default=b'warn',
 )
 coreconfigitem(
     b'ui', b'promptecho', default=False,
 )
 coreconfigitem(
     b'ui', b'quiet', default=False,
 )
 coreconfigitem(
     b'ui', b'quietbookmarkmove', default=False,
 )
 coreconfigitem(
     b'ui', b'relative-paths', default=b'legacy',
 )
 coreconfigitem(
     b'ui', b'remotecmd', default=b'hg',
 )
 coreconfigitem(
     b'ui', b'report_untrusted', default=True,
 )
 coreconfigitem(
     b'ui', b'rollback', default=True,
 )
 coreconfigitem(
     b'ui', b'signal-safe-lock', default=True,
 )
 coreconfigitem(
     b'ui', b'slash', default=False,
 )
 coreconfigitem(
     b'ui', b'ssh', default=b'ssh',
 )
 coreconfigitem(
     b'ui', b'ssherrorhint', default=None,
 )
 coreconfigitem(
     b'ui', b'statuscopies', default=False,
 )
 coreconfigitem(
     b'ui', b'strict', default=False,
 )
 coreconfigitem(
     b'ui', b'style', default=b'',
 )
 coreconfigitem(
     b'ui', b'supportcontact', default=None,
 )
 coreconfigitem(
     b'ui', b'textwidth', default=78,
 )
 coreconfigitem(
     b'ui', b'timeout', default=b'600',
 )
 coreconfigitem(
     b'ui', b'timeout.warn', default=0,
 )
 coreconfigitem(
     b'ui', b'timestamp-output', default=False,
 )
 coreconfigitem(
     b'ui', b'traceback', default=False,
 )
 coreconfigitem(
     b'ui', b'tweakdefaults', default=False,
 )
 coreconfigitem(b'ui', b'username', alias=[(b'ui', b'user')])
 coreconfigitem(
     b'ui', b'verbose', default=False,
 )
 coreconfigitem(
     b'verify', b'skipflags', default=None,
 )
 coreconfigitem(
     b'web', b'allowbz2', default=False,
 )
 coreconfigitem(
     b'web', b'allowgz', default=False,
 )
 coreconfigitem(
     b'web', b'allow-pull', alias=[(b'web', b'allowpull')], default=True,
 )
 coreconfigitem(
     b'web', b'allow-push', alias=[(b'web', b'allow_push')], default=list,
 )
 coreconfigitem(
     b'web', b'allowzip', default=False,
 )
 coreconfigitem(
     b'web', b'archivesubrepos', default=False,
 )
 coreconfigitem(
     b'web', b'cache', default=True,
 )
 coreconfigitem(
     b'web', b'comparisoncontext', default=5,
 )
 coreconfigitem(
     b'web', b'contact', default=None,
 )
 coreconfigitem(
     b'web', b'deny_push', default=list,
 )
 coreconfigitem(
     b'web', b'guessmime', default=False,
 )
 coreconfigitem(
     b'web', b'hidden', default=False,
 )
 coreconfigitem(
     b'web', b'labels', default=list,
 )
 coreconfigitem(
     b'web', b'logoimg', default=b'hglogo.png',
 )
 coreconfigitem(
     b'web', b'logourl', default=b'https://mercurial-scm.org/',
 )
 coreconfigitem(
     b'web', b'accesslog', default=b'-',
 )
 coreconfigitem(
     b'web', b'address', default=b'',
 )
 coreconfigitem(
     b'web', b'allow-archive', alias=[(b'web', b'allow_archive')], default=list,
 )
 coreconfigitem(
     b'web', b'allow_read', default=list,
 )
 coreconfigitem(
     b'web', b'baseurl', default=None,
 )
 coreconfigitem(
     b'web', b'cacerts', default=None,
 )
 coreconfigitem(
     b'web', b'certificate', default=None,
 )
 coreconfigitem(
     b'web', b'collapse', default=False,
 )
 coreconfigitem(
     b'web', b'csp', default=None,
 )
 coreconfigitem(
     b'web', b'deny_read', default=list,
 )
 coreconfigitem(
     b'web', b'descend', default=True,
 )
 coreconfigitem(
     b'web', b'description', default=b"",
 )
 coreconfigitem(
     b'web', b'encoding', default=lambda: encoding.encoding,
 )
 coreconfigitem(
     b'web', b'errorlog', default=b'-',
 )
 coreconfigitem(
     b'web', b'ipv6', default=False,
 )
 coreconfigitem(
     b'web', b'maxchanges', default=10,
 )
 coreconfigitem(
     b'web', b'maxfiles', default=10,
 )
 coreconfigitem(
     b'web', b'maxshortchanges', default=60,
 )
 coreconfigitem(
     b'web', b'motd', default=b'',
 )
 coreconfigitem(
     b'web', b'name', default=dynamicdefault,
 )
 coreconfigitem(
     b'web', b'port', default=8000,
 )
 coreconfigitem(
     b'web', b'prefix', default=b'',
 )
 coreconfigitem(
     b'web', b'push_ssl', default=True,
 )
 coreconfigitem(
     b'web', b'refreshinterval', default=20,
 )
 coreconfigitem(
     b'web', b'server-header', default=None,
 )
 coreconfigitem(
     b'web', b'static', default=None,
 )
 coreconfigitem(
     b'web', b'staticurl', default=None,
 )
 coreconfigitem(
     b'web', b'stripes', default=1,
 )
 coreconfigitem(
     b'web', b'style', default=b'paper',
 )
 coreconfigitem(
     b'web', b'templates', default=None,
 )
 coreconfigitem(
     b'web', b'view', default=b'served', experimental=True,
 )
 coreconfigitem(
     b'worker', b'backgroundclose', default=dynamicdefault,
 )
 # Windows defaults to a limit of 512 open files. A buffer of 128
 # should give us enough headway.
 coreconfigitem(
     b'worker', b'backgroundclosemaxqueue', default=384,
 )
 coreconfigitem(
     b'worker', b'backgroundcloseminfilecount', default=2048,
 )
 coreconfigitem(
     b'worker', b'backgroundclosethreadcount', default=4,
 )
 coreconfigitem(
     b'worker', b'enabled', default=True,
 )
 coreconfigitem(
     b'worker', b'numcpus', default=None,
 )
 
 # Rebase related configuration moved to core because other extension are doing
 # strange things. For example, shelve import the extensions to reuse some bit
 # without formally loading it.
 coreconfigitem(
     b'commands', b'rebase.requiredest', default=False,
 )
 coreconfigitem(
     b'experimental', b'rebaseskipobsolete', default=True,
 )
 coreconfigitem(
     b'rebase', b'singletransaction', default=False,
 )
 coreconfigitem(
     b'rebase', b'experimental.inmemory', default=False,
 )

mercurial/scmutil.py

@@ -1,2290 +1,2297 b''
 # scmutil.py - Mercurial core utility functions
 #
 #  Copyright Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import errno
 import glob
 import os
 import posixpath
 import re
 import subprocess
 import weakref
 
 from .i18n import _
 from .node import (
     bin,
     hex,
     nullid,
     nullrev,
     short,
     wdirid,
     wdirrev,
 )
 from .pycompat import getattr
 from .thirdparty import attr
 from . import (
     copies as copiesmod,
     encoding,
     error,
     match as matchmod,
     obsolete,
     obsutil,
     pathutil,
     phases,
     policy,
     pycompat,
     requirements as requirementsmod,
     revsetlang,
     similar,
     smartset,
     url,
     util,
     vfs,
 )
 
 from .utils import (
     hashutil,
     procutil,
     stringutil,
 )
 
 if pycompat.iswindows:
     from . import scmwindows as scmplatform
 else:
     from . import scmposix as scmplatform
 
 parsers = policy.importmod('parsers')
 rustrevlog = policy.importrust('revlog')
 
 termsize = scmplatform.termsize
 
 
 @attr.s(slots=True, repr=False)
 class status(object):
     '''Struct with a list of files per status.
 
     The 'deleted', 'unknown' and 'ignored' properties are only
     relevant to the working copy.
     '''
 
     modified = attr.ib(default=attr.Factory(list))
     added = attr.ib(default=attr.Factory(list))
     removed = attr.ib(default=attr.Factory(list))
     deleted = attr.ib(default=attr.Factory(list))
     unknown = attr.ib(default=attr.Factory(list))
     ignored = attr.ib(default=attr.Factory(list))
     clean = attr.ib(default=attr.Factory(list))
 
     def __iter__(self):
         yield self.modified
         yield self.added
         yield self.removed
         yield self.deleted
         yield self.unknown
         yield self.ignored
         yield self.clean
 
     def __repr__(self):
         return (
             r'<status modified=%s, added=%s, removed=%s, deleted=%s, '
             r'unknown=%s, ignored=%s, clean=%s>'
         ) % tuple(pycompat.sysstr(stringutil.pprint(v)) for v in self)
 
 
 def itersubrepos(ctx1, ctx2):
     """find subrepos in ctx1 or ctx2"""
     # Create a (subpath, ctx) mapping where we prefer subpaths from
     # ctx1. The subpaths from ctx2 are important when the .hgsub file
     # has been modified (in ctx2) but not yet committed (in ctx1).
     subpaths = dict.fromkeys(ctx2.substate, ctx2)
     subpaths.update(dict.fromkeys(ctx1.substate, ctx1))
 
     missing = set()
 
     for subpath in ctx2.substate:
         if subpath not in ctx1.substate:
             del subpaths[subpath]
             missing.add(subpath)
 
     for subpath, ctx in sorted(pycompat.iteritems(subpaths)):
         yield subpath, ctx.sub(subpath)
 
     # Yield an empty subrepo based on ctx1 for anything only in ctx2.  That way,
     # status and diff will have an accurate result when it does
     # 'sub.{status|diff}(rev2)'.  Otherwise, the ctx2 subrepo is compared
     # against itself.
     for subpath in missing:
         yield subpath, ctx2.nullsub(subpath, ctx1)
 
 
 def nochangesfound(ui, repo, excluded=None):
     '''Report no changes for push/pull, excluded is None or a list of
     nodes excluded from the push/pull.
     '''
     secretlist = []
     if excluded:
         for n in excluded:
             ctx = repo[n]
             if ctx.phase() >= phases.secret and not ctx.extinct():
                 secretlist.append(n)
 
     if secretlist:
         ui.status(
             _(b"no changes found (ignored %d secret changesets)\n")
             % len(secretlist)
         )
     else:
         ui.status(_(b"no changes found\n"))
 
 
 def callcatch(ui, func):
     """call func() with global exception handling
 
     return func() if no exception happens. otherwise do some error handling
     and return an exit code accordingly. does not handle all exceptions.
     """
+    coarse_exit_code = -1
+    detailed_exit_code = -1
     try:
         try:
             return func()
         except:  # re-raises
             ui.traceback()
             raise
     # Global exception handling, alphabetically
     # Mercurial-specific first, followed by built-in and library exceptions
     except error.LockHeld as inst:
         if inst.errno == errno.ETIMEDOUT:
             reason = _(b'timed out waiting for lock held by %r') % (
                 pycompat.bytestr(inst.locker)
             )
         else:
             reason = _(b'lock held by %r') % inst.locker
         ui.error(
             _(b"abort: %s: %s\n")
             % (inst.desc or stringutil.forcebytestr(inst.filename), reason)
         )
         if not inst.locker:
             ui.error(_(b"(lock might be very busy)\n"))
     except error.LockUnavailable as inst:
         ui.error(
             _(b"abort: could not lock %s: %s\n")
             % (
                 inst.desc or stringutil.forcebytestr(inst.filename),
                 encoding.strtolocal(inst.strerror),
             )
         )
     except error.OutOfBandError as inst:
         if inst.args:
             msg = _(b"abort: remote error:\n")
         else:
             msg = _(b"abort: remote error\n")
         ui.error(msg)
         if inst.args:
             ui.error(b''.join(inst.args))
         if inst.hint:
             ui.error(b'(%s)\n' % inst.hint)
     except error.RepoError as inst:
         ui.error(_(b"abort: %s!\n") % inst)
         if inst.hint:
             ui.error(_(b"(%s)\n") % inst.hint)
     except error.ResponseError as inst:
         ui.error(_(b"abort: %s") % inst.args[0])
         msg = inst.args[1]
         if isinstance(msg, type(u'')):
             msg = pycompat.sysbytes(msg)
         if not isinstance(msg, bytes):
             ui.error(b" %r\n" % (msg,))
         elif not msg:
             ui.error(_(b" empty string\n"))
         else:
             ui.error(b"\n%r\n" % pycompat.bytestr(stringutil.ellipsis(msg)))
     except error.CensoredNodeError as inst:
         ui.error(_(b"abort: file censored %s!\n") % inst)
     except error.StorageError as inst:
         ui.error(_(b"abort: %s!\n") % inst)
         if inst.hint:
             ui.error(_(b"(%s)\n") % inst.hint)
     except error.InterventionRequired as inst:
         ui.error(b"%s\n" % inst)
         if inst.hint:
             ui.error(_(b"(%s)\n") % inst.hint)
-        return 1
+        detailed_exit_code = 240
+        coarse_exit_code = 1
     except error.WdirUnsupported:
         ui.error(_(b"abort: working directory revision cannot be specified\n"))
     except error.Abort as inst:
         ui.error(_(b"abort: %s\n") % inst.message)
         if inst.hint:
             ui.error(_(b"(%s)\n") % inst.hint)
     except error.WorkerError as inst:
         # Don't print a message -- the worker already should have
         return inst.status_code
     except ImportError as inst:
         ui.error(_(b"abort: %s!\n") % stringutil.forcebytestr(inst))
         m = stringutil.forcebytestr(inst).split()[-1]
         if m in b"mpatch bdiff".split():
             ui.error(_(b"(did you forget to compile extensions?)\n"))
         elif m in b"zlib".split():
             ui.error(_(b"(is your Python install correct?)\n"))
     except (IOError, OSError) as inst:
         if util.safehasattr(inst, b"code"):  # HTTPError
             ui.error(_(b"abort: %s\n") % stringutil.forcebytestr(inst))
         elif util.safehasattr(inst, b"reason"):  # URLError or SSLError
             try:  # usually it is in the form (errno, strerror)
                 reason = inst.reason.args[1]
             except (AttributeError, IndexError):
                 # it might be anything, for example a string
                 reason = inst.reason
             if isinstance(reason, pycompat.unicode):
                 # SSLError of Python 2.7.9 contains a unicode
                 reason = encoding.unitolocal(reason)
             ui.error(_(b"abort: error: %s\n") % stringutil.forcebytestr(reason))
         elif (
             util.safehasattr(inst, b"args")
             and inst.args
             and inst.args[0] == errno.EPIPE
         ):
             pass
         elif getattr(inst, "strerror", None):  # common IOError or OSError
             if getattr(inst, "filename", None) is not None:
                 ui.error(
                     _(b"abort: %s: '%s'\n")
                     % (
                         encoding.strtolocal(inst.strerror),
                         stringutil.forcebytestr(inst.filename),
                     )
                 )
             else:
                 ui.error(_(b"abort: %s\n") % encoding.strtolocal(inst.strerror))
         else:  # suspicious IOError
             raise
     except MemoryError:
         ui.error(_(b"abort: out of memory\n"))
     except SystemExit as inst:
         # Commands shouldn't sys.exit directly, but give a return code.
         # Just in case catch this and and pass exit code to caller.
-        return inst.code
+        detailed_exit_code = 254
+        coarse_exit_code = inst.code
 
-    return -1
+    if ui.configbool(b'ui', b'detailed-exit-code'):
+        return detailed_exit_code
+    else:
+        return coarse_exit_code
 
 
 def checknewlabel(repo, lbl, kind):
     # Do not use the "kind" parameter in ui output.
     # It makes strings difficult to translate.
     if lbl in [b'tip', b'.', b'null']:
         raise error.Abort(_(b"the name '%s' is reserved") % lbl)
     for c in (b':', b'\0', b'\n', b'\r'):
         if c in lbl:
             raise error.Abort(
                 _(b"%r cannot be used in a name") % pycompat.bytestr(c)
             )
     try:
         int(lbl)
         raise error.Abort(_(b"cannot use an integer as a name"))
     except ValueError:
         pass
     if lbl.strip() != lbl:
         raise error.Abort(_(b"leading or trailing whitespace in name %r") % lbl)
 
 
 def checkfilename(f):
     '''Check that the filename f is an acceptable filename for a tracked file'''
     if b'\r' in f or b'\n' in f:
         raise error.Abort(
             _(b"'\\n' and '\\r' disallowed in filenames: %r")
             % pycompat.bytestr(f)
         )
 
 
 def checkportable(ui, f):
     '''Check if filename f is portable and warn or abort depending on config'''
     checkfilename(f)
     abort, warn = checkportabilityalert(ui)
     if abort or warn:
         msg = util.checkwinfilename(f)
         if msg:
             msg = b"%s: %s" % (msg, procutil.shellquote(f))
             if abort:
                 raise error.Abort(msg)
             ui.warn(_(b"warning: %s\n") % msg)
 
 
 def checkportabilityalert(ui):
     '''check if the user's config requests nothing, a warning, or abort for
     non-portable filenames'''
     val = ui.config(b'ui', b'portablefilenames')
     lval = val.lower()
     bval = stringutil.parsebool(val)
     abort = pycompat.iswindows or lval == b'abort'
     warn = bval or lval == b'warn'
     if bval is None and not (warn or abort or lval == b'ignore'):
         raise error.ConfigError(
             _(b"ui.portablefilenames value is invalid ('%s')") % val
         )
     return abort, warn
 
 
 class casecollisionauditor(object):
     def __init__(self, ui, abort, dirstate):
         self._ui = ui
         self._abort = abort
         allfiles = b'\0'.join(dirstate)
         self._loweredfiles = set(encoding.lower(allfiles).split(b'\0'))
         self._dirstate = dirstate
         # The purpose of _newfiles is so that we don't complain about
         # case collisions if someone were to call this object with the
         # same filename twice.
         self._newfiles = set()
 
     def __call__(self, f):
         if f in self._newfiles:
             return
         fl = encoding.lower(f)
         if fl in self._loweredfiles and f not in self._dirstate:
             msg = _(b'possible case-folding collision for %s') % f
             if self._abort:
                 raise error.Abort(msg)
             self._ui.warn(_(b"warning: %s\n") % msg)
         self._loweredfiles.add(fl)
         self._newfiles.add(f)
 
 
 def filteredhash(repo, maxrev):
     """build hash of filtered revisions in the current repoview.
 
     Multiple caches perform up-to-date validation by checking that the
     tiprev and tipnode stored in the cache file match the current repository.
     However, this is not sufficient for validating repoviews because the set
     of revisions in the view may change without the repository tiprev and
     tipnode changing.
 
     This function hashes all the revs filtered from the view and returns
     that SHA-1 digest.
     """
     cl = repo.changelog
     if not cl.filteredrevs:
         return None
     key = cl._filteredrevs_hashcache.get(maxrev)
     if not key:
         revs = sorted(r for r in cl.filteredrevs if r <= maxrev)
         if revs:
             s = hashutil.sha1()
             for rev in revs:
                 s.update(b'%d;' % rev)
             key = s.digest()
             cl._filteredrevs_hashcache[maxrev] = key
     return key
 
 
 def walkrepos(path, followsym=False, seen_dirs=None, recurse=False):
     '''yield every hg repository under path, always recursively.
     The recurse flag will only control recursion into repo working dirs'''
 
     def errhandler(err):
         if err.filename == path:
             raise err
 
     samestat = getattr(os.path, 'samestat', None)
     if followsym and samestat is not None:
 
         def adddir(dirlst, dirname):
             dirstat = os.stat(dirname)
             match = any(samestat(dirstat, lstdirstat) for lstdirstat in dirlst)
             if not match:
                 dirlst.append(dirstat)
             return not match
 
     else:
         followsym = False
 
     if (seen_dirs is None) and followsym:
         seen_dirs = []
         adddir(seen_dirs, path)
     for root, dirs, files in os.walk(path, topdown=True, onerror=errhandler):
         dirs.sort()
         if b'.hg' in dirs:
             yield root  # found a repository
             qroot = os.path.join(root, b'.hg', b'patches')
             if os.path.isdir(os.path.join(qroot, b'.hg')):
                 yield qroot  # we have a patch queue repo here
             if recurse:
                 # avoid recursing inside the .hg directory
                 dirs.remove(b'.hg')
             else:
                 dirs[:] = []  # don't descend further
         elif followsym:
             newdirs = []
             for d in dirs:
                 fname = os.path.join(root, d)
                 if adddir(seen_dirs, fname):
                     if os.path.islink(fname):
                         for hgname in walkrepos(fname, True, seen_dirs):
                             yield hgname
                     else:
                         newdirs.append(d)
             dirs[:] = newdirs
 
 
 def binnode(ctx):
     """Return binary node id for a given basectx"""
     node = ctx.node()
     if node is None:
         return wdirid
     return node
 
 
 def intrev(ctx):
     """Return integer for a given basectx that can be used in comparison or
     arithmetic operation"""
     rev = ctx.rev()
     if rev is None:
         return wdirrev
     return rev
 
 
 def formatchangeid(ctx):
     """Format changectx as '{rev}:{node|formatnode}', which is the default
     template provided by logcmdutil.changesettemplater"""
     repo = ctx.repo()
     return formatrevnode(repo.ui, intrev(ctx), binnode(ctx))
 
 
 def formatrevnode(ui, rev, node):
     """Format given revision and node depending on the current verbosity"""
     if ui.debugflag:
         hexfunc = hex
     else:
         hexfunc = short
     return b'%d:%s' % (rev, hexfunc(node))
 
 
 def resolvehexnodeidprefix(repo, prefix):
     if prefix.startswith(b'x'):
         prefix = prefix[1:]
     try:
         # Uses unfiltered repo because it's faster when prefix is ambiguous/
         # This matches the shortesthexnodeidprefix() function below.
         node = repo.unfiltered().changelog._partialmatch(prefix)
     except error.AmbiguousPrefixLookupError:
         revset = repo.ui.config(
             b'experimental', b'revisions.disambiguatewithin'
         )
         if revset:
             # Clear config to avoid infinite recursion
             configoverrides = {
                 (b'experimental', b'revisions.disambiguatewithin'): None
             }
             with repo.ui.configoverride(configoverrides):
                 revs = repo.anyrevs([revset], user=True)
                 matches = []
                 for rev in revs:
                     node = repo.changelog.node(rev)
                     if hex(node).startswith(prefix):
                         matches.append(node)
                 if len(matches) == 1:
                     return matches[0]
         raise
     if node is None:
         return
     repo.changelog.rev(node)  # make sure node isn't filtered
     return node
 
 
 def mayberevnum(repo, prefix):
     """Checks if the given prefix may be mistaken for a revision number"""
     try:
         i = int(prefix)
         # if we are a pure int, then starting with zero will not be
         # confused as a rev; or, obviously, if the int is larger
         # than the value of the tip rev. We still need to disambiguate if
         # prefix == '0', since that *is* a valid revnum.
         if (prefix != b'0' and prefix[0:1] == b'0') or i >= len(repo):
             return False
         return True
     except ValueError:
         return False
 
 
 def shortesthexnodeidprefix(repo, node, minlength=1, cache=None):
     """Find the shortest unambiguous prefix that matches hexnode.
 
     If "cache" is not None, it must be a dictionary that can be used for
     caching between calls to this method.
     """
     # _partialmatch() of filtered changelog could take O(len(repo)) time,
     # which would be unacceptably slow. so we look for hash collision in
     # unfiltered space, which means some hashes may be slightly longer.
 
     minlength = max(minlength, 1)
 
     def disambiguate(prefix):
         """Disambiguate against revnums."""
         if repo.ui.configbool(b'experimental', b'revisions.prefixhexnode'):
             if mayberevnum(repo, prefix):
                 return b'x' + prefix
             else:
                 return prefix
 
         hexnode = hex(node)
         for length in range(len(prefix), len(hexnode) + 1):
             prefix = hexnode[:length]
             if not mayberevnum(repo, prefix):
                 return prefix
 
     cl = repo.unfiltered().changelog
     revset = repo.ui.config(b'experimental', b'revisions.disambiguatewithin')
     if revset:
         revs = None
         if cache is not None:
             revs = cache.get(b'disambiguationrevset')
         if revs is None:
             revs = repo.anyrevs([revset], user=True)
             if cache is not None:
                 cache[b'disambiguationrevset'] = revs
         if cl.rev(node) in revs:
             hexnode = hex(node)
             nodetree = None
             if cache is not None:
                 nodetree = cache.get(b'disambiguationnodetree')
             if not nodetree:
                 if util.safehasattr(parsers, 'nodetree'):
                     # The CExt is the only implementation to provide a nodetree
                     # class so far.
                     index = cl.index
                     if util.safehasattr(index, 'get_cindex'):
                         # the rust wrapped need to give access to its internal index
                         index = index.get_cindex()
                     nodetree = parsers.nodetree(index, len(revs))
                     for r in revs:
                         nodetree.insert(r)
                     if cache is not None:
                         cache[b'disambiguationnodetree'] = nodetree
             if nodetree is not None:
                 length = max(nodetree.shortest(node), minlength)
                 prefix = hexnode[:length]
                 return disambiguate(prefix)
             for length in range(minlength, len(hexnode) + 1):
                 matches = []
                 prefix = hexnode[:length]
                 for rev in revs:
                     otherhexnode = repo[rev].hex()
                     if prefix == otherhexnode[:length]:
                         matches.append(otherhexnode)
                 if len(matches) == 1:
                     return disambiguate(prefix)
 
     try:
         return disambiguate(cl.shortest(node, minlength))
     except error.LookupError:
         raise error.RepoLookupError()
 
 
 def isrevsymbol(repo, symbol):
     """Checks if a symbol exists in the repo.
 
     See revsymbol() for details. Raises error.AmbiguousPrefixLookupError if the
     symbol is an ambiguous nodeid prefix.
     """
     try:
         revsymbol(repo, symbol)
         return True
     except error.RepoLookupError:
         return False
 
 
 def revsymbol(repo, symbol):
     """Returns a context given a single revision symbol (as string).
 
     This is similar to revsingle(), but accepts only a single revision symbol,
     i.e. things like ".", "tip", "1234", "deadbeef", "my-bookmark" work, but
     not "max(public())".
     """
     if not isinstance(symbol, bytes):
         msg = (
             b"symbol (%s of type %s) was not a string, did you mean "
             b"repo[symbol]?" % (symbol, type(symbol))
         )
         raise error.ProgrammingError(msg)
     try:
         if symbol in (b'.', b'tip', b'null'):
             return repo[symbol]
 
         try:
             r = int(symbol)
             if b'%d' % r != symbol:
                 raise ValueError
             l = len(repo.changelog)
             if r < 0:
                 r += l
             if r < 0 or r >= l and r != wdirrev:
                 raise ValueError
             return repo[r]
         except error.FilteredIndexError:
             raise
         except (ValueError, OverflowError, IndexError):
             pass
 
         if len(symbol) == 40:
             try:
                 node = bin(symbol)
                 rev = repo.changelog.rev(node)
                 return repo[rev]
             except error.FilteredLookupError:
                 raise
             except (TypeError, LookupError):
                 pass
 
         # look up bookmarks through the name interface
         try:
             node = repo.names.singlenode(repo, symbol)
             rev = repo.changelog.rev(node)
             return repo[rev]
         except KeyError:
             pass
 
         node = resolvehexnodeidprefix(repo, symbol)
         if node is not None:
             rev = repo.changelog.rev(node)
             return repo[rev]
 
         raise error.RepoLookupError(_(b"unknown revision '%s'") % symbol)
 
     except error.WdirUnsupported:
         return repo[None]
     except (
         error.FilteredIndexError,
         error.FilteredLookupError,
         error.FilteredRepoLookupError,
     ):
         raise _filterederror(repo, symbol)
 
 
 def _filterederror(repo, changeid):
     """build an exception to be raised about a filtered changeid
 
     This is extracted in a function to help extensions (eg: evolve) to
     experiment with various message variants."""
     if repo.filtername.startswith(b'visible'):
 
         # Check if the changeset is obsolete
         unfilteredrepo = repo.unfiltered()
         ctx = revsymbol(unfilteredrepo, changeid)
 
         # If the changeset is obsolete, enrich the message with the reason
         # that made this changeset not visible
         if ctx.obsolete():
             msg = obsutil._getfilteredreason(repo, changeid, ctx)
         else:
             msg = _(b"hidden revision '%s'") % changeid
 
         hint = _(b'use --hidden to access hidden revisions')
 
         return error.FilteredRepoLookupError(msg, hint=hint)
     msg = _(b"filtered revision '%s' (not in '%s' subset)")
     msg %= (changeid, repo.filtername)
     return error.FilteredRepoLookupError(msg)
 
 
 def revsingle(repo, revspec, default=b'.', localalias=None):
     if not revspec and revspec != 0:
         return repo[default]
 
     l = revrange(repo, [revspec], localalias=localalias)
     if not l:
         raise error.Abort(_(b'empty revision set'))
     return repo[l.last()]
 
 
 def _pairspec(revspec):
     tree = revsetlang.parse(revspec)
     return tree and tree[0] in (
         b'range',
         b'rangepre',
         b'rangepost',
         b'rangeall',
     )
 
 
 def revpair(repo, revs):
     if not revs:
         return repo[b'.'], repo[None]
 
     l = revrange(repo, revs)
 
     if not l:
         raise error.Abort(_(b'empty revision range'))
 
     first = l.first()
     second = l.last()
 
     if (
         first == second
         and len(revs) >= 2
         and not all(revrange(repo, [r]) for r in revs)
     ):
         raise error.Abort(_(b'empty revision on one side of range'))
 
     # if top-level is range expression, the result must always be a pair
     if first == second and len(revs) == 1 and not _pairspec(revs[0]):
         return repo[first], repo[None]
 
     return repo[first], repo[second]
 
 
 def revrange(repo, specs, localalias=None):
     """Execute 1 to many revsets and return the union.
 
     This is the preferred mechanism for executing revsets using user-specified
     config options, such as revset aliases.
 
     The revsets specified by ``specs`` will be executed via a chained ``OR``
     expression. If ``specs`` is empty, an empty result is returned.
 
     ``specs`` can contain integers, in which case they are assumed to be
     revision numbers.
 
     It is assumed the revsets are already formatted. If you have arguments
     that need to be expanded in the revset, call ``revsetlang.formatspec()``
     and pass the result as an element of ``specs``.
 
     Specifying a single revset is allowed.
 
     Returns a ``smartset.abstractsmartset`` which is a list-like interface over
     integer revisions.
     """
     allspecs = []
     for spec in specs:
         if isinstance(spec, int):
             spec = revsetlang.formatspec(b'%d', spec)
         allspecs.append(spec)
     return repo.anyrevs(allspecs, user=True, localalias=localalias)
 
 
 def increasingwindows(windowsize=8, sizelimit=512):
     while True:
         yield windowsize
         if windowsize < sizelimit:
             windowsize *= 2
 
 
 def walkchangerevs(repo, revs, makefilematcher, prepare):
     '''Iterate over files and the revs in a "windowed" way.
 
     Callers most commonly need to iterate backwards over the history
     in which they are interested. Doing so has awful (quadratic-looking)
     performance, so we use iterators in a "windowed" way.
 
     We walk a window of revisions in the desired order.  Within the
     window, we first walk forwards to gather data, then in the desired
     order (usually backwards) to display it.
 
     This function returns an iterator yielding contexts. Before
     yielding each context, the iterator will first call the prepare
     function on each context in the window in forward order.'''
 
     if not revs:
         return []
     change = repo.__getitem__
 
     def iterate():
         it = iter(revs)
         stopiteration = False
         for windowsize in increasingwindows():
             nrevs = []
             for i in pycompat.xrange(windowsize):
                 rev = next(it, None)
                 if rev is None:
                     stopiteration = True
                     break
                 nrevs.append(rev)
             for rev in sorted(nrevs):
                 ctx = change(rev)
                 prepare(ctx, makefilematcher(ctx))
             for rev in nrevs:
                 yield change(rev)
 
             if stopiteration:
                 break
 
     return iterate()
 
 
 def meaningfulparents(repo, ctx):
     """Return list of meaningful (or all if debug) parentrevs for rev.
 
     For merges (two non-nullrev revisions) both parents are meaningful.
     Otherwise the first parent revision is considered meaningful if it
     is not the preceding revision.
     """
     parents = ctx.parents()
     if len(parents) > 1:
         return parents
     if repo.ui.debugflag:
         return [parents[0], repo[nullrev]]
     if parents[0].rev() >= intrev(ctx) - 1:
         return []
     return parents
 
 
 def getuipathfn(repo, legacyrelativevalue=False, forcerelativevalue=None):
     """Return a function that produced paths for presenting to the user.
 
     The returned function takes a repo-relative path and produces a path
     that can be presented in the UI.
 
     Depending on the value of ui.relative-paths, either a repo-relative or
     cwd-relative path will be produced.
 
     legacyrelativevalue is the value to use if ui.relative-paths=legacy
 
     If forcerelativevalue is not None, then that value will be used regardless
     of what ui.relative-paths is set to.
     """
     if forcerelativevalue is not None:
         relative = forcerelativevalue
     else:
         config = repo.ui.config(b'ui', b'relative-paths')
         if config == b'legacy':
             relative = legacyrelativevalue
         else:
             relative = stringutil.parsebool(config)
             if relative is None:
                 raise error.ConfigError(
                     _(b"ui.relative-paths is not a boolean ('%s')") % config
                 )
 
     if relative:
         cwd = repo.getcwd()
         if cwd != b'':
             # this branch would work even if cwd == b'' (ie cwd = repo
             # root), but its generality makes the returned function slower
             pathto = repo.pathto
             return lambda f: pathto(f, cwd)
     if repo.ui.configbool(b'ui', b'slash'):
         return lambda f: f
     else:
         return util.localpath
 
 
 def subdiruipathfn(subpath, uipathfn):
     '''Create a new uipathfn that treats the file as relative to subpath.'''
     return lambda f: uipathfn(posixpath.join(subpath, f))
 
 
 def anypats(pats, opts):
     '''Checks if any patterns, including --include and --exclude were given.
 
     Some commands (e.g. addremove) use this condition for deciding whether to
     print absolute or relative paths.
     '''
     return bool(pats or opts.get(b'include') or opts.get(b'exclude'))
 
 
 def expandpats(pats):
     '''Expand bare globs when running on windows.
     On posix we assume it already has already been done by sh.'''
     if not util.expandglobs:
         return list(pats)
     ret = []
     for kindpat in pats:
         kind, pat = matchmod._patsplit(kindpat, None)
         if kind is None:
             try:
                 globbed = glob.glob(pat)
             except re.error:
                 globbed = [pat]
             if globbed:
                 ret.extend(globbed)
                 continue
         ret.append(kindpat)
     return ret
 
 
 def matchandpats(
     ctx, pats=(), opts=None, globbed=False, default=b'relpath', badfn=None
 ):
     '''Return a matcher and the patterns that were used.
     The matcher will warn about bad matches, unless an alternate badfn callback
     is provided.'''
     if opts is None:
         opts = {}
     if not globbed and default == b'relpath':
         pats = expandpats(pats or [])
 
     uipathfn = getuipathfn(ctx.repo(), legacyrelativevalue=True)
 
     def bad(f, msg):
         ctx.repo().ui.warn(b"%s: %s\n" % (uipathfn(f), msg))
 
     if badfn is None:
         badfn = bad
 
     m = ctx.match(
         pats,
         opts.get(b'include'),
         opts.get(b'exclude'),
         default,
         listsubrepos=opts.get(b'subrepos'),
         badfn=badfn,
     )
 
     if m.always():
         pats = []
     return m, pats
 
 
 def match(
     ctx, pats=(), opts=None, globbed=False, default=b'relpath', badfn=None
 ):
     '''Return a matcher that will warn about bad matches.'''
     return matchandpats(ctx, pats, opts, globbed, default, badfn=badfn)[0]
 
 
 def matchall(repo):
     '''Return a matcher that will efficiently match everything.'''
     return matchmod.always()
 
 
 def matchfiles(repo, files, badfn=None):
     '''Return a matcher that will efficiently match exactly these files.'''
     return matchmod.exact(files, badfn=badfn)
 
 
 def parsefollowlinespattern(repo, rev, pat, msg):
     """Return a file name from `pat` pattern suitable for usage in followlines
     logic.
     """
     if not matchmod.patkind(pat):
         return pathutil.canonpath(repo.root, repo.getcwd(), pat)
     else:
         ctx = repo[rev]
         m = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=ctx)
         files = [f for f in ctx if m(f)]
         if len(files) != 1:
             raise error.ParseError(msg)
         return files[0]
 
 
 def getorigvfs(ui, repo):
     """return a vfs suitable to save 'orig' file
 
     return None if no special directory is configured"""
     origbackuppath = ui.config(b'ui', b'origbackuppath')
     if not origbackuppath:
         return None
     return vfs.vfs(repo.wvfs.join(origbackuppath))
 
 
 def backuppath(ui, repo, filepath):
     '''customize where working copy backup files (.orig files) are created
 
     Fetch user defined path from config file: [ui] origbackuppath = <path>
     Fall back to default (filepath with .orig suffix) if not specified
 
     filepath is repo-relative
 
     Returns an absolute path
     '''
     origvfs = getorigvfs(ui, repo)
     if origvfs is None:
         return repo.wjoin(filepath + b".orig")
 
     origbackupdir = origvfs.dirname(filepath)
     if not origvfs.isdir(origbackupdir) or origvfs.islink(origbackupdir):
         ui.note(_(b'creating directory: %s\n') % origvfs.join(origbackupdir))
 
         # Remove any files that conflict with the backup file's path
         for f in reversed(list(pathutil.finddirs(filepath))):
             if origvfs.isfileorlink(f):
                 ui.note(_(b'removing conflicting file: %s\n') % origvfs.join(f))
                 origvfs.unlink(f)
                 break
 
         origvfs.makedirs(origbackupdir)
 
     if origvfs.isdir(filepath) and not origvfs.islink(filepath):
         ui.note(
             _(b'removing conflicting directory: %s\n') % origvfs.join(filepath)
         )
         origvfs.rmtree(filepath, forcibly=True)
 
     return origvfs.join(filepath)
 
 
 class _containsnode(object):
     """proxy __contains__(node) to container.__contains__ which accepts revs"""
 
     def __init__(self, repo, revcontainer):
         self._torev = repo.changelog.rev
         self._revcontains = revcontainer.__contains__
 
     def __contains__(self, node):
         return self._revcontains(self._torev(node))
 
 
 def cleanupnodes(
     repo,
     replacements,
     operation,
     moves=None,
     metadata=None,
     fixphase=False,
     targetphase=None,
     backup=True,
 ):
     """do common cleanups when old nodes are replaced by new nodes
 
     That includes writing obsmarkers or stripping nodes, and moving bookmarks.
     (we might also want to move working directory parent in the future)
 
     By default, bookmark moves are calculated automatically from 'replacements',
     but 'moves' can be used to override that. Also, 'moves' may include
     additional bookmark moves that should not have associated obsmarkers.
 
     replacements is {oldnode: [newnode]} or a iterable of nodes if they do not
     have replacements. operation is a string, like "rebase".
 
     metadata is dictionary containing metadata to be stored in obsmarker if
     obsolescence is enabled.
     """
     assert fixphase or targetphase is None
     if not replacements and not moves:
         return
 
     # translate mapping's other forms
     if not util.safehasattr(replacements, b'items'):
         replacements = {(n,): () for n in replacements}
     else:
         # upgrading non tuple "source" to tuple ones for BC
         repls = {}
         for key, value in replacements.items():
             if not isinstance(key, tuple):
                 key = (key,)
             repls[key] = value
         replacements = repls
 
     # Unfiltered repo is needed since nodes in replacements might be hidden.
     unfi = repo.unfiltered()
 
     # Calculate bookmark movements
     if moves is None:
         moves = {}
         for oldnodes, newnodes in replacements.items():
             for oldnode in oldnodes:
                 if oldnode in moves:
                     continue
                 if len(newnodes) > 1:
                     # usually a split, take the one with biggest rev number
                     newnode = next(unfi.set(b'max(%ln)', newnodes)).node()
                 elif len(newnodes) == 0:
                     # move bookmark backwards
                     allreplaced = []
                     for rep in replacements:
                         allreplaced.extend(rep)
                     roots = list(
                         unfi.set(b'max((::%n) - %ln)', oldnode, allreplaced)
                     )
                     if roots:
                         newnode = roots[0].node()
                     else:
                         newnode = nullid
                 else:
                     newnode = newnodes[0]
                 moves[oldnode] = newnode
 
     allnewnodes = [n for ns in replacements.values() for n in ns]
     toretract = {}
     toadvance = {}
     if fixphase:
         precursors = {}
         for oldnodes, newnodes in replacements.items():
             for oldnode in oldnodes:
                 for newnode in newnodes:
                     precursors.setdefault(newnode, []).append(oldnode)
 
         allnewnodes.sort(key=lambda n: unfi[n].rev())
         newphases = {}
 
         def phase(ctx):
             return newphases.get(ctx.node(), ctx.phase())
 
         for newnode in allnewnodes:
             ctx = unfi[newnode]
             parentphase = max(phase(p) for p in ctx.parents())
             if targetphase is None:
                 oldphase = max(
                     unfi[oldnode].phase() for oldnode in precursors[newnode]
                 )
                 newphase = max(oldphase, parentphase)
             else:
                 newphase = max(targetphase, parentphase)
             newphases[newnode] = newphase
             if newphase > ctx.phase():
                 toretract.setdefault(newphase, []).append(newnode)
             elif newphase < ctx.phase():
                 toadvance.setdefault(newphase, []).append(newnode)
 
     with repo.transaction(b'cleanup') as tr:
         # Move bookmarks
         bmarks = repo._bookmarks
         bmarkchanges = []
         for oldnode, newnode in moves.items():
             oldbmarks = repo.nodebookmarks(oldnode)
             if not oldbmarks:
                 continue
             from . import bookmarks  # avoid import cycle
 
             repo.ui.debug(
                 b'moving bookmarks %r from %s to %s\n'
                 % (
                     pycompat.rapply(pycompat.maybebytestr, oldbmarks),
                     hex(oldnode),
                     hex(newnode),
                 )
             )
             # Delete divergent bookmarks being parents of related newnodes
             deleterevs = repo.revs(
                 b'parents(roots(%ln & (::%n))) - parents(%n)',
                 allnewnodes,
                 newnode,
                 oldnode,
             )
             deletenodes = _containsnode(repo, deleterevs)
             for name in oldbmarks:
                 bmarkchanges.append((name, newnode))
                 for b in bookmarks.divergent2delete(repo, deletenodes, name):
                     bmarkchanges.append((b, None))
 
         if bmarkchanges:
             bmarks.applychanges(repo, tr, bmarkchanges)
 
         for phase, nodes in toretract.items():
             phases.retractboundary(repo, tr, phase, nodes)
         for phase, nodes in toadvance.items():
             phases.advanceboundary(repo, tr, phase, nodes)
 
         mayusearchived = repo.ui.config(b'experimental', b'cleanup-as-archived')
         # Obsolete or strip nodes
         if obsolete.isenabled(repo, obsolete.createmarkersopt):
             # If a node is already obsoleted, and we want to obsolete it
             # without a successor, skip that obssolete request since it's
             # unnecessary. That's the "if s or not isobs(n)" check below.
             # Also sort the node in topology order, that might be useful for
             # some obsstore logic.
             # NOTE: the sorting might belong to createmarkers.
             torev = unfi.changelog.rev
             sortfunc = lambda ns: torev(ns[0][0])
             rels = []
             for ns, s in sorted(replacements.items(), key=sortfunc):
                 rel = (tuple(unfi[n] for n in ns), tuple(unfi[m] for m in s))
                 rels.append(rel)
             if rels:
                 obsolete.createmarkers(
                     repo, rels, operation=operation, metadata=metadata
                 )
         elif phases.supportinternal(repo) and mayusearchived:
             # this assume we do not have "unstable" nodes above the cleaned ones
             allreplaced = set()
             for ns in replacements.keys():
                 allreplaced.update(ns)
             if backup:
                 from . import repair  # avoid import cycle
 
                 node = min(allreplaced, key=repo.changelog.rev)
                 repair.backupbundle(
                     repo, allreplaced, allreplaced, node, operation
                 )
             phases.retractboundary(repo, tr, phases.archived, allreplaced)
         else:
             from . import repair  # avoid import cycle
 
             tostrip = list(n for ns in replacements for n in ns)
             if tostrip:
                 repair.delayedstrip(
                     repo.ui, repo, tostrip, operation, backup=backup
                 )
 
 
 def addremove(repo, matcher, prefix, uipathfn, opts=None):
     if opts is None:
         opts = {}
     m = matcher
     dry_run = opts.get(b'dry_run')
     try:
         similarity = float(opts.get(b'similarity') or 0)
     except ValueError:
         raise error.Abort(_(b'similarity must be a number'))
     if similarity < 0 or similarity > 100:
         raise error.Abort(_(b'similarity must be between 0 and 100'))
     similarity /= 100.0
 
     ret = 0
 
     wctx = repo[None]
     for subpath in sorted(wctx.substate):
         submatch = matchmod.subdirmatcher(subpath, m)
         if opts.get(b'subrepos') or m.exact(subpath) or any(submatch.files()):
             sub = wctx.sub(subpath)
             subprefix = repo.wvfs.reljoin(prefix, subpath)
             subuipathfn = subdiruipathfn(subpath, uipathfn)
             try:
                 if sub.addremove(submatch, subprefix, subuipathfn, opts):
                     ret = 1
             except error.LookupError:
                 repo.ui.status(
                     _(b"skipping missing subrepository: %s\n")
                     % uipathfn(subpath)
                 )
 
     rejected = []
 
     def badfn(f, msg):
         if f in m.files():
             m.bad(f, msg)
         rejected.append(f)
 
     badmatch = matchmod.badmatch(m, badfn)
     added, unknown, deleted, removed, forgotten = _interestingfiles(
         repo, badmatch
     )
 
     unknownset = set(unknown + forgotten)
     toprint = unknownset.copy()
     toprint.update(deleted)
     for abs in sorted(toprint):
         if repo.ui.verbose or not m.exact(abs):
             if abs in unknownset:
                 status = _(b'adding %s\n') % uipathfn(abs)
                 label = b'ui.addremove.added'
             else:
                 status = _(b'removing %s\n') % uipathfn(abs)
                 label = b'ui.addremove.removed'
             repo.ui.status(status, label=label)
 
     renames = _findrenames(
         repo, m, added + unknown, removed + deleted, similarity, uipathfn
     )
 
     if not dry_run:
         _markchanges(repo, unknown + forgotten, deleted, renames)
 
     for f in rejected:
         if f in m.files():
             return 1
     return ret
 
 
 def marktouched(repo, files, similarity=0.0):
     '''Assert that files have somehow been operated upon. files are relative to
     the repo root.'''
     m = matchfiles(repo, files, badfn=lambda x, y: rejected.append(x))
     rejected = []
 
     added, unknown, deleted, removed, forgotten = _interestingfiles(repo, m)
 
     if repo.ui.verbose:
         unknownset = set(unknown + forgotten)
         toprint = unknownset.copy()
         toprint.update(deleted)
         for abs in sorted(toprint):
             if abs in unknownset:
                 status = _(b'adding %s\n') % abs
             else:
                 status = _(b'removing %s\n') % abs
             repo.ui.status(status)
 
     # TODO: We should probably have the caller pass in uipathfn and apply it to
     # the messages above too. legacyrelativevalue=True is consistent with how
     # it used to work.
     uipathfn = getuipathfn(repo, legacyrelativevalue=True)
     renames = _findrenames(
         repo, m, added + unknown, removed + deleted, similarity, uipathfn
     )
 
     _markchanges(repo, unknown + forgotten, deleted, renames)
 
     for f in rejected:
         if f in m.files():
             return 1
     return 0
 
 
 def _interestingfiles(repo, matcher):
     '''Walk dirstate with matcher, looking for files that addremove would care
     about.
 
     This is different from dirstate.status because it doesn't care about
     whether files are modified or clean.'''
     added, unknown, deleted, removed, forgotten = [], [], [], [], []
     audit_path = pathutil.pathauditor(repo.root, cached=True)
 
     ctx = repo[None]
     dirstate = repo.dirstate
     matcher = repo.narrowmatch(matcher, includeexact=True)
     walkresults = dirstate.walk(
         matcher,
         subrepos=sorted(ctx.substate),
         unknown=True,
         ignored=False,
         full=False,
     )
     for abs, st in pycompat.iteritems(walkresults):
         dstate = dirstate[abs]
         if dstate == b'?' and audit_path.check(abs):
             unknown.append(abs)
         elif dstate != b'r' and not st:
             deleted.append(abs)
         elif dstate == b'r' and st:
             forgotten.append(abs)
         # for finding renames
         elif dstate == b'r' and not st:
             removed.append(abs)
         elif dstate == b'a':
             added.append(abs)
 
     return added, unknown, deleted, removed, forgotten
 
 
 def _findrenames(repo, matcher, added, removed, similarity, uipathfn):
     '''Find renames from removed files to added ones.'''
     renames = {}
     if similarity > 0:
         for old, new, score in similar.findrenames(
             repo, added, removed, similarity
         ):
             if (
                 repo.ui.verbose
                 or not matcher.exact(old)
                 or not matcher.exact(new)
             ):
                 repo.ui.status(
                     _(
                         b'recording removal of %s as rename to %s '
                         b'(%d%% similar)\n'
                     )
                     % (uipathfn(old), uipathfn(new), score * 100)
                 )
             renames[new] = old
     return renames
 
 
 def _markchanges(repo, unknown, deleted, renames):
     '''Marks the files in unknown as added, the files in deleted as removed,
     and the files in renames as copied.'''
     wctx = repo[None]
     with repo.wlock():
         wctx.forget(deleted)
         wctx.add(unknown)
         for new, old in pycompat.iteritems(renames):
             wctx.copy(old, new)
 
 
 def getrenamedfn(repo, endrev=None):
     if copiesmod.usechangesetcentricalgo(repo):
 
         def getrenamed(fn, rev):
             ctx = repo[rev]
             p1copies = ctx.p1copies()
             if fn in p1copies:
                 return p1copies[fn]
             p2copies = ctx.p2copies()
             if fn in p2copies:
                 return p2copies[fn]
             return None
 
         return getrenamed
 
     rcache = {}
     if endrev is None:
         endrev = len(repo)
 
     def getrenamed(fn, rev):
         '''looks up all renames for a file (up to endrev) the first
         time the file is given. It indexes on the changerev and only
         parses the manifest if linkrev != changerev.
         Returns rename info for fn at changerev rev.'''
         if fn not in rcache:
             rcache[fn] = {}
             fl = repo.file(fn)
             for i in fl:
                 lr = fl.linkrev(i)
                 renamed = fl.renamed(fl.node(i))
                 rcache[fn][lr] = renamed and renamed[0]
                 if lr >= endrev:
                     break
         if rev in rcache[fn]:
             return rcache[fn][rev]
 
         # If linkrev != rev (i.e. rev not found in rcache) fallback to
         # filectx logic.
         try:
             return repo[rev][fn].copysource()
         except error.LookupError:
             return None
 
     return getrenamed
 
 
 def getcopiesfn(repo, endrev=None):
     if copiesmod.usechangesetcentricalgo(repo):
 
         def copiesfn(ctx):
             if ctx.p2copies():
                 allcopies = ctx.p1copies().copy()
                 # There should be no overlap
                 allcopies.update(ctx.p2copies())
                 return sorted(allcopies.items())
             else:
                 return sorted(ctx.p1copies().items())
 
     else:
         getrenamed = getrenamedfn(repo, endrev)
 
         def copiesfn(ctx):
             copies = []
             for fn in ctx.files():
                 rename = getrenamed(fn, ctx.rev())
                 if rename:
                     copies.append((fn, rename))
             return copies
 
     return copiesfn
 
 
 def dirstatecopy(ui, repo, wctx, src, dst, dryrun=False, cwd=None):
     """Update the dirstate to reflect the intent of copying src to dst. For
     different reasons it might not end with dst being marked as copied from src.
     """
     origsrc = repo.dirstate.copied(src) or src
     if dst == origsrc:  # copying back a copy?
         if repo.dirstate[dst] not in b'mn' and not dryrun:
             repo.dirstate.normallookup(dst)
     else:
         if repo.dirstate[origsrc] == b'a' and origsrc == src:
             if not ui.quiet:
                 ui.warn(
                     _(
                         b"%s has not been committed yet, so no copy "
                         b"data will be stored for %s.\n"
                     )
                     % (repo.pathto(origsrc, cwd), repo.pathto(dst, cwd))
                 )
             if repo.dirstate[dst] in b'?r' and not dryrun:
                 wctx.add([dst])
         elif not dryrun:
             wctx.copy(origsrc, dst)
 
 
 def movedirstate(repo, newctx, match=None):
     """Move the dirstate to newctx and adjust it as necessary.
 
     A matcher can be provided as an optimization. It is probably a bug to pass
     a matcher that doesn't match all the differences between the parent of the
     working copy and newctx.
     """
     oldctx = repo[b'.']
     ds = repo.dirstate
     copies = dict(ds.copies())
     ds.setparents(newctx.node(), nullid)
     s = newctx.status(oldctx, match=match)
     for f in s.modified:
         if ds[f] == b'r':
             # modified + removed -> removed
             continue
         ds.normallookup(f)
 
     for f in s.added:
         if ds[f] == b'r':
             # added + removed -> unknown
             ds.drop(f)
         elif ds[f] != b'a':
             ds.add(f)
 
     for f in s.removed:
         if ds[f] == b'a':
             # removed + added -> normal
             ds.normallookup(f)
         elif ds[f] != b'r':
             ds.remove(f)
 
     # Merge old parent and old working dir copies
     oldcopies = copiesmod.pathcopies(newctx, oldctx, match)
     oldcopies.update(copies)
     copies = {
         dst: oldcopies.get(src, src)
         for dst, src in pycompat.iteritems(oldcopies)
     }
     # Adjust the dirstate copies
     for dst, src in pycompat.iteritems(copies):
         if src not in newctx or dst in newctx or ds[dst] != b'a':
             src = None
         ds.copy(src, dst)
     repo._quick_access_changeid_invalidate()
 
 
 def filterrequirements(requirements):
     """ filters the requirements into two sets:
 
     wcreq: requirements which should be written in .hg/requires
     storereq: which should be written in .hg/store/requires
 
     Returns (wcreq, storereq)
     """
     if requirementsmod.SHARESAFE_REQUIREMENT in requirements:
         wc, store = set(), set()
         for r in requirements:
             if r in requirementsmod.WORKING_DIR_REQUIREMENTS:
                 wc.add(r)
             else:
                 store.add(r)
         return wc, store
     return requirements, None
 
 
 def istreemanifest(repo):
     """ returns whether the repository is using treemanifest or not """
     return requirementsmod.TREEMANIFEST_REQUIREMENT in repo.requirements
 
 
 def writereporequirements(repo, requirements=None):
     """ writes requirements for the repo to .hg/requires """
     if requirements:
         repo.requirements = requirements
     wcreq, storereq = filterrequirements(repo.requirements)
     if wcreq is not None:
         writerequires(repo.vfs, wcreq)
     if storereq is not None:
         writerequires(repo.svfs, storereq)
 
 
 def writerequires(opener, requirements):
     with opener(b'requires', b'w', atomictemp=True) as fp:
         for r in sorted(requirements):
             fp.write(b"%s\n" % r)
 
 
 class filecachesubentry(object):
     def __init__(self, path, stat):
         self.path = path
         self.cachestat = None
         self._cacheable = None
 
         if stat:
             self.cachestat = filecachesubentry.stat(self.path)
 
             if self.cachestat:
                 self._cacheable = self.cachestat.cacheable()
             else:
                 # None means we don't know yet
                 self._cacheable = None
 
     def refresh(self):
         if self.cacheable():
             self.cachestat = filecachesubentry.stat(self.path)
 
     def cacheable(self):
         if self._cacheable is not None:
             return self._cacheable
 
         # we don't know yet, assume it is for now
         return True
 
     def changed(self):
         # no point in going further if we can't cache it
         if not self.cacheable():
             return True
 
         newstat = filecachesubentry.stat(self.path)
 
         # we may not know if it's cacheable yet, check again now
         if newstat and self._cacheable is None:
             self._cacheable = newstat.cacheable()
 
             # check again
             if not self._cacheable:
                 return True
 
         if self.cachestat != newstat:
             self.cachestat = newstat
             return True
         else:
             return False
 
     @staticmethod
     def stat(path):
         try:
             return util.cachestat(path)
         except OSError as e:
             if e.errno != errno.ENOENT:
                 raise
 
 
 class filecacheentry(object):
     def __init__(self, paths, stat=True):
         self._entries = []
         for path in paths:
             self._entries.append(filecachesubentry(path, stat))
 
     def changed(self):
         '''true if any entry has changed'''
         for entry in self._entries:
             if entry.changed():
                 return True
         return False
 
     def refresh(self):
         for entry in self._entries:
             entry.refresh()
 
 
 class filecache(object):
     """A property like decorator that tracks files under .hg/ for updates.
 
     On first access, the files defined as arguments are stat()ed and the
     results cached. The decorated function is called. The results are stashed
     away in a ``_filecache`` dict on the object whose method is decorated.
 
     On subsequent access, the cached result is used as it is set to the
     instance dictionary.
 
     On external property set/delete operations, the caller must update the
     corresponding _filecache entry appropriately. Use __class__.<attr>.set()
     instead of directly setting <attr>.
 
     When using the property API, the cached data is always used if available.
     No stat() is performed to check if the file has changed.
 
     Others can muck about with the state of the ``_filecache`` dict. e.g. they
     can populate an entry before the property's getter is called. In this case,
     entries in ``_filecache`` will be used during property operations,
     if available. If the underlying file changes, it is up to external callers
     to reflect this by e.g. calling ``delattr(obj, attr)`` to remove the cached
     method result as well as possibly calling ``del obj._filecache[attr]`` to
     remove the ``filecacheentry``.
     """
 
     def __init__(self, *paths):
         self.paths = paths
 
     def join(self, obj, fname):
         """Used to compute the runtime path of a cached file.
 
         Users should subclass filecache and provide their own version of this
         function to call the appropriate join function on 'obj' (an instance
         of the class that its member function was decorated).
         """
         raise NotImplementedError
 
     def __call__(self, func):
         self.func = func
         self.sname = func.__name__
         self.name = pycompat.sysbytes(self.sname)
         return self
 
     def __get__(self, obj, type=None):
         # if accessed on the class, return the descriptor itself.
         if obj is None:
             return self
 
         assert self.sname not in obj.__dict__
 
         entry = obj._filecache.get(self.name)
 
         if entry:
             if entry.changed():
                 entry.obj = self.func(obj)
         else:
             paths = [self.join(obj, path) for path in self.paths]
 
             # We stat -before- creating the object so our cache doesn't lie if
             # a writer modified between the time we read and stat
             entry = filecacheentry(paths, True)
             entry.obj = self.func(obj)
 
             obj._filecache[self.name] = entry
 
         obj.__dict__[self.sname] = entry.obj
         return entry.obj
 
     # don't implement __set__(), which would make __dict__ lookup as slow as
     # function call.
 
     def set(self, obj, value):
         if self.name not in obj._filecache:
             # we add an entry for the missing value because X in __dict__
             # implies X in _filecache
             paths = [self.join(obj, path) for path in self.paths]
             ce = filecacheentry(paths, False)
             obj._filecache[self.name] = ce
         else:
             ce = obj._filecache[self.name]
 
         ce.obj = value  # update cached copy
         obj.__dict__[self.sname] = value  # update copy returned by obj.x
 
 
 def extdatasource(repo, source):
     """Gather a map of rev -> value dict from the specified source
 
     A source spec is treated as a URL, with a special case shell: type
     for parsing the output from a shell command.
 
     The data is parsed as a series of newline-separated records where
     each record is a revision specifier optionally followed by a space
     and a freeform string value. If the revision is known locally, it
     is converted to a rev, otherwise the record is skipped.
 
     Note that both key and value are treated as UTF-8 and converted to
     the local encoding. This allows uniformity between local and
     remote data sources.
     """
 
     spec = repo.ui.config(b"extdata", source)
     if not spec:
         raise error.Abort(_(b"unknown extdata source '%s'") % source)
 
     data = {}
     src = proc = None
     try:
         if spec.startswith(b"shell:"):
             # external commands should be run relative to the repo root
             cmd = spec[6:]
             proc = subprocess.Popen(
                 procutil.tonativestr(cmd),
                 shell=True,
                 bufsize=-1,
                 close_fds=procutil.closefds,
                 stdout=subprocess.PIPE,
                 cwd=procutil.tonativestr(repo.root),
             )
             src = proc.stdout
         else:
             # treat as a URL or file
             src = url.open(repo.ui, spec)
         for l in src:
             if b" " in l:
                 k, v = l.strip().split(b" ", 1)
             else:
                 k, v = l.strip(), b""
 
             k = encoding.tolocal(k)
             try:
                 data[revsingle(repo, k).rev()] = encoding.tolocal(v)
             except (error.LookupError, error.RepoLookupError):
                 pass  # we ignore data for nodes that don't exist locally
     finally:
         if proc:
             try:
                 proc.communicate()
             except ValueError:
                 # This happens if we started iterating src and then
                 # get a parse error on a line. It should be safe to ignore.
                 pass
         if src:
             src.close()
     if proc and proc.returncode != 0:
         raise error.Abort(
             _(b"extdata command '%s' failed: %s")
             % (cmd, procutil.explainexit(proc.returncode))
         )
 
     return data
 
 
 class progress(object):
     def __init__(self, ui, updatebar, topic, unit=b"", total=None):
         self.ui = ui
         self.pos = 0
         self.topic = topic
         self.unit = unit
         self.total = total
         self.debug = ui.configbool(b'progress', b'debug')
         self._updatebar = updatebar
 
     def __enter__(self):
         return self
 
     def __exit__(self, exc_type, exc_value, exc_tb):
         self.complete()
 
     def update(self, pos, item=b"", total=None):
         assert pos is not None
         if total:
             self.total = total
         self.pos = pos
         self._updatebar(self.topic, self.pos, item, self.unit, self.total)
         if self.debug:
             self._printdebug(item)
 
     def increment(self, step=1, item=b"", total=None):
         self.update(self.pos + step, item, total)
 
     def complete(self):
         self.pos = None
         self.unit = b""
         self.total = None
         self._updatebar(self.topic, self.pos, b"", self.unit, self.total)
 
     def _printdebug(self, item):
         unit = b''
         if self.unit:
             unit = b' ' + self.unit
         if item:
             item = b' ' + item
 
         if self.total:
             pct = 100.0 * self.pos / self.total
             self.ui.debug(
                 b'%s:%s %d/%d%s (%4.2f%%)\n'
                 % (self.topic, item, self.pos, self.total, unit, pct)
             )
         else:
             self.ui.debug(b'%s:%s %d%s\n' % (self.topic, item, self.pos, unit))
 
 
 def gdinitconfig(ui):
     """helper function to know if a repo should be created as general delta
     """
     # experimental config: format.generaldelta
     return ui.configbool(b'format', b'generaldelta') or ui.configbool(
         b'format', b'usegeneraldelta'
     )
 
 
 def gddeltaconfig(ui):
     """helper function to know if incoming delta should be optimised
     """
     # experimental config: format.generaldelta
     return ui.configbool(b'format', b'generaldelta')
 
 
 class simplekeyvaluefile(object):
     """A simple file with key=value lines
 
     Keys must be alphanumerics and start with a letter, values must not
     contain '\n' characters"""
 
     firstlinekey = b'__firstline'
 
     def __init__(self, vfs, path, keys=None):
         self.vfs = vfs
         self.path = path
 
     def read(self, firstlinenonkeyval=False):
         """Read the contents of a simple key-value file
 
         'firstlinenonkeyval' indicates whether the first line of file should
         be treated as a key-value pair or reuturned fully under the
         __firstline key."""
         lines = self.vfs.readlines(self.path)
         d = {}
         if firstlinenonkeyval:
             if not lines:
                 e = _(b"empty simplekeyvalue file")
                 raise error.CorruptedState(e)
             # we don't want to include '\n' in the __firstline
             d[self.firstlinekey] = lines[0][:-1]
             del lines[0]
 
         try:
             # the 'if line.strip()' part prevents us from failing on empty
             # lines which only contain '\n' therefore are not skipped
             # by 'if line'
             updatedict = dict(
                 line[:-1].split(b'=', 1) for line in lines if line.strip()
             )
             if self.firstlinekey in updatedict:
                 e = _(b"%r can't be used as a key")
                 raise error.CorruptedState(e % self.firstlinekey)
             d.update(updatedict)
         except ValueError as e:
             raise error.CorruptedState(stringutil.forcebytestr(e))
         return d
 
     def write(self, data, firstline=None):
         """Write key=>value mapping to a file
         data is a dict. Keys must be alphanumerical and start with a letter.
         Values must not contain newline characters.
 
         If 'firstline' is not None, it is written to file before
         everything else, as it is, not in a key=value form"""
         lines = []
         if firstline is not None:
             lines.append(b'%s\n' % firstline)
 
         for k, v in data.items():
             if k == self.firstlinekey:
                 e = b"key name '%s' is reserved" % self.firstlinekey
                 raise error.ProgrammingError(e)
             if not k[0:1].isalpha():
                 e = b"keys must start with a letter in a key-value file"
                 raise error.ProgrammingError(e)
             if not k.isalnum():
                 e = b"invalid key name in a simple key-value file"
                 raise error.ProgrammingError(e)
             if b'\n' in v:
                 e = b"invalid value in a simple key-value file"
                 raise error.ProgrammingError(e)
             lines.append(b"%s=%s\n" % (k, v))
         with self.vfs(self.path, mode=b'wb', atomictemp=True) as fp:
             fp.write(b''.join(lines))
 
 
 _reportobsoletedsource = [
     b'debugobsolete',
     b'pull',
     b'push',
     b'serve',
     b'unbundle',
 ]
 
 _reportnewcssource = [
     b'pull',
     b'unbundle',
 ]
 
 
 def prefetchfiles(repo, revmatches):
     """Invokes the registered file prefetch functions, allowing extensions to
     ensure the corresponding files are available locally, before the command
     uses them.
 
     Args:
       revmatches: a list of (revision, match) tuples to indicate the files to
       fetch at each revision. If any of the match elements is None, it matches
       all files.
     """
 
     def _matcher(m):
         if m:
             assert isinstance(m, matchmod.basematcher)
             # The command itself will complain about files that don't exist, so
             # don't duplicate the message.
             return matchmod.badmatch(m, lambda fn, msg: None)
         else:
             return matchall(repo)
 
     revbadmatches = [(rev, _matcher(match)) for (rev, match) in revmatches]
 
     fileprefetchhooks(repo, revbadmatches)
 
 
 # a list of (repo, revs, match) prefetch functions
 fileprefetchhooks = util.hooks()
 
 # A marker that tells the evolve extension to suppress its own reporting
 _reportstroubledchangesets = True
 
 
 def registersummarycallback(repo, otr, txnname=b'', as_validator=False):
     """register a callback to issue a summary after the transaction is closed
 
     If as_validator is true, then the callbacks are registered as transaction
     validators instead
     """
 
     def txmatch(sources):
         return any(txnname.startswith(source) for source in sources)
 
     categories = []
 
     def reportsummary(func):
         """decorator for report callbacks."""
         # The repoview life cycle is shorter than the one of the actual
         # underlying repository. So the filtered object can die before the
         # weakref is used leading to troubles. We keep a reference to the
         # unfiltered object and restore the filtering when retrieving the
         # repository through the weakref.
         filtername = repo.filtername
         reporef = weakref.ref(repo.unfiltered())
 
         def wrapped(tr):
             repo = reporef()
             if filtername:
                 assert repo is not None  # help pytype
                 repo = repo.filtered(filtername)
             func(repo, tr)
 
         newcat = b'%02i-txnreport' % len(categories)
         if as_validator:
             otr.addvalidator(newcat, wrapped)
         else:
             otr.addpostclose(newcat, wrapped)
         categories.append(newcat)
         return wrapped
 
     @reportsummary
     def reportchangegroup(repo, tr):
         cgchangesets = tr.changes.get(b'changegroup-count-changesets', 0)
         cgrevisions = tr.changes.get(b'changegroup-count-revisions', 0)
         cgfiles = tr.changes.get(b'changegroup-count-files', 0)
         cgheads = tr.changes.get(b'changegroup-count-heads', 0)
         if cgchangesets or cgrevisions or cgfiles:
             htext = b""
             if cgheads:
                 htext = _(b" (%+d heads)") % cgheads
             msg = _(b"added %d changesets with %d changes to %d files%s\n")
             if as_validator:
                 msg = _(b"adding %d changesets with %d changes to %d files%s\n")
             assert repo is not None  # help pytype
             repo.ui.status(msg % (cgchangesets, cgrevisions, cgfiles, htext))
 
     if txmatch(_reportobsoletedsource):
 
         @reportsummary
         def reportobsoleted(repo, tr):
             obsoleted = obsutil.getobsoleted(repo, tr)
             newmarkers = len(tr.changes.get(b'obsmarkers', ()))
             if newmarkers:
                 repo.ui.status(_(b'%i new obsolescence markers\n') % newmarkers)
             if obsoleted:
                 msg = _(b'obsoleted %i changesets\n')
                 if as_validator:
                     msg = _(b'obsoleting %i changesets\n')
                 repo.ui.status(msg % len(obsoleted))
 
     if obsolete.isenabled(
         repo, obsolete.createmarkersopt
     ) and repo.ui.configbool(
         b'experimental', b'evolution.report-instabilities'
     ):
         instabilitytypes = [
             (b'orphan', b'orphan'),
             (b'phase-divergent', b'phasedivergent'),
             (b'content-divergent', b'contentdivergent'),
         ]
 
         def getinstabilitycounts(repo):
             filtered = repo.changelog.filteredrevs
             counts = {}
             for instability, revset in instabilitytypes:
                 counts[instability] = len(
                     set(obsolete.getrevs(repo, revset)) - filtered
                 )
             return counts
 
         oldinstabilitycounts = getinstabilitycounts(repo)
 
         @reportsummary
         def reportnewinstabilities(repo, tr):
             newinstabilitycounts = getinstabilitycounts(repo)
             for instability, revset in instabilitytypes:
                 delta = (
                     newinstabilitycounts[instability]
                     - oldinstabilitycounts[instability]
                 )
                 msg = getinstabilitymessage(delta, instability)
                 if msg:
                     repo.ui.warn(msg)
 
     if txmatch(_reportnewcssource):
 
         @reportsummary
         def reportnewcs(repo, tr):
             """Report the range of new revisions pulled/unbundled."""
             origrepolen = tr.changes.get(b'origrepolen', len(repo))
             unfi = repo.unfiltered()
             if origrepolen >= len(unfi):
                 return
 
             # Compute the bounds of new visible revisions' range.
             revs = smartset.spanset(repo, start=origrepolen)
             if revs:
                 minrev, maxrev = repo[revs.min()], repo[revs.max()]
 
                 if minrev == maxrev:
                     revrange = minrev
                 else:
                     revrange = b'%s:%s' % (minrev, maxrev)
                 draft = len(repo.revs(b'%ld and draft()', revs))
                 secret = len(repo.revs(b'%ld and secret()', revs))
                 if not (draft or secret):
                     msg = _(b'new changesets %s\n') % revrange
                 elif draft and secret:
                     msg = _(b'new changesets %s (%d drafts, %d secrets)\n')
                     msg %= (revrange, draft, secret)
                 elif draft:
                     msg = _(b'new changesets %s (%d drafts)\n')
                     msg %= (revrange, draft)
                 elif secret:
                     msg = _(b'new changesets %s (%d secrets)\n')
                     msg %= (revrange, secret)
                 else:
                     errormsg = b'entered unreachable condition'
                     raise error.ProgrammingError(errormsg)
                 repo.ui.status(msg)
 
             # search new changesets directly pulled as obsolete
             duplicates = tr.changes.get(b'revduplicates', ())
             obsadded = unfi.revs(
                 b'(%d: + %ld) and obsolete()', origrepolen, duplicates
             )
             cl = repo.changelog
             extinctadded = [r for r in obsadded if r not in cl]
             if extinctadded:
                 # They are not just obsolete, but obsolete and invisible
                 # we call them "extinct" internally but the terms have not been
                 # exposed to users.
                 msg = b'(%d other changesets obsolete on arrival)\n'
                 repo.ui.status(msg % len(extinctadded))
 
         @reportsummary
         def reportphasechanges(repo, tr):
             """Report statistics of phase changes for changesets pre-existing
             pull/unbundle.
             """
             origrepolen = tr.changes.get(b'origrepolen', len(repo))
             published = []
             for revs, (old, new) in tr.changes.get(b'phases', []):
                 if new != phases.public:
                     continue
                 published.extend(rev for rev in revs if rev < origrepolen)
             if not published:
                 return
             msg = _(b'%d local changesets published\n')
             if as_validator:
                 msg = _(b'%d local changesets will be published\n')
             repo.ui.status(msg % len(published))
 
 
 def getinstabilitymessage(delta, instability):
     """function to return the message to show warning about new instabilities
 
     exists as a separate function so that extension can wrap to show more
     information like how to fix instabilities"""
     if delta > 0:
         return _(b'%i new %s changesets\n') % (delta, instability)
 
 
 def nodesummaries(repo, nodes, maxnumnodes=4):
     if len(nodes) <= maxnumnodes or repo.ui.verbose:
         return b' '.join(short(h) for h in nodes)
     first = b' '.join(short(h) for h in nodes[:maxnumnodes])
     return _(b"%s and %d others") % (first, len(nodes) - maxnumnodes)
 
 
 def enforcesinglehead(repo, tr, desc, accountclosed=False):
     """check that no named branch has multiple heads"""
     if desc in (b'strip', b'repair'):
         # skip the logic during strip
         return
     visible = repo.filtered(b'visible')
     # possible improvement: we could restrict the check to affected branch
     bm = visible.branchmap()
     for name in bm:
         heads = bm.branchheads(name, closed=accountclosed)
         if len(heads) > 1:
             msg = _(b'rejecting multiple heads on branch "%s"')
             msg %= name
             hint = _(b'%d heads: %s')
             hint %= (len(heads), nodesummaries(repo, heads))
             raise error.Abort(msg, hint=hint)
 
 
 def wrapconvertsink(sink):
     """Allow extensions to wrap the sink returned by convcmd.convertsink()
     before it is used, whether or not the convert extension was formally loaded.
     """
     return sink
 
 
 def unhidehashlikerevs(repo, specs, hiddentype):
     """parse the user specs and unhide changesets whose hash or revision number
     is passed.
 
     hiddentype can be: 1) 'warn': warn while unhiding changesets
                        2) 'nowarn': don't warn while unhiding changesets
 
     returns a repo object with the required changesets unhidden
     """
     if not repo.filtername or not repo.ui.configbool(
         b'experimental', b'directaccess'
     ):
         return repo
 
     if repo.filtername not in (b'visible', b'visible-hidden'):
         return repo
 
     symbols = set()
     for spec in specs:
         try:
             tree = revsetlang.parse(spec)
         except error.ParseError:  # will be reported by scmutil.revrange()
             continue
 
         symbols.update(revsetlang.gethashlikesymbols(tree))
 
     if not symbols:
         return repo
 
     revs = _getrevsfromsymbols(repo, symbols)
 
     if not revs:
         return repo
 
     if hiddentype == b'warn':
         unfi = repo.unfiltered()
         revstr = b", ".join([pycompat.bytestr(unfi[l]) for l in revs])
         repo.ui.warn(
             _(
                 b"warning: accessing hidden changesets for write "
                 b"operation: %s\n"
             )
             % revstr
         )
 
     # we have to use new filtername to separate branch/tags cache until we can
     # disbale these cache when revisions are dynamically pinned.
     return repo.filtered(b'visible-hidden', revs)
 
 
 def _getrevsfromsymbols(repo, symbols):
     """parse the list of symbols and returns a set of revision numbers of hidden
     changesets present in symbols"""
     revs = set()
     unfi = repo.unfiltered()
     unficl = unfi.changelog
     cl = repo.changelog
     tiprev = len(unficl)
     allowrevnums = repo.ui.configbool(b'experimental', b'directaccess.revnums')
     for s in symbols:
         try:
             n = int(s)
             if n <= tiprev:
                 if not allowrevnums:
                     continue
                 else:
                     if n not in cl:
                         revs.add(n)
                     continue
         except ValueError:
             pass
 
         try:
             s = resolvehexnodeidprefix(unfi, s)
         except (error.LookupError, error.WdirUnsupported):
             s = None
 
         if s is not None:
             rev = unficl.rev(s)
             if rev not in cl:
                 revs.add(rev)
 
     return revs
 
 
 def bookmarkrevs(repo, mark):
     """
     Select revisions reachable by a given bookmark
     """
     return repo.revs(
         b"ancestors(bookmark(%s)) - "
         b"ancestors(head() and not bookmark(%s)) - "
         b"ancestors(bookmark() and not bookmark(%s))",
         mark,
         mark,
         mark,
     )

mercurial/ui.py

@@ -1,2372 +1,2374 b''
 # ui.py - user interface bits for mercurial
 #
 # Copyright 2005-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 __future__ import absolute_import
 
 import collections
 import contextlib
 import datetime
 import errno
 import getpass
 import inspect
 import os
 import re
 import signal
 import socket
 import subprocess
 import sys
 import traceback
 
 from .i18n import _
 from .node import hex
 from .pycompat import (
     getattr,
     open,
     setattr,
 )
 
 from . import (
     color,
     config,
     configitems,
     encoding,
     error,
     formatter,
     loggingutil,
     progress,
     pycompat,
     rcutil,
     scmutil,
     util,
 )
 from .utils import (
     dateutil,
     procutil,
     resourceutil,
     stringutil,
 )
 
 urlreq = util.urlreq
 
 # for use with str.translate(None, _keepalnum), to keep just alphanumerics
 _keepalnum = b''.join(
     c for c in map(pycompat.bytechr, range(256)) if not c.isalnum()
 )
 
 # The config knobs that will be altered (if unset) by ui.tweakdefaults.
 tweakrc = b"""
 [ui]
+# Gives detailed exit codes for input/user errors, config errors, etc.
+detailed-exit-code = True
 # The rollback command is dangerous. As a rule, don't use it.
 rollback = False
 # Make `hg status` report copy information
 statuscopies = yes
 # Prefer curses UIs when available. Revert to plain-text with `text`.
 interface = curses
 # Make compatible commands emit cwd-relative paths by default.
 relative-paths = yes
 
 [commands]
 # Grep working directory by default.
 grep.all-files = True
 # Refuse to perform an `hg update` that would cause a file content merge
 update.check = noconflict
 # Show conflicts information in `hg status`
 status.verbose = True
 # Make `hg resolve` with no action (like `-m`) fail instead of re-merging.
 resolve.explicit-re-merge = True
 
 [diff]
 git = 1
 showfunc = 1
 word-diff = 1
 """
 
 samplehgrcs = {
     b'user': b"""# example user config (see 'hg help config' for more info)
 [ui]
 # name and email, e.g.
 # username = Jane Doe <[e-mail]>
 username =
 
 # We recommend enabling tweakdefaults to get slight improvements to
 # the UI over time. Make sure to set HGPLAIN in the environment when
 # writing scripts!
 # tweakdefaults = True
 
 # uncomment to disable color in command output
 # (see 'hg help color' for details)
 # color = never
 
 # uncomment to disable command output pagination
 # (see 'hg help pager' for details)
 # paginate = never
 
 [extensions]
 # uncomment the lines below to enable some popular extensions
 # (see 'hg help extensions' for more info)
 #
 # histedit =
 # rebase =
 # uncommit =
 """,
     b'cloned': b"""# example repository config (see 'hg help config' for more info)
 [paths]
 default = %s
 
 # path aliases to other clones of this repo in URLs or filesystem paths
 # (see 'hg help config.paths' for more info)
 #
 # default:pushurl = ssh://[e-mail]/hg/jdoes-fork
 # my-fork         = ssh://[e-mail]/hg/jdoes-fork
 # my-clone        = /home/jdoe/jdoes-clone
 
 [ui]
 # name and email (local to this repository, optional), e.g.
 # username = Jane Doe <[e-mail]>
 """,
     b'local': b"""# example repository config (see 'hg help config' for more info)
 [paths]
 # path aliases to other clones of this repo in URLs or filesystem paths
 # (see 'hg help config.paths' for more info)
 #
 # default         = http://example.com/hg/example-repo
 # default:pushurl = ssh://[e-mail]/hg/jdoes-fork
 # my-fork         = ssh://[e-mail]/hg/jdoes-fork
 # my-clone        = /home/jdoe/jdoes-clone
 
 [ui]
 # name and email (local to this repository, optional), e.g.
 # username = Jane Doe <[e-mail]>
 """,
     b'global': b"""# example system-wide hg config (see 'hg help config' for more info)
 
 [ui]
 # uncomment to disable color in command output
 # (see 'hg help color' for details)
 # color = never
 
 # uncomment to disable command output pagination
 # (see 'hg help pager' for details)
 # paginate = never
 
 [extensions]
 # uncomment the lines below to enable some popular extensions
 # (see 'hg help extensions' for more info)
 #
 # blackbox =
 # churn =
 """,
 }
 
 
 def _maybestrurl(maybebytes):
     return pycompat.rapply(pycompat.strurl, maybebytes)
 
 
 def _maybebytesurl(maybestr):
     return pycompat.rapply(pycompat.bytesurl, maybestr)
 
 
 class httppasswordmgrdbproxy(object):
     """Delays loading urllib2 until it's needed."""
 
     def __init__(self):
         self._mgr = None
 
     def _get_mgr(self):
         if self._mgr is None:
             self._mgr = urlreq.httppasswordmgrwithdefaultrealm()
         return self._mgr
 
     def add_password(self, realm, uris, user, passwd):
         return self._get_mgr().add_password(
             _maybestrurl(realm),
             _maybestrurl(uris),
             _maybestrurl(user),
             _maybestrurl(passwd),
         )
 
     def find_user_password(self, realm, uri):
         mgr = self._get_mgr()
         return _maybebytesurl(
             mgr.find_user_password(_maybestrurl(realm), _maybestrurl(uri))
         )
 
 
 def _catchterm(*args):
     raise error.SignalInterrupt
 
 
 # unique object used to detect no default value has been provided when
 # retrieving configuration value.
 _unset = object()
 
 # _reqexithandlers: callbacks run at the end of a request
 _reqexithandlers = []
 
 
 class ui(object):
     def __init__(self, src=None):
         """Create a fresh new ui object if no src given
 
         Use uimod.ui.load() to create a ui which knows global and user configs.
         In most cases, you should use ui.copy() to create a copy of an existing
         ui object.
         """
         # _buffers: used for temporary capture of output
         self._buffers = []
         # 3-tuple describing how each buffer in the stack behaves.
         # Values are (capture stderr, capture subprocesses, apply labels).
         self._bufferstates = []
         # When a buffer is active, defines whether we are expanding labels.
         # This exists to prevent an extra list lookup.
         self._bufferapplylabels = None
         self.quiet = self.verbose = self.debugflag = self.tracebackflag = False
         self._reportuntrusted = True
         self._knownconfig = configitems.coreitems
         self._ocfg = config.config()  # overlay
         self._tcfg = config.config()  # trusted
         self._ucfg = config.config()  # untrusted
         self._trustusers = set()
         self._trustgroups = set()
         self.callhooks = True
         # Insecure server connections requested.
         self.insecureconnections = False
         # Blocked time
         self.logblockedtimes = False
         # color mode: see mercurial/color.py for possible value
         self._colormode = None
         self._terminfoparams = {}
         self._styles = {}
         self._uninterruptible = False
         self.showtimestamp = False
 
         if src:
             self._fout = src._fout
             self._ferr = src._ferr
             self._fin = src._fin
             self._fmsg = src._fmsg
             self._fmsgout = src._fmsgout
             self._fmsgerr = src._fmsgerr
             self._finoutredirected = src._finoutredirected
             self._loggers = src._loggers.copy()
             self.pageractive = src.pageractive
             self._disablepager = src._disablepager
             self._tweaked = src._tweaked
 
             self._tcfg = src._tcfg.copy()
             self._ucfg = src._ucfg.copy()
             self._ocfg = src._ocfg.copy()
             self._trustusers = src._trustusers.copy()
             self._trustgroups = src._trustgroups.copy()
             self.environ = src.environ
             self.callhooks = src.callhooks
             self.insecureconnections = src.insecureconnections
             self._colormode = src._colormode
             self._terminfoparams = src._terminfoparams.copy()
             self._styles = src._styles.copy()
 
             self.fixconfig()
 
             self.httppasswordmgrdb = src.httppasswordmgrdb
             self._blockedtimes = src._blockedtimes
         else:
             self._fout = procutil.stdout
             self._ferr = procutil.stderr
             self._fin = procutil.stdin
             self._fmsg = None
             self._fmsgout = self.fout  # configurable
             self._fmsgerr = self.ferr  # configurable
             self._finoutredirected = False
             self._loggers = {}
             self.pageractive = False
             self._disablepager = False
             self._tweaked = False
 
             # shared read-only environment
             self.environ = encoding.environ
 
             self.httppasswordmgrdb = httppasswordmgrdbproxy()
             self._blockedtimes = collections.defaultdict(int)
 
         allowed = self.configlist(b'experimental', b'exportableenviron')
         if b'*' in allowed:
             self._exportableenviron = self.environ
         else:
             self._exportableenviron = {}
             for k in allowed:
                 if k in self.environ:
                     self._exportableenviron[k] = self.environ[k]
 
     @classmethod
     def load(cls):
         """Create a ui and load global and user configs"""
         u = cls()
         # we always trust global config files and environment variables
         for t, f in rcutil.rccomponents():
             if t == b'path':
                 u.readconfig(f, trust=True)
             elif t == b'resource':
                 u.read_resource_config(f, trust=True)
             elif t == b'items':
                 sections = set()
                 for section, name, value, source in f:
                     # do not set u._ocfg
                     # XXX clean this up once immutable config object is a thing
                     u._tcfg.set(section, name, value, source)
                     u._ucfg.set(section, name, value, source)
                     sections.add(section)
                 for section in sections:
                     u.fixconfig(section=section)
             else:
                 raise error.ProgrammingError(b'unknown rctype: %s' % t)
         u._maybetweakdefaults()
         return u
 
     def _maybetweakdefaults(self):
         if not self.configbool(b'ui', b'tweakdefaults'):
             return
         if self._tweaked or self.plain(b'tweakdefaults'):
             return
 
         # Note: it is SUPER IMPORTANT that you set self._tweaked to
         # True *before* any calls to setconfig(), otherwise you'll get
         # infinite recursion between setconfig and this method.
         #
         # TODO: We should extract an inner method in setconfig() to
         # avoid this weirdness.
         self._tweaked = True
         tmpcfg = config.config()
         tmpcfg.parse(b'<tweakdefaults>', tweakrc)
         for section in tmpcfg:
             for name, value in tmpcfg.items(section):
                 if not self.hasconfig(section, name):
                     self.setconfig(section, name, value, b"<tweakdefaults>")
 
     def copy(self):
         return self.__class__(self)
 
     def resetstate(self):
         """Clear internal state that shouldn't persist across commands"""
         if self._progbar:
             self._progbar.resetstate()  # reset last-print time of progress bar
         self.httppasswordmgrdb = httppasswordmgrdbproxy()
 
     @contextlib.contextmanager
     def timeblockedsection(self, key):
         # this is open-coded below - search for timeblockedsection to find them
         starttime = util.timer()
         try:
             yield
         finally:
             self._blockedtimes[key + b'_blocked'] += (
                 util.timer() - starttime
             ) * 1000
 
     @contextlib.contextmanager
     def uninterruptible(self):
         """Mark an operation as unsafe.
 
         Most operations on a repository are safe to interrupt, but a
         few are risky (for example repair.strip). This context manager
         lets you advise Mercurial that something risky is happening so
         that control-C etc can be blocked if desired.
         """
         enabled = self.configbool(b'experimental', b'nointerrupt')
         if enabled and self.configbool(
             b'experimental', b'nointerrupt-interactiveonly'
         ):
             enabled = self.interactive()
         if self._uninterruptible or not enabled:
             # if nointerrupt support is turned off, the process isn't
             # interactive, or we're already in an uninterruptible
             # block, do nothing.
             yield
             return
 
         def warn():
             self.warn(_(b"shutting down cleanly\n"))
             self.warn(
                 _(b"press ^C again to terminate immediately (dangerous)\n")
             )
             return True
 
         with procutil.uninterruptible(warn):
             try:
                 self._uninterruptible = True
                 yield
             finally:
                 self._uninterruptible = False
 
     def formatter(self, topic, opts):
         return formatter.formatter(self, self, topic, opts)
 
     def _trusted(self, fp, f):
         st = util.fstat(fp)
         if util.isowner(st):
             return True
 
         tusers, tgroups = self._trustusers, self._trustgroups
         if b'*' in tusers or b'*' in tgroups:
             return True
 
         user = util.username(st.st_uid)
         group = util.groupname(st.st_gid)
         if user in tusers or group in tgroups or user == util.username():
             return True
 
         if self._reportuntrusted:
             self.warn(
                 _(
                     b'not trusting file %s from untrusted '
                     b'user %s, group %s\n'
                 )
                 % (f, user, group)
             )
         return False
 
     def read_resource_config(
         self, name, root=None, trust=False, sections=None, remap=None
     ):
         try:
             fp = resourceutil.open_resource(name[0], name[1])
         except IOError:
             if not sections:  # ignore unless we were looking for something
                 return
             raise
 
         self._readconfig(
             b'resource:%s.%s' % name, fp, root, trust, sections, remap
         )
 
     def readconfig(
         self, filename, root=None, trust=False, sections=None, remap=None
     ):
         try:
             fp = open(filename, 'rb')
         except IOError:
             if not sections:  # ignore unless we were looking for something
                 return
             raise
 
         self._readconfig(filename, fp, root, trust, sections, remap)
 
     def _readconfig(
         self, filename, fp, root=None, trust=False, sections=None, remap=None
     ):
         with fp:
             cfg = config.config()
             trusted = sections or trust or self._trusted(fp, filename)
 
             try:
                 cfg.read(filename, fp, sections=sections, remap=remap)
             except error.ParseError as inst:
                 if trusted:
                     raise
                 self.warn(_(b'ignored: %s\n') % stringutil.forcebytestr(inst))
 
         self._applyconfig(cfg, trusted, root)
 
     def applyconfig(self, configitems, source=b"", root=None):
         """Add configitems from a non-file source.  Unlike with ``setconfig()``,
         they can be overridden by subsequent config file reads.  The items are
         in the same format as ``configoverride()``, namely a dict of the
         following structures: {(section, name) : value}
 
         Typically this is used by extensions that inject themselves into the
         config file load procedure by monkeypatching ``localrepo.loadhgrc()``.
         """
         cfg = config.config()
 
         for (section, name), value in configitems.items():
             cfg.set(section, name, value, source)
 
         self._applyconfig(cfg, True, root)
 
     def _applyconfig(self, cfg, trusted, root):
         if self.plain():
             for k in (
                 b'debug',
                 b'fallbackencoding',
                 b'quiet',
                 b'slash',
                 b'logtemplate',
                 b'message-output',
                 b'statuscopies',
                 b'style',
                 b'traceback',
                 b'verbose',
             ):
                 if k in cfg[b'ui']:
                     del cfg[b'ui'][k]
             for k, v in cfg.items(b'defaults'):
                 del cfg[b'defaults'][k]
             for k, v in cfg.items(b'commands'):
                 del cfg[b'commands'][k]
             for k, v in cfg.items(b'command-templates'):
                 del cfg[b'command-templates'][k]
         # Don't remove aliases from the configuration if in the exceptionlist
         if self.plain(b'alias'):
             for k, v in cfg.items(b'alias'):
                 del cfg[b'alias'][k]
         if self.plain(b'revsetalias'):
             for k, v in cfg.items(b'revsetalias'):
                 del cfg[b'revsetalias'][k]
         if self.plain(b'templatealias'):
             for k, v in cfg.items(b'templatealias'):
                 del cfg[b'templatealias'][k]
 
         if trusted:
             self._tcfg.update(cfg)
             self._tcfg.update(self._ocfg)
         self._ucfg.update(cfg)
         self._ucfg.update(self._ocfg)
 
         if root is None:
             root = os.path.expanduser(b'~')
         self.fixconfig(root=root)
 
     def fixconfig(self, root=None, section=None):
         if section in (None, b'paths'):
             # expand vars and ~
             # translate paths relative to root (or home) into absolute paths
             root = root or encoding.getcwd()
             for c in self._tcfg, self._ucfg, self._ocfg:
                 for n, p in c.items(b'paths'):
                     # Ignore sub-options.
                     if b':' in n:
                         continue
                     if not p:
                         continue
                     if b'%%' in p:
                         s = self.configsource(b'paths', n) or b'none'
                         self.warn(
                             _(b"(deprecated '%%' in path %s=%s from %s)\n")
                             % (n, p, s)
                         )
                         p = p.replace(b'%%', b'%')
                     p = util.expandpath(p)
                     if not util.hasscheme(p) and not os.path.isabs(p):
                         p = os.path.normpath(os.path.join(root, p))
                     c.set(b"paths", n, p)
 
         if section in (None, b'ui'):
             # update ui options
             self._fmsgout, self._fmsgerr = _selectmsgdests(self)
             self.debugflag = self.configbool(b'ui', b'debug')
             self.verbose = self.debugflag or self.configbool(b'ui', b'verbose')
             self.quiet = not self.debugflag and self.configbool(b'ui', b'quiet')
             if self.verbose and self.quiet:
                 self.quiet = self.verbose = False
             self._reportuntrusted = self.debugflag or self.configbool(
                 b"ui", b"report_untrusted"
             )
             self.showtimestamp = self.configbool(b'ui', b'timestamp-output')
             self.tracebackflag = self.configbool(b'ui', b'traceback')
             self.logblockedtimes = self.configbool(b'ui', b'logblockedtimes')
 
         if section in (None, b'trusted'):
             # update trust information
             self._trustusers.update(self.configlist(b'trusted', b'users'))
             self._trustgroups.update(self.configlist(b'trusted', b'groups'))
 
         if section in (None, b'devel', b'ui') and self.debugflag:
             tracked = set()
             if self.configbool(b'devel', b'debug.extensions'):
                 tracked.add(b'extension')
             if tracked:
                 logger = loggingutil.fileobjectlogger(self._ferr, tracked)
                 self.setlogger(b'debug', logger)
 
     def backupconfig(self, section, item):
         return (
             self._ocfg.backup(section, item),
             self._tcfg.backup(section, item),
             self._ucfg.backup(section, item),
         )
 
     def restoreconfig(self, data):
         self._ocfg.restore(data[0])
         self._tcfg.restore(data[1])
         self._ucfg.restore(data[2])
 
     def setconfig(self, section, name, value, source=b''):
         for cfg in (self._ocfg, self._tcfg, self._ucfg):
             cfg.set(section, name, value, source)
         self.fixconfig(section=section)
         self._maybetweakdefaults()
 
     def _data(self, untrusted):
         return untrusted and self._ucfg or self._tcfg
 
     def configsource(self, section, name, untrusted=False):
         return self._data(untrusted).source(section, name)
 
     def config(self, section, name, default=_unset, untrusted=False):
         """return the plain string version of a config"""
         value = self._config(
             section, name, default=default, untrusted=untrusted
         )
         if value is _unset:
             return None
         return value
 
     def _config(self, section, name, default=_unset, untrusted=False):
         value = itemdefault = default
         item = self._knownconfig.get(section, {}).get(name)
         alternates = [(section, name)]
 
         if item is not None:
             alternates.extend(item.alias)
             if callable(item.default):
                 itemdefault = item.default()
             else:
                 itemdefault = item.default
         else:
             msg = b"accessing unregistered config item: '%s.%s'"
             msg %= (section, name)
             self.develwarn(msg, 2, b'warn-config-unknown')
 
         if default is _unset:
             if item is None:
                 value = default
             elif item.default is configitems.dynamicdefault:
                 value = None
                 msg = b"config item requires an explicit default value: '%s.%s'"
                 msg %= (section, name)
                 self.develwarn(msg, 2, b'warn-config-default')
             else:
                 value = itemdefault
         elif (
             item is not None
             and item.default is not configitems.dynamicdefault
             and default != itemdefault
         ):
             msg = (
                 b"specifying a mismatched default value for a registered "
                 b"config item: '%s.%s' '%s'"
             )
             msg %= (section, name, pycompat.bytestr(default))
             self.develwarn(msg, 2, b'warn-config-default')
 
         for s, n in alternates:
             candidate = self._data(untrusted).get(s, n, None)
             if candidate is not None:
                 value = candidate
                 break
 
         if self.debugflag and not untrusted and self._reportuntrusted:
             for s, n in alternates:
                 uvalue = self._ucfg.get(s, n)
                 if uvalue is not None and uvalue != value:
                     self.debug(
                         b"ignoring untrusted configuration option "
                         b"%s.%s = %s\n" % (s, n, uvalue)
                     )
         return value
 
     def configsuboptions(self, section, name, default=_unset, untrusted=False):
         """Get a config option and all sub-options.
 
         Some config options have sub-options that are declared with the
         format "key:opt = value". This method is used to return the main
         option and all its declared sub-options.
 
         Returns a 2-tuple of ``(option, sub-options)``, where `sub-options``
         is a dict of defined sub-options where keys and values are strings.
         """
         main = self.config(section, name, default, untrusted=untrusted)
         data = self._data(untrusted)
         sub = {}
         prefix = b'%s:' % name
         for k, v in data.items(section):
             if k.startswith(prefix):
                 sub[k[len(prefix) :]] = v
 
         if self.debugflag and not untrusted and self._reportuntrusted:
             for k, v in sub.items():
                 uvalue = self._ucfg.get(section, b'%s:%s' % (name, k))
                 if uvalue is not None and uvalue != v:
                     self.debug(
                         b'ignoring untrusted configuration option '
                         b'%s:%s.%s = %s\n' % (section, name, k, uvalue)
                     )
 
         return main, sub
 
     def configpath(self, section, name, default=_unset, untrusted=False):
         """get a path config item, expanded relative to repo root or config
         file"""
         v = self.config(section, name, default, untrusted)
         if v is None:
             return None
         if not os.path.isabs(v) or b"://" not in v:
             src = self.configsource(section, name, untrusted)
             if b':' in src:
                 base = os.path.dirname(src.rsplit(b':')[0])
                 v = os.path.join(base, os.path.expanduser(v))
         return v
 
     def configbool(self, section, name, default=_unset, untrusted=False):
         """parse a configuration element as a boolean
 
         >>> u = ui(); s = b'foo'
         >>> u.setconfig(s, b'true', b'yes')
         >>> u.configbool(s, b'true')
         True
         >>> u.setconfig(s, b'false', b'no')
         >>> u.configbool(s, b'false')
         False
         >>> u.configbool(s, b'unknown')
         False
         >>> u.configbool(s, b'unknown', True)
         True
         >>> u.setconfig(s, b'invalid', b'somevalue')
         >>> u.configbool(s, b'invalid')
         Traceback (most recent call last):
             ...
         ConfigError: foo.invalid is not a boolean ('somevalue')
         """
 
         v = self._config(section, name, default, untrusted=untrusted)
         if v is None:
             return v
         if v is _unset:
             if default is _unset:
                 return False
             return default
         if isinstance(v, bool):
             return v
         b = stringutil.parsebool(v)
         if b is None:
             raise error.ConfigError(
                 _(b"%s.%s is not a boolean ('%s')") % (section, name, v)
             )
         return b
 
     def configwith(
         self, convert, section, name, default=_unset, desc=None, untrusted=False
     ):
         """parse a configuration element with a conversion function
 
         >>> u = ui(); s = b'foo'
         >>> u.setconfig(s, b'float1', b'42')
         >>> u.configwith(float, s, b'float1')
         42.0
         >>> u.setconfig(s, b'float2', b'-4.25')
         >>> u.configwith(float, s, b'float2')
         -4.25
         >>> u.configwith(float, s, b'unknown', 7)
         7.0
         >>> u.setconfig(s, b'invalid', b'somevalue')
         >>> u.configwith(float, s, b'invalid')
         Traceback (most recent call last):
             ...
         ConfigError: foo.invalid is not a valid float ('somevalue')
         >>> u.configwith(float, s, b'invalid', desc=b'womble')
         Traceback (most recent call last):
             ...
         ConfigError: foo.invalid is not a valid womble ('somevalue')
         """
 
         v = self.config(section, name, default, untrusted)
         if v is None:
             return v  # do not attempt to convert None
         try:
             return convert(v)
         except (ValueError, error.ParseError):
             if desc is None:
                 desc = pycompat.sysbytes(convert.__name__)
             raise error.ConfigError(
                 _(b"%s.%s is not a valid %s ('%s')") % (section, name, desc, v)
             )
 
     def configint(self, section, name, default=_unset, untrusted=False):
         """parse a configuration element as an integer
 
         >>> u = ui(); s = b'foo'
         >>> u.setconfig(s, b'int1', b'42')
         >>> u.configint(s, b'int1')
         42
         >>> u.setconfig(s, b'int2', b'-42')
         >>> u.configint(s, b'int2')
         -42
         >>> u.configint(s, b'unknown', 7)
         7
         >>> u.setconfig(s, b'invalid', b'somevalue')
         >>> u.configint(s, b'invalid')
         Traceback (most recent call last):
             ...
         ConfigError: foo.invalid is not a valid integer ('somevalue')
         """
 
         return self.configwith(
             int, section, name, default, b'integer', untrusted
         )
 
     def configbytes(self, section, name, default=_unset, untrusted=False):
         """parse a configuration element as a quantity in bytes
 
         Units can be specified as b (bytes), k or kb (kilobytes), m or
         mb (megabytes), g or gb (gigabytes).
 
         >>> u = ui(); s = b'foo'
         >>> u.setconfig(s, b'val1', b'42')
         >>> u.configbytes(s, b'val1')
         42
         >>> u.setconfig(s, b'val2', b'42.5 kb')
         >>> u.configbytes(s, b'val2')
         43520
         >>> u.configbytes(s, b'unknown', b'7 MB')
         7340032
         >>> u.setconfig(s, b'invalid', b'somevalue')
         >>> u.configbytes(s, b'invalid')
         Traceback (most recent call last):
             ...
         ConfigError: foo.invalid is not a byte quantity ('somevalue')
         """
 
         value = self._config(section, name, default, untrusted)
         if value is _unset:
             if default is _unset:
                 default = 0
             value = default
         if not isinstance(value, bytes):
             return value
         try:
             return util.sizetoint(value)
         except error.ParseError:
             raise error.ConfigError(
                 _(b"%s.%s is not a byte quantity ('%s')")
                 % (section, name, value)
             )
 
     def configlist(self, section, name, default=_unset, untrusted=False):
         """parse a configuration element as a list of comma/space separated
         strings
 
         >>> u = ui(); s = b'foo'
         >>> u.setconfig(s, b'list1', b'this,is "a small" ,test')
         >>> u.configlist(s, b'list1')
         ['this', 'is', 'a small', 'test']
         >>> u.setconfig(s, b'list2', b'this, is "a small" , test ')
         >>> u.configlist(s, b'list2')
         ['this', 'is', 'a small', 'test']
         """
         # default is not always a list
         v = self.configwith(
             config.parselist, section, name, default, b'list', untrusted
         )
         if isinstance(v, bytes):
             return config.parselist(v)
         elif v is None:
             return []
         return v
 
     def configdate(self, section, name, default=_unset, untrusted=False):
         """parse a configuration element as a tuple of ints
 
         >>> u = ui(); s = b'foo'
         >>> u.setconfig(s, b'date', b'0 0')
         >>> u.configdate(s, b'date')
         (0, 0)
         """
         if self.config(section, name, default, untrusted):
             return self.configwith(
                 dateutil.parsedate, section, name, default, b'date', untrusted
             )
         if default is _unset:
             return None
         return default
 
     def configdefault(self, section, name):
         """returns the default value of the config item"""
         item = self._knownconfig.get(section, {}).get(name)
         itemdefault = None
         if item is not None:
             if callable(item.default):
                 itemdefault = item.default()
             else:
                 itemdefault = item.default
         return itemdefault
 
     def hasconfig(self, section, name, untrusted=False):
         return self._data(untrusted).hasitem(section, name)
 
     def has_section(self, section, untrusted=False):
         '''tell whether section exists in config.'''
         return section in self._data(untrusted)
 
     def configitems(self, section, untrusted=False, ignoresub=False):
         items = self._data(untrusted).items(section)
         if ignoresub:
             items = [i for i in items if b':' not in i[0]]
         if self.debugflag and not untrusted and self._reportuntrusted:
             for k, v in self._ucfg.items(section):
                 if self._tcfg.get(section, k) != v:
                     self.debug(
                         b"ignoring untrusted configuration option "
                         b"%s.%s = %s\n" % (section, k, v)
                     )
         return items
 
     def walkconfig(self, untrusted=False):
         cfg = self._data(untrusted)
         for section in cfg.sections():
             for name, value in self.configitems(section, untrusted):
                 yield section, name, value
 
     def plain(self, feature=None):
         '''is plain mode active?
 
         Plain mode means that all configuration variables which affect
         the behavior and output of Mercurial should be
         ignored. Additionally, the output should be stable,
         reproducible and suitable for use in scripts or applications.
 
         The only way to trigger plain mode is by setting either the
         `HGPLAIN' or `HGPLAINEXCEPT' environment variables.
 
         The return value can either be
         - False if HGPLAIN is not set, or feature is in HGPLAINEXCEPT
         - False if feature is disabled by default and not included in HGPLAIN
         - True otherwise
         '''
         if (
             b'HGPLAIN' not in encoding.environ
             and b'HGPLAINEXCEPT' not in encoding.environ
         ):
             return False
         exceptions = (
             encoding.environ.get(b'HGPLAINEXCEPT', b'').strip().split(b',')
         )
         # TODO: add support for HGPLAIN=+feature,-feature syntax
         if b'+strictflags' not in encoding.environ.get(b'HGPLAIN', b'').split(
             b','
         ):
             exceptions.append(b'strictflags')
         if feature and exceptions:
             return feature not in exceptions
         return True
 
     def username(self, acceptempty=False):
         """Return default username to be used in commits.
 
         Searched in this order: $HGUSER, [ui] section of hgrcs, $EMAIL
         and stop searching if one of these is set.
         If not found and acceptempty is True, returns None.
         If not found and ui.askusername is True, ask the user, else use
         ($LOGNAME or $USER or $LNAME or $USERNAME) + "@full.hostname".
         If no username could be found, raise an Abort error.
         """
         user = encoding.environ.get(b"HGUSER")
         if user is None:
             user = self.config(b"ui", b"username")
             if user is not None:
                 user = os.path.expandvars(user)
         if user is None:
             user = encoding.environ.get(b"EMAIL")
         if user is None and acceptempty:
             return user
         if user is None and self.configbool(b"ui", b"askusername"):
             user = self.prompt(_(b"enter a commit username:"), default=None)
         if user is None and not self.interactive():
             try:
                 user = b'%s@%s' % (
                     procutil.getuser(),
                     encoding.strtolocal(socket.getfqdn()),
                 )
                 self.warn(_(b"no username found, using '%s' instead\n") % user)
             except KeyError:
                 pass
         if not user:
             raise error.Abort(
                 _(b'no username supplied'),
                 hint=_(b"use 'hg config --edit' " b'to set your username'),
             )
         if b"\n" in user:
             raise error.Abort(
                 _(b"username %r contains a newline\n") % pycompat.bytestr(user)
             )
         return user
 
     def shortuser(self, user):
         """Return a short representation of a user name or email address."""
         if not self.verbose:
             user = stringutil.shortuser(user)
         return user
 
     def expandpath(self, loc, default=None):
         """Return repository location relative to cwd or from [paths]"""
         try:
             p = self.paths.getpath(loc)
             if p:
                 return p.rawloc
         except error.RepoError:
             pass
 
         if default:
             try:
                 p = self.paths.getpath(default)
                 if p:
                     return p.rawloc
             except error.RepoError:
                 pass
 
         return loc
 
     @util.propertycache
     def paths(self):
         return paths(self)
 
     @property
     def fout(self):
         return self._fout
 
     @fout.setter
     def fout(self, f):
         self._fout = f
         self._fmsgout, self._fmsgerr = _selectmsgdests(self)
 
     @property
     def ferr(self):
         return self._ferr
 
     @ferr.setter
     def ferr(self, f):
         self._ferr = f
         self._fmsgout, self._fmsgerr = _selectmsgdests(self)
 
     @property
     def fin(self):
         return self._fin
 
     @fin.setter
     def fin(self, f):
         self._fin = f
 
     @property
     def fmsg(self):
         """Stream dedicated for status/error messages; may be None if
         fout/ferr are used"""
         return self._fmsg
 
     @fmsg.setter
     def fmsg(self, f):
         self._fmsg = f
         self._fmsgout, self._fmsgerr = _selectmsgdests(self)
 
     def pushbuffer(self, error=False, subproc=False, labeled=False):
         """install a buffer to capture standard output of the ui object
 
         If error is True, the error output will be captured too.
 
         If subproc is True, output from subprocesses (typically hooks) will be
         captured too.
 
         If labeled is True, any labels associated with buffered
         output will be handled. By default, this has no effect
         on the output returned, but extensions and GUI tools may
         handle this argument and returned styled output. If output
         is being buffered so it can be captured and parsed or
         processed, labeled should not be set to True.
         """
         self._buffers.append([])
         self._bufferstates.append((error, subproc, labeled))
         self._bufferapplylabels = labeled
 
     def popbuffer(self):
         '''pop the last buffer and return the buffered output'''
         self._bufferstates.pop()
         if self._bufferstates:
             self._bufferapplylabels = self._bufferstates[-1][2]
         else:
             self._bufferapplylabels = None
 
         return b"".join(self._buffers.pop())
 
     def _isbuffered(self, dest):
         if dest is self._fout:
             return bool(self._buffers)
         if dest is self._ferr:
             return bool(self._bufferstates and self._bufferstates[-1][0])
         return False
 
     def canwritewithoutlabels(self):
         '''check if write skips the label'''
         if self._buffers and not self._bufferapplylabels:
             return True
         return self._colormode is None
 
     def canbatchlabeledwrites(self):
         '''check if write calls with labels are batchable'''
         # Windows color printing is special, see ``write``.
         return self._colormode != b'win32'
 
     def write(self, *args, **opts):
         '''write args to output
 
         By default, this method simply writes to the buffer or stdout.
         Color mode can be set on the UI class to have the output decorated
         with color modifier before being written to stdout.
 
         The color used is controlled by an optional keyword argument, "label".
         This should be a string containing label names separated by space.
         Label names take the form of "topic.type". For example, ui.debug()
         issues a label of "ui.debug".
 
         Progress reports via stderr are normally cleared before writing as
         stdout and stderr go to the same terminal. This can be skipped with
         the optional keyword argument "keepprogressbar". The progress bar
         will continue to occupy a partial line on stderr in that case.
         This functionality is intended when Mercurial acts as data source
         in a pipe.
 
         When labeling output for a specific command, a label of
         "cmdname.type" is recommended. For example, status issues
         a label of "status.modified" for modified files.
         '''
         dest = self._fout
 
         # inlined _write() for speed
         if self._buffers:
             label = opts.get('label', b'')
             if label and self._bufferapplylabels:
                 self._buffers[-1].extend(self.label(a, label) for a in args)
             else:
                 self._buffers[-1].extend(args)
             return
 
         # inlined _writenobuf() for speed
         if not opts.get('keepprogressbar', False):
             self._progclear()
         msg = b''.join(args)
 
         # opencode timeblockedsection because this is a critical path
         starttime = util.timer()
         try:
             if self._colormode == b'win32':
                 # windows color printing is its own can of crab, defer to
                 # the color module and that is it.
                 color.win32print(self, dest.write, msg, **opts)
             else:
                 if self._colormode is not None:
                     label = opts.get('label', b'')
                     msg = self.label(msg, label)
                 dest.write(msg)
         except IOError as err:
             raise error.StdioError(err)
         finally:
             self._blockedtimes[b'stdio_blocked'] += (
                 util.timer() - starttime
             ) * 1000
 
     def write_err(self, *args, **opts):
         self._write(self._ferr, *args, **opts)
 
     def _write(self, dest, *args, **opts):
         # update write() as well if you touch this code
         if self._isbuffered(dest):
             label = opts.get('label', b'')
             if label and self._bufferapplylabels:
                 self._buffers[-1].extend(self.label(a, label) for a in args)
             else:
                 self._buffers[-1].extend(args)
         else:
             self._writenobuf(dest, *args, **opts)
 
     def _writenobuf(self, dest, *args, **opts):
         # update write() as well if you touch this code
         if not opts.get('keepprogressbar', False):
             self._progclear()
         msg = b''.join(args)
 
         # opencode timeblockedsection because this is a critical path
         starttime = util.timer()
         try:
             if dest is self._ferr and not getattr(self._fout, 'closed', False):
                 self._fout.flush()
             if getattr(dest, 'structured', False):
                 # channel for machine-readable output with metadata, where
                 # no extra colorization is necessary.
                 dest.write(msg, **opts)
             elif self._colormode == b'win32':
                 # windows color printing is its own can of crab, defer to
                 # the color module and that is it.
                 color.win32print(self, dest.write, msg, **opts)
             else:
                 if self._colormode is not None:
                     label = opts.get('label', b'')
                     msg = self.label(msg, label)
                 dest.write(msg)
             # stderr may be buffered under win32 when redirected to files,
             # including stdout.
             if dest is self._ferr and not getattr(dest, 'closed', False):
                 dest.flush()
         except IOError as err:
             if dest is self._ferr and err.errno in (
                 errno.EPIPE,
                 errno.EIO,
                 errno.EBADF,
             ):
                 # no way to report the error, so ignore it
                 return
             raise error.StdioError(err)
         finally:
             self._blockedtimes[b'stdio_blocked'] += (
                 util.timer() - starttime
             ) * 1000
 
     def _writemsg(self, dest, *args, **opts):
         timestamp = self.showtimestamp and opts.get('type') in {
             b'debug',
             b'error',
             b'note',
             b'status',
             b'warning',
         }
         if timestamp:
             args = (
                 b'[%s] '
                 % pycompat.bytestr(datetime.datetime.now().isoformat()),
             ) + args
         _writemsgwith(self._write, dest, *args, **opts)
         if timestamp:
             dest.flush()
 
     def _writemsgnobuf(self, dest, *args, **opts):
         _writemsgwith(self._writenobuf, dest, *args, **opts)
 
     def flush(self):
         # opencode timeblockedsection because this is a critical path
         starttime = util.timer()
         try:
             try:
                 self._fout.flush()
             except IOError as err:
                 if err.errno not in (errno.EPIPE, errno.EIO, errno.EBADF):
                     raise error.StdioError(err)
             finally:
                 try:
                     self._ferr.flush()
                 except IOError as err:
                     if err.errno not in (errno.EPIPE, errno.EIO, errno.EBADF):
                         raise error.StdioError(err)
         finally:
             self._blockedtimes[b'stdio_blocked'] += (
                 util.timer() - starttime
             ) * 1000
 
     def _isatty(self, fh):
         if self.configbool(b'ui', b'nontty'):
             return False
         return procutil.isatty(fh)
 
     def protectfinout(self):
         """Duplicate ui streams and redirect original if they are stdio
 
         Returns (fin, fout) which point to the original ui fds, but may be
         copy of them. The returned streams can be considered "owned" in that
         print(), exec(), etc. never reach to them.
         """
         if self._finoutredirected:
             # if already redirected, protectstdio() would just create another
             # nullfd pair, which is equivalent to returning self._fin/_fout.
             return self._fin, self._fout
         fin, fout = procutil.protectstdio(self._fin, self._fout)
         self._finoutredirected = (fin, fout) != (self._fin, self._fout)
         return fin, fout
 
     def restorefinout(self, fin, fout):
         """Restore ui streams from possibly duplicated (fin, fout)"""
         if (fin, fout) == (self._fin, self._fout):
             return
         procutil.restorestdio(self._fin, self._fout, fin, fout)
         # protectfinout() won't create more than one duplicated streams,
         # so we can just turn the redirection flag off.
         self._finoutredirected = False
 
     @contextlib.contextmanager
     def protectedfinout(self):
         """Run code block with protected standard streams"""
         fin, fout = self.protectfinout()
         try:
             yield fin, fout
         finally:
             self.restorefinout(fin, fout)
 
     def disablepager(self):
         self._disablepager = True
 
     def pager(self, command):
         """Start a pager for subsequent command output.
 
         Commands which produce a long stream of output should call
         this function to activate the user's preferred pagination
         mechanism (which may be no pager). Calling this function
         precludes any future use of interactive functionality, such as
         prompting the user or activating curses.
 
         Args:
           command: The full, non-aliased name of the command. That is, "log"
                    not "history, "summary" not "summ", etc.
         """
         if self._disablepager or self.pageractive:
             # how pager should do is already determined
             return
 
         if not command.startswith(b'internal-always-') and (
             # explicit --pager=on (= 'internal-always-' prefix) should
             # take precedence over disabling factors below
             command in self.configlist(b'pager', b'ignore')
             or not self.configbool(b'ui', b'paginate')
             or not self.configbool(b'pager', b'attend-' + command, True)
             or encoding.environ.get(b'TERM') == b'dumb'
             # TODO: if we want to allow HGPLAINEXCEPT=pager,
             # formatted() will need some adjustment.
             or not self.formatted()
             or self.plain()
             or self._buffers
             # TODO: expose debugger-enabled on the UI object
             or b'--debugger' in pycompat.sysargv
         ):
             # We only want to paginate if the ui appears to be
             # interactive, the user didn't say HGPLAIN or
             # HGPLAINEXCEPT=pager, and the user didn't specify --debug.
             return
 
         pagercmd = self.config(b'pager', b'pager', rcutil.fallbackpager)
         if not pagercmd:
             return
 
         pagerenv = {}
         for name, value in rcutil.defaultpagerenv().items():
             if name not in encoding.environ:
                 pagerenv[name] = value
 
         self.debug(
             b'starting pager for command %s\n' % stringutil.pprint(command)
         )
         self.flush()
 
         wasformatted = self.formatted()
         if util.safehasattr(signal, b"SIGPIPE"):
             signal.signal(signal.SIGPIPE, _catchterm)
         if self._runpager(pagercmd, pagerenv):
             self.pageractive = True
             # Preserve the formatted-ness of the UI. This is important
             # because we mess with stdout, which might confuse
             # auto-detection of things being formatted.
             self.setconfig(b'ui', b'formatted', wasformatted, b'pager')
             self.setconfig(b'ui', b'interactive', False, b'pager')
 
             # If pagermode differs from color.mode, reconfigure color now that
             # pageractive is set.
             cm = self._colormode
             if cm != self.config(b'color', b'pagermode', cm):
                 color.setup(self)
         else:
             # If the pager can't be spawned in dispatch when --pager=on is
             # given, don't try again when the command runs, to avoid a duplicate
             # warning about a missing pager command.
             self.disablepager()
 
     def _runpager(self, command, env=None):
         """Actually start the pager and set up file descriptors.
 
         This is separate in part so that extensions (like chg) can
         override how a pager is invoked.
         """
         if command == b'cat':
             # Save ourselves some work.
             return False
         # If the command doesn't contain any of these characters, we
         # assume it's a binary and exec it directly. This means for
         # simple pager command configurations, we can degrade
         # gracefully and tell the user about their broken pager.
         shell = any(c in command for c in b"|&;<>()$`\\\"' \t\n*?[#~=%")
 
         if pycompat.iswindows and not shell:
             # Window's built-in `more` cannot be invoked with shell=False, but
             # its `more.com` can.  Hide this implementation detail from the
             # user so we can also get sane bad PAGER behavior.  MSYS has
             # `more.exe`, so do a cmd.exe style resolution of the executable to
             # determine which one to use.
             fullcmd = procutil.findexe(command)
             if not fullcmd:
                 self.warn(
                     _(b"missing pager command '%s', skipping pager\n") % command
                 )
                 return False
 
             command = fullcmd
 
         try:
             pager = subprocess.Popen(
                 procutil.tonativestr(command),
                 shell=shell,
                 bufsize=-1,
                 close_fds=procutil.closefds,
                 stdin=subprocess.PIPE,
                 stdout=procutil.stdout,
                 stderr=procutil.stderr,
                 env=procutil.tonativeenv(procutil.shellenviron(env)),
             )
         except OSError as e:
             if e.errno == errno.ENOENT and not shell:
                 self.warn(
                     _(b"missing pager command '%s', skipping pager\n") % command
                 )
                 return False
             raise
 
         # back up original file descriptors
         stdoutfd = os.dup(procutil.stdout.fileno())
         stderrfd = os.dup(procutil.stderr.fileno())
 
         os.dup2(pager.stdin.fileno(), procutil.stdout.fileno())
         if self._isatty(procutil.stderr):
             os.dup2(pager.stdin.fileno(), procutil.stderr.fileno())
 
         @self.atexit
         def killpager():
             if util.safehasattr(signal, b"SIGINT"):
                 signal.signal(signal.SIGINT, signal.SIG_IGN)
             # restore original fds, closing pager.stdin copies in the process
             os.dup2(stdoutfd, procutil.stdout.fileno())
             os.dup2(stderrfd, procutil.stderr.fileno())
             pager.stdin.close()
             pager.wait()
 
         return True
 
     @property
     def _exithandlers(self):
         return _reqexithandlers
 
     def atexit(self, func, *args, **kwargs):
         '''register a function to run after dispatching a request
 
         Handlers do not stay registered across request boundaries.'''
         self._exithandlers.append((func, args, kwargs))
         return func
 
     def interface(self, feature):
         """what interface to use for interactive console features?
 
         The interface is controlled by the value of `ui.interface` but also by
         the value of feature-specific configuration. For example:
 
         ui.interface.histedit = text
         ui.interface.chunkselector = curses
 
         Here the features are "histedit" and "chunkselector".
 
         The configuration above means that the default interfaces for commands
         is curses, the interface for histedit is text and the interface for
         selecting chunk is crecord (the best curses interface available).
 
         Consider the following example:
         ui.interface = curses
         ui.interface.histedit = text
 
         Then histedit will use the text interface and chunkselector will use
         the default curses interface (crecord at the moment).
         """
         alldefaults = frozenset([b"text", b"curses"])
 
         featureinterfaces = {
             b"chunkselector": [b"text", b"curses",],
             b"histedit": [b"text", b"curses",],
         }
 
         # Feature-specific interface
         if feature not in featureinterfaces.keys():
             # Programming error, not user error
             raise ValueError(b"Unknown feature requested %s" % feature)
 
         availableinterfaces = frozenset(featureinterfaces[feature])
         if alldefaults > availableinterfaces:
             # Programming error, not user error. We need a use case to
             # define the right thing to do here.
             raise ValueError(
                 b"Feature %s does not handle all default interfaces" % feature
             )
 
         if self.plain() or encoding.environ.get(b'TERM') == b'dumb':
             return b"text"
 
         # Default interface for all the features
         defaultinterface = b"text"
         i = self.config(b"ui", b"interface")
         if i in alldefaults:
             defaultinterface = i
 
         choseninterface = defaultinterface
         f = self.config(b"ui", b"interface.%s" % feature)
         if f in availableinterfaces:
             choseninterface = f
 
         if i is not None and defaultinterface != i:
             if f is not None:
                 self.warn(_(b"invalid value for ui.interface: %s\n") % (i,))
             else:
                 self.warn(
                     _(b"invalid value for ui.interface: %s (using %s)\n")
                     % (i, choseninterface)
                 )
         if f is not None and choseninterface != f:
             self.warn(
                 _(b"invalid value for ui.interface.%s: %s (using %s)\n")
                 % (feature, f, choseninterface)
             )
 
         return choseninterface
 
     def interactive(self):
         '''is interactive input allowed?
 
         An interactive session is a session where input can be reasonably read
         from `sys.stdin'. If this function returns false, any attempt to read
         from stdin should fail with an error, unless a sensible default has been
         specified.
 
         Interactiveness is triggered by the value of the `ui.interactive'
         configuration variable or - if it is unset - when `sys.stdin' points
         to a terminal device.
 
         This function refers to input only; for output, see `ui.formatted()'.
         '''
         i = self.configbool(b"ui", b"interactive")
         if i is None:
             # some environments replace stdin without implementing isatty
             # usually those are non-interactive
             return self._isatty(self._fin)
 
         return i
 
     def termwidth(self):
         '''how wide is the terminal in columns?
         '''
         if b'COLUMNS' in encoding.environ:
             try:
                 return int(encoding.environ[b'COLUMNS'])
             except ValueError:
                 pass
         return scmutil.termsize(self)[0]
 
     def formatted(self):
         '''should formatted output be used?
 
         It is often desirable to format the output to suite the output medium.
         Examples of this are truncating long lines or colorizing messages.
         However, this is not often not desirable when piping output into other
         utilities, e.g. `grep'.
 
         Formatted output is triggered by the value of the `ui.formatted'
         configuration variable or - if it is unset - when `sys.stdout' points
         to a terminal device. Please note that `ui.formatted' should be
         considered an implementation detail; it is not intended for use outside
         Mercurial or its extensions.
 
         This function refers to output only; for input, see `ui.interactive()'.
         This function always returns false when in plain mode, see `ui.plain()'.
         '''
         if self.plain():
             return False
 
         i = self.configbool(b"ui", b"formatted")
         if i is None:
             # some environments replace stdout without implementing isatty
             # usually those are non-interactive
             return self._isatty(self._fout)
 
         return i
 
     def _readline(self, prompt=b' ', promptopts=None):
         # Replacing stdin/stdout temporarily is a hard problem on Python 3
         # because they have to be text streams with *no buffering*. Instead,
         # we use rawinput() only if call_readline() will be invoked by
         # PyOS_Readline(), so no I/O will be made at Python layer.
         usereadline = (
             self._isatty(self._fin)
             and self._isatty(self._fout)
             and procutil.isstdin(self._fin)
             and procutil.isstdout(self._fout)
         )
         if usereadline:
             try:
                 # magically add command line editing support, where
                 # available
                 import readline
 
                 # force demandimport to really load the module
                 readline.read_history_file
                 # windows sometimes raises something other than ImportError
             except Exception:
                 usereadline = False
 
         if self._colormode == b'win32' or not usereadline:
             if not promptopts:
                 promptopts = {}
             self._writemsgnobuf(
                 self._fmsgout, prompt, type=b'prompt', **promptopts
             )
             self.flush()
             prompt = b' '
         else:
             prompt = self.label(prompt, b'ui.prompt') + b' '
 
         # prompt ' ' must exist; otherwise readline may delete entire line
         # - http://bugs.python.org/issue12833
         with self.timeblockedsection(b'stdio'):
             if usereadline:
                 self.flush()
                 prompt = encoding.strfromlocal(prompt)
                 line = encoding.strtolocal(pycompat.rawinput(prompt))
                 # When stdin is in binary mode on Windows, it can cause
                 # raw_input() to emit an extra trailing carriage return
                 if pycompat.oslinesep == b'\r\n' and line.endswith(b'\r'):
                     line = line[:-1]
             else:
                 self._fout.write(pycompat.bytestr(prompt))
                 self._fout.flush()
                 line = self._fin.readline()
                 if not line:
                     raise EOFError
                 line = line.rstrip(pycompat.oslinesep)
 
         return line
 
     def prompt(self, msg, default=b"y"):
         """Prompt user with msg, read response.
         If ui is not interactive, the default is returned.
         """
         return self._prompt(msg, default=default)
 
     def _prompt(self, msg, **opts):
         default = opts['default']
         if not self.interactive():
             self._writemsg(self._fmsgout, msg, b' ', type=b'prompt', **opts)
             self._writemsg(
                 self._fmsgout, default or b'', b"\n", type=b'promptecho'
             )
             return default
         try:
             r = self._readline(prompt=msg, promptopts=opts)
             if not r:
                 r = default
             if self.configbool(b'ui', b'promptecho'):
                 self._writemsg(
                     self._fmsgout, r or b'', b"\n", type=b'promptecho'
                 )
             return r
         except EOFError:
             raise error.ResponseExpected()
 
     @staticmethod
     def extractchoices(prompt):
         """Extract prompt message and list of choices from specified prompt.
 
         This returns tuple "(message, choices)", and "choices" is the
         list of tuple "(response character, text without &)".
 
         >>> ui.extractchoices(b"awake? $$ &Yes $$ &No")
         ('awake? ', [('y', 'Yes'), ('n', 'No')])
         >>> ui.extractchoices(b"line\\nbreak? $$ &Yes $$ &No")
         ('line\\nbreak? ', [('y', 'Yes'), ('n', 'No')])
         >>> ui.extractchoices(b"want lots of $$money$$?$$Ye&s$$N&o")
         ('want lots of $$money$$?', [('s', 'Yes'), ('o', 'No')])
         """
 
         # Sadly, the prompt string may have been built with a filename
         # containing "$$" so let's try to find the first valid-looking
         # prompt to start parsing. Sadly, we also can't rely on
         # choices containing spaces, ASCII, or basically anything
         # except an ampersand followed by a character.
         m = re.match(br'(?s)(.+?)\$\$([^$]*&[^ $].*)', prompt)
         msg = m.group(1)
         choices = [p.strip(b' ') for p in m.group(2).split(b'$$')]
 
         def choicetuple(s):
             ampidx = s.index(b'&')
             return s[ampidx + 1 : ampidx + 2].lower(), s.replace(b'&', b'', 1)
 
         return (msg, [choicetuple(s) for s in choices])
 
     def promptchoice(self, prompt, default=0):
         """Prompt user with a message, read response, and ensure it matches
         one of the provided choices. The prompt is formatted as follows:
 
            "would you like fries with that (Yn)? $$ &Yes $$ &No"
 
         The index of the choice is returned. Responses are case
         insensitive. If ui is not interactive, the default is
         returned.
         """
 
         msg, choices = self.extractchoices(prompt)
         resps = [r for r, t in choices]
         while True:
             r = self._prompt(msg, default=resps[default], choices=choices)
             if r.lower() in resps:
                 return resps.index(r.lower())
             # TODO: shouldn't it be a warning?
             self._writemsg(self._fmsgout, _(b"unrecognized response\n"))
 
     def getpass(self, prompt=None, default=None):
         if not self.interactive():
             return default
         try:
             self._writemsg(
                 self._fmsgerr,
                 prompt or _(b'password: '),
                 type=b'prompt',
                 password=True,
             )
             # disable getpass() only if explicitly specified. it's still valid
             # to interact with tty even if fin is not a tty.
             with self.timeblockedsection(b'stdio'):
                 if self.configbool(b'ui', b'nontty'):
                     l = self._fin.readline()
                     if not l:
                         raise EOFError
                     return l.rstrip(b'\n')
                 else:
                     return getpass.getpass('')
         except EOFError:
             raise error.ResponseExpected()
 
     def status(self, *msg, **opts):
         '''write status message to output (if ui.quiet is False)
 
         This adds an output label of "ui.status".
         '''
         if not self.quiet:
             self._writemsg(self._fmsgout, type=b'status', *msg, **opts)
 
     def warn(self, *msg, **opts):
         '''write warning message to output (stderr)
 
         This adds an output label of "ui.warning".
         '''
         self._writemsg(self._fmsgerr, type=b'warning', *msg, **opts)
 
     def error(self, *msg, **opts):
         '''write error message to output (stderr)
 
         This adds an output label of "ui.error".
         '''
         self._writemsg(self._fmsgerr, type=b'error', *msg, **opts)
 
     def note(self, *msg, **opts):
         '''write note to output (if ui.verbose is True)
 
         This adds an output label of "ui.note".
         '''
         if self.verbose:
             self._writemsg(self._fmsgout, type=b'note', *msg, **opts)
 
     def debug(self, *msg, **opts):
         '''write debug message to output (if ui.debugflag is True)
 
         This adds an output label of "ui.debug".
         '''
         if self.debugflag:
             self._writemsg(self._fmsgout, type=b'debug', *msg, **opts)
             self.log(b'debug', b'%s', b''.join(msg))
 
     # Aliases to defeat check-code.
     statusnoi18n = status
     notenoi18n = note
     warnnoi18n = warn
     writenoi18n = write
 
     def edit(
         self,
         text,
         user,
         extra=None,
         editform=None,
         pending=None,
         repopath=None,
         action=None,
     ):
         if action is None:
             self.develwarn(
                 b'action is None but will soon be a required '
                 b'parameter to ui.edit()'
             )
         extra_defaults = {
             b'prefix': b'editor',
             b'suffix': b'.txt',
         }
         if extra is not None:
             if extra.get(b'suffix') is not None:
                 self.develwarn(
                     b'extra.suffix is not None but will soon be '
                     b'ignored by ui.edit()'
                 )
             extra_defaults.update(extra)
         extra = extra_defaults
 
         if action == b'diff':
             suffix = b'.diff'
         elif action:
             suffix = b'.%s.hg.txt' % action
         else:
             suffix = extra[b'suffix']
 
         rdir = None
         if self.configbool(b'experimental', b'editortmpinhg'):
             rdir = repopath
         (fd, name) = pycompat.mkstemp(
             prefix=b'hg-' + extra[b'prefix'] + b'-', suffix=suffix, dir=rdir
         )
         try:
             with os.fdopen(fd, 'wb') as f:
                 f.write(util.tonativeeol(text))
 
             environ = {b'HGUSER': user}
             if b'transplant_source' in extra:
                 environ.update(
                     {b'HGREVISION': hex(extra[b'transplant_source'])}
                 )
             for label in (b'intermediate-source', b'source', b'rebase_source'):
                 if label in extra:
                     environ.update({b'HGREVISION': extra[label]})
                     break
             if editform:
                 environ.update({b'HGEDITFORM': editform})
             if pending:
                 environ.update({b'HG_PENDING': pending})
 
             editor = self.geteditor()
 
             self.system(
                 b"%s \"%s\"" % (editor, name),
                 environ=environ,
                 onerr=error.Abort,
                 errprefix=_(b"edit failed"),
                 blockedtag=b'editor',
             )
 
             with open(name, 'rb') as f:
                 t = util.fromnativeeol(f.read())
         finally:
             os.unlink(name)
 
         return t
 
     def system(
         self,
         cmd,
         environ=None,
         cwd=None,
         onerr=None,
         errprefix=None,
         blockedtag=None,
     ):
         '''execute shell command with appropriate output stream. command
         output will be redirected if fout is not stdout.
 
         if command fails and onerr is None, return status, else raise onerr
         object as exception.
         '''
         if blockedtag is None:
             # Long cmds tend to be because of an absolute path on cmd. Keep
             # the tail end instead
             cmdsuffix = cmd.translate(None, _keepalnum)[-85:]
             blockedtag = b'unknown_system_' + cmdsuffix
         out = self._fout
         if any(s[1] for s in self._bufferstates):
             out = self
         with self.timeblockedsection(blockedtag):
             rc = self._runsystem(cmd, environ=environ, cwd=cwd, out=out)
         if rc and onerr:
             errmsg = b'%s %s' % (
                 procutil.shellsplit(cmd)[0],
                 procutil.explainexit(rc),
             )
             if errprefix:
                 errmsg = b'%s: %s' % (errprefix, errmsg)
             raise onerr(errmsg)
         return rc
 
     def _runsystem(self, cmd, environ, cwd, out):
         """actually execute the given shell command (can be overridden by
         extensions like chg)"""
         return procutil.system(cmd, environ=environ, cwd=cwd, out=out)
 
     def traceback(self, exc=None, force=False):
         '''print exception traceback if traceback printing enabled or forced.
         only to call in exception handler. returns true if traceback
         printed.'''
         if self.tracebackflag or force:
             if exc is None:
                 exc = sys.exc_info()
             cause = getattr(exc[1], 'cause', None)
 
             if cause is not None:
                 causetb = traceback.format_tb(cause[2])
                 exctb = traceback.format_tb(exc[2])
                 exconly = traceback.format_exception_only(cause[0], cause[1])
 
                 # exclude frame where 'exc' was chained and rethrown from exctb
                 self.write_err(
                     b'Traceback (most recent call last):\n',
                     encoding.strtolocal(''.join(exctb[:-1])),
                     encoding.strtolocal(''.join(causetb)),
                     encoding.strtolocal(''.join(exconly)),
                 )
             else:
                 output = traceback.format_exception(exc[0], exc[1], exc[2])
                 self.write_err(encoding.strtolocal(''.join(output)))
         return self.tracebackflag or force
 
     def geteditor(self):
         '''return editor to use'''
         if pycompat.sysplatform == b'plan9':
             # vi is the MIPS instruction simulator on Plan 9. We
             # instead default to E to plumb commit messages to
             # avoid confusion.
             editor = b'E'
         elif pycompat.isdarwin:
             # vi on darwin is POSIX compatible to a fault, and that includes
             # exiting non-zero if you make any mistake when running an ex
             # command. Proof: `vi -c ':unknown' -c ':qa'; echo $?` produces 1,
             # while s/vi/vim/ doesn't.
             editor = b'vim'
         else:
             editor = b'vi'
         return encoding.environ.get(b"HGEDITOR") or self.config(
             b"ui", b"editor", editor
         )
 
     @util.propertycache
     def _progbar(self):
         """setup the progbar singleton to the ui object"""
         if (
             self.quiet
             or self.debugflag
             or self.configbool(b'progress', b'disable')
             or not progress.shouldprint(self)
         ):
             return None
         return getprogbar(self)
 
     def _progclear(self):
         """clear progress bar output if any. use it before any output"""
         if not haveprogbar():  # nothing loaded yet
             return
         if self._progbar is not None and self._progbar.printed:
             self._progbar.clear()
 
     def makeprogress(self, topic, unit=b"", total=None):
         """Create a progress helper for the specified topic"""
         if getattr(self._fmsgerr, 'structured', False):
             # channel for machine-readable output with metadata, just send
             # raw information
             # TODO: consider porting some useful information (e.g. estimated
             # time) from progbar. we might want to support update delay to
             # reduce the cost of transferring progress messages.
             def updatebar(topic, pos, item, unit, total):
                 self._fmsgerr.write(
                     None,
                     type=b'progress',
                     topic=topic,
                     pos=pos,
                     item=item,
                     unit=unit,
                     total=total,
                 )
 
         elif self._progbar is not None:
             updatebar = self._progbar.progress
         else:
 
             def updatebar(topic, pos, item, unit, total):
                 pass
 
         return scmutil.progress(self, updatebar, topic, unit, total)
 
     def getlogger(self, name):
         """Returns a logger of the given name; or None if not registered"""
         return self._loggers.get(name)
 
     def setlogger(self, name, logger):
         """Install logger which can be identified later by the given name
 
         More than one loggers can be registered. Use extension or module
         name to uniquely identify the logger instance.
         """
         self._loggers[name] = logger
 
     def log(self, event, msgfmt, *msgargs, **opts):
         '''hook for logging facility extensions
 
         event should be a readily-identifiable subsystem, which will
         allow filtering.
 
         msgfmt should be a newline-terminated format string to log, and
         *msgargs are %-formatted into it.
 
         **opts currently has no defined meanings.
         '''
         if not self._loggers:
             return
         activeloggers = [
             l for l in pycompat.itervalues(self._loggers) if l.tracked(event)
         ]
         if not activeloggers:
             return
         msg = msgfmt % msgargs
         opts = pycompat.byteskwargs(opts)
         # guard against recursion from e.g. ui.debug()
         registeredloggers = self._loggers
         self._loggers = {}
         try:
             for logger in activeloggers:
                 logger.log(self, event, msg, opts)
         finally:
             self._loggers = registeredloggers
 
     def label(self, msg, label):
         '''style msg based on supplied label
 
         If some color mode is enabled, this will add the necessary control
         characters to apply such color. In addition, 'debug' color mode adds
         markup showing which label affects a piece of text.
 
         ui.write(s, 'label') is equivalent to
         ui.write(ui.label(s, 'label')).
         '''
         if self._colormode is not None:
             return color.colorlabel(self, msg, label)
         return msg
 
     def develwarn(self, msg, stacklevel=1, config=None):
         """issue a developer warning message
 
         Use 'stacklevel' to report the offender some layers further up in the
         stack.
         """
         if not self.configbool(b'devel', b'all-warnings'):
             if config is None or not self.configbool(b'devel', config):
                 return
         msg = b'devel-warn: ' + msg
         stacklevel += 1  # get in develwarn
         if self.tracebackflag:
             util.debugstacktrace(msg, stacklevel, self._ferr, self._fout)
             self.log(
                 b'develwarn',
                 b'%s at:\n%s'
                 % (msg, b''.join(util.getstackframes(stacklevel))),
             )
         else:
             curframe = inspect.currentframe()
             calframe = inspect.getouterframes(curframe, 2)
             fname, lineno, fmsg = calframe[stacklevel][1:4]
             fname, fmsg = pycompat.sysbytes(fname), pycompat.sysbytes(fmsg)
             self.write_err(b'%s at: %s:%d (%s)\n' % (msg, fname, lineno, fmsg))
             self.log(
                 b'develwarn', b'%s at: %s:%d (%s)\n', msg, fname, lineno, fmsg
             )
 
             # avoid cycles
             del curframe
             del calframe
 
     def deprecwarn(self, msg, version, stacklevel=2):
         """issue a deprecation warning
 
         - msg: message explaining what is deprecated and how to upgrade,
         - version: last version where the API will be supported,
         """
         if not (
             self.configbool(b'devel', b'all-warnings')
             or self.configbool(b'devel', b'deprec-warn')
         ):
             return
         msg += (
             b"\n(compatibility will be dropped after Mercurial-%s,"
             b" update your code.)"
         ) % version
         self.develwarn(msg, stacklevel=stacklevel, config=b'deprec-warn')
 
     def exportableenviron(self):
         """The environment variables that are safe to export, e.g. through
         hgweb.
         """
         return self._exportableenviron
 
     @contextlib.contextmanager
     def configoverride(self, overrides, source=b""):
         """Context manager for temporary config overrides
         `overrides` must be a dict of the following structure:
         {(section, name) : value}"""
         backups = {}
         try:
             for (section, name), value in overrides.items():
                 backups[(section, name)] = self.backupconfig(section, name)
                 self.setconfig(section, name, value, source)
             yield
         finally:
             for __, backup in backups.items():
                 self.restoreconfig(backup)
             # just restoring ui.quiet config to the previous value is not enough
             # as it does not update ui.quiet class member
             if (b'ui', b'quiet') in overrides:
                 self.fixconfig(section=b'ui')
 
     def estimatememory(self):
         """Provide an estimate for the available system memory in Bytes.
 
         This can be overriden via ui.available-memory. It returns None, if
         no estimate can be computed.
         """
         value = self.config(b'ui', b'available-memory')
         if value is not None:
             try:
                 return util.sizetoint(value)
             except error.ParseError:
                 raise error.ConfigError(
                     _(b"ui.available-memory value is invalid ('%s')") % value
                 )
         return util._estimatememory()
 
 
 class paths(dict):
     """Represents a collection of paths and their configs.
 
     Data is initially derived from ui instances and the config files they have
     loaded.
     """
 
     def __init__(self, ui):
         dict.__init__(self)
 
         for name, loc in ui.configitems(b'paths', ignoresub=True):
             # No location is the same as not existing.
             if not loc:
                 continue
             loc, sub = ui.configsuboptions(b'paths', name)
             self[name] = path(ui, name, rawloc=loc, suboptions=sub)
 
     def getpath(self, name, default=None):
         """Return a ``path`` from a string, falling back to default.
 
         ``name`` can be a named path or locations. Locations are filesystem
         paths or URIs.
 
         Returns None if ``name`` is not a registered path, a URI, or a local
         path to a repo.
         """
         # Only fall back to default if no path was requested.
         if name is None:
             if not default:
                 default = ()
             elif not isinstance(default, (tuple, list)):
                 default = (default,)
             for k in default:
                 try:
                     return self[k]
                 except KeyError:
                     continue
             return None
 
         # Most likely empty string.
         # This may need to raise in the future.
         if not name:
             return None
 
         try:
             return self[name]
         except KeyError:
             # Try to resolve as a local path or URI.
             try:
                 # We don't pass sub-options in, so no need to pass ui instance.
                 return path(None, None, rawloc=name)
             except ValueError:
                 raise error.RepoError(_(b'repository %s does not exist') % name)
 
 
 _pathsuboptions = {}
 
 
 def pathsuboption(option, attr):
     """Decorator used to declare a path sub-option.
 
     Arguments are the sub-option name and the attribute it should set on
     ``path`` instances.
 
     The decorated function will receive as arguments a ``ui`` instance,
     ``path`` instance, and the string value of this option from the config.
     The function should return the value that will be set on the ``path``
     instance.
 
     This decorator can be used to perform additional verification of
     sub-options and to change the type of sub-options.
     """
 
     def register(func):
         _pathsuboptions[option] = (attr, func)
         return func
 
     return register
 
 
 @pathsuboption(b'pushurl', b'pushloc')
 def pushurlpathoption(ui, path, value):
     u = util.url(value)
     # Actually require a URL.
     if not u.scheme:
         ui.warn(_(b'(paths.%s:pushurl not a URL; ignoring)\n') % path.name)
         return None
 
     # Don't support the #foo syntax in the push URL to declare branch to
     # push.
     if u.fragment:
         ui.warn(
             _(
                 b'("#fragment" in paths.%s:pushurl not supported; '
                 b'ignoring)\n'
             )
             % path.name
         )
         u.fragment = None
 
     return bytes(u)
 
 
 @pathsuboption(b'pushrev', b'pushrev')
 def pushrevpathoption(ui, path, value):
     return value
 
 
 class path(object):
     """Represents an individual path and its configuration."""
 
     def __init__(self, ui, name, rawloc=None, suboptions=None):
         """Construct a path from its config options.
 
         ``ui`` is the ``ui`` instance the path is coming from.
         ``name`` is the symbolic name of the path.
         ``rawloc`` is the raw location, as defined in the config.
         ``pushloc`` is the raw locations pushes should be made to.
 
         If ``name`` is not defined, we require that the location be a) a local
         filesystem path with a .hg directory or b) a URL. If not,
         ``ValueError`` is raised.
         """
         if not rawloc:
             raise ValueError(b'rawloc must be defined')
 
         # Locations may define branches via syntax <base>#<branch>.
         u = util.url(rawloc)
         branch = None
         if u.fragment:
             branch = u.fragment
             u.fragment = None
 
         self.url = u
         self.branch = branch
 
         self.name = name
         self.rawloc = rawloc
         self.loc = b'%s' % u
 
         # When given a raw location but not a symbolic name, validate the
         # location is valid.
         if not name and not u.scheme and not self._isvalidlocalpath(self.loc):
             raise ValueError(
                 b'location is not a URL or path to a local '
                 b'repo: %s' % rawloc
             )
 
         suboptions = suboptions or {}
 
         # Now process the sub-options. If a sub-option is registered, its
         # attribute will always be present. The value will be None if there
         # was no valid sub-option.
         for suboption, (attr, func) in pycompat.iteritems(_pathsuboptions):
             if suboption not in suboptions:
                 setattr(self, attr, None)
                 continue
 
             value = func(ui, self, suboptions[suboption])
             setattr(self, attr, value)
 
     def _isvalidlocalpath(self, path):
         """Returns True if the given path is a potentially valid repository.
         This is its own function so that extensions can change the definition of
         'valid' in this case (like when pulling from a git repo into a hg
         one)."""
         try:
             return os.path.isdir(os.path.join(path, b'.hg'))
         # Python 2 may return TypeError. Python 3, ValueError.
         except (TypeError, ValueError):
             return False
 
     @property
     def suboptions(self):
         """Return sub-options and their values for this path.
 
         This is intended to be used for presentation purposes.
         """
         d = {}
         for subopt, (attr, _func) in pycompat.iteritems(_pathsuboptions):
             value = getattr(self, attr)
             if value is not None:
                 d[subopt] = value
         return d
 
 
 # we instantiate one globally shared progress bar to avoid
 # competing progress bars when multiple UI objects get created
 _progresssingleton = None
 
 
 def getprogbar(ui):
     global _progresssingleton
     if _progresssingleton is None:
         # passing 'ui' object to the singleton is fishy,
         # this is how the extension used to work but feel free to rework it.
         _progresssingleton = progress.progbar(ui)
     return _progresssingleton
 
 
 def haveprogbar():
     return _progresssingleton is not None
 
 
 def _selectmsgdests(ui):
     name = ui.config(b'ui', b'message-output')
     if name == b'channel':
         if ui.fmsg:
             return ui.fmsg, ui.fmsg
         else:
             # fall back to ferr if channel isn't ready so that status/error
             # messages can be printed
             return ui.ferr, ui.ferr
     if name == b'stdio':
         return ui.fout, ui.ferr
     if name == b'stderr':
         return ui.ferr, ui.ferr
     raise error.Abort(b'invalid ui.message-output destination: %s' % name)
 
 
 def _writemsgwith(write, dest, *args, **opts):
     """Write ui message with the given ui._write*() function
 
     The specified message type is translated to 'ui.<type>' label if the dest
     isn't a structured channel, so that the message will be colorized.
     """
     # TODO: maybe change 'type' to a mandatory option
     if 'type' in opts and not getattr(dest, 'structured', False):
         opts['label'] = opts.get('label', b'') + b' ui.%s' % opts.pop('type')
     write(dest, *args, **opts)

tests/run-tests.py

@@ -1,3780 +1,3781 b''
 #!/usr/bin/env python
 #
 # run-tests.py - Run a set of tests on Mercurial
 #
 # Copyright 2006 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.
 
 # Modifying this script is tricky because it has many modes:
 #   - serial (default) vs parallel (-jN, N > 1)
 #   - no coverage (default) vs coverage (-c, -C, -s)
 #   - temp install (default) vs specific hg script (--with-hg, --local)
 #   - tests are a mix of shell scripts and Python scripts
 #
 # If you change this script, it is recommended that you ensure you
 # haven't broken it by running it in various modes with a representative
 # sample of test scripts.  For example:
 #
 #  1) serial, no coverage, temp install:
 #      ./run-tests.py test-s*
 #  2) serial, no coverage, local hg:
 #      ./run-tests.py --local test-s*
 #  3) serial, coverage, temp install:
 #      ./run-tests.py -c test-s*
 #  4) serial, coverage, local hg:
 #      ./run-tests.py -c --local test-s*      # unsupported
 #  5) parallel, no coverage, temp install:
 #      ./run-tests.py -j2 test-s*
 #  6) parallel, no coverage, local hg:
 #      ./run-tests.py -j2 --local test-s*
 #  7) parallel, coverage, temp install:
 #      ./run-tests.py -j2 -c test-s*          # currently broken
 #  8) parallel, coverage, local install:
 #      ./run-tests.py -j2 -c --local test-s*  # unsupported (and broken)
 #  9) parallel, custom tmp dir:
 #      ./run-tests.py -j2 --tmpdir /tmp/myhgtests
 #  10) parallel, pure, tests that call run-tests:
 #      ./run-tests.py --pure `grep -l run-tests.py *.t`
 #
 # (You could use any subset of the tests: test-s* happens to match
 # enough that it's worth doing parallel runs, few enough that it
 # completes fairly quickly, includes both shell and Python scripts, and
 # includes some scripts that run daemon processes.)
 
 from __future__ import absolute_import, print_function
 
 import argparse
 import collections
 import difflib
 import distutils.version as version
 import errno
 import json
 import multiprocessing
 import os
 import platform
 import random
 import re
 import shutil
 import signal
 import socket
 import subprocess
 import sys
 import sysconfig
 import tempfile
 import threading
 import time
 import unittest
 import uuid
 import xml.dom.minidom as minidom
 
 try:
     import Queue as queue
 except ImportError:
     import queue
 
 try:
     import shlex
 
     shellquote = shlex.quote
 except (ImportError, AttributeError):
     import pipes
 
     shellquote = pipes.quote
 
 processlock = threading.Lock()
 
 pygmentspresent = False
 # ANSI color is unsupported prior to Windows 10
 if os.name != 'nt':
     try:  # is pygments installed
         import pygments
         import pygments.lexers as lexers
         import pygments.lexer as lexer
         import pygments.formatters as formatters
         import pygments.token as token
         import pygments.style as style
 
         pygmentspresent = True
         difflexer = lexers.DiffLexer()
         terminal256formatter = formatters.Terminal256Formatter()
     except ImportError:
         pass
 
 if pygmentspresent:
 
     class TestRunnerStyle(style.Style):
         default_style = ""
         skipped = token.string_to_tokentype("Token.Generic.Skipped")
         failed = token.string_to_tokentype("Token.Generic.Failed")
         skippedname = token.string_to_tokentype("Token.Generic.SName")
         failedname = token.string_to_tokentype("Token.Generic.FName")
         styles = {
             skipped: '#e5e5e5',
             skippedname: '#00ffff',
             failed: '#7f0000',
             failedname: '#ff0000',
         }
 
     class TestRunnerLexer(lexer.RegexLexer):
         testpattern = r'[\w-]+\.(t|py)(#[a-zA-Z0-9_\-\.]+)?'
         tokens = {
             'root': [
                 (r'^Skipped', token.Generic.Skipped, 'skipped'),
                 (r'^Failed ', token.Generic.Failed, 'failed'),
                 (r'^ERROR: ', token.Generic.Failed, 'failed'),
             ],
             'skipped': [
                 (testpattern, token.Generic.SName),
                 (r':.*', token.Generic.Skipped),
             ],
             'failed': [
                 (testpattern, token.Generic.FName),
                 (r'(:| ).*', token.Generic.Failed),
             ],
         }
 
     runnerformatter = formatters.Terminal256Formatter(style=TestRunnerStyle)
     runnerlexer = TestRunnerLexer()
 
 origenviron = os.environ.copy()
 
 if sys.version_info > (3, 5, 0):
     PYTHON3 = True
     xrange = range  # we use xrange in one place, and we'd rather not use range
 
     def _sys2bytes(p):
         if p is None:
             return p
         return p.encode('utf-8')
 
     def _bytes2sys(p):
         if p is None:
             return p
         return p.decode('utf-8')
 
     osenvironb = getattr(os, 'environb', None)
     if osenvironb is None:
         # Windows lacks os.environb, for instance.  A proxy over the real thing
         # instead of a copy allows the environment to be updated via bytes on
         # all platforms.
         class environbytes(object):
             def __init__(self, strenv):
                 self.__len__ = strenv.__len__
                 self.clear = strenv.clear
                 self._strenv = strenv
 
             def __getitem__(self, k):
                 v = self._strenv.__getitem__(_bytes2sys(k))
                 return _sys2bytes(v)
 
             def __setitem__(self, k, v):
                 self._strenv.__setitem__(_bytes2sys(k), _bytes2sys(v))
 
             def __delitem__(self, k):
                 self._strenv.__delitem__(_bytes2sys(k))
 
             def __contains__(self, k):
                 return self._strenv.__contains__(_bytes2sys(k))
 
             def __iter__(self):
                 return iter([_sys2bytes(k) for k in iter(self._strenv)])
 
             def get(self, k, default=None):
                 v = self._strenv.get(_bytes2sys(k), _bytes2sys(default))
                 return _sys2bytes(v)
 
             def pop(self, k, default=None):
                 v = self._strenv.pop(_bytes2sys(k), _bytes2sys(default))
                 return _sys2bytes(v)
 
         osenvironb = environbytes(os.environ)
 
     getcwdb = getattr(os, 'getcwdb')
     if not getcwdb or os.name == 'nt':
         getcwdb = lambda: _sys2bytes(os.getcwd())
 
 elif sys.version_info >= (3, 0, 0):
     print(
         '%s is only supported on Python 3.5+ and 2.7, not %s'
         % (sys.argv[0], '.'.join(str(v) for v in sys.version_info[:3]))
     )
     sys.exit(70)  # EX_SOFTWARE from `man 3 sysexit`
 else:
     PYTHON3 = False
 
     # In python 2.x, path operations are generally done using
     # bytestrings by default, so we don't have to do any extra
     # fiddling there. We define the wrapper functions anyway just to
     # help keep code consistent between platforms.
     def _sys2bytes(p):
         return p
 
     _bytes2sys = _sys2bytes
     osenvironb = os.environ
     getcwdb = os.getcwd
 
 # For Windows support
 wifexited = getattr(os, "WIFEXITED", lambda x: False)
 
 # Whether to use IPv6
 def checksocketfamily(name, port=20058):
     """return true if we can listen on localhost using family=name
 
     name should be either 'AF_INET', or 'AF_INET6'.
     port being used is okay - EADDRINUSE is considered as successful.
     """
     family = getattr(socket, name, None)
     if family is None:
         return False
     try:
         s = socket.socket(family, socket.SOCK_STREAM)
         s.bind(('localhost', port))
         s.close()
         return True
     except socket.error as exc:
         if exc.errno == errno.EADDRINUSE:
             return True
         elif exc.errno in (errno.EADDRNOTAVAIL, errno.EPROTONOSUPPORT):
             return False
         else:
             raise
     else:
         return False
 
 
 # useipv6 will be set by parseargs
 useipv6 = None
 
 
 def checkportisavailable(port):
     """return true if a port seems free to bind on localhost"""
     if useipv6:
         family = socket.AF_INET6
     else:
         family = socket.AF_INET
     try:
         s = socket.socket(family, socket.SOCK_STREAM)
         s.bind(('localhost', port))
         s.close()
         return True
     except socket.error as exc:
         if exc.errno not in (
             errno.EADDRINUSE,
             errno.EADDRNOTAVAIL,
             errno.EPROTONOSUPPORT,
         ):
             raise
     return False
 
 
 closefds = os.name == 'posix'
 
 
 def Popen4(cmd, wd, timeout, env=None):
     processlock.acquire()
     p = subprocess.Popen(
         _bytes2sys(cmd),
         shell=True,
         bufsize=-1,
         cwd=_bytes2sys(wd),
         env=env,
         close_fds=closefds,
         stdin=subprocess.PIPE,
         stdout=subprocess.PIPE,
         stderr=subprocess.STDOUT,
     )
     processlock.release()
 
     p.fromchild = p.stdout
     p.tochild = p.stdin
     p.childerr = p.stderr
 
     p.timeout = False
     if timeout:
 
         def t():
             start = time.time()
             while time.time() - start < timeout and p.returncode is None:
                 time.sleep(0.1)
             p.timeout = True
             if p.returncode is None:
                 terminate(p)
 
         threading.Thread(target=t).start()
 
     return p
 
 
 if sys.executable:
     sysexecutable = sys.executable
 elif os.environ.get('PYTHONEXECUTABLE'):
     sysexecutable = os.environ['PYTHONEXECUTABLE']
 elif os.environ.get('PYTHON'):
     sysexecutable = os.environ['PYTHON']
 else:
     raise AssertionError('Could not find Python interpreter')
 
 PYTHON = _sys2bytes(sysexecutable.replace('\\', '/'))
 IMPL_PATH = b'PYTHONPATH'
 if 'java' in sys.platform:
     IMPL_PATH = b'JYTHONPATH'
 
 default_defaults = {
     'jobs': ('HGTEST_JOBS', multiprocessing.cpu_count()),
     'timeout': ('HGTEST_TIMEOUT', 180),
     'slowtimeout': ('HGTEST_SLOWTIMEOUT', 1500),
     'port': ('HGTEST_PORT', 20059),
     'shell': ('HGTEST_SHELL', 'sh'),
 }
 
 defaults = default_defaults.copy()
 
 
 def canonpath(path):
     return os.path.realpath(os.path.expanduser(path))
 
 
 def parselistfiles(files, listtype, warn=True):
     entries = dict()
     for filename in files:
         try:
             path = os.path.expanduser(os.path.expandvars(filename))
             f = open(path, "rb")
         except IOError as err:
             if err.errno != errno.ENOENT:
                 raise
             if warn:
                 print("warning: no such %s file: %s" % (listtype, filename))
             continue
 
         for line in f.readlines():
             line = line.split(b'#', 1)[0].strip()
             if line:
                 entries[line] = filename
 
         f.close()
     return entries
 
 
 def parsettestcases(path):
     """read a .t test file, return a set of test case names
 
     If path does not exist, return an empty set.
     """
     cases = []
     try:
         with open(path, 'rb') as f:
             for l in f:
                 if l.startswith(b'#testcases '):
                     cases.append(sorted(l[11:].split()))
     except IOError as ex:
         if ex.errno != errno.ENOENT:
             raise
     return cases
 
 
 def getparser():
     """Obtain the OptionParser used by the CLI."""
     parser = argparse.ArgumentParser(usage='%(prog)s [options] [tests]')
 
     selection = parser.add_argument_group('Test Selection')
     selection.add_argument(
         '--allow-slow-tests',
         action='store_true',
         help='allow extremely slow tests',
     )
     selection.add_argument(
         "--blacklist",
         action="append",
         help="skip tests listed in the specified blacklist file",
     )
     selection.add_argument(
         "--changed",
         help="run tests that are changed in parent rev or working directory",
     )
     selection.add_argument(
         "-k", "--keywords", help="run tests matching keywords"
     )
     selection.add_argument(
         "-r", "--retest", action="store_true", help="retest failed tests"
     )
     selection.add_argument(
         "--test-list",
         action="append",
         help="read tests to run from the specified file",
     )
     selection.add_argument(
         "--whitelist",
         action="append",
         help="always run tests listed in the specified whitelist file",
     )
     selection.add_argument(
         'tests', metavar='TESTS', nargs='*', help='Tests to run'
     )
 
     harness = parser.add_argument_group('Test Harness Behavior')
     harness.add_argument(
         '--bisect-repo',
         metavar='bisect_repo',
         help=(
             "Path of a repo to bisect. Use together with " "--known-good-rev"
         ),
     )
     harness.add_argument(
         "-d",
         "--debug",
         action="store_true",
         help="debug mode: write output of test scripts to console"
         " rather than capturing and diffing it (disables timeout)",
     )
     harness.add_argument(
         "-f",
         "--first",
         action="store_true",
         help="exit on the first test failure",
     )
     harness.add_argument(
         "-i",
         "--interactive",
         action="store_true",
         help="prompt to accept changed output",
     )
     harness.add_argument(
         "-j",
         "--jobs",
         type=int,
         help="number of jobs to run in parallel"
         " (default: $%s or %d)" % defaults['jobs'],
     )
     harness.add_argument(
         "--keep-tmpdir",
         action="store_true",
         help="keep temporary directory after running tests",
     )
     harness.add_argument(
         '--known-good-rev',
         metavar="known_good_rev",
         help=(
             "Automatically bisect any failures using this "
             "revision as a known-good revision."
         ),
     )
     harness.add_argument(
         "--list-tests",
         action="store_true",
         help="list tests instead of running them",
     )
     harness.add_argument(
         "--loop", action="store_true", help="loop tests repeatedly"
     )
     harness.add_argument(
         '--random', action="store_true", help='run tests in random order'
     )
     harness.add_argument(
         '--order-by-runtime',
         action="store_true",
         help='run slowest tests first, according to .testtimes',
     )
     harness.add_argument(
         "-p",
         "--port",
         type=int,
         help="port on which servers should listen"
         " (default: $%s or %d)" % defaults['port'],
     )
     harness.add_argument(
         '--profile-runner',
         action='store_true',
         help='run statprof on run-tests',
     )
     harness.add_argument(
         "-R", "--restart", action="store_true", help="restart at last error"
     )
     harness.add_argument(
         "--runs-per-test",
         type=int,
         dest="runs_per_test",
         help="run each test N times (default=1)",
         default=1,
     )
     harness.add_argument(
         "--shell", help="shell to use (default: $%s or %s)" % defaults['shell']
     )
     harness.add_argument(
         '--showchannels', action='store_true', help='show scheduling channels'
     )
     harness.add_argument(
         "--slowtimeout",
         type=int,
         help="kill errant slow tests after SLOWTIMEOUT seconds"
         " (default: $%s or %d)" % defaults['slowtimeout'],
     )
     harness.add_argument(
         "-t",
         "--timeout",
         type=int,
         help="kill errant tests after TIMEOUT seconds"
         " (default: $%s or %d)" % defaults['timeout'],
     )
     harness.add_argument(
         "--tmpdir",
         help="run tests in the given temporary directory"
         " (implies --keep-tmpdir)",
     )
     harness.add_argument(
         "-v", "--verbose", action="store_true", help="output verbose messages"
     )
 
     hgconf = parser.add_argument_group('Mercurial Configuration')
     hgconf.add_argument(
         "--chg",
         action="store_true",
         help="install and use chg wrapper in place of hg",
     )
     hgconf.add_argument(
         "--chg-debug", action="store_true", help="show chg debug logs",
     )
     hgconf.add_argument("--compiler", help="compiler to build with")
     hgconf.add_argument(
         '--extra-config-opt',
         action="append",
         default=[],
         help='set the given config opt in the test hgrc',
     )
     hgconf.add_argument(
         "-l",
         "--local",
         action="store_true",
         help="shortcut for --with-hg=<testdir>/../hg, "
         "and --with-chg=<testdir>/../contrib/chg/chg if --chg is set",
     )
     hgconf.add_argument(
         "--ipv6",
         action="store_true",
         help="prefer IPv6 to IPv4 for network related tests",
     )
     hgconf.add_argument(
         "--pure",
         action="store_true",
         help="use pure Python code instead of C extensions",
     )
     hgconf.add_argument(
         "--rust",
         action="store_true",
         help="use Rust code alongside C extensions",
     )
     hgconf.add_argument(
         "--no-rust",
         action="store_true",
         help="do not use Rust code even if compiled",
     )
     hgconf.add_argument(
         "--with-chg",
         metavar="CHG",
         help="use specified chg wrapper in place of hg",
     )
     hgconf.add_argument(
         "--with-hg",
         metavar="HG",
         help="test using specified hg script rather than a "
         "temporary installation",
     )
 
     reporting = parser.add_argument_group('Results Reporting')
     reporting.add_argument(
         "-C",
         "--annotate",
         action="store_true",
         help="output files annotated with coverage",
     )
     reporting.add_argument(
         "--color",
         choices=["always", "auto", "never"],
         default=os.environ.get('HGRUNTESTSCOLOR', 'auto'),
         help="colorisation: always|auto|never (default: auto)",
     )
     reporting.add_argument(
         "-c",
         "--cover",
         action="store_true",
         help="print a test coverage report",
     )
     reporting.add_argument(
         '--exceptions',
         action='store_true',
         help='log all exceptions and generate an exception report',
     )
     reporting.add_argument(
         "-H",
         "--htmlcov",
         action="store_true",
         help="create an HTML report of the coverage of the files",
     )
     reporting.add_argument(
         "--json",
         action="store_true",
         help="store test result data in 'report.json' file",
     )
     reporting.add_argument(
         "--outputdir",
         help="directory to write error logs to (default=test directory)",
     )
     reporting.add_argument(
         "-n", "--nodiff", action="store_true", help="skip showing test changes"
     )
     reporting.add_argument(
         "-S",
         "--noskips",
         action="store_true",
         help="don't report skip tests verbosely",
     )
     reporting.add_argument(
         "--time", action="store_true", help="time how long each test takes"
     )
     reporting.add_argument("--view", help="external diff viewer")
     reporting.add_argument(
         "--xunit", help="record xunit results at specified path"
     )
 
     for option, (envvar, default) in defaults.items():
         defaults[option] = type(default)(os.environ.get(envvar, default))
     parser.set_defaults(**defaults)
 
     return parser
 
 
 def parseargs(args, parser):
     """Parse arguments with our OptionParser and validate results."""
     options = parser.parse_args(args)
 
     # jython is always pure
     if 'java' in sys.platform or '__pypy__' in sys.modules:
         options.pure = True
 
     if platform.python_implementation() != 'CPython' and options.rust:
         parser.error('Rust extensions are only available with CPython')
 
     if options.pure and options.rust:
         parser.error('--rust cannot be used with --pure')
 
     if options.rust and options.no_rust:
         parser.error('--rust cannot be used with --no-rust')
 
     if options.local:
         if options.with_hg or options.with_chg:
             parser.error('--local cannot be used with --with-hg or --with-chg')
         testdir = os.path.dirname(_sys2bytes(canonpath(sys.argv[0])))
         reporootdir = os.path.dirname(testdir)
         pathandattrs = [(b'hg', 'with_hg')]
         if options.chg:
             pathandattrs.append((b'contrib/chg/chg', 'with_chg'))
         for relpath, attr in pathandattrs:
             binpath = os.path.join(reporootdir, relpath)
             if os.name != 'nt' and not os.access(binpath, os.X_OK):
                 parser.error(
                     '--local specified, but %r not found or '
                     'not executable' % binpath
                 )
             setattr(options, attr, _bytes2sys(binpath))
 
     if options.with_hg:
         options.with_hg = canonpath(_sys2bytes(options.with_hg))
         if not (
             os.path.isfile(options.with_hg)
             and os.access(options.with_hg, os.X_OK)
         ):
             parser.error('--with-hg must specify an executable hg script')
         if os.path.basename(options.with_hg) not in [b'hg', b'hg.exe']:
             sys.stderr.write('warning: --with-hg should specify an hg script\n')
             sys.stderr.flush()
 
     if (options.chg or options.with_chg) and os.name == 'nt':
         parser.error('chg does not work on %s' % os.name)
     if options.with_chg:
         options.chg = False  # no installation to temporary location
         options.with_chg = canonpath(_sys2bytes(options.with_chg))
         if not (
             os.path.isfile(options.with_chg)
             and os.access(options.with_chg, os.X_OK)
         ):
             parser.error('--with-chg must specify a chg executable')
     if options.chg and options.with_hg:
         # chg shares installation location with hg
         parser.error(
             '--chg does not work when --with-hg is specified '
             '(use --with-chg instead)'
         )
 
     if options.color == 'always' and not pygmentspresent:
         sys.stderr.write(
             'warning: --color=always ignored because '
             'pygments is not installed\n'
         )
 
     if options.bisect_repo and not options.known_good_rev:
         parser.error("--bisect-repo cannot be used without --known-good-rev")
 
     global useipv6
     if options.ipv6:
         useipv6 = checksocketfamily('AF_INET6')
     else:
         # only use IPv6 if IPv4 is unavailable and IPv6 is available
         useipv6 = (not checksocketfamily('AF_INET')) and checksocketfamily(
             'AF_INET6'
         )
 
     options.anycoverage = options.cover or options.annotate or options.htmlcov
     if options.anycoverage:
         try:
             import coverage
 
             covver = version.StrictVersion(coverage.__version__).version
             if covver < (3, 3):
                 parser.error('coverage options require coverage 3.3 or later')
         except ImportError:
             parser.error('coverage options now require the coverage package')
 
     if options.anycoverage and options.local:
         # this needs some path mangling somewhere, I guess
         parser.error(
             "sorry, coverage options do not work when --local " "is specified"
         )
 
     if options.anycoverage and options.with_hg:
         parser.error(
             "sorry, coverage options do not work when --with-hg " "is specified"
         )
 
     global verbose
     if options.verbose:
         verbose = ''
 
     if options.tmpdir:
         options.tmpdir = canonpath(options.tmpdir)
 
     if options.jobs < 1:
         parser.error('--jobs must be positive')
     if options.interactive and options.debug:
         parser.error("-i/--interactive and -d/--debug are incompatible")
     if options.debug:
         if options.timeout != defaults['timeout']:
             sys.stderr.write('warning: --timeout option ignored with --debug\n')
         if options.slowtimeout != defaults['slowtimeout']:
             sys.stderr.write(
                 'warning: --slowtimeout option ignored with --debug\n'
             )
         options.timeout = 0
         options.slowtimeout = 0
 
     if options.blacklist:
         options.blacklist = parselistfiles(options.blacklist, 'blacklist')
     if options.whitelist:
         options.whitelisted = parselistfiles(options.whitelist, 'whitelist')
     else:
         options.whitelisted = {}
 
     if options.showchannels:
         options.nodiff = True
 
     return options
 
 
 def rename(src, dst):
     """Like os.rename(), trade atomicity and opened files friendliness
     for existing destination support.
     """
     shutil.copy(src, dst)
     os.remove(src)
 
 
 def makecleanable(path):
     """Try to fix directory permission recursively so that the entire tree
     can be deleted"""
     for dirpath, dirnames, _filenames in os.walk(path, topdown=True):
         for d in dirnames:
             p = os.path.join(dirpath, d)
             try:
                 os.chmod(p, os.stat(p).st_mode & 0o777 | 0o700)  # chmod u+rwx
             except OSError:
                 pass
 
 
 _unified_diff = difflib.unified_diff
 if PYTHON3:
     import functools
 
     _unified_diff = functools.partial(difflib.diff_bytes, difflib.unified_diff)
 
 
 def getdiff(expected, output, ref, err):
     servefail = False
     lines = []
     for line in _unified_diff(expected, output, ref, err):
         if line.startswith(b'+++') or line.startswith(b'---'):
             line = line.replace(b'\\', b'/')
             if line.endswith(b' \n'):
                 line = line[:-2] + b'\n'
         lines.append(line)
         if not servefail and line.startswith(
             b'+  abort: child process failed to start'
         ):
             servefail = True
 
     return servefail, lines
 
 
 verbose = False
 
 
 def vlog(*msg):
     """Log only when in verbose mode."""
     if verbose is False:
         return
 
     return log(*msg)
 
 
 # Bytes that break XML even in a CDATA block: control characters 0-31
 # sans \t, \n and \r
 CDATA_EVIL = re.compile(br"[\000-\010\013\014\016-\037]")
 
 # Match feature conditionalized output lines in the form, capturing the feature
 # list in group 2, and the preceeding line output in group 1:
 #
 #   output..output (feature !)\n
 optline = re.compile(br'(.*) \((.+?) !\)\n$')
 
 
 def cdatasafe(data):
     """Make a string safe to include in a CDATA block.
 
     Certain control characters are illegal in a CDATA block, and
     there's no way to include a ]]> in a CDATA either. This function
     replaces illegal bytes with ? and adds a space between the ]] so
     that it won't break the CDATA block.
     """
     return CDATA_EVIL.sub(b'?', data).replace(b']]>', b'] ]>')
 
 
 def log(*msg):
     """Log something to stdout.
 
     Arguments are strings to print.
     """
     with iolock:
         if verbose:
             print(verbose, end=' ')
         for m in msg:
             print(m, end=' ')
         print()
         sys.stdout.flush()
 
 
 def highlightdiff(line, color):
     if not color:
         return line
     assert pygmentspresent
     return pygments.highlight(
         line.decode('latin1'), difflexer, terminal256formatter
     ).encode('latin1')
 
 
 def highlightmsg(msg, color):
     if not color:
         return msg
     assert pygmentspresent
     return pygments.highlight(msg, runnerlexer, runnerformatter)
 
 
 def terminate(proc):
     """Terminate subprocess"""
     vlog('# Terminating process %d' % proc.pid)
     try:
         proc.terminate()
     except OSError:
         pass
 
 
 def killdaemons(pidfile):
     import killdaemons as killmod
 
     return killmod.killdaemons(pidfile, tryhard=False, remove=True, logfn=vlog)
 
 
 class Test(unittest.TestCase):
     """Encapsulates a single, runnable test.
 
     While this class conforms to the unittest.TestCase API, it differs in that
     instances need to be instantiated manually. (Typically, unittest.TestCase
     classes are instantiated automatically by scanning modules.)
     """
 
     # Status code reserved for skipped tests (used by hghave).
     SKIPPED_STATUS = 80
 
     def __init__(
         self,
         path,
         outputdir,
         tmpdir,
         keeptmpdir=False,
         debug=False,
         first=False,
         timeout=None,
         startport=None,
         extraconfigopts=None,
         shell=None,
         hgcommand=None,
         slowtimeout=None,
         usechg=False,
         chgdebug=False,
         useipv6=False,
     ):
         """Create a test from parameters.
 
         path is the full path to the file defining the test.
 
         tmpdir is the main temporary directory to use for this test.
 
         keeptmpdir determines whether to keep the test's temporary directory
         after execution. It defaults to removal (False).
 
         debug mode will make the test execute verbosely, with unfiltered
         output.
 
         timeout controls the maximum run time of the test. It is ignored when
         debug is True. See slowtimeout for tests with #require slow.
 
         slowtimeout overrides timeout if the test has #require slow.
 
         startport controls the starting port number to use for this test. Each
         test will reserve 3 port numbers for execution. It is the caller's
         responsibility to allocate a non-overlapping port range to Test
         instances.
 
         extraconfigopts is an iterable of extra hgrc config options. Values
         must have the form "key=value" (something understood by hgrc). Values
         of the form "foo.key=value" will result in "[foo] key=value".
 
         shell is the shell to execute tests in.
         """
         if timeout is None:
             timeout = defaults['timeout']
         if startport is None:
             startport = defaults['port']
         if slowtimeout is None:
             slowtimeout = defaults['slowtimeout']
         self.path = path
         self.relpath = os.path.relpath(path)
         self.bname = os.path.basename(path)
         self.name = _bytes2sys(self.bname)
         self._testdir = os.path.dirname(path)
         self._outputdir = outputdir
         self._tmpname = os.path.basename(path)
         self.errpath = os.path.join(self._outputdir, b'%s.err' % self.bname)
 
         self._threadtmp = tmpdir
         self._keeptmpdir = keeptmpdir
         self._debug = debug
         self._first = first
         self._timeout = timeout
         self._slowtimeout = slowtimeout
         self._startport = startport
         self._extraconfigopts = extraconfigopts or []
         self._shell = _sys2bytes(shell)
         self._hgcommand = hgcommand or b'hg'
         self._usechg = usechg
         self._chgdebug = chgdebug
         self._useipv6 = useipv6
 
         self._aborted = False
         self._daemonpids = []
         self._finished = None
         self._ret = None
         self._out = None
         self._skipped = None
         self._testtmp = None
         self._chgsockdir = None
 
         self._refout = self.readrefout()
 
     def readrefout(self):
         """read reference output"""
         # If we're not in --debug mode and reference output file exists,
         # check test output against it.
         if self._debug:
             return None  # to match "out is None"
         elif os.path.exists(self.refpath):
             with open(self.refpath, 'rb') as f:
                 return f.read().splitlines(True)
         else:
             return []
 
     # needed to get base class __repr__ running
     @property
     def _testMethodName(self):
         return self.name
 
     def __str__(self):
         return self.name
 
     def shortDescription(self):
         return self.name
 
     def setUp(self):
         """Tasks to perform before run()."""
         self._finished = False
         self._ret = None
         self._out = None
         self._skipped = None
 
         try:
             os.mkdir(self._threadtmp)
         except OSError as e:
             if e.errno != errno.EEXIST:
                 raise
 
         name = self._tmpname
         self._testtmp = os.path.join(self._threadtmp, name)
         os.mkdir(self._testtmp)
 
         # Remove any previous output files.
         if os.path.exists(self.errpath):
             try:
                 os.remove(self.errpath)
             except OSError as e:
                 # We might have raced another test to clean up a .err
                 # file, so ignore ENOENT when removing a previous .err
                 # file.
                 if e.errno != errno.ENOENT:
                     raise
 
         if self._usechg:
             self._chgsockdir = os.path.join(
                 self._threadtmp, b'%s.chgsock' % name
             )
             os.mkdir(self._chgsockdir)
 
     def run(self, result):
         """Run this test and report results against a TestResult instance."""
         # This function is extremely similar to unittest.TestCase.run(). Once
         # we require Python 2.7 (or at least its version of unittest), this
         # function can largely go away.
         self._result = result
         result.startTest(self)
         try:
             try:
                 self.setUp()
             except (KeyboardInterrupt, SystemExit):
                 self._aborted = True
                 raise
             except Exception:
                 result.addError(self, sys.exc_info())
                 return
 
             success = False
             try:
                 self.runTest()
             except KeyboardInterrupt:
                 self._aborted = True
                 raise
             except unittest.SkipTest as e:
                 result.addSkip(self, str(e))
                 # The base class will have already counted this as a
                 # test we "ran", but we want to exclude skipped tests
                 # from those we count towards those run.
                 result.testsRun -= 1
             except self.failureException as e:
                 # This differs from unittest in that we don't capture
                 # the stack trace. This is for historical reasons and
                 # this decision could be revisited in the future,
                 # especially for PythonTest instances.
                 if result.addFailure(self, str(e)):
                     success = True
             except Exception:
                 result.addError(self, sys.exc_info())
             else:
                 success = True
 
             try:
                 self.tearDown()
             except (KeyboardInterrupt, SystemExit):
                 self._aborted = True
                 raise
             except Exception:
                 result.addError(self, sys.exc_info())
                 success = False
 
             if success:
                 result.addSuccess(self)
         finally:
             result.stopTest(self, interrupted=self._aborted)
 
     def runTest(self):
         """Run this test instance.
 
         This will return a tuple describing the result of the test.
         """
         env = self._getenv()
         self._genrestoreenv(env)
         self._daemonpids.append(env['DAEMON_PIDS'])
         self._createhgrc(env['HGRCPATH'])
 
         vlog('# Test', self.name)
 
         ret, out = self._run(env)
         self._finished = True
         self._ret = ret
         self._out = out
 
         def describe(ret):
             if ret < 0:
                 return 'killed by signal: %d' % -ret
             return 'returned error code %d' % ret
 
         self._skipped = False
 
         if ret == self.SKIPPED_STATUS:
             if out is None:  # Debug mode, nothing to parse.
                 missing = ['unknown']
                 failed = None
             else:
                 missing, failed = TTest.parsehghaveoutput(out)
 
             if not missing:
                 missing = ['skipped']
 
             if failed:
                 self.fail('hg have failed checking for %s' % failed[-1])
             else:
                 self._skipped = True
                 raise unittest.SkipTest(missing[-1])
         elif ret == 'timeout':
             self.fail('timed out')
         elif ret is False:
             self.fail('no result code from test')
         elif out != self._refout:
             # Diff generation may rely on written .err file.
             if (
                 (ret != 0 or out != self._refout)
                 and not self._skipped
                 and not self._debug
             ):
                 with open(self.errpath, 'wb') as f:
                     for line in out:
                         f.write(line)
 
             # The result object handles diff calculation for us.
             with firstlock:
                 if self._result.addOutputMismatch(self, ret, out, self._refout):
                     # change was accepted, skip failing
                     return
                 if self._first:
                     global firsterror
                     firsterror = True
 
             if ret:
                 msg = 'output changed and ' + describe(ret)
             else:
                 msg = 'output changed'
 
             self.fail(msg)
         elif ret:
             self.fail(describe(ret))
 
     def tearDown(self):
         """Tasks to perform after run()."""
         for entry in self._daemonpids:
             killdaemons(entry)
         self._daemonpids = []
 
         if self._keeptmpdir:
             log(
                 '\nKeeping testtmp dir: %s\nKeeping threadtmp dir: %s'
                 % (_bytes2sys(self._testtmp), _bytes2sys(self._threadtmp),)
             )
         else:
             try:
                 shutil.rmtree(self._testtmp)
             except OSError:
                 # unreadable directory may be left in $TESTTMP; fix permission
                 # and try again
                 makecleanable(self._testtmp)
                 shutil.rmtree(self._testtmp, True)
             shutil.rmtree(self._threadtmp, True)
 
         if self._usechg:
             # chgservers will stop automatically after they find the socket
             # files are deleted
             shutil.rmtree(self._chgsockdir, True)
 
         if (
             (self._ret != 0 or self._out != self._refout)
             and not self._skipped
             and not self._debug
             and self._out
         ):
             with open(self.errpath, 'wb') as f:
                 for line in self._out:
                     f.write(line)
 
         vlog("# Ret was:", self._ret, '(%s)' % self.name)
 
     def _run(self, env):
         # This should be implemented in child classes to run tests.
         raise unittest.SkipTest('unknown test type')
 
     def abort(self):
         """Terminate execution of this test."""
         self._aborted = True
 
     def _portmap(self, i):
         offset = b'' if i == 0 else b'%d' % i
         return (br':%d\b' % (self._startport + i), b':$HGPORT%s' % offset)
 
     def _getreplacements(self):
         """Obtain a mapping of text replacements to apply to test output.
 
         Test output needs to be normalized so it can be compared to expected
         output. This function defines how some of that normalization will
         occur.
         """
         r = [
             # This list should be parallel to defineport in _getenv
             self._portmap(0),
             self._portmap(1),
             self._portmap(2),
             (br'([^0-9])%s' % re.escape(self._localip()), br'\1$LOCALIP'),
             (br'\bHG_TXNID=TXN:[a-f0-9]{40}\b', br'HG_TXNID=TXN:$ID$'),
         ]
         r.append((self._escapepath(self._testtmp), b'$TESTTMP'))
 
         replacementfile = os.path.join(self._testdir, b'common-pattern.py')
 
         if os.path.exists(replacementfile):
             data = {}
             with open(replacementfile, mode='rb') as source:
                 # the intermediate 'compile' step help with debugging
                 code = compile(source.read(), replacementfile, 'exec')
                 exec(code, data)
                 for value in data.get('substitutions', ()):
                     if len(value) != 2:
                         msg = 'malformatted substitution in %s: %r'
                         msg %= (replacementfile, value)
                         raise ValueError(msg)
                     r.append(value)
         return r
 
     def _escapepath(self, p):
         if os.name == 'nt':
             return b''.join(
                 c.isalpha()
                 and b'[%s%s]' % (c.lower(), c.upper())
                 or c in b'/\\'
                 and br'[/\\]'
                 or c.isdigit()
                 and c
                 or b'\\' + c
                 for c in [p[i : i + 1] for i in range(len(p))]
             )
         else:
             return re.escape(p)
 
     def _localip(self):
         if self._useipv6:
             return b'::1'
         else:
             return b'127.0.0.1'
 
     def _genrestoreenv(self, testenv):
         """Generate a script that can be used by tests to restore the original
         environment."""
         # Put the restoreenv script inside self._threadtmp
         scriptpath = os.path.join(self._threadtmp, b'restoreenv.sh')
         testenv['HGTEST_RESTOREENV'] = _bytes2sys(scriptpath)
 
         # Only restore environment variable names that the shell allows
         # us to export.
         name_regex = re.compile('^[a-zA-Z][a-zA-Z0-9_]*$')
 
         # Do not restore these variables; otherwise tests would fail.
         reqnames = {'PYTHON', 'TESTDIR', 'TESTTMP'}
 
         with open(scriptpath, 'w') as envf:
             for name, value in origenviron.items():
                 if not name_regex.match(name):
                     # Skip environment variables with unusual names not
                     # allowed by most shells.
                     continue
                 if name in reqnames:
                     continue
                 envf.write('%s=%s\n' % (name, shellquote(value)))
 
             for name in testenv:
                 if name in origenviron or name in reqnames:
                     continue
                 envf.write('unset %s\n' % (name,))
 
     def _getenv(self):
         """Obtain environment variables to use during test execution."""
 
         def defineport(i):
             offset = '' if i == 0 else '%s' % i
             env["HGPORT%s" % offset] = '%s' % (self._startport + i)
 
         env = os.environ.copy()
         env['PYTHONUSERBASE'] = sysconfig.get_config_var('userbase') or ''
         env['HGEMITWARNINGS'] = '1'
         env['TESTTMP'] = _bytes2sys(self._testtmp)
         env['TESTNAME'] = self.name
         env['HOME'] = _bytes2sys(self._testtmp)
         formated_timeout = _bytes2sys(b"%d" % default_defaults['timeout'][1])
         env['HGTEST_TIMEOUT_DEFAULT'] = formated_timeout
         env['HGTEST_TIMEOUT'] = _bytes2sys(b"%d" % self._timeout)
         # This number should match portneeded in _getport
         for port in xrange(3):
             # This list should be parallel to _portmap in _getreplacements
             defineport(port)
         env["HGRCPATH"] = _bytes2sys(os.path.join(self._threadtmp, b'.hgrc'))
         env["DAEMON_PIDS"] = _bytes2sys(
             os.path.join(self._threadtmp, b'daemon.pids')
         )
         env["HGEDITOR"] = (
             '"' + sysexecutable + '"' + ' -c "import sys; sys.exit(0)"'
         )
         env["HGUSER"] = "test"
         env["HGENCODING"] = "ascii"
         env["HGENCODINGMODE"] = "strict"
         env["HGHOSTNAME"] = "test-hostname"
         env['HGIPV6'] = str(int(self._useipv6))
         # See contrib/catapipe.py for how to use this functionality.
         if 'HGTESTCATAPULTSERVERPIPE' not in env:
             # If we don't have HGTESTCATAPULTSERVERPIPE explicitly set, pull the
             # non-test one in as a default, otherwise set to devnull
             env['HGTESTCATAPULTSERVERPIPE'] = env.get(
                 'HGCATAPULTSERVERPIPE', os.devnull
             )
 
         extraextensions = []
         for opt in self._extraconfigopts:
             section, key = _sys2bytes(opt).split(b'.', 1)
             if section != 'extensions':
                 continue
             name = key.split(b'=', 1)[0]
             extraextensions.append(name)
 
         if extraextensions:
             env['HGTESTEXTRAEXTENSIONS'] = b' '.join(extraextensions)
 
         # LOCALIP could be ::1 or 127.0.0.1. Useful for tests that require raw
         # IP addresses.
         env['LOCALIP'] = _bytes2sys(self._localip())
 
         # This has the same effect as Py_LegacyWindowsStdioFlag in exewrapper.c,
         # but this is needed for testing python instances like dummyssh,
         # dummysmtpd.py, and dumbhttp.py.
         if PYTHON3 and os.name == 'nt':
             env['PYTHONLEGACYWINDOWSSTDIO'] = '1'
 
         # Modified HOME in test environment can confuse Rust tools. So set
         # CARGO_HOME and RUSTUP_HOME automatically if a Rust toolchain is
         # present and these variables aren't already defined.
         cargo_home_path = os.path.expanduser('~/.cargo')
         rustup_home_path = os.path.expanduser('~/.rustup')
 
         if os.path.exists(cargo_home_path) and b'CARGO_HOME' not in osenvironb:
             env['CARGO_HOME'] = cargo_home_path
         if (
             os.path.exists(rustup_home_path)
             and b'RUSTUP_HOME' not in osenvironb
         ):
             env['RUSTUP_HOME'] = rustup_home_path
 
         # Reset some environment variables to well-known values so that
         # the tests produce repeatable output.
         env['LANG'] = env['LC_ALL'] = env['LANGUAGE'] = 'C'
         env['TZ'] = 'GMT'
         env["EMAIL"] = "Foo Bar <[e-mail]>"
         env['COLUMNS'] = '80'
         env['TERM'] = 'xterm'
 
         dropped = [
             'CDPATH',
             'CHGDEBUG',
             'EDITOR',
             'GREP_OPTIONS',
             'HG',
             'HGMERGE',
             'HGPLAIN',
             'HGPLAINEXCEPT',
             'HGPROF',
             'http_proxy',
             'no_proxy',
             'NO_PROXY',
             'PAGER',
             'VISUAL',
         ]
 
         for k in dropped:
             if k in env:
                 del env[k]
 
         # unset env related to hooks
         for k in list(env):
             if k.startswith('HG_'):
                 del env[k]
 
         if self._usechg:
             env['CHGSOCKNAME'] = os.path.join(self._chgsockdir, b'server')
         if self._chgdebug:
             env['CHGDEBUG'] = 'true'
 
         return env
 
     def _createhgrc(self, path):
         """Create an hgrc file for this test."""
         with open(path, 'wb') as hgrc:
             hgrc.write(b'[ui]\n')
             hgrc.write(b'slash = True\n')
             hgrc.write(b'interactive = False\n')
+            hgrc.write(b'detailed-exit-code = True\n')
             hgrc.write(b'merge = internal:merge\n')
             hgrc.write(b'mergemarkers = detailed\n')
             hgrc.write(b'promptecho = True\n')
             hgrc.write(b'[defaults]\n')
             hgrc.write(b'[devel]\n')
             hgrc.write(b'all-warnings = true\n')
             hgrc.write(b'default-date = 0 0\n')
             hgrc.write(b'[largefiles]\n')
             hgrc.write(
                 b'usercache = %s\n'
                 % (os.path.join(self._testtmp, b'.cache/largefiles'))
             )
             hgrc.write(b'[lfs]\n')
             hgrc.write(
                 b'usercache = %s\n'
                 % (os.path.join(self._testtmp, b'.cache/lfs'))
             )
             hgrc.write(b'[web]\n')
             hgrc.write(b'address = localhost\n')
             hgrc.write(b'ipv6 = %r\n' % self._useipv6)
             hgrc.write(b'server-header = testing stub value\n')
 
             for opt in self._extraconfigopts:
                 section, key = _sys2bytes(opt).split(b'.', 1)
                 assert b'=' in key, (
                     'extra config opt %s must ' 'have an = for assignment' % opt
                 )
                 hgrc.write(b'[%s]\n%s\n' % (section, key))
 
     def fail(self, msg):
         # unittest differentiates between errored and failed.
         # Failed is denoted by AssertionError (by default at least).
         raise AssertionError(msg)
 
     def _runcommand(self, cmd, env, normalizenewlines=False):
         """Run command in a sub-process, capturing the output (stdout and
         stderr).
 
         Return a tuple (exitcode, output). output is None in debug mode.
         """
         if self._debug:
             proc = subprocess.Popen(
                 _bytes2sys(cmd),
                 shell=True,
                 cwd=_bytes2sys(self._testtmp),
                 env=env,
             )
             ret = proc.wait()
             return (ret, None)
 
         proc = Popen4(cmd, self._testtmp, self._timeout, env)
 
         def cleanup():
             terminate(proc)
             ret = proc.wait()
             if ret == 0:
                 ret = signal.SIGTERM << 8
             killdaemons(env['DAEMON_PIDS'])
             return ret
 
         proc.tochild.close()
 
         try:
             output = proc.fromchild.read()
         except KeyboardInterrupt:
             vlog('# Handling keyboard interrupt')
             cleanup()
             raise
 
         ret = proc.wait()
         if wifexited(ret):
             ret = os.WEXITSTATUS(ret)
 
         if proc.timeout:
             ret = 'timeout'
 
         if ret:
             killdaemons(env['DAEMON_PIDS'])
 
         for s, r in self._getreplacements():
             output = re.sub(s, r, output)
 
         if normalizenewlines:
             output = output.replace(b'\r\n', b'\n')
 
         return ret, output.splitlines(True)
 
 
 class PythonTest(Test):
     """A Python-based test."""
 
     @property
     def refpath(self):
         return os.path.join(self._testdir, b'%s.out' % self.bname)
 
     def _run(self, env):
         # Quote the python(3) executable for Windows
         cmd = b'"%s" "%s"' % (PYTHON, self.path)
         vlog("# Running", cmd.decode("utf-8"))
         normalizenewlines = os.name == 'nt'
         result = self._runcommand(cmd, env, normalizenewlines=normalizenewlines)
         if self._aborted:
             raise KeyboardInterrupt()
 
         return result
 
 
 # Some glob patterns apply only in some circumstances, so the script
 # might want to remove (glob) annotations that otherwise should be
 # retained.
 checkcodeglobpats = [
     # On Windows it looks like \ doesn't require a (glob), but we know
     # better.
     re.compile(br'^pushing to \$TESTTMP/.*[^)]$'),
     re.compile(br'^moving \S+/.*[^)]$'),
     re.compile(br'^pulling from \$TESTTMP/.*[^)]$'),
     # Not all platforms have 127.0.0.1 as loopback (though most do),
     # so we always glob that too.
     re.compile(br'.*\$LOCALIP.*$'),
 ]
 
 bchr = chr
 if PYTHON3:
     bchr = lambda x: bytes([x])
 
 WARN_UNDEFINED = 1
 WARN_YES = 2
 WARN_NO = 3
 
 MARK_OPTIONAL = b" (?)\n"
 
 
 def isoptional(line):
     return line.endswith(MARK_OPTIONAL)
 
 
 class TTest(Test):
     """A "t test" is a test backed by a .t file."""
 
     SKIPPED_PREFIX = b'skipped: '
     FAILED_PREFIX = b'hghave check failed: '
     NEEDESCAPE = re.compile(br'[\x00-\x08\x0b-\x1f\x7f-\xff]').search
 
     ESCAPESUB = re.compile(br'[\x00-\x08\x0b-\x1f\\\x7f-\xff]').sub
     ESCAPEMAP = {bchr(i): br'\x%02x' % i for i in range(256)}
     ESCAPEMAP.update({b'\\': b'\\\\', b'\r': br'\r'})
 
     def __init__(self, path, *args, **kwds):
         # accept an extra "case" parameter
         case = kwds.pop('case', [])
         self._case = case
         self._allcases = {x for y in parsettestcases(path) for x in y}
         super(TTest, self).__init__(path, *args, **kwds)
         if case:
             casepath = b'#'.join(case)
             self.name = '%s#%s' % (self.name, _bytes2sys(casepath))
             self.errpath = b'%s#%s.err' % (self.errpath[:-4], casepath)
             self._tmpname += b'-%s' % casepath.replace(b'#', b'-')
         self._have = {}
 
     @property
     def refpath(self):
         return os.path.join(self._testdir, self.bname)
 
     def _run(self, env):
         with open(self.path, 'rb') as f:
             lines = f.readlines()
 
         # .t file is both reference output and the test input, keep reference
         # output updated with the the test input. This avoids some race
         # conditions where the reference output does not match the actual test.
         if self._refout is not None:
             self._refout = lines
 
         salt, script, after, expected = self._parsetest(lines)
 
         # Write out the generated script.
         fname = b'%s.sh' % self._testtmp
         with open(fname, 'wb') as f:
             for l in script:
                 f.write(l)
 
         cmd = b'%s "%s"' % (self._shell, fname)
         vlog("# Running", cmd.decode("utf-8"))
 
         exitcode, output = self._runcommand(cmd, env)
 
         if self._aborted:
             raise KeyboardInterrupt()
 
         # Do not merge output if skipped. Return hghave message instead.
         # Similarly, with --debug, output is None.
         if exitcode == self.SKIPPED_STATUS or output is None:
             return exitcode, output
 
         return self._processoutput(exitcode, output, salt, after, expected)
 
     def _hghave(self, reqs):
         allreqs = b' '.join(reqs)
 
         self._detectslow(reqs)
 
         if allreqs in self._have:
             return self._have.get(allreqs)
 
         # TODO do something smarter when all other uses of hghave are gone.
         runtestdir = osenvironb[b'RUNTESTDIR']
         tdir = runtestdir.replace(b'\\', b'/')
         proc = Popen4(
             b'%s -c "%s/hghave %s"' % (self._shell, tdir, allreqs),
             self._testtmp,
             0,
             self._getenv(),
         )
         stdout, stderr = proc.communicate()
         ret = proc.wait()
         if wifexited(ret):
             ret = os.WEXITSTATUS(ret)
         if ret == 2:
             print(stdout.decode('utf-8'))
             sys.exit(1)
 
         if ret != 0:
             self._have[allreqs] = (False, stdout)
             return False, stdout
 
         self._have[allreqs] = (True, None)
         return True, None
 
     def _detectslow(self, reqs):
         """update the timeout of slow test when appropriate"""
         if b'slow' in reqs:
             self._timeout = self._slowtimeout
 
     def _iftest(self, args):
         # implements "#if"
         reqs = []
         for arg in args:
             if arg.startswith(b'no-') and arg[3:] in self._allcases:
                 if arg[3:] in self._case:
                     return False
             elif arg in self._allcases:
                 if arg not in self._case:
                     return False
             else:
                 reqs.append(arg)
         self._detectslow(reqs)
         return self._hghave(reqs)[0]
 
     def _parsetest(self, lines):
         # We generate a shell script which outputs unique markers to line
         # up script results with our source. These markers include input
         # line number and the last return code.
         salt = b"SALT%d" % time.time()
 
         def addsalt(line, inpython):
             if inpython:
                 script.append(b'%s %d 0\n' % (salt, line))
             else:
                 script.append(b'echo %s %d $?\n' % (salt, line))
 
         activetrace = []
         session = str(uuid.uuid4())
         if PYTHON3:
             session = session.encode('ascii')
         hgcatapult = os.getenv('HGTESTCATAPULTSERVERPIPE') or os.getenv(
             'HGCATAPULTSERVERPIPE'
         )
 
         def toggletrace(cmd=None):
             if not hgcatapult or hgcatapult == os.devnull:
                 return
 
             if activetrace:
                 script.append(
                     b'echo END %s %s >> "$HGTESTCATAPULTSERVERPIPE"\n'
                     % (session, activetrace[0])
                 )
             if cmd is None:
                 return
 
             if isinstance(cmd, str):
                 quoted = shellquote(cmd.strip())
             else:
                 quoted = shellquote(cmd.strip().decode('utf8')).encode('utf8')
             quoted = quoted.replace(b'\\', b'\\\\')
             script.append(
                 b'echo START %s %s >> "$HGTESTCATAPULTSERVERPIPE"\n'
                 % (session, quoted)
             )
             activetrace[0:] = [quoted]
 
         script = []
 
         # After we run the shell script, we re-unify the script output
         # with non-active parts of the source, with synchronization by our
         # SALT line number markers. The after table contains the non-active
         # components, ordered by line number.
         after = {}
 
         # Expected shell script output.
         expected = {}
 
         pos = prepos = -1
 
         # True or False when in a true or false conditional section
         skipping = None
 
         # We keep track of whether or not we're in a Python block so we
         # can generate the surrounding doctest magic.
         inpython = False
 
         if self._debug:
             script.append(b'set -x\n')
         if self._hgcommand != b'hg':
             script.append(b'alias hg="%s"\n' % self._hgcommand)
         if os.getenv('MSYSTEM'):
             script.append(b'alias pwd="pwd -W"\n')
 
         if hgcatapult and hgcatapult != os.devnull:
             if PYTHON3:
                 hgcatapult = hgcatapult.encode('utf8')
                 cataname = self.name.encode('utf8')
             else:
                 cataname = self.name
 
             # Kludge: use a while loop to keep the pipe from getting
             # closed by our echo commands. The still-running file gets
             # reaped at the end of the script, which causes the while
             # loop to exit and closes the pipe. Sigh.
             script.append(
                 b'rtendtracing() {\n'
                 b'  echo END %(session)s %(name)s >> %(catapult)s\n'
                 b'  rm -f "$TESTTMP/.still-running"\n'
                 b'}\n'
                 b'trap "rtendtracing" 0\n'
                 b'touch "$TESTTMP/.still-running"\n'
                 b'while [ -f "$TESTTMP/.still-running" ]; do sleep 1; done '
                 b'> %(catapult)s &\n'
                 b'HGCATAPULTSESSION=%(session)s ; export HGCATAPULTSESSION\n'
                 b'echo START %(session)s %(name)s >> %(catapult)s\n'
                 % {
                     b'name': cataname,
                     b'session': session,
                     b'catapult': hgcatapult,
                 }
             )
 
         if self._case:
             casestr = b'#'.join(self._case)
             if isinstance(casestr, str):
                 quoted = shellquote(casestr)
             else:
                 quoted = shellquote(casestr.decode('utf8')).encode('utf8')
             script.append(b'TESTCASE=%s\n' % quoted)
             script.append(b'export TESTCASE\n')
 
         n = 0
         for n, l in enumerate(lines):
             if not l.endswith(b'\n'):
                 l += b'\n'
             if l.startswith(b'#require'):
                 lsplit = l.split()
                 if len(lsplit) < 2 or lsplit[0] != b'#require':
                     after.setdefault(pos, []).append(
                         b'  !!! invalid #require\n'
                     )
                 if not skipping:
                     haveresult, message = self._hghave(lsplit[1:])
                     if not haveresult:
                         script = [b'echo "%s"\nexit 80\n' % message]
                         break
                 after.setdefault(pos, []).append(l)
             elif l.startswith(b'#if'):
                 lsplit = l.split()
                 if len(lsplit) < 2 or lsplit[0] != b'#if':
                     after.setdefault(pos, []).append(b'  !!! invalid #if\n')
                 if skipping is not None:
                     after.setdefault(pos, []).append(b'  !!! nested #if\n')
                 skipping = not self._iftest(lsplit[1:])
                 after.setdefault(pos, []).append(l)
             elif l.startswith(b'#else'):
                 if skipping is None:
                     after.setdefault(pos, []).append(b'  !!! missing #if\n')
                 skipping = not skipping
                 after.setdefault(pos, []).append(l)
             elif l.startswith(b'#endif'):
                 if skipping is None:
                     after.setdefault(pos, []).append(b'  !!! missing #if\n')
                 skipping = None
                 after.setdefault(pos, []).append(l)
             elif skipping:
                 after.setdefault(pos, []).append(l)
             elif l.startswith(b'  >>> '):  # python inlines
                 after.setdefault(pos, []).append(l)
                 prepos = pos
                 pos = n
                 if not inpython:
                     # We've just entered a Python block. Add the header.
                     inpython = True
                     addsalt(prepos, False)  # Make sure we report the exit code.
                     script.append(b'"%s" -m heredoctest <<EOF\n' % PYTHON)
                 addsalt(n, True)
                 script.append(l[2:])
             elif l.startswith(b'  ... '):  # python inlines
                 after.setdefault(prepos, []).append(l)
                 script.append(l[2:])
             elif l.startswith(b'  $ '):  # commands
                 if inpython:
                     script.append(b'EOF\n')
                     inpython = False
                 after.setdefault(pos, []).append(l)
                 prepos = pos
                 pos = n
                 addsalt(n, False)
                 rawcmd = l[4:]
                 cmd = rawcmd.split()
                 toggletrace(rawcmd)
                 if len(cmd) == 2 and cmd[0] == b'cd':
                     rawcmd = b'cd %s || exit 1\n' % cmd[1]
                 script.append(rawcmd)
             elif l.startswith(b'  > '):  # continuations
                 after.setdefault(prepos, []).append(l)
                 script.append(l[4:])
             elif l.startswith(b'  '):  # results
                 # Queue up a list of expected results.
                 expected.setdefault(pos, []).append(l[2:])
             else:
                 if inpython:
                     script.append(b'EOF\n')
                     inpython = False
                 # Non-command/result. Queue up for merged output.
                 after.setdefault(pos, []).append(l)
 
         if inpython:
             script.append(b'EOF\n')
         if skipping is not None:
             after.setdefault(pos, []).append(b'  !!! missing #endif\n')
         addsalt(n + 1, False)
         # Need to end any current per-command trace
         if activetrace:
             toggletrace()
         return salt, script, after, expected
 
     def _processoutput(self, exitcode, output, salt, after, expected):
         # Merge the script output back into a unified test.
         warnonly = WARN_UNDEFINED  # 1: not yet; 2: yes; 3: for sure not
         if exitcode != 0:
             warnonly = WARN_NO
 
         pos = -1
         postout = []
         for out_rawline in output:
             out_line, cmd_line = out_rawline, None
             if salt in out_rawline:
                 out_line, cmd_line = out_rawline.split(salt, 1)
 
             pos, postout, warnonly = self._process_out_line(
                 out_line, pos, postout, expected, warnonly
             )
             pos, postout = self._process_cmd_line(cmd_line, pos, postout, after)
 
         if pos in after:
             postout += after.pop(pos)
 
         if warnonly == WARN_YES:
             exitcode = False  # Set exitcode to warned.
 
         return exitcode, postout
 
     def _process_out_line(self, out_line, pos, postout, expected, warnonly):
         while out_line:
             if not out_line.endswith(b'\n'):
                 out_line += b' (no-eol)\n'
 
             # Find the expected output at the current position.
             els = [None]
             if expected.get(pos, None):
                 els = expected[pos]
 
             optional = []
             for i, el in enumerate(els):
                 r = False
                 if el:
                     r, exact = self.linematch(el, out_line)
                 if isinstance(r, str):
                     if r == '-glob':
                         out_line = ''.join(el.rsplit(' (glob)', 1))
                         r = ''  # Warn only this line.
                     elif r == "retry":
                         postout.append(b'  ' + el)
                     else:
                         log('\ninfo, unknown linematch result: %r\n' % r)
                         r = False
                 if r:
                     els.pop(i)
                     break
                 if el:
                     if isoptional(el):
                         optional.append(i)
                     else:
                         m = optline.match(el)
                         if m:
                             conditions = [c for c in m.group(2).split(b' ')]
 
                             if not self._iftest(conditions):
                                 optional.append(i)
                     if exact:
                         # Don't allow line to be matches against a later
                         # line in the output
                         els.pop(i)
                         break
 
             if r:
                 if r == "retry":
                     continue
                 # clean up any optional leftovers
                 for i in optional:
                     postout.append(b'  ' + els[i])
                 for i in reversed(optional):
                     del els[i]
                 postout.append(b'  ' + el)
             else:
                 if self.NEEDESCAPE(out_line):
                     out_line = TTest._stringescape(
                         b'%s (esc)\n' % out_line.rstrip(b'\n')
                     )
                 postout.append(b'  ' + out_line)  # Let diff deal with it.
                 if r != '':  # If line failed.
                     warnonly = WARN_NO
                 elif warnonly == WARN_UNDEFINED:
                     warnonly = WARN_YES
             break
         else:
             # clean up any optional leftovers
             while expected.get(pos, None):
                 el = expected[pos].pop(0)
                 if el:
                     if not isoptional(el):
                         m = optline.match(el)
                         if m:
                             conditions = [c for c in m.group(2).split(b' ')]
 
                             if self._iftest(conditions):
                                 # Don't append as optional line
                                 continue
                         else:
                             continue
                 postout.append(b'  ' + el)
         return pos, postout, warnonly
 
     def _process_cmd_line(self, cmd_line, pos, postout, after):
         """process a "command" part of a line from unified test output"""
         if cmd_line:
             # Add on last return code.
             ret = int(cmd_line.split()[1])
             if ret != 0:
                 postout.append(b'  [%d]\n' % ret)
             if pos in after:
                 # Merge in non-active test bits.
                 postout += after.pop(pos)
             pos = int(cmd_line.split()[0])
         return pos, postout
 
     @staticmethod
     def rematch(el, l):
         try:
             # parse any flags at the beginning of the regex. Only 'i' is
             # supported right now, but this should be easy to extend.
             flags, el = re.match(br'^(\(\?i\))?(.*)', el).groups()[0:2]
             flags = flags or b''
             el = flags + b'(?:' + el + b')'
             # use \Z to ensure that the regex matches to the end of the string
             if os.name == 'nt':
                 return re.match(el + br'\r?\n\Z', l)
             return re.match(el + br'\n\Z', l)
         except re.error:
             # el is an invalid regex
             return False
 
     @staticmethod
     def globmatch(el, l):
         # The only supported special characters are * and ? plus / which also
         # matches \ on windows. Escaping of these characters is supported.
         if el + b'\n' == l:
             if os.altsep:
                 # matching on "/" is not needed for this line
                 for pat in checkcodeglobpats:
                     if pat.match(el):
                         return True
                 return b'-glob'
             return True
         el = el.replace(b'$LOCALIP', b'*')
         i, n = 0, len(el)
         res = b''
         while i < n:
             c = el[i : i + 1]
             i += 1
             if c == b'\\' and i < n and el[i : i + 1] in b'*?\\/':
                 res += el[i - 1 : i + 1]
                 i += 1
             elif c == b'*':
                 res += b'.*'
             elif c == b'?':
                 res += b'.'
             elif c == b'/' and os.altsep:
                 res += b'[/\\\\]'
             else:
                 res += re.escape(c)
         return TTest.rematch(res, l)
 
     def linematch(self, el, l):
         if el == l:  # perfect match (fast)
             return True, True
         retry = False
         if isoptional(el):
             retry = "retry"
             el = el[: -len(MARK_OPTIONAL)] + b"\n"
         else:
             m = optline.match(el)
             if m:
                 conditions = [c for c in m.group(2).split(b' ')]
 
                 el = m.group(1) + b"\n"
                 if not self._iftest(conditions):
                     # listed feature missing, should not match
                     return "retry", False
 
         if el.endswith(b" (esc)\n"):
             if PYTHON3:
                 el = el[:-7].decode('unicode_escape') + '\n'
                 el = el.encode('latin-1')
             else:
                 el = el[:-7].decode('string-escape') + '\n'
         if el == l or os.name == 'nt' and el[:-1] + b'\r\n' == l:
             return True, True
         if el.endswith(b" (re)\n"):
             return (TTest.rematch(el[:-6], l) or retry), False
         if el.endswith(b" (glob)\n"):
             # ignore '(glob)' added to l by 'replacements'
             if l.endswith(b" (glob)\n"):
                 l = l[:-8] + b"\n"
             return (TTest.globmatch(el[:-8], l) or retry), False
         if os.altsep:
             _l = l.replace(b'\\', b'/')
             if el == _l or os.name == 'nt' and el[:-1] + b'\r\n' == _l:
                 return True, True
         return retry, True
 
     @staticmethod
     def parsehghaveoutput(lines):
         '''Parse hghave log lines.
 
         Return tuple of lists (missing, failed):
           * the missing/unknown features
           * the features for which existence check failed'''
         missing = []
         failed = []
         for line in lines:
             if line.startswith(TTest.SKIPPED_PREFIX):
                 line = line.splitlines()[0]
                 missing.append(_bytes2sys(line[len(TTest.SKIPPED_PREFIX) :]))
             elif line.startswith(TTest.FAILED_PREFIX):
                 line = line.splitlines()[0]
                 failed.append(_bytes2sys(line[len(TTest.FAILED_PREFIX) :]))
 
         return missing, failed
 
     @staticmethod
     def _escapef(m):
         return TTest.ESCAPEMAP[m.group(0)]
 
     @staticmethod
     def _stringescape(s):
         return TTest.ESCAPESUB(TTest._escapef, s)
 
 
 iolock = threading.RLock()
 firstlock = threading.RLock()
 firsterror = False
 
 
 class TestResult(unittest._TextTestResult):
     """Holds results when executing via unittest."""
 
     # Don't worry too much about accessing the non-public _TextTestResult.
     # It is relatively common in Python testing tools.
     def __init__(self, options, *args, **kwargs):
         super(TestResult, self).__init__(*args, **kwargs)
 
         self._options = options
 
         # unittest.TestResult didn't have skipped until 2.7. We need to
         # polyfill it.
         self.skipped = []
 
         # We have a custom "ignored" result that isn't present in any Python
         # unittest implementation. It is very similar to skipped. It may make
         # sense to map it into skip some day.
         self.ignored = []
 
         self.times = []
         self._firststarttime = None
         # Data stored for the benefit of generating xunit reports.
         self.successes = []
         self.faildata = {}
 
         if options.color == 'auto':
             self.color = pygmentspresent and self.stream.isatty()
         elif options.color == 'never':
             self.color = False
         else:  # 'always', for testing purposes
             self.color = pygmentspresent
 
     def onStart(self, test):
         """ Can be overriden by custom TestResult
         """
 
     def onEnd(self):
         """ Can be overriden by custom TestResult
         """
 
     def addFailure(self, test, reason):
         self.failures.append((test, reason))
 
         if self._options.first:
             self.stop()
         else:
             with iolock:
                 if reason == "timed out":
                     self.stream.write('t')
                 else:
                     if not self._options.nodiff:
                         self.stream.write('\n')
                         # Exclude the '\n' from highlighting to lex correctly
                         formatted = 'ERROR: %s output changed\n' % test
                         self.stream.write(highlightmsg(formatted, self.color))
                     self.stream.write('!')
 
                 self.stream.flush()
 
     def addSuccess(self, test):
         with iolock:
             super(TestResult, self).addSuccess(test)
         self.successes.append(test)
 
     def addError(self, test, err):
         super(TestResult, self).addError(test, err)
         if self._options.first:
             self.stop()
 
     # Polyfill.
     def addSkip(self, test, reason):
         self.skipped.append((test, reason))
         with iolock:
             if self.showAll:
                 self.stream.writeln('skipped %s' % reason)
             else:
                 self.stream.write('s')
                 self.stream.flush()
 
     def addIgnore(self, test, reason):
         self.ignored.append((test, reason))
         with iolock:
             if self.showAll:
                 self.stream.writeln('ignored %s' % reason)
             else:
                 if reason not in ('not retesting', "doesn't match keyword"):
                     self.stream.write('i')
                 else:
                     self.testsRun += 1
                 self.stream.flush()
 
     def addOutputMismatch(self, test, ret, got, expected):
         """Record a mismatch in test output for a particular test."""
         if self.shouldStop or firsterror:
             # don't print, some other test case already failed and
             # printed, we're just stale and probably failed due to our
             # temp dir getting cleaned up.
             return
 
         accepted = False
         lines = []
 
         with iolock:
             if self._options.nodiff:
                 pass
             elif self._options.view:
                 v = self._options.view
                 subprocess.call(
                     r'"%s" "%s" "%s"'
                     % (v, _bytes2sys(test.refpath), _bytes2sys(test.errpath)),
                     shell=True,
                 )
             else:
                 servefail, lines = getdiff(
                     expected, got, test.refpath, test.errpath
                 )
                 self.stream.write('\n')
                 for line in lines:
                     line = highlightdiff(line, self.color)
                     if PYTHON3:
                         self.stream.flush()
                         self.stream.buffer.write(line)
                         self.stream.buffer.flush()
                     else:
                         self.stream.write(line)
                         self.stream.flush()
 
                 if servefail:
                     raise test.failureException(
                         'server failed to start (HGPORT=%s)' % test._startport
                     )
 
             # handle interactive prompt without releasing iolock
             if self._options.interactive:
                 if test.readrefout() != expected:
                     self.stream.write(
                         'Reference output has changed (run again to prompt '
                         'changes)'
                     )
                 else:
                     self.stream.write('Accept this change? [y/N] ')
                     self.stream.flush()
                     answer = sys.stdin.readline().strip()
                     if answer.lower() in ('y', 'yes'):
                         if test.path.endswith(b'.t'):
                             rename(test.errpath, test.path)
                         else:
                             rename(test.errpath, '%s.out' % test.path)
                         accepted = True
             if not accepted:
                 self.faildata[test.name] = b''.join(lines)
 
         return accepted
 
     def startTest(self, test):
         super(TestResult, self).startTest(test)
 
         # os.times module computes the user time and system time spent by
         # child's processes along with real elapsed time taken by a process.
         # This module has one limitation. It can only work for Linux user
         # and not for Windows. Hence why we fall back to another function
         # for wall time calculations.
         test.started_times = os.times()
         # TODO use a monotonic clock once support for Python 2.7 is dropped.
         test.started_time = time.time()
         if self._firststarttime is None:  # thread racy but irrelevant
             self._firststarttime = test.started_time
 
     def stopTest(self, test, interrupted=False):
         super(TestResult, self).stopTest(test)
 
         test.stopped_times = os.times()
         stopped_time = time.time()
 
         starttime = test.started_times
         endtime = test.stopped_times
         origin = self._firststarttime
         self.times.append(
             (
                 test.name,
                 endtime[2] - starttime[2],  # user space CPU time
                 endtime[3] - starttime[3],  # sys  space CPU time
                 stopped_time - test.started_time,  # real time
                 test.started_time - origin,  # start date in run context
                 stopped_time - origin,  # end date in run context
             )
         )
 
         if interrupted:
             with iolock:
                 self.stream.writeln(
                     'INTERRUPTED: %s (after %d seconds)'
                     % (test.name, self.times[-1][3])
                 )
 
 
 def getTestResult():
     """
     Returns the relevant test result
     """
     if "CUSTOM_TEST_RESULT" in os.environ:
         testresultmodule = __import__(os.environ["CUSTOM_TEST_RESULT"])
         return testresultmodule.TestResult
     else:
         return TestResult
 
 
 class TestSuite(unittest.TestSuite):
     """Custom unittest TestSuite that knows how to execute Mercurial tests."""
 
     def __init__(
         self,
         testdir,
         jobs=1,
         whitelist=None,
         blacklist=None,
         keywords=None,
         loop=False,
         runs_per_test=1,
         loadtest=None,
         showchannels=False,
         *args,
         **kwargs
     ):
         """Create a new instance that can run tests with a configuration.
 
         testdir specifies the directory where tests are executed from. This
         is typically the ``tests`` directory from Mercurial's source
         repository.
 
         jobs specifies the number of jobs to run concurrently. Each test
         executes on its own thread. Tests actually spawn new processes, so
         state mutation should not be an issue.
 
         If there is only one job, it will use the main thread.
 
         whitelist and blacklist denote tests that have been whitelisted and
         blacklisted, respectively. These arguments don't belong in TestSuite.
         Instead, whitelist and blacklist should be handled by the thing that
         populates the TestSuite with tests. They are present to preserve
         backwards compatible behavior which reports skipped tests as part
         of the results.
 
         keywords denotes key words that will be used to filter which tests
         to execute. This arguably belongs outside of TestSuite.
 
         loop denotes whether to loop over tests forever.
         """
         super(TestSuite, self).__init__(*args, **kwargs)
 
         self._jobs = jobs
         self._whitelist = whitelist
         self._blacklist = blacklist
         self._keywords = keywords
         self._loop = loop
         self._runs_per_test = runs_per_test
         self._loadtest = loadtest
         self._showchannels = showchannels
 
     def run(self, result):
         # We have a number of filters that need to be applied. We do this
         # here instead of inside Test because it makes the running logic for
         # Test simpler.
         tests = []
         num_tests = [0]
         for test in self._tests:
 
             def get():
                 num_tests[0] += 1
                 if getattr(test, 'should_reload', False):
                     return self._loadtest(test, num_tests[0])
                 return test
 
             if not os.path.exists(test.path):
                 result.addSkip(test, "Doesn't exist")
                 continue
 
             is_whitelisted = self._whitelist and (
                 test.relpath in self._whitelist or test.bname in self._whitelist
             )
             if not is_whitelisted:
                 is_blacklisted = self._blacklist and (
                     test.relpath in self._blacklist
                     or test.bname in self._blacklist
                 )
                 if is_blacklisted:
                     result.addSkip(test, 'blacklisted')
                     continue
                 if self._keywords:
                     with open(test.path, 'rb') as f:
                         t = f.read().lower() + test.bname.lower()
                     ignored = False
                     for k in self._keywords.lower().split():
                         if k not in t:
                             result.addIgnore(test, "doesn't match keyword")
                             ignored = True
                             break
 
                     if ignored:
                         continue
             for _ in xrange(self._runs_per_test):
                 tests.append(get())
 
         runtests = list(tests)
         done = queue.Queue()
         running = 0
 
         channels = [""] * self._jobs
 
         def job(test, result):
             for n, v in enumerate(channels):
                 if not v:
                     channel = n
                     break
             else:
                 raise ValueError('Could not find output channel')
             channels[channel] = "=" + test.name[5:].split(".")[0]
             try:
                 test(result)
                 done.put(None)
             except KeyboardInterrupt:
                 pass
             except:  # re-raises
                 done.put(('!', test, 'run-test raised an error, see traceback'))
                 raise
             finally:
                 try:
                     channels[channel] = ''
                 except IndexError:
                     pass
 
         def stat():
             count = 0
             while channels:
                 d = '\n%03s  ' % count
                 for n, v in enumerate(channels):
                     if v:
                         d += v[0]
                         channels[n] = v[1:] or '.'
                     else:
                         d += ' '
                     d += ' '
                 with iolock:
                     sys.stdout.write(d + '  ')
                     sys.stdout.flush()
                 for x in xrange(10):
                     if channels:
                         time.sleep(0.1)
                 count += 1
 
         stoppedearly = False
 
         if self._showchannels:
             statthread = threading.Thread(target=stat, name="stat")
             statthread.start()
 
         try:
             while tests or running:
                 if not done.empty() or running == self._jobs or not tests:
                     try:
                         done.get(True, 1)
                         running -= 1
                         if result and result.shouldStop:
                             stoppedearly = True
                             break
                     except queue.Empty:
                         continue
                 if tests and not running == self._jobs:
                     test = tests.pop(0)
                     if self._loop:
                         if getattr(test, 'should_reload', False):
                             num_tests[0] += 1
                             tests.append(self._loadtest(test, num_tests[0]))
                         else:
                             tests.append(test)
                     if self._jobs == 1:
                         job(test, result)
                     else:
                         t = threading.Thread(
                             target=job, name=test.name, args=(test, result)
                         )
                         t.start()
                     running += 1
 
             # If we stop early we still need to wait on started tests to
             # finish. Otherwise, there is a race between the test completing
             # and the test's cleanup code running. This could result in the
             # test reporting incorrect.
             if stoppedearly:
                 while running:
                     try:
                         done.get(True, 1)
                         running -= 1
                     except queue.Empty:
                         continue
         except KeyboardInterrupt:
             for test in runtests:
                 test.abort()
 
         channels = []
 
         return result
 
 
 # Save the most recent 5 wall-clock runtimes of each test to a
 # human-readable text file named .testtimes. Tests are sorted
 # alphabetically, while times for each test are listed from oldest to
 # newest.
 
 
 def loadtimes(outputdir):
     times = []
     try:
         with open(os.path.join(outputdir, b'.testtimes')) as fp:
             for line in fp:
                 m = re.match('(.*?) ([0-9. ]+)', line)
                 times.append(
                     (m.group(1), [float(t) for t in m.group(2).split()])
                 )
     except IOError as err:
         if err.errno != errno.ENOENT:
             raise
     return times
 
 
 def savetimes(outputdir, result):
     saved = dict(loadtimes(outputdir))
     maxruns = 5
     skipped = {str(t[0]) for t in result.skipped}
     for tdata in result.times:
         test, real = tdata[0], tdata[3]
         if test not in skipped:
             ts = saved.setdefault(test, [])
             ts.append(real)
             ts[:] = ts[-maxruns:]
 
     fd, tmpname = tempfile.mkstemp(
         prefix=b'.testtimes', dir=outputdir, text=True
     )
     with os.fdopen(fd, 'w') as fp:
         for name, ts in sorted(saved.items()):
             fp.write('%s %s\n' % (name, ' '.join(['%.3f' % (t,) for t in ts])))
     timepath = os.path.join(outputdir, b'.testtimes')
     try:
         os.unlink(timepath)
     except OSError:
         pass
     try:
         os.rename(tmpname, timepath)
     except OSError:
         pass
 
 
 class TextTestRunner(unittest.TextTestRunner):
     """Custom unittest test runner that uses appropriate settings."""
 
     def __init__(self, runner, *args, **kwargs):
         super(TextTestRunner, self).__init__(*args, **kwargs)
 
         self._runner = runner
 
         self._result = getTestResult()(
             self._runner.options, self.stream, self.descriptions, self.verbosity
         )
 
     def listtests(self, test):
         test = sorted(test, key=lambda t: t.name)
 
         self._result.onStart(test)
 
         for t in test:
             print(t.name)
             self._result.addSuccess(t)
 
         if self._runner.options.xunit:
             with open(self._runner.options.xunit, "wb") as xuf:
                 self._writexunit(self._result, xuf)
 
         if self._runner.options.json:
             jsonpath = os.path.join(self._runner._outputdir, b'report.json')
             with open(jsonpath, 'w') as fp:
                 self._writejson(self._result, fp)
 
         return self._result
 
     def run(self, test):
         self._result.onStart(test)
         test(self._result)
 
         failed = len(self._result.failures)
         skipped = len(self._result.skipped)
         ignored = len(self._result.ignored)
 
         with iolock:
             self.stream.writeln('')
 
             if not self._runner.options.noskips:
                 for test, msg in sorted(
                     self._result.skipped, key=lambda s: s[0].name
                 ):
                     formatted = 'Skipped %s: %s\n' % (test.name, msg)
                     msg = highlightmsg(formatted, self._result.color)
                     self.stream.write(msg)
             for test, msg in sorted(
                 self._result.failures, key=lambda f: f[0].name
             ):
                 formatted = 'Failed %s: %s\n' % (test.name, msg)
                 self.stream.write(highlightmsg(formatted, self._result.color))
             for test, msg in sorted(
                 self._result.errors, key=lambda e: e[0].name
             ):
                 self.stream.writeln('Errored %s: %s' % (test.name, msg))
 
             if self._runner.options.xunit:
                 with open(self._runner.options.xunit, "wb") as xuf:
                     self._writexunit(self._result, xuf)
 
             if self._runner.options.json:
                 jsonpath = os.path.join(self._runner._outputdir, b'report.json')
                 with open(jsonpath, 'w') as fp:
                     self._writejson(self._result, fp)
 
             self._runner._checkhglib('Tested')
 
             savetimes(self._runner._outputdir, self._result)
 
             if failed and self._runner.options.known_good_rev:
                 self._bisecttests(t for t, m in self._result.failures)
             self.stream.writeln(
                 '# Ran %d tests, %d skipped, %d failed.'
                 % (self._result.testsRun, skipped + ignored, failed)
             )
             if failed:
                 self.stream.writeln(
                     'python hash seed: %s' % os.environ['PYTHONHASHSEED']
                 )
             if self._runner.options.time:
                 self.printtimes(self._result.times)
 
             if self._runner.options.exceptions:
                 exceptions = aggregateexceptions(
                     os.path.join(self._runner._outputdir, b'exceptions')
                 )
 
                 self.stream.writeln('Exceptions Report:')
                 self.stream.writeln(
                     '%d total from %d frames'
                     % (exceptions['total'], len(exceptions['exceptioncounts']))
                 )
                 combined = exceptions['combined']
                 for key in sorted(combined, key=combined.get, reverse=True):
                     frame, line, exc = key
                     totalcount, testcount, leastcount, leasttest = combined[key]
 
                     self.stream.writeln(
                         '%d (%d tests)\t%s: %s (%s - %d total)'
                         % (
                             totalcount,
                             testcount,
                             frame,
                             exc,
                             leasttest,
                             leastcount,
                         )
                     )
 
             self.stream.flush()
 
         return self._result
 
     def _bisecttests(self, tests):
         bisectcmd = ['hg', 'bisect']
         bisectrepo = self._runner.options.bisect_repo
         if bisectrepo:
             bisectcmd.extend(['-R', os.path.abspath(bisectrepo)])
 
         def pread(args):
             env = os.environ.copy()
             env['HGPLAIN'] = '1'
             p = subprocess.Popen(
                 args, stderr=subprocess.STDOUT, stdout=subprocess.PIPE, env=env
             )
             data = p.stdout.read()
             p.wait()
             return data
 
         for test in tests:
             pread(bisectcmd + ['--reset']),
             pread(bisectcmd + ['--bad', '.'])
             pread(bisectcmd + ['--good', self._runner.options.known_good_rev])
             # TODO: we probably need to forward more options
             # that alter hg's behavior inside the tests.
             opts = ''
             withhg = self._runner.options.with_hg
             if withhg:
                 opts += ' --with-hg=%s ' % shellquote(_bytes2sys(withhg))
             rtc = '%s %s %s %s' % (sysexecutable, sys.argv[0], opts, test)
             data = pread(bisectcmd + ['--command', rtc])
             m = re.search(
                 (
                     br'\nThe first (?P<goodbad>bad|good) revision '
                     br'is:\nchangeset: +\d+:(?P<node>[a-f0-9]+)\n.*\n'
                     br'summary: +(?P<summary>[^\n]+)\n'
                 ),
                 data,
                 (re.MULTILINE | re.DOTALL),
             )
             if m is None:
                 self.stream.writeln(
                     'Failed to identify failure point for %s' % test
                 )
                 continue
             dat = m.groupdict()
             verb = 'broken' if dat['goodbad'] == b'bad' else 'fixed'
             self.stream.writeln(
                 '%s %s by %s (%s)'
                 % (
                     test,
                     verb,
                     dat['node'].decode('ascii'),
                     dat['summary'].decode('utf8', 'ignore'),
                 )
             )
 
     def printtimes(self, times):
         # iolock held by run
         self.stream.writeln('# Producing time report')
         times.sort(key=lambda t: (t[3]))
         cols = '%7.3f %7.3f %7.3f %7.3f %7.3f   %s'
         self.stream.writeln(
             '%-7s %-7s %-7s %-7s %-7s   %s'
             % ('start', 'end', 'cuser', 'csys', 'real', 'Test')
         )
         for tdata in times:
             test = tdata[0]
             cuser, csys, real, start, end = tdata[1:6]
             self.stream.writeln(cols % (start, end, cuser, csys, real, test))
 
     @staticmethod
     def _writexunit(result, outf):
         # See http://llg.cubic.org/docs/junit/ for a reference.
         timesd = {t[0]: t[3] for t in result.times}
         doc = minidom.Document()
         s = doc.createElement('testsuite')
         s.setAttribute('errors', "0")  # TODO
         s.setAttribute('failures', str(len(result.failures)))
         s.setAttribute('name', 'run-tests')
         s.setAttribute(
             'skipped', str(len(result.skipped) + len(result.ignored))
         )
         s.setAttribute('tests', str(result.testsRun))
         doc.appendChild(s)
         for tc in result.successes:
             t = doc.createElement('testcase')
             t.setAttribute('name', tc.name)
             tctime = timesd.get(tc.name)
             if tctime is not None:
                 t.setAttribute('time', '%.3f' % tctime)
             s.appendChild(t)
         for tc, err in sorted(result.faildata.items()):
             t = doc.createElement('testcase')
             t.setAttribute('name', tc)
             tctime = timesd.get(tc)
             if tctime is not None:
                 t.setAttribute('time', '%.3f' % tctime)
             # createCDATASection expects a unicode or it will
             # convert using default conversion rules, which will
             # fail if string isn't ASCII.
             err = cdatasafe(err).decode('utf-8', 'replace')
             cd = doc.createCDATASection(err)
             # Use 'failure' here instead of 'error' to match errors = 0,
             # failures = len(result.failures) in the testsuite element.
             failelem = doc.createElement('failure')
             failelem.setAttribute('message', 'output changed')
             failelem.setAttribute('type', 'output-mismatch')
             failelem.appendChild(cd)
             t.appendChild(failelem)
             s.appendChild(t)
         for tc, message in result.skipped:
             # According to the schema, 'skipped' has no attributes. So store
             # the skip message as a text node instead.
             t = doc.createElement('testcase')
             t.setAttribute('name', tc.name)
             binmessage = message.encode('utf-8')
             message = cdatasafe(binmessage).decode('utf-8', 'replace')
             cd = doc.createCDATASection(message)
             skipelem = doc.createElement('skipped')
             skipelem.appendChild(cd)
             t.appendChild(skipelem)
             s.appendChild(t)
         outf.write(doc.toprettyxml(indent='  ', encoding='utf-8'))
 
     @staticmethod
     def _writejson(result, outf):
         timesd = {}
         for tdata in result.times:
             test = tdata[0]
             timesd[test] = tdata[1:]
 
         outcome = {}
         groups = [
             ('success', ((tc, None) for tc in result.successes)),
             ('failure', result.failures),
             ('skip', result.skipped),
         ]
         for res, testcases in groups:
             for tc, __ in testcases:
                 if tc.name in timesd:
                     diff = result.faildata.get(tc.name, b'')
                     try:
                         diff = diff.decode('unicode_escape')
                     except UnicodeDecodeError as e:
                         diff = '%r decoding diff, sorry' % e
                     tres = {
                         'result': res,
                         'time': ('%0.3f' % timesd[tc.name][2]),
                         'cuser': ('%0.3f' % timesd[tc.name][0]),
                         'csys': ('%0.3f' % timesd[tc.name][1]),
                         'start': ('%0.3f' % timesd[tc.name][3]),
                         'end': ('%0.3f' % timesd[tc.name][4]),
                         'diff': diff,
                     }
                 else:
                     # blacklisted test
                     tres = {'result': res}
 
                 outcome[tc.name] = tres
         jsonout = json.dumps(
             outcome, sort_keys=True, indent=4, separators=(',', ': ')
         )
         outf.writelines(("testreport =", jsonout))
 
 
 def sorttests(testdescs, previoustimes, shuffle=False):
     """Do an in-place sort of tests."""
     if shuffle:
         random.shuffle(testdescs)
         return
 
     if previoustimes:
 
         def sortkey(f):
             f = f['path']
             if f in previoustimes:
                 # Use most recent time as estimate
                 return -(previoustimes[f][-1])
             else:
                 # Default to a rather arbitrary value of 1 second for new tests
                 return -1.0
 
     else:
         # keywords for slow tests
         slow = {
             b'svn': 10,
             b'cvs': 10,
             b'hghave': 10,
             b'largefiles-update': 10,
             b'run-tests': 10,
             b'corruption': 10,
             b'race': 10,
             b'i18n': 10,
             b'check': 100,
             b'gendoc': 100,
             b'contrib-perf': 200,
             b'merge-combination': 100,
         }
         perf = {}
 
         def sortkey(f):
             # run largest tests first, as they tend to take the longest
             f = f['path']
             try:
                 return perf[f]
             except KeyError:
                 try:
                     val = -os.stat(f).st_size
                 except OSError as e:
                     if e.errno != errno.ENOENT:
                         raise
                     perf[f] = -1e9  # file does not exist, tell early
                     return -1e9
                 for kw, mul in slow.items():
                     if kw in f:
                         val *= mul
                 if f.endswith(b'.py'):
                     val /= 10.0
                 perf[f] = val / 1000.0
                 return perf[f]
 
     testdescs.sort(key=sortkey)
 
 
 class TestRunner(object):
     """Holds context for executing tests.
 
     Tests rely on a lot of state. This object holds it for them.
     """
 
     # Programs required to run tests.
     REQUIREDTOOLS = [
         b'diff',
         b'grep',
         b'unzip',
         b'gunzip',
         b'bunzip2',
         b'sed',
     ]
 
     # Maps file extensions to test class.
     TESTTYPES = [
         (b'.py', PythonTest),
         (b'.t', TTest),
     ]
 
     def __init__(self):
         self.options = None
         self._hgroot = None
         self._testdir = None
         self._outputdir = None
         self._hgtmp = None
         self._installdir = None
         self._bindir = None
         self._tmpbinddir = None
         self._pythondir = None
         self._coveragefile = None
         self._createdfiles = []
         self._hgcommand = None
         self._hgpath = None
         self._portoffset = 0
         self._ports = {}
 
     def run(self, args, parser=None):
         """Run the test suite."""
         oldmask = os.umask(0o22)
         try:
             parser = parser or getparser()
             options = parseargs(args, parser)
             tests = [_sys2bytes(a) for a in options.tests]
             if options.test_list is not None:
                 for listfile in options.test_list:
                     with open(listfile, 'rb') as f:
                         tests.extend(t for t in f.read().splitlines() if t)
             self.options = options
 
             self._checktools()
             testdescs = self.findtests(tests)
             if options.profile_runner:
                 import statprof
 
                 statprof.start()
             result = self._run(testdescs)
             if options.profile_runner:
                 statprof.stop()
                 statprof.display()
             return result
 
         finally:
             os.umask(oldmask)
 
     def _run(self, testdescs):
         testdir = getcwdb()
         self._testdir = osenvironb[b'TESTDIR'] = getcwdb()
         # assume all tests in same folder for now
         if testdescs:
             pathname = os.path.dirname(testdescs[0]['path'])
             if pathname:
                 testdir = os.path.join(testdir, pathname)
         self._testdir = osenvironb[b'TESTDIR'] = testdir
         if self.options.outputdir:
             self._outputdir = canonpath(_sys2bytes(self.options.outputdir))
         else:
             self._outputdir = getcwdb()
             if testdescs and pathname:
                 self._outputdir = os.path.join(self._outputdir, pathname)
         previoustimes = {}
         if self.options.order_by_runtime:
             previoustimes = dict(loadtimes(self._outputdir))
         sorttests(testdescs, previoustimes, shuffle=self.options.random)
 
         if 'PYTHONHASHSEED' not in os.environ:
             # use a random python hash seed all the time
             # we do the randomness ourself to know what seed is used
             os.environ['PYTHONHASHSEED'] = str(random.getrandbits(32))
 
         # Rayon (Rust crate for multi-threading) will use all logical CPU cores
         # by default, causing thrashing on high-cpu-count systems.
         # Setting its limit to 3 during tests should still let us uncover
         # multi-threading bugs while keeping the thrashing reasonable.
         os.environ.setdefault("RAYON_NUM_THREADS", "3")
 
         if self.options.tmpdir:
             self.options.keep_tmpdir = True
             tmpdir = _sys2bytes(self.options.tmpdir)
             if os.path.exists(tmpdir):
                 # Meaning of tmpdir has changed since 1.3: we used to create
                 # HGTMP inside tmpdir; now HGTMP is tmpdir.  So fail if
                 # tmpdir already exists.
                 print("error: temp dir %r already exists" % tmpdir)
                 return 1
 
             os.makedirs(tmpdir)
         else:
             d = None
             if os.name == 'nt':
                 # without this, we get the default temp dir location, but
                 # in all lowercase, which causes troubles with paths (issue3490)
                 d = osenvironb.get(b'TMP', None)
             tmpdir = tempfile.mkdtemp(b'', b'hgtests.', d)
 
         self._hgtmp = osenvironb[b'HGTMP'] = os.path.realpath(tmpdir)
 
         if self.options.with_hg:
             self._installdir = None
             whg = self.options.with_hg
             self._bindir = os.path.dirname(os.path.realpath(whg))
             assert isinstance(self._bindir, bytes)
             self._hgcommand = os.path.basename(whg)
             self._tmpbindir = os.path.join(self._hgtmp, b'install', b'bin')
             os.makedirs(self._tmpbindir)
 
             normbin = os.path.normpath(os.path.abspath(whg))
             normbin = normbin.replace(_sys2bytes(os.sep), b'/')
 
             # Other Python scripts in the test harness need to
             # `import mercurial`. If `hg` is a Python script, we assume
             # the Mercurial modules are relative to its path and tell the tests
             # to load Python modules from its directory.
             with open(whg, 'rb') as fh:
                 initial = fh.read(1024)
 
             if re.match(b'#!.*python', initial):
                 self._pythondir = self._bindir
             # If it looks like our in-repo Rust binary, use the source root.
             # This is a bit hacky. But rhg is still not supported outside the
             # source directory. So until it is, do the simple thing.
             elif re.search(b'/rust/target/[^/]+/hg', normbin):
                 self._pythondir = os.path.dirname(self._testdir)
             # Fall back to the legacy behavior.
             else:
                 self._pythondir = self._bindir
 
         else:
             self._installdir = os.path.join(self._hgtmp, b"install")
             self._bindir = os.path.join(self._installdir, b"bin")
             self._hgcommand = b'hg'
             self._tmpbindir = self._bindir
             self._pythondir = os.path.join(self._installdir, b"lib", b"python")
 
         # Force the use of hg.exe instead of relying on MSYS to recognize hg is
         # a python script and feed it to python.exe.  Legacy stdio is force
         # enabled by hg.exe, and this is a more realistic way to launch hg
         # anyway.
         if os.name == 'nt' and not self._hgcommand.endswith(b'.exe'):
             self._hgcommand += b'.exe'
 
         # set CHGHG, then replace "hg" command by "chg"
         chgbindir = self._bindir
         if self.options.chg or self.options.with_chg:
             osenvironb[b'CHGHG'] = os.path.join(self._bindir, self._hgcommand)
         else:
             osenvironb.pop(b'CHGHG', None)  # drop flag for hghave
         if self.options.chg:
             self._hgcommand = b'chg'
         elif self.options.with_chg:
             chgbindir = os.path.dirname(os.path.realpath(self.options.with_chg))
             self._hgcommand = os.path.basename(self.options.with_chg)
 
         osenvironb[b"BINDIR"] = self._bindir
         osenvironb[b"PYTHON"] = PYTHON
 
         fileb = _sys2bytes(__file__)
         runtestdir = os.path.abspath(os.path.dirname(fileb))
         osenvironb[b'RUNTESTDIR'] = runtestdir
         if PYTHON3:
             sepb = _sys2bytes(os.pathsep)
         else:
             sepb = os.pathsep
         path = [self._bindir, runtestdir] + osenvironb[b"PATH"].split(sepb)
         if os.path.islink(__file__):
             # test helper will likely be at the end of the symlink
             realfile = os.path.realpath(fileb)
             realdir = os.path.abspath(os.path.dirname(realfile))
             path.insert(2, realdir)
         if chgbindir != self._bindir:
             path.insert(1, chgbindir)
         if self._testdir != runtestdir:
             path = [self._testdir] + path
         if self._tmpbindir != self._bindir:
             path = [self._tmpbindir] + path
         osenvironb[b"PATH"] = sepb.join(path)
 
         # Include TESTDIR in PYTHONPATH so that out-of-tree extensions
         # can run .../tests/run-tests.py test-foo where test-foo
         # adds an extension to HGRC. Also include run-test.py directory to
         # import modules like heredoctest.
         pypath = [self._pythondir, self._testdir, runtestdir]
         # We have to augment PYTHONPATH, rather than simply replacing
         # it, in case external libraries are only available via current
         # PYTHONPATH.  (In particular, the Subversion bindings on OS X
         # are in /opt/subversion.)
         oldpypath = osenvironb.get(IMPL_PATH)
         if oldpypath:
             pypath.append(oldpypath)
         osenvironb[IMPL_PATH] = sepb.join(pypath)
 
         if self.options.pure:
             os.environ["HGTEST_RUN_TESTS_PURE"] = "--pure"
             os.environ["HGMODULEPOLICY"] = "py"
         if self.options.rust:
             os.environ["HGMODULEPOLICY"] = "rust+c"
         if self.options.no_rust:
             current_policy = os.environ.get("HGMODULEPOLICY", "")
             if current_policy.startswith("rust+"):
                 os.environ["HGMODULEPOLICY"] = current_policy[len("rust+") :]
             os.environ.pop("HGWITHRUSTEXT", None)
 
         if self.options.allow_slow_tests:
             os.environ["HGTEST_SLOW"] = "slow"
         elif 'HGTEST_SLOW' in os.environ:
             del os.environ['HGTEST_SLOW']
 
         self._coveragefile = os.path.join(self._testdir, b'.coverage')
 
         if self.options.exceptions:
             exceptionsdir = os.path.join(self._outputdir, b'exceptions')
             try:
                 os.makedirs(exceptionsdir)
             except OSError as e:
                 if e.errno != errno.EEXIST:
                     raise
 
             # Remove all existing exception reports.
             for f in os.listdir(exceptionsdir):
                 os.unlink(os.path.join(exceptionsdir, f))
 
             osenvironb[b'HGEXCEPTIONSDIR'] = exceptionsdir
             logexceptions = os.path.join(self._testdir, b'logexceptions.py')
             self.options.extra_config_opt.append(
                 'extensions.logexceptions=%s' % logexceptions.decode('utf-8')
             )
 
         vlog("# Using TESTDIR", _bytes2sys(self._testdir))
         vlog("# Using RUNTESTDIR", _bytes2sys(osenvironb[b'RUNTESTDIR']))
         vlog("# Using HGTMP", _bytes2sys(self._hgtmp))
         vlog("# Using PATH", os.environ["PATH"])
         vlog(
             "# Using", _bytes2sys(IMPL_PATH), _bytes2sys(osenvironb[IMPL_PATH]),
         )
         vlog("# Writing to directory", _bytes2sys(self._outputdir))
 
         try:
             return self._runtests(testdescs) or 0
         finally:
             time.sleep(0.1)
             self._cleanup()
 
     def findtests(self, args):
         """Finds possible test files from arguments.
 
         If you wish to inject custom tests into the test harness, this would
         be a good function to monkeypatch or override in a derived class.
         """
         if not args:
             if self.options.changed:
                 proc = Popen4(
                     b'hg st --rev "%s" -man0 .'
                     % _sys2bytes(self.options.changed),
                     None,
                     0,
                 )
                 stdout, stderr = proc.communicate()
                 args = stdout.strip(b'\0').split(b'\0')
             else:
                 args = os.listdir(b'.')
 
         expanded_args = []
         for arg in args:
             if os.path.isdir(arg):
                 if not arg.endswith(b'/'):
                     arg += b'/'
                 expanded_args.extend([arg + a for a in os.listdir(arg)])
             else:
                 expanded_args.append(arg)
         args = expanded_args
 
         testcasepattern = re.compile(br'([\w-]+\.t|py)(?:#([a-zA-Z0-9_\-.#]+))')
         tests = []
         for t in args:
             case = []
 
             if not (
                 os.path.basename(t).startswith(b'test-')
                 and (t.endswith(b'.py') or t.endswith(b'.t'))
             ):
 
                 m = testcasepattern.match(os.path.basename(t))
                 if m is not None:
                     t_basename, casestr = m.groups()
                     t = os.path.join(os.path.dirname(t), t_basename)
                     if casestr:
                         case = casestr.split(b'#')
                 else:
                     continue
 
             if t.endswith(b'.t'):
                 # .t file may contain multiple test cases
                 casedimensions = parsettestcases(t)
                 if casedimensions:
                     cases = []
 
                     def addcases(case, casedimensions):
                         if not casedimensions:
                             cases.append(case)
                         else:
                             for c in casedimensions[0]:
                                 addcases(case + [c], casedimensions[1:])
 
                     addcases([], casedimensions)
                     if case and case in cases:
                         cases = [case]
                     elif case:
                         # Ignore invalid cases
                         cases = []
                     else:
                         pass
                     tests += [{'path': t, 'case': c} for c in sorted(cases)]
                 else:
                     tests.append({'path': t})
             else:
                 tests.append({'path': t})
 
         if self.options.retest:
             retest_args = []
             for test in tests:
                 errpath = self._geterrpath(test)
                 if os.path.exists(errpath):
                     retest_args.append(test)
             tests = retest_args
         return tests
 
     def _runtests(self, testdescs):
         def _reloadtest(test, i):
             # convert a test back to its description dict
             desc = {'path': test.path}
             case = getattr(test, '_case', [])
             if case:
                 desc['case'] = case
             return self._gettest(desc, i)
 
         try:
             if self.options.restart:
                 orig = list(testdescs)
                 while testdescs:
                     desc = testdescs[0]
                     errpath = self._geterrpath(desc)
                     if os.path.exists(errpath):
                         break
                     testdescs.pop(0)
                 if not testdescs:
                     print("running all tests")
                     testdescs = orig
 
             tests = [self._gettest(d, i) for i, d in enumerate(testdescs)]
             num_tests = len(tests) * self.options.runs_per_test
 
             jobs = min(num_tests, self.options.jobs)
 
             failed = False
             kws = self.options.keywords
             if kws is not None and PYTHON3:
                 kws = kws.encode('utf-8')
 
             suite = TestSuite(
                 self._testdir,
                 jobs=jobs,
                 whitelist=self.options.whitelisted,
                 blacklist=self.options.blacklist,
                 keywords=kws,
                 loop=self.options.loop,
                 runs_per_test=self.options.runs_per_test,
                 showchannels=self.options.showchannels,
                 tests=tests,
                 loadtest=_reloadtest,
             )
             verbosity = 1
             if self.options.list_tests:
                 verbosity = 0
             elif self.options.verbose:
                 verbosity = 2
             runner = TextTestRunner(self, verbosity=verbosity)
 
             if self.options.list_tests:
                 result = runner.listtests(suite)
             else:
                 if self._installdir:
                     self._installhg()
                     self._checkhglib("Testing")
                 else:
                     self._usecorrectpython()
                 if self.options.chg:
                     assert self._installdir
                     self._installchg()
 
                 log(
                     'running %d tests using %d parallel processes'
                     % (num_tests, jobs)
                 )
 
                 result = runner.run(suite)
 
             if result.failures or result.errors:
                 failed = True
 
             result.onEnd()
 
             if self.options.anycoverage:
                 self._outputcoverage()
         except KeyboardInterrupt:
             failed = True
             print("\ninterrupted!")
 
         if failed:
             return 1
 
     def _geterrpath(self, test):
         # test['path'] is a relative path
         if 'case' in test:
             # for multiple dimensions test cases
             casestr = b'#'.join(test['case'])
             errpath = b'%s#%s.err' % (test['path'], casestr)
         else:
             errpath = b'%s.err' % test['path']
         if self.options.outputdir:
             self._outputdir = canonpath(_sys2bytes(self.options.outputdir))
             errpath = os.path.join(self._outputdir, errpath)
         return errpath
 
     def _getport(self, count):
         port = self._ports.get(count)  # do we have a cached entry?
         if port is None:
             portneeded = 3
             # above 100 tries we just give up and let test reports failure
             for tries in xrange(100):
                 allfree = True
                 port = self.options.port + self._portoffset
                 for idx in xrange(portneeded):
                     if not checkportisavailable(port + idx):
                         allfree = False
                         break
                 self._portoffset += portneeded
                 if allfree:
                     break
             self._ports[count] = port
         return port
 
     def _gettest(self, testdesc, count):
         """Obtain a Test by looking at its filename.
 
         Returns a Test instance. The Test may not be runnable if it doesn't
         map to a known type.
         """
         path = testdesc['path']
         lctest = path.lower()
         testcls = Test
 
         for ext, cls in self.TESTTYPES:
             if lctest.endswith(ext):
                 testcls = cls
                 break
 
         refpath = os.path.join(getcwdb(), path)
         tmpdir = os.path.join(self._hgtmp, b'child%d' % count)
 
         # extra keyword parameters. 'case' is used by .t tests
         kwds = {k: testdesc[k] for k in ['case'] if k in testdesc}
 
         t = testcls(
             refpath,
             self._outputdir,
             tmpdir,
             keeptmpdir=self.options.keep_tmpdir,
             debug=self.options.debug,
             first=self.options.first,
             timeout=self.options.timeout,
             startport=self._getport(count),
             extraconfigopts=self.options.extra_config_opt,
             shell=self.options.shell,
             hgcommand=self._hgcommand,
             usechg=bool(self.options.with_chg or self.options.chg),
             chgdebug=self.options.chg_debug,
             useipv6=useipv6,
             **kwds
         )
         t.should_reload = True
         return t
 
     def _cleanup(self):
         """Clean up state from this test invocation."""
         if self.options.keep_tmpdir:
             return
 
         vlog("# Cleaning up HGTMP", _bytes2sys(self._hgtmp))
         shutil.rmtree(self._hgtmp, True)
         for f in self._createdfiles:
             try:
                 os.remove(f)
             except OSError:
                 pass
 
     def _usecorrectpython(self):
         """Configure the environment to use the appropriate Python in tests."""
         # Tests must use the same interpreter as us or bad things will happen.
         pyexename = sys.platform == 'win32' and b'python.exe' or b'python'
 
         # os.symlink() is a thing with py3 on Windows, but it requires
         # Administrator rights.
         if getattr(os, 'symlink', None) and os.name != 'nt':
             vlog(
                 "# Making python executable in test path a symlink to '%s'"
                 % sysexecutable
             )
             mypython = os.path.join(self._tmpbindir, pyexename)
             try:
                 if os.readlink(mypython) == sysexecutable:
                     return
                 os.unlink(mypython)
             except OSError as err:
                 if err.errno != errno.ENOENT:
                     raise
             if self._findprogram(pyexename) != sysexecutable:
                 try:
                     os.symlink(sysexecutable, mypython)
                     self._createdfiles.append(mypython)
                 except OSError as err:
                     # child processes may race, which is harmless
                     if err.errno != errno.EEXIST:
                         raise
         else:
             exedir, exename = os.path.split(sysexecutable)
             vlog(
                 "# Modifying search path to find %s as %s in '%s'"
                 % (exename, pyexename, exedir)
             )
             path = os.environ['PATH'].split(os.pathsep)
             while exedir in path:
                 path.remove(exedir)
             os.environ['PATH'] = os.pathsep.join([exedir] + path)
             if not self._findprogram(pyexename):
                 print("WARNING: Cannot find %s in search path" % pyexename)
 
     def _installhg(self):
         """Install hg into the test environment.
 
         This will also configure hg with the appropriate testing settings.
         """
         vlog("# Performing temporary installation of HG")
         installerrs = os.path.join(self._hgtmp, b"install.err")
         compiler = ''
         if self.options.compiler:
             compiler = '--compiler ' + self.options.compiler
         setup_opts = b""
         if self.options.pure:
             setup_opts = b"--pure"
         elif self.options.rust:
             setup_opts = b"--rust"
         elif self.options.no_rust:
             setup_opts = b"--no-rust"
 
         # Run installer in hg root
         script = os.path.realpath(sys.argv[0])
         exe = sysexecutable
         if PYTHON3:
             compiler = _sys2bytes(compiler)
             script = _sys2bytes(script)
             exe = _sys2bytes(exe)
         hgroot = os.path.dirname(os.path.dirname(script))
         self._hgroot = hgroot
         os.chdir(hgroot)
         nohome = b'--home=""'
         if os.name == 'nt':
             # The --home="" trick works only on OS where os.sep == '/'
             # because of a distutils convert_path() fast-path. Avoid it at
             # least on Windows for now, deal with .pydistutils.cfg bugs
             # when they happen.
             nohome = b''
         cmd = (
             b'"%(exe)s" setup.py %(setup_opts)s clean --all'
             b' build %(compiler)s --build-base="%(base)s"'
             b' install --force --prefix="%(prefix)s"'
             b' --install-lib="%(libdir)s"'
             b' --install-scripts="%(bindir)s" %(nohome)s >%(logfile)s 2>&1'
             % {
                 b'exe': exe,
                 b'setup_opts': setup_opts,
                 b'compiler': compiler,
                 b'base': os.path.join(self._hgtmp, b"build"),
                 b'prefix': self._installdir,
                 b'libdir': self._pythondir,
                 b'bindir': self._bindir,
                 b'nohome': nohome,
                 b'logfile': installerrs,
             }
         )
 
         # setuptools requires install directories to exist.
         def makedirs(p):
             try:
                 os.makedirs(p)
             except OSError as e:
                 if e.errno != errno.EEXIST:
                     raise
 
         makedirs(self._pythondir)
         makedirs(self._bindir)
 
         vlog("# Running", cmd.decode("utf-8"))
         if subprocess.call(_bytes2sys(cmd), shell=True) == 0:
             if not self.options.verbose:
                 try:
                     os.remove(installerrs)
                 except OSError as e:
                     if e.errno != errno.ENOENT:
                         raise
         else:
             with open(installerrs, 'rb') as f:
                 for line in f:
                     if PYTHON3:
                         sys.stdout.buffer.write(line)
                     else:
                         sys.stdout.write(line)
             sys.exit(1)
         os.chdir(self._testdir)
 
         self._usecorrectpython()
 
         hgbat = os.path.join(self._bindir, b'hg.bat')
         if os.path.isfile(hgbat):
             # hg.bat expects to be put in bin/scripts while run-tests.py
             # installation layout put it in bin/ directly. Fix it
             with open(hgbat, 'rb') as f:
                 data = f.read()
             if br'"%~dp0..\python" "%~dp0hg" %*' in data:
                 data = data.replace(
                     br'"%~dp0..\python" "%~dp0hg" %*',
                     b'"%~dp0python" "%~dp0hg" %*',
                 )
                 with open(hgbat, 'wb') as f:
                     f.write(data)
             else:
                 print('WARNING: cannot fix hg.bat reference to python.exe')
 
         if self.options.anycoverage:
             custom = os.path.join(
                 osenvironb[b'RUNTESTDIR'], b'sitecustomize.py'
             )
             target = os.path.join(self._pythondir, b'sitecustomize.py')
             vlog('# Installing coverage trigger to %s' % target)
             shutil.copyfile(custom, target)
             rc = os.path.join(self._testdir, b'.coveragerc')
             vlog('# Installing coverage rc to %s' % rc)
             osenvironb[b'COVERAGE_PROCESS_START'] = rc
             covdir = os.path.join(self._installdir, b'..', b'coverage')
             try:
                 os.mkdir(covdir)
             except OSError as e:
                 if e.errno != errno.EEXIST:
                     raise
 
             osenvironb[b'COVERAGE_DIR'] = covdir
 
     def _checkhglib(self, verb):
         """Ensure that the 'mercurial' package imported by python is
         the one we expect it to be.  If not, print a warning to stderr."""
         if (self._bindir == self._pythondir) and (
             self._bindir != self._tmpbindir
         ):
             # The pythondir has been inferred from --with-hg flag.
             # We cannot expect anything sensible here.
             return
         expecthg = os.path.join(self._pythondir, b'mercurial')
         actualhg = self._gethgpath()
         if os.path.abspath(actualhg) != os.path.abspath(expecthg):
             sys.stderr.write(
                 'warning: %s with unexpected mercurial lib: %s\n'
                 '         (expected %s)\n' % (verb, actualhg, expecthg)
             )
 
     def _gethgpath(self):
         """Return the path to the mercurial package that is actually found by
         the current Python interpreter."""
         if self._hgpath is not None:
             return self._hgpath
 
         cmd = b'"%s" -c "import mercurial; print (mercurial.__path__[0])"'
         cmd = cmd % PYTHON
         if PYTHON3:
             cmd = _bytes2sys(cmd)
 
         p = subprocess.Popen(cmd, stdout=subprocess.PIPE, shell=True)
         out, err = p.communicate()
 
         self._hgpath = out.strip()
 
         return self._hgpath
 
     def _installchg(self):
         """Install chg into the test environment"""
         vlog('# Performing temporary installation of CHG')
         assert os.path.dirname(self._bindir) == self._installdir
         assert self._hgroot, 'must be called after _installhg()'
         cmd = b'"%(make)s" clean install PREFIX="%(prefix)s"' % {
             b'make': b'make',  # TODO: switch by option or environment?
             b'prefix': self._installdir,
         }
         cwd = os.path.join(self._hgroot, b'contrib', b'chg')
         vlog("# Running", cmd)
         proc = subprocess.Popen(
             cmd,
             shell=True,
             cwd=cwd,
             stdin=subprocess.PIPE,
             stdout=subprocess.PIPE,
             stderr=subprocess.STDOUT,
         )
         out, _err = proc.communicate()
         if proc.returncode != 0:
             if PYTHON3:
                 sys.stdout.buffer.write(out)
             else:
                 sys.stdout.write(out)
             sys.exit(1)
 
     def _outputcoverage(self):
         """Produce code coverage output."""
         import coverage
 
         coverage = coverage.coverage
 
         vlog('# Producing coverage report')
         # chdir is the easiest way to get short, relative paths in the
         # output.
         os.chdir(self._hgroot)
         covdir = os.path.join(_bytes2sys(self._installdir), '..', 'coverage')
         cov = coverage(data_file=os.path.join(covdir, 'cov'))
 
         # Map install directory paths back to source directory.
         cov.config.paths['srcdir'] = ['.', _bytes2sys(self._pythondir)]
 
         cov.combine()
 
         omit = [
             _bytes2sys(os.path.join(x, b'*'))
             for x in [self._bindir, self._testdir]
         ]
         cov.report(ignore_errors=True, omit=omit)
 
         if self.options.htmlcov:
             htmldir = os.path.join(_bytes2sys(self._outputdir), 'htmlcov')
             cov.html_report(directory=htmldir, omit=omit)
         if self.options.annotate:
             adir = os.path.join(_bytes2sys(self._outputdir), 'annotated')
             if not os.path.isdir(adir):
                 os.mkdir(adir)
             cov.annotate(directory=adir, omit=omit)
 
     def _findprogram(self, program):
         """Search PATH for a executable program"""
         dpb = _sys2bytes(os.defpath)
         sepb = _sys2bytes(os.pathsep)
         for p in osenvironb.get(b'PATH', dpb).split(sepb):
             name = os.path.join(p, program)
             if os.name == 'nt' or os.access(name, os.X_OK):
                 return _bytes2sys(name)
         return None
 
     def _checktools(self):
         """Ensure tools required to run tests are present."""
         for p in self.REQUIREDTOOLS:
             if os.name == 'nt' and not p.endswith(b'.exe'):
                 p += b'.exe'
             found = self._findprogram(p)
             p = p.decode("utf-8")
             if found:
                 vlog("# Found prerequisite", p, "at", found)
             else:
                 print("WARNING: Did not find prerequisite tool: %s " % p)
 
 
 def aggregateexceptions(path):
     exceptioncounts = collections.Counter()
     testsbyfailure = collections.defaultdict(set)
     failuresbytest = collections.defaultdict(set)
 
     for f in os.listdir(path):
         with open(os.path.join(path, f), 'rb') as fh:
             data = fh.read().split(b'\0')
             if len(data) != 5:
                 continue
 
             exc, mainframe, hgframe, hgline, testname = data
             exc = exc.decode('utf-8')
             mainframe = mainframe.decode('utf-8')
             hgframe = hgframe.decode('utf-8')
             hgline = hgline.decode('utf-8')
             testname = testname.decode('utf-8')
 
             key = (hgframe, hgline, exc)
             exceptioncounts[key] += 1
             testsbyfailure[key].add(testname)
             failuresbytest[testname].add(key)
 
     # Find test having fewest failures for each failure.
     leastfailing = {}
     for key, tests in testsbyfailure.items():
         fewesttest = None
         fewestcount = 99999999
         for test in sorted(tests):
             if len(failuresbytest[test]) < fewestcount:
                 fewesttest = test
                 fewestcount = len(failuresbytest[test])
 
         leastfailing[key] = (fewestcount, fewesttest)
 
     # Create a combined counter so we can sort by total occurrences and
     # impacted tests.
     combined = {}
     for key in exceptioncounts:
         combined[key] = (
             exceptioncounts[key],
             len(testsbyfailure[key]),
             leastfailing[key][0],
             leastfailing[key][1],
         )
 
     return {
         'exceptioncounts': exceptioncounts,
         'total': sum(exceptioncounts.values()),
         'combined': combined,
         'leastfailing': leastfailing,
         'byfailure': testsbyfailure,
         'bytest': failuresbytest,
     }
 
 
 if __name__ == '__main__':
     runner = TestRunner()
 
     try:
         import msvcrt
 
         msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY)
         msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
         msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY)
     except ImportError:
         pass
 
     sys.exit(runner.run(sys.argv[1:]))

tests/test-absorb-unfinished.t

@@ -1,30 +1,30 b''
   $ cat >> $HGRCPATH << EOF
   > [extensions]
   > absorb=
   > EOF
 
 Abort absorb if there is an unfinished operation.
 
   $ hg init abortunresolved
   $ cd abortunresolved
 
   $ echo "foo1" > foo.whole
   $ hg commit -Aqm "foo 1"
 
   $ hg update null
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo "foo2" > foo.whole
   $ hg commit -Aqm "foo 2"
 
   $ hg --config extensions.rebase= rebase -r 1 -d 0
   rebasing 1:c3b6dc0e177a tip "foo 2"
   merging foo.whole
   warning: conflicts while merging foo.whole! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg rebase --continue')
-  [1]
+  [240]
 
   $ hg --config extensions.rebase= absorb
   abort: rebase in progress
   (use 'hg rebase --continue', 'hg rebase --abort', or 'hg rebase --stop')
   [255]
 

tests/test-basic.t

@@ -1,227 +1,228 b''
 Create a repository:
 
 #if no-extraextensions
   $ hg config
   devel.all-warnings=true
   devel.default-date=0 0
   extensions.fsmonitor= (fsmonitor !)
   largefiles.usercache=$TESTTMP/.cache/largefiles
   lfs.usercache=$TESTTMP/.cache/lfs
   ui.slash=True
   ui.interactive=False
+  ui.detailed-exit-code=True
   ui.merge=internal:merge
   ui.mergemarkers=detailed
   ui.promptecho=True
   web.address=localhost
   web\.ipv6=(?:True|False) (re)
   web.server-header=testing stub value
 #endif
 
   $ hg init t
   $ cd t
 
 Prepare a changeset:
 
   $ echo a > a
   $ hg add a
 
   $ hg status
   A a
 
 Writes to stdio succeed and fail appropriately
 
 #if devfull
   $ hg status 2>/dev/full
   A a
 
   $ hg status >/dev/full
   abort: No space left on device
   [255]
 #endif
 
 #if devfull
   $ hg status >/dev/full 2>&1
   [255]
 
   $ hg status ENOENT 2>/dev/full
   [255]
 #endif
 
   $ hg commit -m test
 
 This command is ancient:
 
   $ hg history
   changeset:   0:acb14030fe0a
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     test
   
 
 Verify that updating to revision 0 via commands.update() works properly
 
   $ cat <<EOF > update_to_rev0.py
   > from mercurial import commands, hg, ui as uimod
   > myui = uimod.ui.load()
   > repo = hg.repository(myui, path=b'.')
   > commands.update(myui, repo, rev=b"0")
   > EOF
   $ hg up null
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ "$PYTHON" ./update_to_rev0.py
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg identify -n
   0
 
 
 Poke around at hashes:
 
   $ hg manifest --debug
   b789fdd96dc2f3bd229c1dd8eedf0fc60e2b68e3 644   a
 
   $ hg cat a
   a
 
 Verify should succeed:
 
   $ hg verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   checked 1 changesets with 1 changes to 1 files
 
 Repository root:
 
   $ hg root
   $TESTTMP/t
   $ hg log -l1 -T '{reporoot}\n'
   $TESTTMP/t
   $ hg root -Tjson | sed 's|\\\\|\\|g'
   [
    {
     "hgpath": "$TESTTMP/t/.hg",
     "reporoot": "$TESTTMP/t",
     "storepath": "$TESTTMP/t/.hg/store"
    }
   ]
 
 At the end...
 
   $ cd ..
 
 Status message redirection:
 
   $ hg init empty
 
  status messages are sent to stdout by default:
 
   $ hg outgoing -R t empty -Tjson 2>/dev/null
   comparing with empty
   searching for changes
   [
    {
     "bookmarks": [],
     "branch": "default",
     "date": [0, 0],
     "desc": "test",
     "node": "acb14030fe0a21b60322c440ad2d20cf7685a376",
     "parents": ["0000000000000000000000000000000000000000"],
     "phase": "draft",
     "rev": 0,
     "tags": ["tip"],
     "user": "test"
    }
   ]
 
  which can be configured to send to stderr, so the output wouldn't be
  interleaved:
 
   $ cat <<'EOF' >> "$HGRCPATH"
   > [ui]
   > message-output = stderr
   > EOF
   $ hg outgoing -R t empty -Tjson 2>/dev/null
   [
    {
     "bookmarks": [],
     "branch": "default",
     "date": [0, 0],
     "desc": "test",
     "node": "acb14030fe0a21b60322c440ad2d20cf7685a376",
     "parents": ["0000000000000000000000000000000000000000"],
     "phase": "draft",
     "rev": 0,
     "tags": ["tip"],
     "user": "test"
    }
   ]
   $ hg outgoing -R t empty -Tjson >/dev/null
   comparing with empty
   searching for changes
 
  this option should be turned off by HGPLAIN= since it may break scripting use:
 
   $ HGPLAIN= hg outgoing -R t empty -Tjson 2>/dev/null
   comparing with empty
   searching for changes
   [
    {
     "bookmarks": [],
     "branch": "default",
     "date": [0, 0],
     "desc": "test",
     "node": "acb14030fe0a21b60322c440ad2d20cf7685a376",
     "parents": ["0000000000000000000000000000000000000000"],
     "phase": "draft",
     "rev": 0,
     "tags": ["tip"],
     "user": "test"
    }
   ]
 
  but still overridden by --config:
 
   $ HGPLAIN= hg outgoing -R t empty -Tjson --config ui.message-output=stderr \
   > 2>/dev/null
   [
    {
     "bookmarks": [],
     "branch": "default",
     "date": [0, 0],
     "desc": "test",
     "node": "acb14030fe0a21b60322c440ad2d20cf7685a376",
     "parents": ["0000000000000000000000000000000000000000"],
     "phase": "draft",
     "rev": 0,
     "tags": ["tip"],
     "user": "test"
    }
   ]
 
 Invalid ui.message-output option:
 
   $ hg log -R t --config ui.message-output=bad
   abort: invalid ui.message-output destination: bad
   [255]
 
 Underlying message streams should be updated when ui.fout/ferr are set:
 
   $ cat <<'EOF' > capui.py
   > from mercurial import pycompat, registrar
   > cmdtable = {}
   > command = registrar.command(cmdtable)
   > @command(b'capui', norepo=True)
   > def capui(ui):
   >     out = ui.fout
   >     ui.fout = pycompat.bytesio()
   >     ui.status(b'status\n')
   >     ui.ferr = pycompat.bytesio()
   >     ui.warn(b'warn\n')
   >     out.write(b'stdout: %s' % ui.fout.getvalue())
   >     out.write(b'stderr: %s' % ui.ferr.getvalue())
   > EOF
   $ hg --config extensions.capui=capui.py --config ui.message-output=stdio capui
   stdout: status
   stderr: warn

tests/test-bookmarks-rebase.t

@@ -1,105 +1,105 b''
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "rebase=" >> $HGRCPATH
 
 initialize repository
 
   $ hg init
 
   $ echo 'a' > a
   $ hg ci -A -m "0"
   adding a
 
   $ echo 'b' > b
   $ hg ci -A -m "1"
   adding b
 
   $ hg up 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo 'c' > c
   $ hg ci -A -m "2"
   adding c
   created new head
 
   $ echo 'd' > d
   $ hg ci -A -m "3"
   adding d
 
   $ hg bookmark -r 1 one
   $ hg bookmark -r 3 two
   $ hg up -q two
 
 bookmark list
 
   $ hg bookmark
      one                       1:925d80f479bb
    * two                       3:2ae46b1d99a7
 
 rebase
 
   $ hg rebase -s two -d one
   rebasing 3:2ae46b1d99a7 two tip "3"
   saved backup bundle to $TESTTMP/.hg/strip-backup/2ae46b1d99a7-e6b057bc-rebase.hg
 
   $ hg log
   changeset:   3:42e5ed2cdcf4
   bookmark:    two
   tag:         tip
   parent:      1:925d80f479bb
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     3
   
   changeset:   2:db815d6d32e6
   parent:      0:f7b1eb17ad24
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2
   
   changeset:   1:925d80f479bb
   bookmark:    one
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1
   
   changeset:   0:f7b1eb17ad24
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0
   
 aborted rebase should restore active bookmark.
 
   $ hg up 1
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   (leaving bookmark two)
   $ echo 'e' > d
   $ hg ci -A -m "4"
   adding d
   created new head
   $ hg bookmark three
   $ hg rebase -s three -d two
   rebasing 4:dd7c838e8362 three tip "4"
   merging d
   warning: conflicts while merging d! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg rebase --continue')
-  [1]
+  [240]
   $ hg rebase --abort
   rebase aborted
   $ hg bookmark
      one                       1:925d80f479bb
    * three                     4:dd7c838e8362
      two                       3:42e5ed2cdcf4
 
 after aborted rebase, restoring a bookmark that has been removed should not fail
 
   $ hg rebase -s three -d two
   rebasing 4:dd7c838e8362 three tip "4"
   merging d
   warning: conflicts while merging d! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg rebase --continue')
-  [1]
+  [240]
   $ hg bookmark -d three
   $ hg rebase --abort
   rebase aborted
   $ hg bookmark
      one                       1:925d80f479bb
      two                       3:42e5ed2cdcf4

tests/test-commandserver.t

@@ -1,1156 +1,1158 b''
 #if windows
   $ PYTHONPATH="$TESTDIR/../contrib;$PYTHONPATH"
 #else
   $ PYTHONPATH="$TESTDIR/../contrib:$PYTHONPATH"
 #endif
   $ export PYTHONPATH
 
 typical client does not want echo-back messages, so test without it:
 
   $ grep -v '^promptecho ' < $HGRCPATH >> $HGRCPATH.new
   $ mv $HGRCPATH.new $HGRCPATH
 
   $ hg init repo
   $ cd repo
 
   >>> from __future__ import absolute_import
   >>> import os
   >>> import sys
   >>> from hgclient import bprint, check, readchannel, runcommand
   >>> @check
   ... def hellomessage(server):
   ...     ch, data = readchannel(server)
   ...     bprint(b'%c, %r' % (ch, data))
   ...     # run an arbitrary command to make sure the next thing the server
   ...     # sends isn't part of the hello message
   ...     runcommand(server, [b'id'])
   o, 'capabilities: getencoding runcommand\nencoding: *\npid: *' (glob)
   *** runcommand id
   000000000000 tip
 
   >>> from hgclient import check
   >>> @check
   ... def unknowncommand(server):
   ...     server.stdin.write(b'unknowncommand\n')
   abort: unknown command unknowncommand
 
   >>> from hgclient import check, readchannel, runcommand
   >>> @check
   ... def checkruncommand(server):
   ...     # hello block
   ...     readchannel(server)
   ... 
   ...     # no args
   ...     runcommand(server, [])
   ... 
   ...     # global options
   ...     runcommand(server, [b'id', b'--quiet'])
   ... 
   ...     # make sure global options don't stick through requests
   ...     runcommand(server, [b'id'])
   ... 
   ...     # --config
   ...     runcommand(server, [b'id', b'--config', b'ui.quiet=True'])
   ... 
   ...     # make sure --config doesn't stick
   ...     runcommand(server, [b'id'])
   ... 
   ...     # negative return code should be masked
   ...     runcommand(server, [b'id', b'-runknown'])
   *** runcommand 
   Mercurial Distributed SCM
   
   basic commands:
   
    add           add the specified files on the next commit
    annotate      show changeset information by line for each file
    clone         make a copy of an existing repository
    commit        commit the specified files or all outstanding changes
    diff          diff repository (or selected files)
    export        dump the header and diffs for one or more changesets
    forget        forget the specified files on the next commit
    init          create a new repository in the given directory
    log           show revision history of entire repository or files
    merge         merge another revision into working directory
    pull          pull changes from the specified source
    push          push changes to the specified destination
    remove        remove the specified files on the next commit
    serve         start stand-alone webserver
    status        show changed files in the working directory
    summary       summarize working directory state
    update        update working directory (or switch revisions)
   
   (use 'hg help' for the full list of commands or 'hg -v' for details)
   *** runcommand id --quiet
   000000000000
   *** runcommand id
   000000000000 tip
   *** runcommand id --config ui.quiet=True
   000000000000
   *** runcommand id
   000000000000 tip
   *** runcommand id -runknown
   abort: unknown revision 'unknown'!
    [255]
 
   >>> from hgclient import bprint, check, readchannel
   >>> @check
   ... def inputeof(server):
   ...     readchannel(server)
   ...     server.stdin.write(b'runcommand\n')
   ...     # close stdin while server is waiting for input
   ...     server.stdin.close()
   ... 
   ...     # server exits with 1 if the pipe closed while reading the command
   ...     bprint(b'server exit code =', b'%d' % server.wait())
   server exit code = 1
 
   >>> from hgclient import check, readchannel, runcommand, stringio
   >>> @check
   ... def serverinput(server):
   ...     readchannel(server)
   ... 
   ...     patch = b"""
   ... # HG changeset patch
   ... # User test
   ... # Date 0 0
   ... # Node ID c103a3dec114d882c98382d684d8af798d09d857
   ... # Parent  0000000000000000000000000000000000000000
   ... 1
   ... 
   ... diff -r 000000000000 -r c103a3dec114 a
   ... --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   ... +++ b/a	Thu Jan 01 00:00:00 1970 +0000
   ... @@ -0,0 +1,1 @@
   ... +1
   ... """
   ... 
   ...     runcommand(server, [b'import', b'-'], input=stringio(patch))
   ...     runcommand(server, [b'log'])
   *** runcommand import -
   applying patch from stdin
   *** runcommand log
   changeset:   0:eff892de26ec
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1
   
 
 check strict parsing of early options:
 
   >>> import os
   >>> from hgclient import check, readchannel, runcommand
   >>> os.environ['HGPLAIN'] = '+strictflags'
   >>> @check
   ... def cwd(server):
   ...     readchannel(server)
   ...     runcommand(server, [b'log', b'-b', b'--config=alias.log=!echo pwned',
   ...                         b'default'])
   *** runcommand log -b --config=alias.log=!echo pwned default
   abort: unknown revision '--config=alias.log=!echo pwned'!
    [255]
 
 check that "histedit --commands=-" can read rules from the input channel:
 
   >>> from hgclient import check, readchannel, runcommand, stringio
   >>> @check
   ... def serverinput(server):
   ...     readchannel(server)
   ...     rules = b'pick eff892de26ec\n'
   ...     runcommand(server, [b'histedit', b'0', b'--commands=-',
   ...                         b'--config', b'extensions.histedit='],
   ...                input=stringio(rules))
   *** runcommand histedit 0 --commands=- --config extensions.histedit=
 
 check that --cwd doesn't persist between requests:
 
   $ mkdir foo
   $ touch foo/bar
   >>> from hgclient import check, readchannel, runcommand
   >>> @check
   ... def cwd(server):
   ...     readchannel(server)
   ...     runcommand(server, [b'--cwd', b'foo', b'st', b'bar'])
   ...     runcommand(server, [b'st', b'foo/bar'])
   *** runcommand --cwd foo st bar
   ? bar
   *** runcommand st foo/bar
   ? foo/bar
 
   $ rm foo/bar
 
 
 check that local configs for the cached repo aren't inherited when -R is used:
 
   $ cat <<EOF >> .hg/hgrc
   > [ui]
   > foo = bar
   > EOF
 
 #if no-extraextensions
 
   >>> from hgclient import check, readchannel, runcommand, sep
   >>> @check
   ... def localhgrc(server):
   ...     readchannel(server)
   ... 
   ...     # the cached repo local hgrc contains ui.foo=bar, so showconfig should
   ...     # show it
   ...     runcommand(server, [b'showconfig'], outfilter=sep)
   ... 
   ...     # but not for this repo
   ...     runcommand(server, [b'init', b'foo'])
   ...     runcommand(server, [b'-R', b'foo', b'showconfig', b'ui', b'defaults'])
   *** runcommand showconfig
   bundle.mainreporoot=$TESTTMP/repo
   devel.all-warnings=true
   devel.default-date=0 0
   extensions.fsmonitor= (fsmonitor !)
   largefiles.usercache=$TESTTMP/.cache/largefiles
   lfs.usercache=$TESTTMP/.cache/lfs
   ui.slash=True
   ui.interactive=False
+  ui.detailed-exit-code=True
   ui.merge=internal:merge
   ui.mergemarkers=detailed
   ui.foo=bar
   ui.nontty=true
   web.address=localhost
   web\.ipv6=(?:True|False) (re)
   web.server-header=testing stub value
   *** runcommand init foo
   *** runcommand -R foo showconfig ui defaults
   ui.slash=True
   ui.interactive=False
+  ui.detailed-exit-code=True
   ui.merge=internal:merge
   ui.mergemarkers=detailed
   ui.nontty=true
 #endif
 
   $ rm -R foo
 
 #if windows
   $ PYTHONPATH="$TESTTMP/repo;$PYTHONPATH"
 #else
   $ PYTHONPATH="$TESTTMP/repo:$PYTHONPATH"
 #endif
 
   $ cat <<EOF > hook.py
   > import sys
   > from hgclient import bprint
   > def hook(**args):
   >     bprint(b'hook talking')
   >     bprint(b'now try to read something: %r' % sys.stdin.read())
   > EOF
 
   >>> from hgclient import check, readchannel, runcommand, stringio
   >>> @check
   ... def hookoutput(server):
   ...     readchannel(server)
   ...     runcommand(server, [b'--config',
   ...                         b'hooks.pre-identify=python:hook.hook',
   ...                         b'id'],
   ...                input=stringio(b'some input'))
   *** runcommand --config hooks.pre-identify=python:hook.hook id
   eff892de26ec tip
   hook talking
   now try to read something: ''
 
 Clean hook cached version
   $ rm hook.py*
   $ rm -Rf __pycache__
 
   $ echo a >> a
   >>> import os
   >>> from hgclient import check, readchannel, runcommand
   >>> @check
   ... def outsidechanges(server):
   ...     readchannel(server)
   ...     runcommand(server, [b'status'])
   ...     os.system('hg ci -Am2')
   ...     runcommand(server, [b'tip'])
   ...     runcommand(server, [b'status'])
   *** runcommand status
   M a
   *** runcommand tip
   changeset:   1:d3a0a68be6de
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2
   
   *** runcommand status
 
   >>> import os
   >>> from hgclient import bprint, check, readchannel, runcommand
   >>> @check
   ... def bookmarks(server):
   ...     readchannel(server)
   ...     runcommand(server, [b'bookmarks'])
   ... 
   ...     # changes .hg/bookmarks
   ...     os.system('hg bookmark -i bm1')
   ...     os.system('hg bookmark -i bm2')
   ...     runcommand(server, [b'bookmarks'])
   ... 
   ...     # changes .hg/bookmarks.current
   ...     os.system('hg upd bm1 -q')
   ...     runcommand(server, [b'bookmarks'])
   ... 
   ...     runcommand(server, [b'bookmarks', b'bm3'])
   ...     f = open('a', 'ab')
   ...     f.write(b'a\n') and None
   ...     f.close()
   ...     runcommand(server, [b'commit', b'-Amm'])
   ...     runcommand(server, [b'bookmarks'])
   ...     bprint(b'')
   *** runcommand bookmarks
   no bookmarks set
   *** runcommand bookmarks
      bm1                       1:d3a0a68be6de
      bm2                       1:d3a0a68be6de
   *** runcommand bookmarks
    * bm1                       1:d3a0a68be6de
      bm2                       1:d3a0a68be6de
   *** runcommand bookmarks bm3
   *** runcommand commit -Amm
   *** runcommand bookmarks
      bm1                       1:d3a0a68be6de
      bm2                       1:d3a0a68be6de
    * bm3                       2:aef17e88f5f0
   
 
   >>> import os
   >>> from hgclient import check, readchannel, runcommand
   >>> @check
   ... def tagscache(server):
   ...     readchannel(server)
   ...     runcommand(server, [b'id', b'-t', b'-r', b'0'])
   ...     os.system('hg tag -r 0 foo')
   ...     runcommand(server, [b'id', b'-t', b'-r', b'0'])
   *** runcommand id -t -r 0
   
   *** runcommand id -t -r 0
   foo
 
   >>> import os
   >>> from hgclient import check, readchannel, runcommand
   >>> @check
   ... def setphase(server):
   ...     readchannel(server)
   ...     runcommand(server, [b'phase', b'-r', b'.'])
   ...     os.system('hg phase -r . -p')
   ...     runcommand(server, [b'phase', b'-r', b'.'])
   *** runcommand phase -r .
   3: draft
   *** runcommand phase -r .
   3: public
 
   $ echo a >> a
   >>> from hgclient import bprint, check, readchannel, runcommand
   >>> @check
   ... def rollback(server):
   ...     readchannel(server)
   ...     runcommand(server, [b'phase', b'-r', b'.', b'-p'])
   ...     runcommand(server, [b'commit', b'-Am.'])
   ...     runcommand(server, [b'rollback'])
   ...     runcommand(server, [b'phase', b'-r', b'.'])
   ...     bprint(b'')
   *** runcommand phase -r . -p
   no phases changed
   *** runcommand commit -Am.
   *** runcommand rollback
   repository tip rolled back to revision 3 (undo commit)
   working directory now based on revision 3
   *** runcommand phase -r .
   3: public
   
 
   >>> import os
   >>> from hgclient import check, readchannel, runcommand
   >>> @check
   ... def branch(server):
   ...     readchannel(server)
   ...     runcommand(server, [b'branch'])
   ...     os.system('hg branch foo')
   ...     runcommand(server, [b'branch'])
   ...     os.system('hg branch default')
   *** runcommand branch
   default
   marked working directory as branch foo
   (branches are permanent and global, did you want a bookmark?)
   *** runcommand branch
   foo
   marked working directory as branch default
   (branches are permanent and global, did you want a bookmark?)
 
   $ touch .hgignore
   >>> import os
   >>> from hgclient import bprint, check, readchannel, runcommand
   >>> @check
   ... def hgignore(server):
   ...     readchannel(server)
   ...     runcommand(server, [b'commit', b'-Am.'])
   ...     f = open('ignored-file', 'ab')
   ...     f.write(b'') and None
   ...     f.close()
   ...     f = open('.hgignore', 'ab')
   ...     f.write(b'ignored-file')
   ...     f.close()
   ...     runcommand(server, [b'status', b'-i', b'-u'])
   ...     bprint(b'')
   *** runcommand commit -Am.
   adding .hgignore
   *** runcommand status -i -u
   I ignored-file
   
 
 cache of non-public revisions should be invalidated on repository change
 (issue4855):
 
   >>> import os
   >>> from hgclient import bprint, check, readchannel, runcommand
   >>> @check
   ... def phasesetscacheaftercommit(server):
   ...     readchannel(server)
   ...     # load _phasecache._phaserevs and _phasesets
   ...     runcommand(server, [b'log', b'-qr', b'draft()'])
   ...     # create draft commits by another process
   ...     for i in range(5, 7):
   ...         f = open('a', 'ab')
   ...         f.seek(0, os.SEEK_END)
   ...         f.write(b'a\n') and None
   ...         f.close()
   ...         os.system('hg commit -Aqm%d' % i)
   ...     # new commits should be listed as draft revisions
   ...     runcommand(server, [b'log', b'-qr', b'draft()'])
   ...     bprint(b'')
   *** runcommand log -qr draft()
   4:7966c8e3734d
   *** runcommand log -qr draft()
   4:7966c8e3734d
   5:41f6602d1c4f
   6:10501e202c35
   
 
   >>> import os
   >>> from hgclient import bprint, check, readchannel, runcommand
   >>> @check
   ... def phasesetscacheafterstrip(server):
   ...     readchannel(server)
   ...     # load _phasecache._phaserevs and _phasesets
   ...     runcommand(server, [b'log', b'-qr', b'draft()'])
   ...     # strip cached revisions by another process
   ...     os.system('hg --config extensions.strip= strip -q 5')
   ...     # shouldn't abort by "unknown revision '6'"
   ...     runcommand(server, [b'log', b'-qr', b'draft()'])
   ...     bprint(b'')
   *** runcommand log -qr draft()
   4:7966c8e3734d
   5:41f6602d1c4f
   6:10501e202c35
   *** runcommand log -qr draft()
   4:7966c8e3734d
   
 
 cache of phase roots should be invalidated on strip (issue3827):
 
   >>> import os
   >>> from hgclient import check, readchannel, runcommand, sep
   >>> @check
   ... def phasecacheafterstrip(server):
   ...     readchannel(server)
   ... 
   ...     # create new head, 5:731265503d86
   ...     runcommand(server, [b'update', b'-C', b'0'])
   ...     f = open('a', 'ab')
   ...     f.write(b'a\n') and None
   ...     f.close()
   ...     runcommand(server, [b'commit', b'-Am.', b'a'])
   ...     runcommand(server, [b'log', b'-Gq'])
   ... 
   ...     # make it public; draft marker moves to 4:7966c8e3734d
   ...     runcommand(server, [b'phase', b'-p', b'.'])
   ...     # load _phasecache.phaseroots
   ...     runcommand(server, [b'phase', b'.'], outfilter=sep)
   ... 
   ...     # strip 1::4 outside server
   ...     os.system('hg -q --config extensions.mq= strip 1')
   ... 
   ...     # shouldn't raise "7966c8e3734d: no node!"
   ...     runcommand(server, [b'branches'])
   *** runcommand update -C 0
   1 files updated, 0 files merged, 2 files removed, 0 files unresolved
   (leaving bookmark bm3)
   *** runcommand commit -Am. a
   created new head
   *** runcommand log -Gq
   @  5:731265503d86
   |
   | o  4:7966c8e3734d
   | |
   | o  3:b9b85890c400
   | |
   | o  2:aef17e88f5f0
   | |
   | o  1:d3a0a68be6de
   |/
   o  0:eff892de26ec
   
   *** runcommand phase -p .
   *** runcommand phase .
   5: public
   *** runcommand branches
   default                        1:731265503d86
 
 in-memory cache must be reloaded if transaction is aborted. otherwise
 changelog and manifest would have invalid node:
 
   $ echo a >> a
   >>> from hgclient import check, readchannel, runcommand
   >>> @check
   ... def txabort(server):
   ...     readchannel(server)
   ...     runcommand(server, [b'commit', b'--config', b'hooks.pretxncommit=false',
   ...                         b'-mfoo'])
   ...     runcommand(server, [b'verify'])
   *** runcommand commit --config hooks.pretxncommit=false -mfoo
   transaction abort!
   rollback completed
   abort: pretxncommit hook exited with status 1
    [255]
   *** runcommand verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   checked 2 changesets with 2 changes to 1 files
   $ hg revert --no-backup -aq
 
   $ cat >> .hg/hgrc << EOF
   > [experimental]
   > evolution.createmarkers=True
   > EOF
 
   >>> import os
   >>> from hgclient import check, readchannel, runcommand
   >>> @check
   ... def obsolete(server):
   ...     readchannel(server)
   ... 
   ...     runcommand(server, [b'up', b'null'])
   ...     runcommand(server, [b'phase', b'-df', b'tip'])
   ...     cmd = 'hg debugobsolete `hg log -r tip --template {node}`'
   ...     if os.name == 'nt':
   ...         cmd = 'sh -c "%s"' % cmd # run in sh, not cmd.exe
   ...     os.system(cmd)
   ...     runcommand(server, [b'log', b'--hidden'])
   ...     runcommand(server, [b'log'])
   *** runcommand up null
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   *** runcommand phase -df tip
   1 new obsolescence markers
   obsoleted 1 changesets
   *** runcommand log --hidden
   changeset:   1:731265503d86
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   obsolete:    pruned
   summary:     .
   
   changeset:   0:eff892de26ec
   bookmark:    bm1
   bookmark:    bm2
   bookmark:    bm3
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1
   
   *** runcommand log
   changeset:   0:eff892de26ec
   bookmark:    bm1
   bookmark:    bm2
   bookmark:    bm3
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1
   
 
   $ cat <<EOF >> .hg/hgrc
   > [extensions]
   > mq =
   > EOF
 
   >>> import os
   >>> from hgclient import check, readchannel, runcommand
   >>> @check
   ... def mqoutsidechanges(server):
   ...     readchannel(server)
   ... 
   ...     # load repo.mq
   ...     runcommand(server, [b'qapplied'])
   ...     os.system('hg qnew 0.diff')
   ...     # repo.mq should be invalidated
   ...     runcommand(server, [b'qapplied'])
   ... 
   ...     runcommand(server, [b'qpop', b'--all'])
   ...     os.system('hg qqueue --create foo')
   ...     # repo.mq should be recreated to point to new queue
   ...     runcommand(server, [b'qqueue', b'--active'])
   *** runcommand qapplied
   *** runcommand qapplied
   0.diff
   *** runcommand qpop --all
   popping 0.diff
   patch queue now empty
   *** runcommand qqueue --active
   foo
 
   $ cat <<'EOF' > ../dbgui.py
   > import os
   > import sys
   > from mercurial import commands, registrar
   > cmdtable = {}
   > command = registrar.command(cmdtable)
   > @command(b"debuggetpass", norepo=True)
   > def debuggetpass(ui):
   >     ui.write(b"%s\n" % ui.getpass())
   > @command(b"debugprompt", norepo=True)
   > def debugprompt(ui):
   >     ui.write(b"%s\n" % ui.prompt(b"prompt:"))
   > @command(b"debugpromptchoice", norepo=True)
   > def debugpromptchoice(ui):
   >     msg = b"promptchoice (y/n)? $$ &Yes $$ &No"
   >     ui.write(b"%d\n" % ui.promptchoice(msg))
   > @command(b"debugreadstdin", norepo=True)
   > def debugreadstdin(ui):
   >     ui.write(b"read: %r\n" % sys.stdin.read(1))
   > @command(b"debugwritestdout", norepo=True)
   > def debugwritestdout(ui):
   >     os.write(1, b"low-level stdout fd and\n")
   >     sys.stdout.write("stdout should be redirected to stderr\n")
   >     sys.stdout.flush()
   > EOF
   $ cat <<EOF >> .hg/hgrc
   > [extensions]
   > dbgui = ../dbgui.py
   > EOF
 
   >>> from hgclient import check, readchannel, runcommand, stringio
   >>> @check
   ... def getpass(server):
   ...     readchannel(server)
   ...     runcommand(server, [b'debuggetpass', b'--config',
   ...                         b'ui.interactive=True'],
   ...                input=stringio(b'1234\n'))
   ...     runcommand(server, [b'debuggetpass', b'--config',
   ...                         b'ui.interactive=True'],
   ...                input=stringio(b'\n'))
   ...     runcommand(server, [b'debuggetpass', b'--config',
   ...                         b'ui.interactive=True'],
   ...                input=stringio(b''))
   ...     runcommand(server, [b'debugprompt', b'--config',
   ...                         b'ui.interactive=True'],
   ...                input=stringio(b'5678\n'))
   ...     runcommand(server, [b'debugprompt', b'--config',
   ...                         b'ui.interactive=True'],
   ...                input=stringio(b'\nremainder\nshould\nnot\nbe\nread\n'))
   ...     runcommand(server, [b'debugreadstdin'])
   ...     runcommand(server, [b'debugwritestdout'])
   *** runcommand debuggetpass --config ui.interactive=True
   password: 1234
   *** runcommand debuggetpass --config ui.interactive=True
   password: 
   *** runcommand debuggetpass --config ui.interactive=True
   password: abort: response expected
    [255]
   *** runcommand debugprompt --config ui.interactive=True
   prompt: 5678
   *** runcommand debugprompt --config ui.interactive=True
   prompt: y
   *** runcommand debugreadstdin
   read: ''
   *** runcommand debugwritestdout
   low-level stdout fd and
   stdout should be redirected to stderr
 
 
 run commandserver in commandserver, which is silly but should work:
 
   >>> from hgclient import bprint, check, readchannel, runcommand, stringio
   >>> @check
   ... def nested(server):
   ...     bprint(b'%c, %r' % readchannel(server))
   ...     class nestedserver(object):
   ...         stdin = stringio(b'getencoding\n')
   ...         stdout = stringio()
   ...     runcommand(server, [b'serve', b'--cmdserver', b'pipe'],
   ...                output=nestedserver.stdout, input=nestedserver.stdin)
   ...     nestedserver.stdout.seek(0)
   ...     bprint(b'%c, %r' % readchannel(nestedserver))  # hello
   ...     bprint(b'%c, %r' % readchannel(nestedserver))  # getencoding
   o, 'capabilities: getencoding runcommand\nencoding: *\npid: *' (glob)
   *** runcommand serve --cmdserver pipe
   o, 'capabilities: getencoding runcommand\nencoding: *\npid: *' (glob)
   r, '*' (glob)
 
 
 start without repository:
 
   $ cd ..
 
   >>> from hgclient import bprint, check, readchannel, runcommand
   >>> @check
   ... def hellomessage(server):
   ...     ch, data = readchannel(server)
   ...     bprint(b'%c, %r' % (ch, data))
   ...     # run an arbitrary command to make sure the next thing the server
   ...     # sends isn't part of the hello message
   ...     runcommand(server, [b'id'])
   o, 'capabilities: getencoding runcommand\nencoding: *\npid: *' (glob)
   *** runcommand id
   abort: there is no Mercurial repository here (.hg not found)
    [255]
 
   >>> from hgclient import check, readchannel, runcommand
   >>> @check
   ... def startwithoutrepo(server):
   ...     readchannel(server)
   ...     runcommand(server, [b'init', b'repo2'])
   ...     runcommand(server, [b'id', b'-R', b'repo2'])
   *** runcommand init repo2
   *** runcommand id -R repo2
   000000000000 tip
 
 
 don't fall back to cwd if invalid -R path is specified (issue4805):
 
   $ cd repo
   $ hg serve --cmdserver pipe -R ../nonexistent
   abort: repository ../nonexistent not found!
   [255]
   $ cd ..
 
 
 #if no-windows
 
 option to not shutdown on SIGINT:
 
   $ cat <<'EOF' > dbgint.py
   > import os
   > import signal
   > import time
   > from mercurial import commands, registrar
   > cmdtable = {}
   > command = registrar.command(cmdtable)
   > @command(b"debugsleep", norepo=True)
   > def debugsleep(ui):
   >     time.sleep(1)
   > @command(b"debugsuicide", norepo=True)
   > def debugsuicide(ui):
   >     os.kill(os.getpid(), signal.SIGINT)
   >     time.sleep(1)
   > EOF
 
   >>> import signal
   >>> import time
   >>> from hgclient import checkwith, readchannel, runcommand
   >>> @checkwith(extraargs=[b'--config', b'cmdserver.shutdown-on-interrupt=False',
   ...                       b'--config', b'extensions.dbgint=dbgint.py'])
   ... def nointr(server):
   ...     readchannel(server)
   ...     server.send_signal(signal.SIGINT)  # server won't be terminated
   ...     time.sleep(1)
   ...     runcommand(server, [b'debugsleep'])
   ...     server.send_signal(signal.SIGINT)  # server won't be terminated
   ...     runcommand(server, [b'debugsleep'])
   ...     runcommand(server, [b'debugsuicide'])  # command can be interrupted
   ...     server.send_signal(signal.SIGTERM)  # server will be terminated
   ...     time.sleep(1)
   *** runcommand debugsleep
   *** runcommand debugsleep
   *** runcommand debugsuicide
   interrupted!
   killed!
    [255]
 
 #endif
 
 
 structured message channel:
 
   $ cat <<'EOF' >> repo2/.hg/hgrc
   > [ui]
   > # server --config should precede repository option
   > message-output = stdio
   > EOF
 
   >>> from hgclient import bprint, checkwith, readchannel, runcommand
   >>> @checkwith(extraargs=[b'--config', b'ui.message-output=channel',
   ...                       b'--config', b'cmdserver.message-encodings=foo cbor'])
   ... def verify(server):
   ...     _ch, data = readchannel(server)
   ...     bprint(data)
   ...     runcommand(server, [b'-R', b'repo2', b'verify'])
   capabilities: getencoding runcommand
   encoding: ascii
   message-encoding: cbor
   pid: * (glob)
   pgid: * (glob) (no-windows !)
   *** runcommand -R repo2 verify
   message: '\xa2DdataTchecking changesets\nDtypeFstatus'
   message: '\xa6Ditem@Cpos\xf6EtopicHcheckingEtotal\xf6DtypeHprogressDunit@'
   message: '\xa2DdataSchecking manifests\nDtypeFstatus'
   message: '\xa6Ditem@Cpos\xf6EtopicHcheckingEtotal\xf6DtypeHprogressDunit@'
   message: '\xa2DdataX0crosschecking files in changesets and manifests\nDtypeFstatus'
   message: '\xa6Ditem@Cpos\xf6EtopicMcrosscheckingEtotal\xf6DtypeHprogressDunit@'
   message: '\xa2DdataOchecking files\nDtypeFstatus'
   message: '\xa6Ditem@Cpos\xf6EtopicHcheckingEtotal\xf6DtypeHprogressDunit@'
   message: '\xa2DdataX/checked 0 changesets with 0 changes to 0 files\nDtypeFstatus'
 
   >>> from hgclient import checkwith, readchannel, runcommand, stringio
   >>> @checkwith(extraargs=[b'--config', b'ui.message-output=channel',
   ...                       b'--config', b'cmdserver.message-encodings=cbor',
   ...                       b'--config', b'extensions.dbgui=dbgui.py'])
   ... def prompt(server):
   ...     readchannel(server)
   ...     interactive = [b'--config', b'ui.interactive=True']
   ...     runcommand(server, [b'debuggetpass'] + interactive,
   ...                input=stringio(b'1234\n'))
   ...     runcommand(server, [b'debugprompt'] + interactive,
   ...                input=stringio(b'5678\n'))
   ...     runcommand(server, [b'debugpromptchoice'] + interactive,
   ...                input=stringio(b'n\n'))
   *** runcommand debuggetpass --config ui.interactive=True
   message: '\xa3DdataJpassword: Hpassword\xf5DtypeFprompt'
   1234
   *** runcommand debugprompt --config ui.interactive=True
   message: '\xa3DdataGprompt:GdefaultAyDtypeFprompt'
    5678
   *** runcommand debugpromptchoice --config ui.interactive=True
   message: '\xa4Gchoices\x82\x82AyCYes\x82AnBNoDdataTpromptchoice (y/n)? GdefaultAyDtypeFprompt'
    1
 
 bad message encoding:
 
   $ hg serve --cmdserver pipe --config ui.message-output=channel
   abort: no supported message encodings: 
   [255]
   $ hg serve --cmdserver pipe --config ui.message-output=channel \
   > --config cmdserver.message-encodings='foo bar'
   abort: no supported message encodings: foo bar
   [255]
 
 unix domain socket:
 
   $ cd repo
   $ hg update -q
 
 #if unix-socket unix-permissions
 
   >>> from hgclient import bprint, check, readchannel, runcommand, stringio, unixserver
   >>> server = unixserver(b'.hg/server.sock', b'.hg/server.log')
   >>> def hellomessage(conn):
   ...     ch, data = readchannel(conn)
   ...     bprint(b'%c, %r' % (ch, data))
   ...     runcommand(conn, [b'id'])
   >>> check(hellomessage, server.connect)
   o, 'capabilities: getencoding runcommand\nencoding: *\npid: *' (glob)
   *** runcommand id
   eff892de26ec tip bm1/bm2/bm3
   >>> def unknowncommand(conn):
   ...     readchannel(conn)
   ...     conn.stdin.write(b'unknowncommand\n')
   >>> check(unknowncommand, server.connect)  # error sent to server.log
   >>> def serverinput(conn):
   ...     readchannel(conn)
   ...     patch = b"""
   ... # HG changeset patch
   ... # User test
   ... # Date 0 0
   ... 2
   ... 
   ... diff -r eff892de26ec -r 1ed24be7e7a0 a
   ... --- a/a
   ... +++ b/a
   ... @@ -1,1 +1,2 @@
   ...  1
   ... +2
   ... """
   ...     runcommand(conn, [b'import', b'-'], input=stringio(patch))
   ...     runcommand(conn, [b'log', b'-rtip', b'-q'])
   >>> check(serverinput, server.connect)
   *** runcommand import -
   applying patch from stdin
   *** runcommand log -rtip -q
   2:1ed24be7e7a0
   >>> server.shutdown()
 
   $ cat .hg/server.log
   listening at .hg/server.sock
   abort: unknown command unknowncommand
   killed!
   $ rm .hg/server.log
 
  if server crashed before hello, traceback will be sent to 'e' channel as
  last ditch:
 
   $ cat <<'EOF' > ../earlycrasher.py
   > from mercurial import commandserver, extensions
   > def _serverequest(orig, ui, repo, conn, createcmdserver, prereposetups):
   >     def createcmdserver(*args, **kwargs):
   >         raise Exception('crash')
   >     return orig(ui, repo, conn, createcmdserver, prereposetups)
   > def extsetup(ui):
   >     extensions.wrapfunction(commandserver, b'_serverequest', _serverequest)
   > EOF
   $ cat <<EOF >> .hg/hgrc
   > [extensions]
   > earlycrasher = ../earlycrasher.py
   > EOF
   >>> from hgclient import bprint, check, readchannel, unixserver
   >>> server = unixserver(b'.hg/server.sock', b'.hg/server.log')
   >>> def earlycrash(conn):
   ...     while True:
   ...         try:
   ...             ch, data = readchannel(conn)
   ...             for l in data.splitlines(True):
   ...                 if not l.startswith(b'  '):
   ...                     bprint(b'%c, %r' % (ch, l))
   ...         except EOFError:
   ...             break
   >>> check(earlycrash, server.connect)
   e, 'Traceback (most recent call last):\n'
   e, 'Exception: crash\n'
   >>> server.shutdown()
 
   $ cat .hg/server.log | grep -v '^  '
   listening at .hg/server.sock
   Traceback (most recent call last):
   Exception: crash
   killed!
 #endif
 #if no-unix-socket
 
   $ hg serve --cmdserver unix -a .hg/server.sock
   abort: unsupported platform
   [255]
 
 #endif
 
   $ cd ..
 
 Test that accessing to invalid changelog cache is avoided at
 subsequent operations even if repo object is reused even after failure
 of transaction (see 0a7610758c42 also)
 
 "hg log" after failure of transaction is needed to detect invalid
 cache in repoview: this can't detect by "hg verify" only.
 
 Combination of "finalization" and "empty-ness of changelog" (2 x 2 =
 4) are tested, because '00changelog.i' are differently changed in each
 cases.
 
   $ cat > $TESTTMP/failafterfinalize.py <<EOF
   > # extension to abort transaction after finalization forcibly
   > from mercurial import commands, error, extensions, lock as lockmod
   > from mercurial import registrar
   > cmdtable = {}
   > command = registrar.command(cmdtable)
   > configtable = {}
   > configitem = registrar.configitem(configtable)
   > configitem(b'failafterfinalize', b'fail',
   >     default=None,
   > )
   > def fail(tr):
   >     raise error.Abort(b'fail after finalization')
   > def reposetup(ui, repo):
   >     class failrepo(repo.__class__):
   >         def commitctx(self, ctx, error=False, origctx=None):
   >             if self.ui.configbool(b'failafterfinalize', b'fail'):
   >                 # 'sorted()' by ASCII code on category names causes
   >                 # invoking 'fail' after finalization of changelog
   >                 # using "'cl-%i' % id(self)" as category name
   >                 self.currenttransaction().addfinalize(b'zzzzzzzz', fail)
   >             return super(failrepo, self).commitctx(ctx, error, origctx)
   >     repo.__class__ = failrepo
   > EOF
 
   $ hg init repo3
   $ cd repo3
 
   $ cat <<EOF >> $HGRCPATH
   > [command-templates]
   > log = {rev} {desc|firstline} ({files})\n
   > 
   > [extensions]
   > failafterfinalize = $TESTTMP/failafterfinalize.py
   > EOF
 
 - test failure with "empty changelog"
 
   $ echo foo > foo
   $ hg add foo
 
 (failure before finalization)
 
   >>> from hgclient import check, readchannel, runcommand
   >>> @check
   ... def abort(server):
   ...     readchannel(server)
   ...     runcommand(server, [b'commit',
   ...                         b'--config', b'hooks.pretxncommit=false',
   ...                         b'-mfoo'])
   ...     runcommand(server, [b'log'])
   ...     runcommand(server, [b'verify', b'-q'])
   *** runcommand commit --config hooks.pretxncommit=false -mfoo
   transaction abort!
   rollback completed
   abort: pretxncommit hook exited with status 1
    [255]
   *** runcommand log
   *** runcommand verify -q
 
 (failure after finalization)
 
   >>> from hgclient import check, readchannel, runcommand
   >>> @check
   ... def abort(server):
   ...     readchannel(server)
   ...     runcommand(server, [b'commit',
   ...                         b'--config', b'failafterfinalize.fail=true',
   ...                         b'-mfoo'])
   ...     runcommand(server, [b'log'])
   ...     runcommand(server, [b'verify', b'-q'])
   *** runcommand commit --config failafterfinalize.fail=true -mfoo
   transaction abort!
   rollback completed
   abort: fail after finalization
    [255]
   *** runcommand log
   *** runcommand verify -q
 
 - test failure with "not-empty changelog"
 
   $ echo bar > bar
   $ hg add bar
   $ hg commit -mbar bar
 
 (failure before finalization)
 
   >>> from hgclient import check, readchannel, runcommand
   >>> @check
   ... def abort(server):
   ...     readchannel(server)
   ...     runcommand(server, [b'commit',
   ...                         b'--config', b'hooks.pretxncommit=false',
   ...                         b'-mfoo', b'foo'])
   ...     runcommand(server, [b'log'])
   ...     runcommand(server, [b'verify', b'-q'])
   *** runcommand commit --config hooks.pretxncommit=false -mfoo foo
   transaction abort!
   rollback completed
   abort: pretxncommit hook exited with status 1
    [255]
   *** runcommand log
   0 bar (bar)
   *** runcommand verify -q
 
 (failure after finalization)
 
   >>> from hgclient import check, readchannel, runcommand
   >>> @check
   ... def abort(server):
   ...     readchannel(server)
   ...     runcommand(server, [b'commit',
   ...                         b'--config', b'failafterfinalize.fail=true',
   ...                         b'-mfoo', b'foo'])
   ...     runcommand(server, [b'log'])
   ...     runcommand(server, [b'verify', b'-q'])
   *** runcommand commit --config failafterfinalize.fail=true -mfoo foo
   transaction abort!
   rollback completed
   abort: fail after finalization
    [255]
   *** runcommand log
   0 bar (bar)
   *** runcommand verify -q
 
   $ cd ..
 
 Test symlink traversal over cached audited paths:
 -------------------------------------------------
 
 #if symlink
 
 set up symlink hell
 
   $ mkdir merge-symlink-out
   $ hg init merge-symlink
   $ cd merge-symlink
   $ touch base
   $ hg commit -qAm base
   $ ln -s ../merge-symlink-out a
   $ hg commit -qAm 'symlink a -> ../merge-symlink-out'
   $ hg up -q 0
   $ mkdir a
   $ touch a/poisoned
   $ hg commit -qAm 'file a/poisoned'
   $ hg log -G -T '{rev}: {desc}\n'
   @  2: file a/poisoned
   |
   | o  1: symlink a -> ../merge-symlink-out
   |/
   o  0: base
   
 
 try trivial merge after update: cache of audited paths should be discarded,
 and the merge should fail (issue5628)
 
   $ hg up -q null
   >>> from hgclient import check, readchannel, runcommand
   >>> @check
   ... def merge(server):
   ...     readchannel(server)
   ...     # audit a/poisoned as a good path
   ...     runcommand(server, [b'up', b'-qC', b'2'])
   ...     runcommand(server, [b'up', b'-qC', b'1'])
   ...     # here a is a symlink, so a/poisoned is bad
   ...     runcommand(server, [b'merge', b'2'])
   *** runcommand up -qC 2
   *** runcommand up -qC 1
   *** runcommand merge 2
   abort: path 'a/poisoned' traverses symbolic link 'a'
    [255]
   $ ls ../merge-symlink-out
 
 cache of repo.auditor should be discarded, so matcher would never traverse
 symlinks:
 
   $ hg up -qC 0
   $ touch ../merge-symlink-out/poisoned
   >>> from hgclient import check, readchannel, runcommand
   >>> @check
   ... def files(server):
   ...     readchannel(server)
   ...     runcommand(server, [b'up', b'-qC', b'2'])
   ...     # audit a/poisoned as a good path
   ...     runcommand(server, [b'files', b'a/poisoned'])
   ...     runcommand(server, [b'up', b'-qC', b'0'])
   ...     runcommand(server, [b'up', b'-qC', b'1'])
   ...     # here 'a' is a symlink, so a/poisoned should be warned
   ...     runcommand(server, [b'files', b'a/poisoned'])
   *** runcommand up -qC 2
   *** runcommand files a/poisoned
   a/poisoned
   *** runcommand up -qC 0
   *** runcommand up -qC 1
   *** runcommand files a/poisoned
   abort: path 'a/poisoned' traverses symbolic link 'a'
    [255]
 
   $ cd ..
 
 #endif

tests/test-copytrace-heuristics.t

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

tests/test-fix.t

@@ -1,1693 +1,1693 b''
 A script that implements uppercasing of specific lines in a file. This
 approximates the behavior of code formatters well enough for our tests.
 
   $ UPPERCASEPY="$TESTTMP/uppercase.py"
   $ cat > $UPPERCASEPY <<EOF
   > import sys
   > from mercurial.utils.procutil import setbinary
   > setbinary(sys.stdin)
   > setbinary(sys.stdout)
   > lines = set()
   > for arg in sys.argv[1:]:
   >   if arg == 'all':
   >     sys.stdout.write(sys.stdin.read().upper())
   >     sys.exit(0)
   >   else:
   >     first, last = arg.split('-')
   >     lines.update(range(int(first), int(last) + 1))
   > for i, line in enumerate(sys.stdin.readlines()):
   >   if i + 1 in lines:
   >     sys.stdout.write(line.upper())
   >   else:
   >     sys.stdout.write(line)
   > EOF
   $ TESTLINES="foo\nbar\nbaz\nqux\n"
   $ printf $TESTLINES | "$PYTHON" $UPPERCASEPY
   foo
   bar
   baz
   qux
   $ printf $TESTLINES | "$PYTHON" $UPPERCASEPY all
   FOO
   BAR
   BAZ
   QUX
   $ printf $TESTLINES | "$PYTHON" $UPPERCASEPY 1-1
   FOO
   bar
   baz
   qux
   $ printf $TESTLINES | "$PYTHON" $UPPERCASEPY 1-2
   FOO
   BAR
   baz
   qux
   $ printf $TESTLINES | "$PYTHON" $UPPERCASEPY 2-3
   foo
   BAR
   BAZ
   qux
   $ printf $TESTLINES | "$PYTHON" $UPPERCASEPY 2-2 4-4
   foo
   BAR
   baz
   QUX
 
 Set up the config with two simple fixers: one that fixes specific line ranges,
 and one that always fixes the whole file. They both "fix" files by converting
 letters to uppercase. They use different file extensions, so each test case can
 choose which behavior to use by naming files.
 
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > fix =
   > [experimental]
   > evolution.createmarkers=True
   > evolution.allowunstable=True
   > [fix]
   > uppercase-whole-file:command="$PYTHON" $UPPERCASEPY all
   > uppercase-whole-file:pattern=set:**.whole
   > uppercase-changed-lines:command="$PYTHON" $UPPERCASEPY
   > uppercase-changed-lines:linerange={first}-{last}
   > uppercase-changed-lines:pattern=set:**.changed
   > EOF
 
 Help text for fix.
 
   $ hg help fix
   hg fix [OPTION]... [FILE]...
   
   rewrite file content in changesets or working directory
   
       Runs any configured tools to fix the content of files. Only affects files
       with changes, unless file arguments are provided. Only affects changed
       lines of files, unless the --whole flag is used. Some tools may always
       affect the whole file regardless of --whole.
   
       If --working-dir is used, files with uncommitted changes in the working
       copy will be fixed. Note that no backup are made.
   
       If revisions are specified with --source, those revisions and their
       descendants will be checked, and they may be replaced with new revisions
       that have fixed file content. By automatically including the descendants,
       no merging, rebasing, or evolution will be required. If an ancestor of the
       working copy is included, then the working copy itself will also be fixed,
       and the working copy will be updated to the fixed parent.
   
       When determining what lines of each file to fix at each revision, the
       whole set of revisions being fixed is considered, so that fixes to earlier
       revisions are not forgotten in later ones. The --base flag can be used to
       override this default behavior, though it is not usually desirable to do
       so.
   
   (use 'hg help -e fix' to show help for the fix extension)
   
   options ([+] can be repeated):
   
       --all            fix all non-public non-obsolete revisions
       --base REV [+]   revisions to diff against (overrides automatic selection,
                        and applies to every revision being fixed)
    -s --source REV [+] fix the specified revisions and their descendants
    -w --working-dir    fix the working directory
       --whole          always fix every line of a file
   
   (some details hidden, use --verbose to show complete help)
 
   $ hg help -e fix
   fix extension - rewrite file content in changesets or working copy
   (EXPERIMENTAL)
   
   Provides a command that runs configured tools on the contents of modified
   files, writing back any fixes to the working copy or replacing changesets.
   
   Here is an example configuration that causes 'hg fix' to apply automatic
   formatting fixes to modified lines in C++ code:
   
     [fix]
     clang-format:command=clang-format --assume-filename={rootpath}
     clang-format:linerange=--lines={first}:{last}
     clang-format:pattern=set:**.cpp or **.hpp
   
   The :command suboption forms the first part of the shell command that will be
   used to fix a file. The content of the file is passed on standard input, and
   the fixed file content is expected on standard output. Any output on standard
   error will be displayed as a warning. If the exit status is not zero, the file
   will not be affected. A placeholder warning is displayed if there is a non-
   zero exit status but no standard error output. Some values may be substituted
   into the command:
   
     {rootpath}  The path of the file being fixed, relative to the repo root
     {basename}  The name of the file being fixed, without the directory path
   
   If the :linerange suboption is set, the tool will only be run if there are
   changed lines in a file. The value of this suboption is appended to the shell
   command once for every range of changed lines in the file. Some values may be
   substituted into the command:
   
     {first}   The 1-based line number of the first line in the modified range
     {last}    The 1-based line number of the last line in the modified range
   
   Deleted sections of a file will be ignored by :linerange, because there is no
   corresponding line range in the version being fixed.
   
   By default, tools that set :linerange will only be executed if there is at
   least one changed line range. This is meant to prevent accidents like running
   a code formatter in such a way that it unexpectedly reformats the whole file.
   If such a tool needs to operate on unchanged files, it should set the
   :skipclean suboption to false.
   
   The :pattern suboption determines which files will be passed through each
   configured tool. See 'hg help patterns' for possible values. However, all
   patterns are relative to the repo root, even if that text says they are
   relative to the current working directory. If there are file arguments to 'hg
   fix', the intersection of these patterns is used.
   
   There is also a configurable limit for the maximum size of file that will be
   processed by 'hg fix':
   
     [fix]
     maxfilesize = 2MB
   
   Normally, execution of configured tools will continue after a failure
   (indicated by a non-zero exit status). It can also be configured to abort
   after the first such failure, so that no files will be affected if any tool
   fails. This abort will also cause 'hg fix' to exit with a non-zero status:
   
     [fix]
     failure = abort
   
   When multiple tools are configured to affect a file, they execute in an order
   defined by the :priority suboption. The priority suboption has a default value
   of zero for each tool. Tools are executed in order of descending priority. The
   execution order of tools with equal priority is unspecified. For example, you
   could use the 'sort' and 'head' utilities to keep only the 10 smallest numbers
   in a text file by ensuring that 'sort' runs before 'head':
   
     [fix]
     sort:command = sort -n
     head:command = head -n 10
     sort:pattern = numbers.txt
     head:pattern = numbers.txt
     sort:priority = 2
     head:priority = 1
   
   To account for changes made by each tool, the line numbers used for
   incremental formatting are recomputed before executing the next tool. So, each
   tool may see different values for the arguments added by the :linerange
   suboption.
   
   Each fixer tool is allowed to return some metadata in addition to the fixed
   file content. The metadata must be placed before the file content on stdout,
   separated from the file content by a zero byte. The metadata is parsed as a
   JSON value (so, it should be UTF-8 encoded and contain no zero bytes). A fixer
   tool is expected to produce this metadata encoding if and only if the
   :metadata suboption is true:
   
     [fix]
     tool:command = tool --prepend-json-metadata
     tool:metadata = true
   
   The metadata values are passed to hooks, which can be used to print summaries
   or perform other post-fixing work. The supported hooks are:
   
     "postfixfile"
       Run once for each file in each revision where any fixer tools made changes
       to the file content. Provides "$HG_REV" and "$HG_PATH" to identify the file,
       and "$HG_METADATA" with a map of fixer names to metadata values from fixer
       tools that affected the file. Fixer tools that didn't affect the file have a
       value of None. Only fixer tools that executed are present in the metadata.
   
     "postfix"
       Run once after all files and revisions have been handled. Provides
       "$HG_REPLACEMENTS" with information about what revisions were created and
       made obsolete. Provides a boolean "$HG_WDIRWRITTEN" to indicate whether any
       files in the working copy were updated. Provides a list "$HG_METADATA"
       mapping fixer tool names to lists of metadata values returned from
       executions that modified a file. This aggregates the same metadata
       previously passed to the "postfixfile" hook.
   
   Fixer tools are run in the repository's root directory. This allows them to
   read configuration files from the working copy, or even write to the working
   copy. The working copy is not updated to match the revision being fixed. In
   fact, several revisions may be fixed in parallel. Writes to the working copy
   are not amended into the revision being fixed; fixer tools should always write
   fixed file content back to stdout as documented above.
   
   list of commands:
   
    fix           rewrite file content in changesets or working directory
   
   (use 'hg help -v -e fix' to show built-in aliases and global options)
 
 There is no default behavior in the absence of --rev and --working-dir.
 
   $ hg init badusage
   $ cd badusage
 
   $ hg fix
   abort: no changesets specified
   (use --source or --working-dir)
   [255]
   $ hg fix --whole
   abort: no changesets specified
   (use --source or --working-dir)
   [255]
   $ hg fix --base 0
   abort: no changesets specified
   (use --source or --working-dir)
   [255]
 
 Fixing a public revision isn't allowed. It should abort early enough that
 nothing happens, even to the working directory.
 
   $ printf "hello\n" > hello.whole
   $ hg commit -Aqm "hello"
   $ hg phase -r 0 --public
   $ hg fix -r 0
   abort: cannot fix public changesets
   (see 'hg help phases' for details)
   [255]
   $ hg fix -r 0 --working-dir
   abort: cannot fix public changesets
   (see 'hg help phases' for details)
   [255]
   $ hg cat -r tip hello.whole
   hello
   $ cat hello.whole
   hello
 
   $ cd ..
 
 Fixing a clean working directory should do nothing. Even the --whole flag
 shouldn't cause any clean files to be fixed. Specifying a clean file explicitly
 should only fix it if the fixer always fixes the whole file. The combination of
 an explicit filename and --whole should format the entire file regardless.
 
   $ hg init fixcleanwdir
   $ cd fixcleanwdir
 
   $ printf "hello\n" > hello.changed
   $ printf "world\n" > hello.whole
   $ hg commit -Aqm "foo"
   $ hg fix --working-dir
   $ hg diff
   $ hg fix --working-dir --whole
   $ hg diff
   $ hg fix --working-dir *
   $ cat *
   hello
   WORLD
   $ hg revert --all --no-backup
   reverting hello.whole
   $ hg fix --working-dir * --whole
   $ cat *
   HELLO
   WORLD
 
 The same ideas apply to fixing a revision, so we create a revision that doesn't
 modify either of the files in question and try fixing it. This also tests that
 we ignore a file that doesn't match any configured fixer.
 
   $ hg revert --all --no-backup
   reverting hello.changed
   reverting hello.whole
   $ printf "unimportant\n" > some.file
   $ hg commit -Aqm "some other file"
 
   $ hg fix -r .
   $ hg cat -r tip *
   hello
   world
   unimportant
   $ hg fix -r . --whole
   $ hg cat -r tip *
   hello
   world
   unimportant
   $ hg fix -r . *
   $ hg cat -r tip *
   hello
   WORLD
   unimportant
   $ hg fix -r . * --whole --config experimental.evolution.allowdivergence=true
   2 new content-divergent changesets
   $ hg cat -r tip *
   HELLO
   WORLD
   unimportant
 
   $ cd ..
 
 Fixing the working directory should still work if there are no revisions.
 
   $ hg init norevisions
   $ cd norevisions
 
   $ printf "something\n" > something.whole
   $ hg add
   adding something.whole
   $ hg fix --working-dir
   $ cat something.whole
   SOMETHING
 
   $ cd ..
 
 Test the effect of fixing the working directory for each possible status, with
 and without providing explicit file arguments.
 
   $ hg init implicitlyfixstatus
   $ cd implicitlyfixstatus
 
   $ printf "modified\n" > modified.whole
   $ printf "removed\n" > removed.whole
   $ printf "deleted\n" > deleted.whole
   $ printf "clean\n" > clean.whole
   $ printf "ignored.whole" > .hgignore
   $ hg commit -Aqm "stuff"
 
   $ printf "modified!!!\n" > modified.whole
   $ printf "unknown\n" > unknown.whole
   $ printf "ignored\n" > ignored.whole
   $ printf "added\n" > added.whole
   $ hg add added.whole
   $ hg remove removed.whole
   $ rm deleted.whole
 
   $ hg status --all
   M modified.whole
   A added.whole
   R removed.whole
   ! deleted.whole
   ? unknown.whole
   I ignored.whole
   C .hgignore
   C clean.whole
 
   $ hg fix --working-dir
 
   $ hg status --all
   M modified.whole
   A added.whole
   R removed.whole
   ! deleted.whole
   ? unknown.whole
   I ignored.whole
   C .hgignore
   C clean.whole
 
   $ cat *.whole
   ADDED
   clean
   ignored
   MODIFIED!!!
   unknown
 
   $ printf "modified!!!\n" > modified.whole
   $ printf "added\n" > added.whole
 
 Listing the files explicitly causes untracked files to also be fixed, but
 ignored files are still unaffected.
 
   $ hg fix --working-dir *.whole
 
   $ hg status --all
   M clean.whole
   M modified.whole
   A added.whole
   R removed.whole
   ! deleted.whole
   ? unknown.whole
   I ignored.whole
   C .hgignore
 
   $ cat *.whole
   ADDED
   CLEAN
   ignored
   MODIFIED!!!
   UNKNOWN
 
   $ cd ..
 
 Test that incremental fixing works on files with additions, deletions, and
 changes in multiple line ranges. Note that deletions do not generally cause
 neighboring lines to be fixed, so we don't return a line range for purely
 deleted sections. In the future we should support a :deletion config that
 allows fixers to know where deletions are located.
 
   $ hg init incrementalfixedlines
   $ cd incrementalfixedlines
 
   $ printf "a\nb\nc\nd\ne\nf\ng\n" > foo.txt
   $ hg commit -Aqm "foo"
   $ printf "zz\na\nc\ndd\nee\nff\nf\ngg\n" > foo.txt
 
   $ hg --config "fix.fail:command=echo" \
   >    --config "fix.fail:linerange={first}:{last}" \
   >    --config "fix.fail:pattern=foo.txt" \
   >    fix --working-dir
   $ cat foo.txt
   1:1 4:6 8:8
 
   $ cd ..
 
 Test that --whole fixes all lines regardless of the diffs present.
 
   $ hg init wholeignoresdiffs
   $ cd wholeignoresdiffs
 
   $ printf "a\nb\nc\nd\ne\nf\ng\n" > foo.changed
   $ hg commit -Aqm "foo"
   $ printf "zz\na\nc\ndd\nee\nff\nf\ngg\n" > foo.changed
 
   $ hg fix --working-dir
   $ cat foo.changed
   ZZ
   a
   c
   DD
   EE
   FF
   f
   GG
 
   $ hg fix --working-dir --whole
   $ cat foo.changed
   ZZ
   A
   C
   DD
   EE
   FF
   F
   GG
 
   $ cd ..
 
 We should do nothing with symlinks, and their targets should be unaffected. Any
 other behavior would be more complicated to implement and harder to document.
 
 #if symlink
   $ hg init dontmesswithsymlinks
   $ cd dontmesswithsymlinks
 
   $ printf "hello\n" > hello.whole
   $ ln -s hello.whole hellolink
   $ hg add
   adding hello.whole
   adding hellolink
   $ hg fix --working-dir hellolink
   $ hg status
   A hello.whole
   A hellolink
 
   $ cd ..
 #endif
 
 We should allow fixers to run on binary files, even though this doesn't sound
 like a common use case. There's not much benefit to disallowing it, and users
 can add "and not binary()" to their filesets if needed. The Mercurial
 philosophy is generally to not handle binary files specially anyway.
 
   $ hg init cantouchbinaryfiles
   $ cd cantouchbinaryfiles
 
   $ printf "hello\0\n" > hello.whole
   $ hg add
   adding hello.whole
   $ hg fix --working-dir 'set:binary()'
   $ cat hello.whole
   HELLO\x00 (esc)
 
   $ cd ..
 
 We have a config for the maximum size of file we will attempt to fix. This can
 be helpful to avoid running unsuspecting fixer tools on huge inputs, which
 could happen by accident without a well considered configuration. A more
 precise configuration could use the size() fileset function if one global limit
 is undesired.
 
   $ hg init maxfilesize
   $ cd maxfilesize
 
   $ printf "this file is huge\n" > hello.whole
   $ hg add
   adding hello.whole
   $ hg --config fix.maxfilesize=10 fix --working-dir
   ignoring file larger than 10 bytes: hello.whole
   $ cat hello.whole
   this file is huge
 
   $ cd ..
 
 If we specify a file to fix, other files should be left alone, even if they
 have changes.
 
   $ hg init fixonlywhatitellyouto
   $ cd fixonlywhatitellyouto
 
   $ printf "fix me!\n" > fixme.whole
   $ printf "not me.\n" > notme.whole
   $ hg add
   adding fixme.whole
   adding notme.whole
   $ hg fix --working-dir fixme.whole
   $ cat *.whole
   FIX ME!
   not me.
 
   $ cd ..
 
 If we try to fix a missing file, we still fix other files.
 
   $ hg init fixmissingfile
   $ cd fixmissingfile
 
   $ printf "fix me!\n" > foo.whole
   $ hg add
   adding foo.whole
   $ hg fix --working-dir foo.whole bar.whole
   bar.whole: $ENOENT$
   $ cat *.whole
   FIX ME!
 
   $ cd ..
 
 Specifying a directory name should fix all its files and subdirectories.
 
   $ hg init fixdirectory
   $ cd fixdirectory
 
   $ mkdir -p dir1/dir2
   $ printf "foo\n" > foo.whole
   $ printf "bar\n" > dir1/bar.whole
   $ printf "baz\n" > dir1/dir2/baz.whole
   $ hg add
   adding dir1/bar.whole
   adding dir1/dir2/baz.whole
   adding foo.whole
   $ hg fix --working-dir dir1
   $ cat foo.whole dir1/bar.whole dir1/dir2/baz.whole
   foo
   BAR
   BAZ
 
   $ cd ..
 
 Fixing a file in the working directory that needs no fixes should not actually
 write back to the file, so for example the mtime shouldn't change.
 
   $ hg init donttouchunfixedfiles
   $ cd donttouchunfixedfiles
 
   $ printf "NO FIX NEEDED\n" > foo.whole
   $ hg add
   adding foo.whole
   $ cp -p foo.whole foo.whole.orig
   $ cp -p foo.whole.orig foo.whole
   $ sleep 2 # mtime has a resolution of one or two seconds.
   $ hg fix --working-dir
   $ f foo.whole.orig --newer foo.whole
   foo.whole.orig: newer than foo.whole
 
   $ cd ..
 
 When a fixer prints to stderr, we don't assume that it has failed. We show the
 error messages to the user, and we still let the fixer affect the file it was
 fixing if its exit code is zero. Some code formatters might emit error messages
 on stderr and nothing on stdout, which would cause us the clear the file,
 except that they also exit with a non-zero code. We show the user which fixer
 emitted the stderr, and which revision, but we assume that the fixer will print
 the filename if it is relevant (since the issue may be non-specific). There is
 also a config to abort (without affecting any files whatsoever) if we see any
 tool with a non-zero exit status.
 
   $ hg init showstderr
   $ cd showstderr
 
   $ printf "hello\n" > hello.txt
   $ hg add
   adding hello.txt
   $ cat > $TESTTMP/work.sh <<'EOF'
   > printf 'HELLO\n'
   > printf "$@: some\nerror that didn't stop the tool" >&2
   > exit 0 # success despite the stderr output
   > EOF
   $ hg --config "fix.work:command=sh $TESTTMP/work.sh {rootpath}" \
   >    --config "fix.work:pattern=hello.txt" \
   >    fix --working-dir
   [wdir] work: hello.txt: some
   [wdir] work: error that didn't stop the tool
   $ cat hello.txt
   HELLO
 
   $ printf "goodbye\n" > hello.txt
   $ printf "foo\n" > foo.whole
   $ hg add
   adding foo.whole
   $ cat > $TESTTMP/fail.sh <<'EOF'
   > printf 'GOODBYE\n'
   > printf "$@: some\nerror that did stop the tool\n" >&2
   > exit 42 # success despite the stdout output
   > EOF
   $ hg --config "fix.fail:command=sh $TESTTMP/fail.sh {rootpath}" \
   >    --config "fix.fail:pattern=hello.txt" \
   >    --config "fix.failure=abort" \
   >    fix --working-dir
   [wdir] fail: hello.txt: some
   [wdir] fail: error that did stop the tool
   abort: no fixes will be applied
   (use --config fix.failure=continue to apply any successful fixes anyway)
   [255]
   $ cat hello.txt
   goodbye
   $ cat foo.whole
   foo
 
   $ hg --config "fix.fail:command=sh $TESTTMP/fail.sh {rootpath}" \
   >    --config "fix.fail:pattern=hello.txt" \
   >    fix --working-dir
   [wdir] fail: hello.txt: some
   [wdir] fail: error that did stop the tool
   $ cat hello.txt
   goodbye
   $ cat foo.whole
   FOO
 
   $ hg --config "fix.fail:command=exit 42" \
   >    --config "fix.fail:pattern=hello.txt" \
   >    fix --working-dir
   [wdir] fail: exited with status 42
 
   $ cd ..
 
 Fixing the working directory and its parent revision at the same time should
 check out the replacement revision for the parent. This prevents any new
 uncommitted changes from appearing. We test this for a clean working directory
 and a dirty one. In both cases, all lines/files changed since the grandparent
 will be fixed. The grandparent is the "baserev" for both the parent and the
 working copy.
 
   $ hg init fixdotandcleanwdir
   $ cd fixdotandcleanwdir
 
   $ printf "hello\n" > hello.whole
   $ printf "world\n" > world.whole
   $ hg commit -Aqm "the parent commit"
 
   $ hg parents --template '{rev} {desc}\n'
   0 the parent commit
   $ hg fix --working-dir -r .
   $ hg parents --template '{rev} {desc}\n'
   1 the parent commit
   $ hg cat -r . *.whole
   HELLO
   WORLD
   $ cat *.whole
   HELLO
   WORLD
   $ hg status
 
   $ cd ..
 
 Same test with a dirty working copy.
 
   $ hg init fixdotanddirtywdir
   $ cd fixdotanddirtywdir
 
   $ printf "hello\n" > hello.whole
   $ printf "world\n" > world.whole
   $ hg commit -Aqm "the parent commit"
 
   $ printf "hello,\n" > hello.whole
   $ printf "world!\n" > world.whole
 
   $ hg parents --template '{rev} {desc}\n'
   0 the parent commit
   $ hg fix --working-dir -r .
   $ hg parents --template '{rev} {desc}\n'
   1 the parent commit
   $ hg cat -r . *.whole
   HELLO
   WORLD
   $ cat *.whole
   HELLO,
   WORLD!
   $ hg status
   M hello.whole
   M world.whole
 
   $ cd ..
 
 When we have a chain of commits that change mutually exclusive lines of code,
 we should be able to do incremental fixing that causes each commit in the chain
 to include fixes made to the previous commits. This prevents children from
 backing out the fixes made in their parents. A dirty working directory is
 conceptually similar to another commit in the chain.
 
   $ hg init incrementallyfixchain
   $ cd incrementallyfixchain
 
   $ cat > file.changed <<EOF
   > first
   > second
   > third
   > fourth
   > fifth
   > EOF
   $ hg commit -Aqm "the common ancestor (the baserev)"
   $ cat > file.changed <<EOF
   > first (changed)
   > second
   > third
   > fourth
   > fifth
   > EOF
   $ hg commit -Aqm "the first commit to fix"
   $ cat > file.changed <<EOF
   > first (changed)
   > second
   > third (changed)
   > fourth
   > fifth
   > EOF
   $ hg commit -Aqm "the second commit to fix"
   $ cat > file.changed <<EOF
   > first (changed)
   > second
   > third (changed)
   > fourth
   > fifth (changed)
   > EOF
 
   $ hg fix -r . -r '.^' --working-dir
 
   $ hg parents --template '{rev}\n'
   4
   $ hg cat -r '.^^' file.changed
   first
   second
   third
   fourth
   fifth
   $ hg cat -r '.^' file.changed
   FIRST (CHANGED)
   second
   third
   fourth
   fifth
   $ hg cat -r . file.changed
   FIRST (CHANGED)
   second
   THIRD (CHANGED)
   fourth
   fifth
   $ cat file.changed
   FIRST (CHANGED)
   second
   THIRD (CHANGED)
   fourth
   FIFTH (CHANGED)
 
   $ cd ..
 
 If we incrementally fix a merge commit, we should fix any lines that changed
 versus either parent. You could imagine only fixing the intersection or some
 other subset, but this is necessary if either parent is being fixed. It
 prevents us from forgetting fixes made in either parent.
 
   $ hg init incrementallyfixmergecommit
   $ cd incrementallyfixmergecommit
 
   $ printf "a\nb\nc\n" > file.changed
   $ hg commit -Aqm "ancestor"
 
   $ printf "aa\nb\nc\n" > file.changed
   $ hg commit -m "change a"
 
   $ hg checkout '.^'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ printf "a\nb\ncc\n" > file.changed
   $ hg commit -m "change c"
   created new head
 
   $ hg merge
   merging file.changed
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg commit -m "merge"
   $ hg cat -r . file.changed
   aa
   b
   cc
 
   $ hg fix -r . --working-dir
   $ hg cat -r . file.changed
   AA
   b
   CC
 
   $ cd ..
 
 Abort fixing revisions if there is an unfinished operation. We don't want to
 make things worse by editing files or stripping/obsoleting things. Also abort
 fixing the working directory if there are unresolved merge conflicts.
 
   $ hg init abortunresolved
   $ cd abortunresolved
 
   $ echo "foo1" > foo.whole
   $ hg commit -Aqm "foo 1"
 
   $ hg update null
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo "foo2" > foo.whole
   $ hg commit -Aqm "foo 2"
 
   $ hg --config extensions.rebase= rebase -r 1 -d 0
   rebasing 1:c3b6dc0e177a tip "foo 2"
   merging foo.whole
   warning: conflicts while merging foo.whole! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg rebase --continue')
-  [1]
+  [240]
 
   $ hg --config extensions.rebase= fix --working-dir
   abort: unresolved conflicts
   (use 'hg resolve')
   [255]
 
   $ hg --config extensions.rebase= fix -r .
   abort: rebase in progress
   (use 'hg rebase --continue', 'hg rebase --abort', or 'hg rebase --stop')
   [255]
 
   $ cd ..
 
 When fixing a file that was renamed, we should diff against the source of the
 rename for incremental fixing and we should correctly reproduce the rename in
 the replacement revision.
 
   $ hg init fixrenamecommit
   $ cd fixrenamecommit
 
   $ printf "a\nb\nc\n" > source.changed
   $ hg commit -Aqm "source revision"
   $ hg move source.changed dest.changed
   $ printf "a\nb\ncc\n" > dest.changed
   $ hg commit -m "dest revision"
 
   $ hg fix -r .
   $ hg log -r tip --copies --template "{file_copies}\n"
   dest.changed (source.changed)
   $ hg cat -r tip dest.changed
   a
   b
   CC
 
   $ cd ..
 
 When fixing revisions that remove files we must ensure that the replacement
 actually removes the file, whereas it could accidentally leave it unchanged or
 write an empty string to it.
 
   $ hg init fixremovedfile
   $ cd fixremovedfile
 
   $ printf "foo\n" > foo.whole
   $ printf "bar\n" > bar.whole
   $ hg commit -Aqm "add files"
   $ hg remove bar.whole
   $ hg commit -m "remove file"
   $ hg status --change .
   R bar.whole
   $ hg fix -r . foo.whole
   $ hg status --change tip
   M foo.whole
   R bar.whole
 
   $ cd ..
 
 If fixing a revision finds no fixes to make, no replacement revision should be
 created.
 
   $ hg init nofixesneeded
   $ cd nofixesneeded
 
   $ printf "FOO\n" > foo.whole
   $ hg commit -Aqm "add file"
   $ hg log --template '{rev}\n'
   0
   $ hg fix -r .
   $ hg log --template '{rev}\n'
   0
 
   $ cd ..
 
 If fixing a commit reverts all the changes in the commit, we replace it with a
 commit that changes no files.
 
   $ hg init nochangesleft
   $ cd nochangesleft
 
   $ printf "FOO\n" > foo.whole
   $ hg commit -Aqm "add file"
   $ printf "foo\n" > foo.whole
   $ hg commit -m "edit file"
   $ hg status --change .
   M foo.whole
   $ hg fix -r .
   $ hg status --change tip
 
   $ cd ..
 
 If we fix a parent and child revision together, the child revision must be
 replaced if the parent is replaced, even if the diffs of the child needed no
 fixes. However, we're free to not replace revisions that need no fixes and have
 no ancestors that are replaced.
 
   $ hg init mustreplacechild
   $ cd mustreplacechild
 
   $ printf "FOO\n" > foo.whole
   $ hg commit -Aqm "add foo"
   $ printf "foo\n" > foo.whole
   $ hg commit -m "edit foo"
   $ printf "BAR\n" > bar.whole
   $ hg commit -Aqm "add bar"
 
   $ hg log --graph --template '{rev} {files}'
   @  2 bar.whole
   |
   o  1 foo.whole
   |
   o  0 foo.whole
   
   $ hg fix -r 0:2
   $ hg log --graph --template '{rev} {files}'
   o  4 bar.whole
   |
   o  3
   |
   | @  2 bar.whole
   | |
   | x  1 foo.whole
   |/
   o  0 foo.whole
   
 
   $ cd ..
 
 It's also possible that the child needs absolutely no changes, but we still
 need to replace it to update its parent. If we skipped replacing the child
 because it had no file content changes, it would become an orphan for no good
 reason.
 
   $ hg init mustreplacechildevenifnop
   $ cd mustreplacechildevenifnop
 
   $ printf "Foo\n" > foo.whole
   $ hg commit -Aqm "add a bad foo"
   $ printf "FOO\n" > foo.whole
   $ hg commit -m "add a good foo"
   $ hg fix -r . -r '.^'
   $ hg log --graph --template '{rev} {desc}'
   o  3 add a good foo
   |
   o  2 add a bad foo
   
   @  1 add a good foo
   |
   x  0 add a bad foo
   
 
   $ cd ..
 
 Similar to the case above, the child revision may become empty as a result of
 fixing its parent. We should still create an empty replacement child.
 TODO: determine how this should interact with ui.allowemptycommit given that
 the empty replacement could have children.
 
   $ hg init mustreplacechildevenifempty
   $ cd mustreplacechildevenifempty
 
   $ printf "foo\n" > foo.whole
   $ hg commit -Aqm "add foo"
   $ printf "Foo\n" > foo.whole
   $ hg commit -m "edit foo"
   $ hg fix -r . -r '.^'
   $ hg log --graph --template '{rev} {desc}\n' --stat
   o  3 edit foo
   |
   o  2 add foo
       foo.whole |  1 +
       1 files changed, 1 insertions(+), 0 deletions(-)
   
   @  1 edit foo
   |   foo.whole |  2 +-
   |   1 files changed, 1 insertions(+), 1 deletions(-)
   |
   x  0 add foo
       foo.whole |  1 +
       1 files changed, 1 insertions(+), 0 deletions(-)
   
 
   $ cd ..
 
 Fixing a secret commit should replace it with another secret commit.
 
   $ hg init fixsecretcommit
   $ cd fixsecretcommit
 
   $ printf "foo\n" > foo.whole
   $ hg commit -Aqm "add foo" --secret
   $ hg fix -r .
   $ hg log --template '{rev} {phase}\n'
   1 secret
   0 secret
 
   $ cd ..
 
 We should also preserve phase when fixing a draft commit while the user has
 their default set to secret.
 
   $ hg init respectphasesnewcommit
   $ cd respectphasesnewcommit
 
   $ printf "foo\n" > foo.whole
   $ hg commit -Aqm "add foo"
   $ hg --config phases.newcommit=secret fix -r .
   $ hg log --template '{rev} {phase}\n'
   1 draft
   0 draft
 
   $ cd ..
 
 Debug output should show what fixer commands are being subprocessed, which is
 useful for anyone trying to set up a new config.
 
   $ hg init debugoutput
   $ cd debugoutput
 
   $ printf "foo\nbar\nbaz\n" > foo.changed
   $ hg commit -Aqm "foo"
   $ printf "Foo\nbar\nBaz\n" > foo.changed
   $ hg --debug fix --working-dir
   subprocess: * $TESTTMP/uppercase.py 1-1 3-3 (glob)
 
   $ cd ..
 
 Fixing an obsolete revision can cause divergence, so we abort unless the user
 configures to allow it. This is not yet smart enough to know whether there is a
 successor, but even then it is not likely intentional or idiomatic to fix an
 obsolete revision.
 
   $ hg init abortobsoleterev
   $ cd abortobsoleterev
 
   $ printf "foo\n" > foo.changed
   $ hg commit -Aqm "foo"
   $ hg debugobsolete `hg parents --template '{node}'`
   1 new obsolescence markers
   obsoleted 1 changesets
   $ hg --hidden fix -r 0
   abort: fixing obsolete revision could cause divergence
   [255]
 
   $ hg --hidden fix -r 0 --config experimental.evolution.allowdivergence=true
   $ hg cat -r tip foo.changed
   FOO
 
   $ cd ..
 
 Test all of the available substitution values for fixer commands.
 
   $ hg init substitution
   $ cd substitution
 
   $ mkdir foo
   $ printf "hello\ngoodbye\n" > foo/bar
   $ hg add
   adding foo/bar
   $ hg --config "fix.fail:command=printf '%s\n' '{rootpath}' '{basename}'" \
   >    --config "fix.fail:linerange='{first}' '{last}'" \
   >    --config "fix.fail:pattern=foo/bar" \
   >    fix --working-dir
   $ cat foo/bar
   foo/bar
   bar
   1
   2
 
   $ cd ..
 
 The --base flag should allow picking the revisions to diff against for changed
 files and incremental line formatting.
 
   $ hg init baseflag
   $ cd baseflag
 
   $ printf "one\ntwo\n" > foo.changed
   $ printf "bar\n" > bar.changed
   $ hg commit -Aqm "first"
   $ printf "one\nTwo\n" > foo.changed
   $ hg commit -m "second"
   $ hg fix -w --base .
   $ hg status
   $ hg fix -w --base null
   $ cat foo.changed
   ONE
   TWO
   $ cat bar.changed
   BAR
 
   $ cd ..
 
 If the user asks to fix the parent of another commit, they are asking to create
 an orphan. We must respect experimental.evolution.allowunstable.
 
   $ hg init allowunstable
   $ cd allowunstable
 
   $ printf "one\n" > foo.whole
   $ hg commit -Aqm "first"
   $ printf "two\n" > foo.whole
   $ hg commit -m "second"
   $ hg --config experimental.evolution.allowunstable=False fix -r '.^'
   abort: cannot fix changeset with children
   [255]
   $ hg fix -r '.^'
   1 new orphan changesets
   $ hg cat -r 2 foo.whole
   ONE
 
   $ cd ..
 
 The --base flag affects the set of files being fixed. So while the --whole flag
 makes the base irrelevant for changed line ranges, it still changes the
 meaning and effect of the command. In this example, no files or lines are fixed
 until we specify the base, but then we do fix unchanged lines.
 
   $ hg init basewhole
   $ cd basewhole
   $ printf "foo1\n" > foo.changed
   $ hg commit -Aqm "first"
   $ printf "foo2\n" >> foo.changed
   $ printf "bar\n" > bar.changed
   $ hg commit -Aqm "second"
 
   $ hg fix --working-dir --whole
   $ cat *.changed
   bar
   foo1
   foo2
 
   $ hg fix --working-dir --base 0 --whole
   $ cat *.changed
   BAR
   FOO1
   FOO2
 
   $ cd ..
 
 The execution order of tools can be controlled. This example doesn't work if
 you sort after truncating, but the config defines the correct order while the
 definitions are out of order (which might imply the incorrect order given the
 implementation of fix). The goal is to use multiple tools to select the lowest
 5 numbers in the file.
 
   $ hg init priorityexample
   $ cd priorityexample
 
   $ cat >> .hg/hgrc <<EOF
   > [fix]
   > head:command = head -n 5
   > head:pattern = numbers.txt
   > head:priority = 1
   > sort:command = sort -n
   > sort:pattern = numbers.txt
   > sort:priority = 2
   > EOF
 
   $ printf "8\n2\n3\n6\n7\n4\n9\n5\n1\n0\n" > numbers.txt
   $ hg add -q
   $ hg fix -w
   $ cat numbers.txt
   0
   1
   2
   3
   4
 
 And of course we should be able to break this by reversing the execution order.
 Test negative priorities while we're at it.
 
   $ cat >> .hg/hgrc <<EOF
   > [fix]
   > head:priority = -1
   > sort:priority = -2
   > EOF
   $ printf "8\n2\n3\n6\n7\n4\n9\n5\n1\n0\n" > numbers.txt
   $ hg fix -w
   $ cat numbers.txt
   2
   3
   6
   7
   8
 
   $ cd ..
 
 It's possible for repeated applications of a fixer tool to create cycles in the
 generated content of a file. For example, two users with different versions of
 a code formatter might fight over the formatting when they run hg fix. In the
 absence of other changes, this means we could produce commits with the same
 hash in subsequent runs of hg fix. This is a problem unless we support
 obsolescence cycles well. We avoid this by adding an extra field to the
 successor which forces it to have a new hash. That's why this test creates
 three revisions instead of two.
 
   $ hg init cyclictool
   $ cd cyclictool
 
   $ cat >> .hg/hgrc <<EOF
   > [fix]
   > swapletters:command = tr ab ba
   > swapletters:pattern = foo
   > EOF
 
   $ echo ab > foo
   $ hg commit -Aqm foo
 
   $ hg fix -r 0
   $ hg fix -r 1
 
   $ hg cat -r 0 foo --hidden
   ab
   $ hg cat -r 1 foo --hidden
   ba
   $ hg cat -r 2 foo
   ab
 
   $ cd ..
 
 We run fixer tools in the repo root so they can look for config files or other
 important things in the working directory. This does NOT mean we are
 reconstructing a working copy of every revision being fixed; we're just giving
 the tool knowledge of the repo's location in case it can do something
 reasonable with that.
 
   $ hg init subprocesscwd
   $ cd subprocesscwd
 
   $ cat >> .hg/hgrc <<EOF
   > [fix]
   > printcwd:command = "$PYTHON" -c "import os; print(os.getcwd())"
   > printcwd:pattern = relpath:foo/bar
   > filesetpwd:command = "$PYTHON" -c "import os; print('fs: ' + os.getcwd())"
   > filesetpwd:pattern = set:**quux
   > EOF
 
   $ mkdir foo
   $ printf "bar\n" > foo/bar
   $ printf "quux\n" > quux
   $ hg commit -Aqm blah
 
   $ hg fix -w -r . foo/bar
   $ hg cat -r tip foo/bar
   $TESTTMP/subprocesscwd
   $ cat foo/bar
   $TESTTMP/subprocesscwd
 
   $ cd foo
 
   $ hg fix -w -r . bar
   $ hg cat -r tip bar ../quux
   $TESTTMP/subprocesscwd
   quux
   $ cat bar ../quux
   $TESTTMP/subprocesscwd
   quux
   $ echo modified > bar
   $ hg fix -w bar
   $ cat bar
   $TESTTMP/subprocesscwd
 
 Apparently fixing p1() and its descendants doesn't include wdir() unless
 explicitly stated.
 
   $ hg fix -r '.::'
   $ hg cat -r . ../quux
   quux
   $ hg cat -r tip ../quux
   fs: $TESTTMP/subprocesscwd
   $ cat ../quux
   quux
 
 Clean files are not fixed unless explicitly named
   $ echo 'dirty' > ../quux
 
   $ hg fix --working-dir
   $ cat ../quux
   fs: $TESTTMP/subprocesscwd
 
   $ cd ../..
 
 Tools configured without a pattern are ignored. It would be too dangerous to
 run them on all files, because this might happen while testing a configuration
 that also deletes all of the file content. There is no reasonable subset of the
 files to use as a default. Users should be explicit about what files are
 affected by a tool. This test also confirms that we don't crash when the
 pattern config is missing, and that we only warn about it once.
 
   $ hg init nopatternconfigured
   $ cd nopatternconfigured
 
   $ printf "foo" > foo
   $ printf "bar" > bar
   $ hg add -q
   $ hg fix --debug --working-dir --config "fix.nopattern:command=echo fixed"
   fixer tool has no pattern configuration: nopattern
   $ cat foo bar
   foobar (no-eol)
   $ hg fix --debug --working-dir --config "fix.nocommand:pattern=foo.bar"
   fixer tool has no command configuration: nocommand
 
   $ cd ..
 
 Tools can be disabled. Disabled tools do nothing but print a debug message.
 
   $ hg init disabled
   $ cd disabled
 
   $ printf "foo\n" > foo
   $ hg add -q
   $ hg fix --debug --working-dir --config "fix.disabled:command=echo fixed" \
   >                              --config "fix.disabled:pattern=foo" \
   >                              --config "fix.disabled:enabled=false"
   ignoring disabled fixer tool: disabled
   $ cat foo
   foo
 
   $ cd ..
 
 Test that we can configure a fixer to affect all files regardless of the cwd.
 The way we invoke matching must not prohibit this.
 
   $ hg init affectallfiles
   $ cd affectallfiles
 
   $ mkdir foo bar
   $ printf "foo" > foo/file
   $ printf "bar" > bar/file
   $ printf "baz" > baz_file
   $ hg add -q
 
   $ cd bar
   $ hg fix --working-dir --config "fix.cooltool:command=echo fixed" \
   >                      --config "fix.cooltool:pattern=glob:**"
   $ cd ..
 
   $ cat foo/file
   fixed
   $ cat bar/file
   fixed
   $ cat baz_file
   fixed
 
   $ cd ..
 
 Tools should be able to run on unchanged files, even if they set :linerange.
 This includes a corner case where deleted chunks of a file are not considered
 changes.
 
   $ hg init skipclean
   $ cd skipclean
 
   $ printf "a\nb\nc\n" > foo
   $ printf "a\nb\nc\n" > bar
   $ printf "a\nb\nc\n" > baz
   $ hg commit -Aqm "base"
 
   $ printf "a\nc\n" > foo
   $ printf "a\nx\nc\n" > baz
 
   $ cat >> print.py <<EOF
   > import sys
   > for a in sys.argv[1:]:
   >    print(a)
   > EOF
 
   $ hg fix --working-dir foo bar baz \
   >        --config "fix.changedlines:command=\"$PYTHON\" print.py \"Line ranges:\"" \
   >        --config 'fix.changedlines:linerange="{first} through {last}"' \
   >        --config 'fix.changedlines:pattern=glob:**' \
   >        --config 'fix.changedlines:skipclean=false'
 
   $ cat foo
   Line ranges:
   $ cat bar
   Line ranges:
   $ cat baz
   Line ranges:
   2 through 2
 
   $ cd ..
 
 Test various cases around merges. We were previously dropping files if they were
 created on only the p2 side of the merge, so let's test permutations of:
 *   added, was fixed
 *   added, considered for fixing but was already good
 *   added, not considered for fixing
 *   modified, was fixed
 *   modified, considered for fixing but was already good
 *   modified, not considered for fixing
 
 Before the bug was fixed where we would drop files, this test demonstrated the
 following issues:
 *   new_in_r1.ignored, new_in_r1_already_good.changed, and
 >   mod_in_r1_already_good.changed were NOT in the manifest for the merge commit
 *   mod_in_r1.ignored had its contents from r0, NOT r1.
 
 We're also setting a named branch for every commit to demonstrate that the
 branch is kept intact and there aren't issues updating to another branch in the
 middle of fix.
 
   $ hg init merge_keeps_files
   $ cd merge_keeps_files
   $ for f in r0 mod_in_r1 mod_in_r2 mod_in_merge mod_in_child; do
   >   for c in changed whole ignored; do
   >     printf "hello\n" > $f.$c
   >   done
   >   printf "HELLO\n" > "mod_in_${f}_already_good.changed"
   > done
   $ hg branch -q r0
   $ hg ci -Aqm 'r0'
   $ hg phase -p
   $ make_test_files() {
   >   printf "world\n" >> "mod_in_$1.changed"
   >   printf "world\n" >> "mod_in_$1.whole"
   >   printf "world\n" >> "mod_in_$1.ignored"
   >   printf "WORLD\n" >> "mod_in_$1_already_good.changed"
   >   printf "new in $1\n" > "new_in_$1.changed"
   >   printf "new in $1\n" > "new_in_$1.whole"
   >   printf "new in $1\n" > "new_in_$1.ignored"
   >   printf "ALREADY GOOD, NEW IN THIS REV\n" > "new_in_$1_already_good.changed"
   > }
   $ make_test_commit() {
   >   make_test_files "$1"
   >   hg branch -q "$1"
   >   hg ci -Aqm "$2"
   > }
   $ make_test_commit r1 "merge me, pt1"
   $ hg co -q ".^"
   $ make_test_commit r2 "merge me, pt2"
   $ hg merge -qr 1
   $ make_test_commit merge "evil merge"
   $ make_test_commit child "child of merge"
   $ make_test_files wdir
   $ hg fix -r 'not public()' -w
   $ hg log -G -T'{rev}:{shortest(node,8)}: branch:{branch} desc:{desc}'
   @  8:c22ce900: branch:child desc:child of merge
   |
   o    7:5a30615a: branch:merge desc:evil merge
   |\
   | o  6:4e5acdc4: branch:r2 desc:merge me, pt2
   | |
   o |  5:eea01878: branch:r1 desc:merge me, pt1
   |/
   o  0:0c548d87: branch:r0 desc:r0
   
   $ hg files -r tip
   mod_in_child.changed
   mod_in_child.ignored
   mod_in_child.whole
   mod_in_child_already_good.changed
   mod_in_merge.changed
   mod_in_merge.ignored
   mod_in_merge.whole
   mod_in_merge_already_good.changed
   mod_in_mod_in_child_already_good.changed
   mod_in_mod_in_merge_already_good.changed
   mod_in_mod_in_r1_already_good.changed
   mod_in_mod_in_r2_already_good.changed
   mod_in_r0_already_good.changed
   mod_in_r1.changed
   mod_in_r1.ignored
   mod_in_r1.whole
   mod_in_r1_already_good.changed
   mod_in_r2.changed
   mod_in_r2.ignored
   mod_in_r2.whole
   mod_in_r2_already_good.changed
   new_in_child.changed
   new_in_child.ignored
   new_in_child.whole
   new_in_child_already_good.changed
   new_in_merge.changed
   new_in_merge.ignored
   new_in_merge.whole
   new_in_merge_already_good.changed
   new_in_r1.changed
   new_in_r1.ignored
   new_in_r1.whole
   new_in_r1_already_good.changed
   new_in_r2.changed
   new_in_r2.ignored
   new_in_r2.whole
   new_in_r2_already_good.changed
   r0.changed
   r0.ignored
   r0.whole
   $ for f in "$(hg files -r tip)"; do hg cat -r tip $f -T'{path}:\n{data}\n'; done
   mod_in_child.changed:
   hello
   WORLD
   
   mod_in_child.ignored:
   hello
   world
   
   mod_in_child.whole:
   HELLO
   WORLD
   
   mod_in_child_already_good.changed:
   WORLD
   
   mod_in_merge.changed:
   hello
   WORLD
   
   mod_in_merge.ignored:
   hello
   world
   
   mod_in_merge.whole:
   HELLO
   WORLD
   
   mod_in_merge_already_good.changed:
   WORLD
   
   mod_in_mod_in_child_already_good.changed:
   HELLO
   
   mod_in_mod_in_merge_already_good.changed:
   HELLO
   
   mod_in_mod_in_r1_already_good.changed:
   HELLO
   
   mod_in_mod_in_r2_already_good.changed:
   HELLO
   
   mod_in_r0_already_good.changed:
   HELLO
   
   mod_in_r1.changed:
   hello
   WORLD
   
   mod_in_r1.ignored:
   hello
   world
   
   mod_in_r1.whole:
   HELLO
   WORLD
   
   mod_in_r1_already_good.changed:
   WORLD
   
   mod_in_r2.changed:
   hello
   WORLD
   
   mod_in_r2.ignored:
   hello
   world
   
   mod_in_r2.whole:
   HELLO
   WORLD
   
   mod_in_r2_already_good.changed:
   WORLD
   
   new_in_child.changed:
   NEW IN CHILD
   
   new_in_child.ignored:
   new in child
   
   new_in_child.whole:
   NEW IN CHILD
   
   new_in_child_already_good.changed:
   ALREADY GOOD, NEW IN THIS REV
   
   new_in_merge.changed:
   NEW IN MERGE
   
   new_in_merge.ignored:
   new in merge
   
   new_in_merge.whole:
   NEW IN MERGE
   
   new_in_merge_already_good.changed:
   ALREADY GOOD, NEW IN THIS REV
   
   new_in_r1.changed:
   NEW IN R1
   
   new_in_r1.ignored:
   new in r1
   
   new_in_r1.whole:
   NEW IN R1
   
   new_in_r1_already_good.changed:
   ALREADY GOOD, NEW IN THIS REV
   
   new_in_r2.changed:
   NEW IN R2
   
   new_in_r2.ignored:
   new in r2
   
   new_in_r2.whole:
   NEW IN R2
   
   new_in_r2_already_good.changed:
   ALREADY GOOD, NEW IN THIS REV
   
   r0.changed:
   hello
   
   r0.ignored:
   hello
   
   r0.whole:
   hello
   

tests/test-histedit-arguments.t

@@ -1,605 +1,605 b''
 #testcases abortcommand abortflag
 
 #if abortflag
   $ cat >> $HGRCPATH <<EOF
   > [alias]
   > abort = histedit --abort
   > EOF
 #endif
 
 Test argument handling and various data parsing
 ==================================================
 
 
 Enable extensions used by this test.
   $ cat >>$HGRCPATH <<EOF
   > [extensions]
   > histedit=
   > EOF
 
 Repo setup.
   $ hg init foo
   $ cd foo
   $ echo alpha >> alpha
   $ hg addr
   adding alpha
   $ hg ci -m one
   $ echo alpha >> alpha
   $ hg ci -m two
   $ echo alpha >> alpha
   $ hg ci -m three
   $ echo alpha >> alpha
   $ hg ci -m four
   $ echo alpha >> alpha
   $ hg ci -m five
 
   $ hg log --style compact --graph
   @  4[tip]   08d98a8350f3   1970-01-01 00:00 +0000   test
   |    five
   |
   o  3   c8e68270e35a   1970-01-01 00:00 +0000   test
   |    four
   |
   o  2   eb57da33312f   1970-01-01 00:00 +0000   test
   |    three
   |
   o  1   579e40513370   1970-01-01 00:00 +0000   test
   |    two
   |
   o  0   6058cbb6cfd7   1970-01-01 00:00 +0000   test
        one
   
 
 histedit --continue/--abort with no existing state
 --------------------------------------------------
 
   $ hg histedit --continue
   abort: no histedit in progress
   [255]
   $ hg abort
   abort: no histedit in progress (abortflag !)
   abort: no operation in progress (abortcommand !)
   [255]
 
 Run a dummy edit to make sure we get tip^^ correctly via revsingle.
 --------------------------------------------------------------------
 
   $ HGEDITOR=cat hg histedit "tip^^"
   pick eb57da33312f 2 three
   pick c8e68270e35a 3 four
   pick 08d98a8350f3 4 five
   
   # Edit history between eb57da33312f and 08d98a8350f3
   #
   # Commits are listed from least to most recent
   #
   # You can reorder changesets by reordering the lines
   #
   # Commands:
   #
   #  e, edit = use commit, but stop for amending
   #  m, mess = edit commit message without changing commit content
   #  p, pick = use commit
   #  b, base = checkout changeset and apply further changesets from there
   #  d, drop = remove commit from history
   #  f, fold = use commit, but combine it with the one above
   #  r, roll = like fold, but discard this commit's description and date
   #
 
 Run on a revision not ancestors of the current working directory.
 --------------------------------------------------------------------
 
   $ hg up 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg histedit -r 4
   abort: 08d98a8350f3 is not an ancestor of working directory
   [255]
   $ hg up --quiet
 
 
 Test that we pick the minimum of a revrange
 ---------------------------------------
 
   $ HGEDITOR=cat hg histedit '2::' --commands - << EOF
   > pick eb57da33312f 2 three
   > pick c8e68270e35a 3 four
   > pick 08d98a8350f3 4 five
   > EOF
   $ hg up --quiet
 
   $ HGEDITOR=cat hg histedit 'tip:2' --commands - << EOF
   > pick eb57da33312f 2 three
   > pick c8e68270e35a 3 four
   > pick 08d98a8350f3 4 five
   > EOF
   $ hg up --quiet
 
 Test config specified default
 -----------------------------
 
   $ HGEDITOR=cat hg histedit --config "histedit.defaultrev=only(.) - ::eb57da33312f" --commands - << EOF
   > pick c8e68270e35a 3 four
   > pick 08d98a8350f3 4 five
   > EOF
 
 Test invalid config default
 ---------------------------
 
   $ hg histedit --config "histedit.defaultrev="
   abort: config option histedit.defaultrev can't be empty
   [255]
 
 Run on a revision not descendants of the initial parent
 --------------------------------------------------------------------
 
 Test the message shown for inconsistent histedit state, which may be
 created (and forgotten) by Mercurial earlier than 2.7. This emulates
 Mercurial earlier than 2.7 by renaming ".hg/histedit-state"
 temporarily.
 
   $ hg log -G -T '{rev} {shortest(node)} {desc}\n' -r 2::
   @  4 08d9 five
   |
   o  3 c8e6 four
   |
   o  2 eb57 three
   |
   ~
   $ HGEDITOR=cat hg histedit -r 4 --commands - << EOF
   > edit 08d98a8350f3 4 five
   > EOF
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   Editing (08d98a8350f3), you may commit or record as needed now.
   (hg histedit --continue to resume)
-  [1]
+  [240]
 
   $ hg graft --continue
   abort: no graft in progress
   (continue: hg histedit --continue)
   [255]
 
   $ mv .hg/histedit-state .hg/histedit-state.back
   $ hg update --quiet --clean 2
   $ echo alpha >> alpha
   $ mv .hg/histedit-state.back .hg/histedit-state
 
   $ hg histedit --continue
   saved backup bundle to $TESTTMP/foo/.hg/strip-backup/08d98a8350f3-02594089-histedit.hg
   $ hg log -G -T '{rev} {shortest(node)} {desc}\n' -r 2::
   @  4 f5ed five
   |
   | o  3 c8e6 four
   |/
   o  2 eb57 three
   |
   ~
 
   $ hg unbundle -q $TESTTMP/foo/.hg/strip-backup/08d98a8350f3-02594089-histedit.hg
   $ hg strip -q -r f5ed --config extensions.strip=
   $ hg up -q 08d98a8350f3
 
 Test that missing revisions are detected
 ---------------------------------------
 
   $ HGEDITOR=cat hg histedit "tip^^" --commands - << EOF
   > pick eb57da33312f 2 three
   > pick 08d98a8350f3 4 five
   > EOF
   hg: parse error: missing rules for changeset c8e68270e35a
   (use "drop c8e68270e35a" to discard, see also: 'hg help -e histedit.config')
   [255]
 
 Test that extra revisions are detected
 ---------------------------------------
 
   $ HGEDITOR=cat hg histedit "tip^^" --commands - << EOF
   > pick 6058cbb6cfd7 0 one
   > pick c8e68270e35a 3 four
   > pick 08d98a8350f3 4 five
   > EOF
   hg: parse error: pick "6058cbb6cfd7" changeset was not a candidate
   (only use listed changesets)
   [255]
 
 Test malformed line
 ---------------------------------------
 
   $ HGEDITOR=cat hg histedit "tip^^" --commands - << EOF
   > pickeb57da33312f2three
   > pick c8e68270e35a 3 four
   > pick 08d98a8350f3 4 five
   > EOF
   hg: parse error: malformed line "pickeb57da33312f2three"
   [255]
 
 Test unknown changeset
 ---------------------------------------
 
   $ HGEDITOR=cat hg histedit "tip^^" --commands - << EOF
   > pick 0123456789ab 2 three
   > pick c8e68270e35a 3 four
   > pick 08d98a8350f3 4 five
   > EOF
   hg: parse error: unknown changeset 0123456789ab listed
   [255]
 
 Test unknown command
 ---------------------------------------
 
   $ HGEDITOR=cat hg histedit "tip^^" --commands - << EOF
   > coin eb57da33312f 2 three
   > pick c8e68270e35a 3 four
   > pick 08d98a8350f3 4 five
   > EOF
   hg: parse error: unknown action "coin"
   [255]
 
 Test duplicated changeset
 ---------------------------------------
 
 So one is missing and one appear twice.
 
   $ HGEDITOR=cat hg histedit "tip^^" --commands - << EOF
   > pick eb57da33312f 2 three
   > pick eb57da33312f 2 three
   > pick 08d98a8350f3 4 five
   > EOF
   hg: parse error: duplicated command for changeset eb57da33312f
   [255]
 
 Test bogus rev
 ---------------------------------------
 
   $ HGEDITOR=cat hg histedit "tip^^" --commands - << EOF
   > pick eb57da33312f 2 three
   > pick 0u98
   > pick 08d98a8350f3 4 five
   > EOF
   hg: parse error: invalid changeset 0u98
   [255]
 
 Test short version of command
 ---------------------------------------
 
 Note: we use varying amounts of white space between command name and changeset
 short hash. This tests issue3893.
 
   $ HGEDITOR=cat hg histedit "tip^^" --commands - << EOF
   > pick eb57da33312f 2 three
   > p    c8e68270e35a 3 four
   > f 08d98a8350f3 4 five
   > EOF
   four
   ***
   five
   
   
   
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: test
   HG: branch 'default'
   HG: changed alpha
   saved backup bundle to $TESTTMP/foo/.hg/strip-backup/c8e68270e35a-63d8b8d8-histedit.hg
 
   $ hg update -q 2
   $ echo x > x
   $ hg add x
   $ hg commit -m'x' x
   created new head
   $ hg histedit -r 'heads(all())'
   abort: The specified revisions must have exactly one common root
   [255]
 
 Test that trimming description using multi-byte characters
 --------------------------------------------------------------------
 
   $ "$PYTHON" <<EOF
   > fp = open('logfile', 'wb')
   > fp.write(b'12345678901234567890123456789012345678901234567890' +
   >          b'12345') # there are 5 more columns for 80 columns
   > 
   > # 2 x 4 = 8 columns, but 3 x 4 = 12 bytes
   > fp.write(u'\u3042\u3044\u3046\u3048'.encode('utf-8'))
   > 
   > fp.close()
   > EOF
   $ echo xx >> x
   $ hg --encoding utf-8 commit --logfile logfile
 
   $ HGEDITOR=cat hg --encoding utf-8 histedit tip
   pick 3d3ea1f3a10b 5 1234567890123456789012345678901234567890123456789012345\xe3\x81\x82... (esc)
   
   # Edit history between 3d3ea1f3a10b and 3d3ea1f3a10b
   #
   # Commits are listed from least to most recent
   #
   # You can reorder changesets by reordering the lines
   #
   # Commands:
   #
   #  e, edit = use commit, but stop for amending
   #  m, mess = edit commit message without changing commit content
   #  p, pick = use commit
   #  b, base = checkout changeset and apply further changesets from there
   #  d, drop = remove commit from history
   #  f, fold = use commit, but combine it with the one above
   #  r, roll = like fold, but discard this commit's description and date
   #
 
 Test --continue with --keep
 
   $ hg strip -q -r . --config extensions.strip=
   $ hg histedit '.^' -q --keep --commands - << EOF
   > edit eb57da33312f 2 three
   > pick f3cfcca30c44 4 x
   > EOF
   Editing (eb57da33312f), you may commit or record as needed now.
   (hg histedit --continue to resume)
-  [1]
+  [240]
   $ echo edit >> alpha
   $ hg histedit -q --continue
   $ hg log -G -T '{rev}:{node|short} {desc}'
   @  6:8fda0c726bf2 x
   |
   o  5:63379946892c three
   |
   | o  4:f3cfcca30c44 x
   | |
   | | o  3:2a30f3cfee78 four
   | |/   ***
   | |    five
   | o  2:eb57da33312f three
   |/
   o  1:579e40513370 two
   |
   o  0:6058cbb6cfd7 one
   
 
 Test that abort fails gracefully on exception
 ----------------------------------------------
   $ hg histedit . -q --commands - << EOF
   > edit 8fda0c726bf2 6 x
   > EOF
   Editing (8fda0c726bf2), you may commit or record as needed now.
   (hg histedit --continue to resume)
-  [1]
+  [240]
 Corrupt histedit state file
   $ sed 's/8fda0c726bf2/123456789012/' .hg/histedit-state > ../corrupt-histedit
   $ mv ../corrupt-histedit .hg/histedit-state
   $ hg abort
   warning: encountered an exception during histedit --abort; the repository may not have been completely cleaned up
   abort: $TESTTMP/foo/.hg/strip-backup/*-histedit.hg: $ENOENT$ (glob) (windows !)
   abort: $ENOENT$: '$TESTTMP/foo/.hg/strip-backup/*-histedit.hg' (glob) (no-windows !)
   [255]
 Histedit state has been exited
   $ hg summary -q
   parent: 5:63379946892c 
   commit: 1 added, 1 unknown (new branch head)
   update: 4 new changesets (update)
 
   $ cd ..
 
 Set up default base revision tests
 
   $ hg init defaultbase
   $ cd defaultbase
   $ touch foo
   $ hg -q commit -A -m root
   $ echo 1 > foo
   $ hg commit -m 'public 1'
   $ hg phase --force --public -r .
   $ echo 2 > foo
   $ hg commit -m 'draft after public'
   $ hg -q up -r 1
   $ echo 3 > foo
   $ hg commit -m 'head 1 public'
   created new head
   $ hg phase --force --public -r .
   $ echo 4 > foo
   $ hg commit -m 'head 1 draft 1'
   $ echo 5 > foo
   $ hg commit -m 'head 1 draft 2'
   $ hg -q up -r 2
   $ echo 6 > foo
   $ hg commit -m 'head 2 commit 1'
   $ echo 7 > foo
   $ hg commit -m 'head 2 commit 2'
   $ hg -q up -r 2
   $ echo 8 > foo
   $ hg commit -m 'head 3'
   created new head
   $ hg -q up -r 2
   $ echo 9 > foo
   $ hg commit -m 'head 4'
   created new head
   $ hg merge --tool :local -r 8
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg commit -m 'merge head 3 into head 4'
   $ echo 11 > foo
   $ hg commit -m 'commit 1 after merge'
   $ echo 12 > foo
   $ hg commit -m 'commit 2 after merge'
 
   $ hg log -G -T '{rev}:{node|short} {phase} {desc}\n'
   @  12:8cde254db839 draft commit 2 after merge
   |
   o  11:6f2f0241f119 draft commit 1 after merge
   |
   o    10:90506cc76b00 draft merge head 3 into head 4
   |\
   | o  9:f8607a373a97 draft head 4
   | |
   o |  8:0da92be05148 draft head 3
   |/
   | o  7:4c35cdf97d5e draft head 2 commit 2
   | |
   | o  6:931820154288 draft head 2 commit 1
   |/
   | o  5:8cdc02b9bc63 draft head 1 draft 2
   | |
   | o  4:463b8c0d2973 draft head 1 draft 1
   | |
   | o  3:23a0c4eefcbf public head 1 public
   | |
   o |  2:4117331c3abb draft draft after public
   |/
   o  1:4426d359ea59 public public 1
   |
   o  0:54136a8ddf32 public root
   
 
 Default base revision should stop at public changesets
 
   $ hg -q up 8cdc02b9bc63
   $ hg histedit --commands - <<EOF
   > pick 463b8c0d2973
   > pick 8cdc02b9bc63
   > EOF
 
 Default base revision should stop at branchpoint
 
   $ hg -q up 4c35cdf97d5e
   $ hg histedit --commands - <<EOF
   > pick 931820154288
   > pick 4c35cdf97d5e
   > EOF
 
 Default base revision should stop at merge commit
 
   $ hg -q up 8cde254db839
   $ hg histedit --commands - <<EOF
   > pick 6f2f0241f119
   > pick 8cde254db839
   > EOF
 
 commit --amend should abort if histedit is in progress
 (issue4800) and markers are not being created.
 Eventually, histedit could perhaps look at `source` extra,
 in which case this test should be revisited.
 
   $ hg -q up 8cde254db839
   $ hg histedit 6f2f0241f119 --commands - <<EOF
   > pick 8cde254db839
   > edit 6f2f0241f119
   > EOF
   merging foo
   warning: conflicts while merging foo! (edit, then use 'hg resolve --mark')
   Fix up the change (pick 8cde254db839)
   (hg histedit --continue to resume)
-  [1]
+  [240]
   $ hg resolve -m --all
   (no more unresolved files)
   continue: hg histedit --continue
   $ hg histedit --cont
   merging foo
   warning: conflicts while merging foo! (edit, then use 'hg resolve --mark')
   Editing (6f2f0241f119), you may commit or record as needed now.
   (hg histedit --continue to resume)
-  [1]
+  [240]
   $ hg resolve -m --all
   (no more unresolved files)
   continue: hg histedit --continue
   $ hg commit --amend -m 'reject this fold'
   abort: histedit in progress
   (use 'hg histedit --continue' or 'hg histedit --abort')
   [255]
 
 With markers enabled, histedit does not get confused, and
 amend should not be blocked by the ongoing histedit.
 
   $ cat >>$HGRCPATH <<EOF
   > [experimental]
   > evolution.createmarkers=True
   > evolution.allowunstable=True
   > EOF
   $ hg commit --amend -m 'allow this fold'
   $ hg histedit --continue
 
   $ cd ..
 
 Test autoverb feature
 
   $ hg init autoverb
   $ cd autoverb
   $ echo alpha >> alpha
   $ hg ci -qAm one
   $ echo alpha >> alpha
   $ hg ci -qm two
   $ echo beta >> beta
   $ hg ci -qAm "roll! one"
 
   $ hg log --style compact --graph
   @  2[tip]   4f34d0f8b5fa   1970-01-01 00:00 +0000   test
   |    roll! one
   |
   o  1   579e40513370   1970-01-01 00:00 +0000   test
   |    two
   |
   o  0   6058cbb6cfd7   1970-01-01 00:00 +0000   test
        one
   
 
 Check that 'roll' is selected by default
 
   $ HGEDITOR=cat hg histedit 0 --config experimental.histedit.autoverb=True
   pick 6058cbb6cfd7 0 one
   roll 4f34d0f8b5fa 2 roll! one
   pick 579e40513370 1 two
   
   # Edit history between 6058cbb6cfd7 and 4f34d0f8b5fa
   #
   # Commits are listed from least to most recent
   #
   # You can reorder changesets by reordering the lines
   #
   # Commands:
   #
   #  e, edit = use commit, but stop for amending
   #  m, mess = edit commit message without changing commit content
   #  p, pick = use commit
   #  b, base = checkout changeset and apply further changesets from there
   #  d, drop = remove commit from history
   #  f, fold = use commit, but combine it with the one above
   #  r, roll = like fold, but discard this commit's description and date
   #
 
   $ cd ..
 
 Check that histedit's commands accept revsets
   $ hg init bar
   $ cd bar
   $ echo w >> a
   $ hg ci -qAm "adds a"
   $ echo x >> b
   $ hg ci -qAm "adds b"
   $ echo y >> c
   $ hg ci -qAm "adds c"
   $ echo z >> d
   $ hg ci -qAm "adds d"
   $ hg log -G -T '{rev} {desc}\n'
   @  3 adds d
   |
   o  2 adds c
   |
   o  1 adds b
   |
   o  0 adds a
   
   $ HGEDITOR=cat hg histedit "2" --commands - << EOF
   > base -4 adds c
   > pick 2 adds c
   > pick tip adds d
   > EOF
   $ hg log -G -T '{rev} {desc}\n'
   @  5 adds d
   |
   o  4 adds c
   |
   | o  1 adds b
   |/
   o  0 adds a
   
 

tests/test-histedit-edit.t

@@ -1,556 +1,556 b''
   $ . "$TESTDIR/histedit-helpers.sh"
 
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > histedit=
   > strip=
   > mockmakedate = $TESTDIR/mockmakedate.py
   > EOF
 
   $ initrepo ()
   > {
   >     hg init r
   >     cd r
   >     for x in a b c d e f g; do
   >         echo $x > $x
   >         hg add $x
   >         hg ci -m $x
   >     done
   > }
 
   $ initrepo
 
 log before edit
   $ hg log --graph
   @  changeset:   6:3c6a8ed2ebe8
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     g
   |
   o  changeset:   5:652413bf663e
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     f
   |
   o  changeset:   4:e860deea161a
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     e
   |
   o  changeset:   3:055a42cdd887
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     d
   |
   o  changeset:   2:177f92b77385
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     c
   |
   o  changeset:   1:d2ae7f538514
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     b
   |
   o  changeset:   0:cb9a9f314b8b
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     a
   
 dirty a file
   $ echo a > g
   $ hg histedit 177f92b77385 --commands - 2>&1 << EOF
   > EOF
   abort: uncommitted changes
   [255]
   $ echo g > g
 
 edit the history
   $ hg histedit 177f92b77385 --commands - 2>&1 << EOF| fixbundle
   > pick 177f92b77385 c
   > pick 055a42cdd887 d
   > edit e860deea161a e
   > pick 652413bf663e f
   > pick 3c6a8ed2ebe8 g
   > EOF
   0 files updated, 0 files merged, 3 files removed, 0 files unresolved
   Editing (e860deea161a), you may commit or record as needed now.
   (hg histedit --continue to resume)
 
 try to update and get an error
   $ hg update tip
   abort: histedit in progress
   (use 'hg histedit --continue' or 'hg histedit --abort')
   [255]
 
 edit the plan via the editor
   $ cat >> $TESTTMP/editplan.sh <<EOF
   > cat > \$1 <<EOF2
   > drop e860deea161a e
   > drop 652413bf663e f
   > drop 3c6a8ed2ebe8 g
   > EOF2
   > EOF
   $ HGEDITOR="sh $TESTTMP/editplan.sh" hg histedit --edit-plan
   $ cat .hg/histedit-state
   v1
   055a42cdd88768532f9cf79daa407fc8d138de9b
   3c6a8ed2ebe862cc949d2caa30775dd6f16fb799
   False
   3
   drop
   e860deea161a2f77de56603b340ebbb4536308ae
   drop
   652413bf663ef2a641cab26574e46d5f5a64a55a
   drop
   3c6a8ed2ebe862cc949d2caa30775dd6f16fb799
   0
   strip-backup/177f92b77385-0ebe6a8f-histedit.hg
 
 edit the plan via --commands
   $ hg histedit --edit-plan --commands - 2>&1 << EOF
   > edit e860deea161a e
   > pick 652413bf663e f
   > drop 3c6a8ed2ebe8 g
   > EOF
   $ cat .hg/histedit-state
   v1
   055a42cdd88768532f9cf79daa407fc8d138de9b
   3c6a8ed2ebe862cc949d2caa30775dd6f16fb799
   False
   3
   edit
   e860deea161a2f77de56603b340ebbb4536308ae
   pick
   652413bf663ef2a641cab26574e46d5f5a64a55a
   drop
   3c6a8ed2ebe862cc949d2caa30775dd6f16fb799
   0
   strip-backup/177f92b77385-0ebe6a8f-histedit.hg
 
 Go at a random point and try to continue
 
   $ hg id -n
   3+
   $ hg up 0
   abort: histedit in progress
   (use 'hg histedit --continue' or 'hg histedit --abort')
   [255]
 
 Try to delete necessary commit
   $ hg strip -r 652413b
   abort: histedit in progress, can't strip 652413bf663e
   [255]
 
 commit, then edit the revision
   $ hg ci -m 'wat'
   created new head
   $ echo a > e
 
 qnew should fail while we're in the middle of the edit step
 
   $ hg --config extensions.mq= qnew please-fail
   abort: histedit in progress
   (use 'hg histedit --continue' or 'hg histedit --abort')
   [255]
   $ HGEDITOR='echo foobaz > ' hg histedit --continue 2>&1 | fixbundle
 
   $ hg log --graph
   @  changeset:   6:b5f70786f9b0
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     f
   |
   o  changeset:   5:a5e1ba2f7afb
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     foobaz
   |
   o  changeset:   4:1a60820cd1f6
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     wat
   |
   o  changeset:   3:055a42cdd887
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     d
   |
   o  changeset:   2:177f92b77385
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     c
   |
   o  changeset:   1:d2ae7f538514
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     b
   |
   o  changeset:   0:cb9a9f314b8b
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     a
   
 
   $ hg cat e
   a
 
 Stripping necessary commits should not break --abort
 
   $ hg histedit 1a60820cd1f6 --commands - 2>&1 << EOF| fixbundle
   > edit 1a60820cd1f6 wat
   > pick a5e1ba2f7afb foobaz
   > pick b5f70786f9b0 g
   > EOF
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   Editing (1a60820cd1f6), you may commit or record as needed now.
   (hg histedit --continue to resume)
 
   $ mv .hg/histedit-state .hg/histedit-state.bak
   $ hg strip -q -r b5f70786f9b0
   $ mv .hg/histedit-state.bak .hg/histedit-state
   $ hg histedit --abort
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 3 files
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg log -r .
   changeset:   6:b5f70786f9b0
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     f
   
 
 check histedit_source
 
   $ hg log --debug --rev 5
   changeset:   5:a5e1ba2f7afb899ef1581cea528fd885d2fca70d
   phase:       draft
   parent:      4:1a60820cd1f6004a362aa622ebc47d59bc48eb34
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    5:5ad3be8791f39117565557781f5464363b918a45
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files:       e
   extra:       branch=default
   extra:       histedit_source=e860deea161a2f77de56603b340ebbb4536308ae
   description:
   foobaz
   
   
 
   $ hg histedit tip --commands - 2>&1 <<EOF| fixbundle
   > edit b5f70786f9b0 f
   > EOF
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   Editing (b5f70786f9b0), you may commit or record as needed now.
   (hg histedit --continue to resume)
   $ hg status
   A f
 
   $ hg summary
   parent: 5:a5e1ba2f7afb 
    foobaz
   branch: default
   commit: 1 added (new branch head)
   update: 1 new changesets (update)
   phases: 7 draft
   hist:   1 remaining (histedit --continue)
 
 (test also that editor is invoked if histedit is continued for
 "edit" action)
 
   $ HGEDITOR='cat' hg histedit --continue
   f
   
   
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: test
   HG: branch 'default'
   HG: added f
   saved backup bundle to $TESTTMP/r/.hg/strip-backup/b5f70786f9b0-c28d9c86-histedit.hg
 
   $ hg status
 
 log after edit
   $ hg log --limit 1
   changeset:   6:a107ee126658
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     f
   
 
 say we'll change the message, but don't.
   $ cat > ../edit.sh <<EOF
   > cat "\$1" | sed s/pick/mess/ > tmp
   > mv tmp "\$1"
   > EOF
   $ HGEDITOR="sh ../edit.sh" hg histedit tip 2>&1 | fixbundle
   $ hg status
   $ hg log --limit 1
   changeset:   6:1fd3b2fe7754
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     f
   
 
 modify the message
 
 check saving last-message.txt, at first
 
   $ cat > $TESTTMP/commitfailure.py <<EOF
   > from mercurial import error
   > def reposetup(ui, repo):
   >     class commitfailure(repo.__class__):
   >         def commit(self, *args, **kwargs):
   >             raise error.Abort(b'emulating unexpected abort')
   >     repo.__class__ = commitfailure
   > EOF
   $ cat >> .hg/hgrc <<EOF
   > [extensions]
   > # this failure occurs before editor invocation
   > commitfailure = $TESTTMP/commitfailure.py
   > EOF
 
   $ cat > $TESTTMP/editor.sh <<EOF
   > echo "==== before editing"
   > cat \$1
   > echo "===="
   > echo "check saving last-message.txt" >> \$1
   > EOF
 
 (test that editor is not invoked before transaction starting)
 
   $ rm -f .hg/last-message.txt
   $ HGEDITOR="sh $TESTTMP/editor.sh" hg histedit tip --commands - 2>&1 << EOF | fixbundle
   > mess 1fd3b2fe7754 f
   > EOF
   abort: emulating unexpected abort
   $ test -f .hg/last-message.txt
   [1]
 
   $ cat >> .hg/hgrc <<EOF
   > [extensions]
   > commitfailure = !
   > EOF
   $ hg histedit --abort -q
 
 (test that editor is invoked and commit message is saved into
 "last-message.txt")
 
   $ cat >> .hg/hgrc <<EOF
   > [hooks]
   > # this failure occurs after editor invocation
   > pretxncommit.unexpectedabort = false
   > EOF
 
   $ hg status --rev '1fd3b2fe7754^1' --rev 1fd3b2fe7754
   A f
 
   $ rm -f .hg/last-message.txt
   $ HGEDITOR="sh $TESTTMP/editor.sh" hg histedit tip --commands - 2>&1 << EOF
   > mess 1fd3b2fe7754 f
   > EOF
   ==== before editing
   f
   
   
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: test
   HG: branch 'default'
   HG: added f
   ====
   transaction abort!
   rollback completed
   note: commit message saved in .hg/last-message.txt
   note: use 'hg commit --logfile .hg/last-message.txt --edit' to reuse it
   abort: pretxncommit.unexpectedabort hook exited with status 1
   [255]
   $ cat .hg/last-message.txt
   f
   
   
   check saving last-message.txt
 
 (test also that editor is invoked if histedit is continued for "message"
 action)
 
   $ HGEDITOR=cat hg histedit --continue
   f
   
   
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: test
   HG: branch 'default'
   HG: added f
   transaction abort!
   rollback completed
   note: commit message saved in .hg/last-message.txt
   note: use 'hg commit --logfile .hg/last-message.txt --edit' to reuse it
   abort: pretxncommit.unexpectedabort hook exited with status 1
   [255]
 
   $ cat >> .hg/hgrc <<EOF
   > [hooks]
   > pretxncommit.unexpectedabort =
   > EOF
   $ hg histedit --abort -q
 
 then, check "modify the message" itself
 
   $ hg histedit tip --commands - 2>&1 << EOF | fixbundle
   > mess 1fd3b2fe7754 f
   > EOF
   $ hg status
   $ hg log --limit 1
   changeset:   6:62feedb1200e
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     f
   
 
 rollback should not work after a histedit
   $ hg rollback
   no rollback information available
   [1]
 
   $ cd ..
   $ hg clone -qr0 r r0
   $ cd r0
   $ hg phase -fdr0
   $ hg histedit --commands - 0 2>&1 << EOF
   > edit cb9a9f314b8b a > $EDITED
   > EOF
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   Editing (cb9a9f314b8b), you may commit or record as needed now.
   (hg histedit --continue to resume)
-  [1]
+  [240]
   $ HGEDITOR=true hg histedit --continue
   saved backup bundle to $TESTTMP/r0/.hg/strip-backup/cb9a9f314b8b-cc5ccb0b-histedit.hg
 
   $ hg log -G
   @  changeset:   0:0efcea34f18a
      tag:         tip
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     a
   
   $ echo foo >> b
   $ hg addr
   adding b
   $ hg ci -m 'add b'
   $ echo foo >> a
   $ hg ci -m 'extend a'
   $ hg phase --public 1
 Attempting to fold a change into a public change should not work:
   $ cat > ../edit.sh <<EOF
   > cat "\$1" | sed s/pick/fold/ > tmp
   > mv tmp "\$1"
   > EOF
   $ HGEDITOR="sh ../edit.sh" hg histedit 2
   warning: histedit rules saved to: .hg/histedit-last-edit.txt
   hg: parse error: first changeset cannot use verb "fold"
   [255]
   $ cat .hg/histedit-last-edit.txt
   fold 0012be4a27ea 2 extend a
   
   # Edit history between 0012be4a27ea and 0012be4a27ea
   #
   # Commits are listed from least to most recent
   #
   # You can reorder changesets by reordering the lines
   #
   # Commands:
   #
   #  e, edit = use commit, but stop for amending
   #  m, mess = edit commit message without changing commit content
   #  p, fold = use commit
   #  b, base = checkout changeset and apply further changesets from there
   #  d, drop = remove commit from history
   #  f, fold = use commit, but combine it with the one above
   #  r, roll = like fold, but discard this commit's description and date
   #
 
   $ cd ..
 
 ============================================
 Test update-timestamp config option in mess|
 ============================================
 
   $ addwithdate ()
   > {
   >     echo $1 > $1
   >     hg add $1
   >     hg ci -m $1 -d "$2 0"
   > }
 
   $ initrepo ()
   > {
   >     hg init r2
   >     cd r2
   >     addwithdate a 1
   >     addwithdate b 2
   >     addwithdate c 3
   >     addwithdate d 4
   >     addwithdate e 5
   >     addwithdate f 6
   > }
 
   $ initrepo
 
 log before edit
 
   $ hg log --limit 1
   changeset:   5:178e35e0ce73
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:06 1970 +0000
   summary:     f
   
   $ hg histedit tip --commands - 2>&1 --config rewrite.update-timestamp=True << EOF | fixbundle
   > mess 178e35e0ce73 f
   > EOF
 
 log after edit
 
   $ hg log --limit 1
   changeset:   5:98bf456d476b
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     f
   
 
   $ cd ..
 
 warn the user on editing tagged commits
 
   $ hg init issue4017
   $ cd issue4017
   $ echo > a
   $ hg ci -Am 'add a'
   adding a
   $ hg tag a
   $ hg tags
   tip                                1:bd7ee4f3939b
   a                                  0:a8a82d372bb3
   $ hg histedit
   warning: tags associated with the given changeset will be lost after histedit.
   do you want to continue (yN)?  n
   abort: histedit cancelled
   
   [255]
   $ cd ..

tests/test-histedit-fold.t

@@ -1,706 +1,706 b''
 Test histedit extension: Fold commands
 ======================================
 
 This test file is dedicated to testing the fold command in non conflicting
 case.
 
 Initialization
 ---------------
 
 
   $ . "$TESTDIR/histedit-helpers.sh"
 
   $ cat >> $HGRCPATH <<EOF
   > [alias]
   > logt = log --template '{rev}:{node|short} {desc|firstline}\n'
   > [extensions]
   > histedit=
   > mockmakedate = $TESTDIR/mockmakedate.py
   > EOF
 
 
 Simple folding
 --------------------
   $ addwithdate ()
   > {
   >     echo $1 > $1
   >     hg add $1
   >     hg ci -m $1 -d "$2 0"
   > }
 
   $ initrepo ()
   > {
   >     hg init r
   >     cd r
   >     addwithdate a 1
   >     addwithdate b 2
   >     addwithdate c 3
   >     addwithdate d 4
   >     addwithdate e 5
   >     addwithdate f 6
   > }
 
   $ initrepo
 
 log before edit
   $ hg logt --graph
   @  5:178e35e0ce73 f
   |
   o  4:1ddb6c90f2ee e
   |
   o  3:532247a8969b d
   |
   o  2:ff2c9fa2018b c
   |
   o  1:97d72e5f12c7 b
   |
   o  0:8580ff50825a a
   
 
   $ hg histedit ff2c9fa2018b --commands - 2>&1 <<EOF | fixbundle
   > pick 1ddb6c90f2ee e
   > pick 178e35e0ce73 f
   > fold ff2c9fa2018b c
   > pick 532247a8969b d
   > EOF
 
 log after edit
   $ hg logt --graph
   @  4:c4d7f3def76d d
   |
   o  3:575228819b7e f
   |
   o  2:505a591af19e e
   |
   o  1:97d72e5f12c7 b
   |
   o  0:8580ff50825a a
   
 
 post-fold manifest
   $ hg manifest
   a
   b
   c
   d
   e
   f
 
 
 check histedit_source, including that it uses the later date, from the first changeset
 
   $ hg log --debug --rev 3
   changeset:   3:575228819b7e6ed69e8c0a6a383ee59a80db7358
   phase:       draft
   parent:      2:505a591af19eed18f560af827b9e03d2076773dc
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    3:81eede616954057198ead0b2c73b41d1f392829a
   user:        test
   date:        Thu Jan 01 00:00:06 1970 +0000
   files+:      c f
   extra:       branch=default
   extra:       histedit_source=7cad1d7030207872dfd1c3a7cb430f24f2884086,ff2c9fa2018b15fa74b33363bda9527323e2a99f
   description:
   f
   ***
   c
   
   
 
 rollup will fold without preserving the folded commit's message or date
 
   $ OLDHGEDITOR=$HGEDITOR
   $ HGEDITOR=false
   $ hg histedit 97d72e5f12c7 --commands - 2>&1 <<EOF | fixbundle
   > pick 97d72e5f12c7 b
   > roll 505a591af19e e
   > pick 575228819b7e f
   > pick c4d7f3def76d d
   > EOF
 
   $ HGEDITOR=$OLDHGEDITOR
 
 log after edit
   $ hg logt --graph
   @  3:bab801520cec d
   |
   o  2:58c8f2bfc151 f
   |
   o  1:5d939c56c72e b
   |
   o  0:8580ff50825a a
   
 
 description is taken from rollup target commit
 
   $ hg log --debug --rev 1
   changeset:   1:5d939c56c72e77e29f5167696218e2131a40f5cf
   phase:       draft
   parent:      0:8580ff50825a50c8f716709acdf8de0deddcd6ab
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    1:b5e112a3a8354e269b1524729f0918662d847c38
   user:        test
   date:        Thu Jan 01 00:00:02 1970 +0000
   files+:      b e
   extra:       branch=default
   extra:       histedit_source=97d72e5f12c7e84f85064aa72e5a297142c36ed9,505a591af19eed18f560af827b9e03d2076773dc
   description:
   b
   
   
 
 check saving last-message.txt
 
   $ cat > $TESTTMP/abortfolding.py <<EOF
   > from mercurial import util
   > def abortfolding(ui, repo, hooktype, **kwargs):
   >     ctx = repo[kwargs.get('node')]
   >     if set(ctx.files()) == {b'c', b'd', b'f'}:
   >         return True # abort folding commit only
   >     ui.warn(b'allow non-folding commit\\n')
   > EOF
   $ cat > .hg/hgrc <<EOF
   > [hooks]
   > pretxncommit.abortfolding = python:$TESTTMP/abortfolding.py:abortfolding
   > EOF
 
   $ cat > $TESTTMP/editor.sh << EOF
   > echo "==== before editing"
   > cat \$1
   > echo "===="
   > echo "check saving last-message.txt" >> \$1
   > EOF
 
   $ rm -f .hg/last-message.txt
   $ hg status --rev '58c8f2bfc151^1::bab801520cec'
   A c
   A d
   A f
   $ HGEDITOR="sh $TESTTMP/editor.sh" hg histedit 58c8f2bfc151 --commands - 2>&1 <<EOF
   > pick 58c8f2bfc151 f
   > fold bab801520cec d
   > EOF
   allow non-folding commit
   ==== before editing
   f
   ***
   c
   ***
   d
   
   
   
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: test
   HG: branch 'default'
   HG: added c
   HG: added d
   HG: added f
   ====
   transaction abort!
   rollback completed
   abort: pretxncommit.abortfolding hook failed
   [255]
 
   $ cat .hg/last-message.txt
   f
   ***
   c
   ***
   d
   
   
   
   check saving last-message.txt
 
   $ cd ..
   $ rm -r r
 
 folding preserves initial author but uses later date
 ----------------------------------------------------
 
   $ initrepo
 
   $ hg ci -d '7 0' --user "someone else" --amend --quiet
 
 tip before edit
   $ hg log --rev .
   changeset:   5:10c36dd37515
   tag:         tip
   user:        someone else
   date:        Thu Jan 01 00:00:07 1970 +0000
   summary:     f
   
 
   $ hg --config progress.debug=1 --debug \
   > histedit 1ddb6c90f2ee --commands - 2>&1 <<EOF | \
   > egrep 'editing|unresolved'
   > pick 1ddb6c90f2ee e
   > fold 10c36dd37515 f
   > EOF
   editing: pick 1ddb6c90f2ee 4 e 1/2 changes (50.00%)
   editing: fold 10c36dd37515 5 f 2/2 changes (100.00%)
 
 tip after edit, which should use the later date, from the second changeset
   $ hg log --rev .
   changeset:   4:e4f3ec5d0b40
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:07 1970 +0000
   summary:     e
   
 
   $ cd ..
   $ rm -r r
 
 folding and creating no new change doesn't break:
 -------------------------------------------------
 
 folded content is dropped during a merge. The folded commit should properly disappear.
 
   $ mkdir fold-to-empty-test
   $ cd fold-to-empty-test
   $ hg init
   $ printf "1\n2\n3\n" > file
   $ hg add file
   $ hg commit -m '1+2+3'
   $ echo 4 >> file
   $ hg commit -m '+4'
   $ echo 5 >> file
   $ hg commit -m '+5'
   $ echo 6 >> file
   $ hg commit -m '+6'
   $ hg logt --graph
   @  3:251d831eeec5 +6
   |
   o  2:888f9082bf99 +5
   |
   o  1:617f94f13c0f +4
   |
   o  0:0189ba417d34 1+2+3
   
 
   $ hg histedit 1 --commands - << EOF
   > pick 617f94f13c0f 1 +4
   > drop 888f9082bf99 2 +5
   > fold 251d831eeec5 3 +6
   > EOF
   merging file
   warning: conflicts while merging file! (edit, then use 'hg resolve --mark')
   Fix up the change (fold 251d831eeec5)
   (hg histedit --continue to resume)
-  [1]
+  [240]
 There were conflicts, we keep P1 content. This
 should effectively drop the changes from +6.
 
   $ hg status -v
   M file
   ? file.orig
   # The repository is in an unfinished *histedit* state.
   
   # Unresolved merge conflicts:
   # 
   #     file
   # 
   # To mark files as resolved:  hg resolve --mark FILE
   
   # To continue:    hg histedit --continue
   # To abort:       hg histedit --abort
   
   $ hg resolve -l
   U file
   $ hg revert -r 'p1()' file
   $ hg resolve --mark file
   (no more unresolved files)
   continue: hg histedit --continue
   $ hg histedit --continue
   251d831eeec5: empty changeset
   saved backup bundle to $TESTTMP/fold-to-empty-test/.hg/strip-backup/888f9082bf99-daa0b8b3-histedit.hg
   $ hg logt --graph
   @  1:617f94f13c0f +4
   |
   o  0:0189ba417d34 1+2+3
   
 
   $ cd ..
 
 
 Test fold through dropped
 -------------------------
 
 
 Test corner case where folded revision is separated from its parent by a
 dropped revision.
 
 
   $ hg init fold-with-dropped
   $ cd fold-with-dropped
   $ printf "1\n2\n3\n" > file
   $ hg commit -Am '1+2+3'
   adding file
   $ echo 4 >> file
   $ hg commit -m '+4'
   $ echo 5 >> file
   $ hg commit -m '+5'
   $ echo 6 >> file
   $ hg commit -m '+6'
   $ hg logt -G
   @  3:251d831eeec5 +6
   |
   o  2:888f9082bf99 +5
   |
   o  1:617f94f13c0f +4
   |
   o  0:0189ba417d34 1+2+3
   
   $ hg histedit 1 --commands -  << EOF
   > pick 617f94f13c0f 1 +4
   > drop 888f9082bf99 2 +5
   > fold 251d831eeec5 3 +6
   > EOF
   merging file
   warning: conflicts while merging file! (edit, then use 'hg resolve --mark')
   Fix up the change (fold 251d831eeec5)
   (hg histedit --continue to resume)
-  [1]
+  [240]
   $ cat > file << EOF
   > 1
   > 2
   > 3
   > 4
   > 5
   > EOF
   $ hg resolve --mark file
   (no more unresolved files)
   continue: hg histedit --continue
   $ hg commit -m '+5.2'
   created new head
   $ echo 6 >> file
   $ HGEDITOR=cat hg histedit --continue
   +4
   ***
   +5.2
   ***
   +6
   
   
   
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: test
   HG: branch 'default'
   HG: changed file
   saved backup bundle to $TESTTMP/fold-with-dropped/.hg/strip-backup/617f94f13c0f-3d69522c-histedit.hg
   $ hg logt -G
   @  1:10c647b2cdd5 +4
   |
   o  0:0189ba417d34 1+2+3
   
   $ hg export tip
   # HG changeset patch
   # User test
   # Date 0 0
   #      Thu Jan 01 00:00:00 1970 +0000
   # Node ID 10c647b2cdd54db0603ecb99b2ff5ce66d5a5323
   # Parent  0189ba417d34df9dda55f88b637dcae9917b5964
   +4
   ***
   +5.2
   ***
   +6
   
   diff -r 0189ba417d34 -r 10c647b2cdd5 file
   --- a/file	Thu Jan 01 00:00:00 1970 +0000
   +++ b/file	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,3 +1,6 @@
    1
    2
    3
   +4
   +5
   +6
   $ cd ..
 
 
 Folding with initial rename (issue3729)
 ---------------------------------------
 
   $ hg init fold-rename
   $ cd fold-rename
   $ echo a > a.txt
   $ hg add a.txt
   $ hg commit -m a
   $ hg rename a.txt b.txt
   $ hg commit -m rename
   $ echo b >> b.txt
   $ hg commit -m b
 
   $ hg logt --follow b.txt
   2:e0371e0426bc b
   1:1c4f440a8085 rename
   0:6c795aa153cb a
 
   $ hg histedit 1c4f440a8085 --commands - 2>&1 << EOF | fixbundle
   > pick 1c4f440a8085 rename
   > fold e0371e0426bc b
   > EOF
 
   $ hg logt --follow b.txt
   1:cf858d235c76 rename
   0:6c795aa153cb a
 
   $ cd ..
 
 Folding with swapping
 ---------------------
 
 This is an excuse to test hook with histedit temporary commit (issue4422)
 
 
   $ hg init issue4422
   $ cd issue4422
   $ echo a > a.txt
   $ hg add a.txt
   $ hg commit -m a
   $ echo b > b.txt
   $ hg add b.txt
   $ hg commit -m b
   $ echo c > c.txt
   $ hg add c.txt
   $ hg commit -m c
 
   $ hg logt
   2:a1a953ffb4b0 c
   1:199b6bb90248 b
   0:6c795aa153cb a
 
   $ hg histedit 6c795aa153cb --config hooks.commit='echo commit $HG_NODE' --config hooks.tonative.commit=True \
   >     --commands - 2>&1 << EOF | fixbundle
   > pick 199b6bb90248 b
   > fold a1a953ffb4b0 c
   > pick 6c795aa153cb a
   > EOF
   commit 9599899f62c05f4377548c32bf1c9f1a39634b0c
 
   $ hg logt
   1:9599899f62c0 a
   0:79b99e9c8e49 b
 
 Test unix -> windows style variable substitution in external hooks.
 
   $ cat > $TESTTMP/tmp.hgrc <<'EOF'
   > [hooks]
   > pre-add = echo no variables
   > post-add = echo ran $HG_ARGS, literal \$non-var, 'also $non-var', $HG_RESULT
   > tonative.post-add = True
   > EOF
 
   $ echo "foo" > amended.txt
   $ HGRCPATH=$TESTTMP/tmp.hgrc hg add -v amended.txt
   running hook pre-add: echo no variables
   no variables
   adding amended.txt
   converting hook "post-add" to native (windows !)
   running hook post-add: echo ran %HG_ARGS%, literal $non-var, "also $non-var", %HG_RESULT% (windows !)
   running hook post-add: echo ran $HG_ARGS, literal \$non-var, 'also $non-var', $HG_RESULT (no-windows !)
   ran add -v amended.txt, literal $non-var, "also $non-var", 0 (windows !)
   ran add -v amended.txt, literal $non-var, also $non-var, 0 (no-windows !)
   $ hg ci -q --config extensions.largefiles= --amend -I amended.txt
   The fsmonitor extension is incompatible with the largefiles extension and has been disabled. (fsmonitor !)
 
 Test that folding multiple changes in a row doesn't show multiple
 editors.
 
   $ echo foo >> foo
   $ hg add foo
   $ hg ci -m foo1
   $ echo foo >> foo
   $ hg ci -m foo2
   $ echo foo >> foo
   $ hg ci -m foo3
   $ hg logt
   4:21679ff7675c foo3
   3:b7389cc4d66e foo2
   2:0e01aeef5fa8 foo1
   1:578c7455730c a
   0:79b99e9c8e49 b
   $ cat > "$TESTTMP/editor.sh" <<EOF
   > echo ran editor >> "$TESTTMP/editorlog.txt"
   > cat \$1 >> "$TESTTMP/editorlog.txt"
   > echo END >> "$TESTTMP/editorlog.txt"
   > echo merged foos > \$1
   > EOF
   $ HGEDITOR="sh \"$TESTTMP/editor.sh\"" hg histedit 1 --commands - 2>&1 <<EOF | fixbundle
   > pick 578c7455730c 1 a
   > pick 0e01aeef5fa8 2 foo1
   > fold b7389cc4d66e 3 foo2
   > fold 21679ff7675c 4 foo3
   > EOF
   merging foo
   $ hg logt
   2:e8bedbda72c1 merged foos
   1:578c7455730c a
   0:79b99e9c8e49 b
 Editor should have run only once
   $ cat $TESTTMP/editorlog.txt
   ran editor
   foo1
   ***
   foo2
   ***
   foo3
   
   
   
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: test
   HG: branch 'default'
   HG: added foo
   END
 
   $ cd ..
 
 Test rolling into a commit with multiple children (issue5498)
 
   $ hg init roll
   $ cd roll
   $ echo a > a
   $ hg commit -qAm aa
   $ echo b > b
   $ hg commit -qAm bb
   $ hg up -q ".^"
   $ echo c > c
   $ hg commit -qAm cc
   $ hg log -G -T '{node|short} {desc}'
   @  5db65b93a12b cc
   |
   | o  301d76bdc3ae bb
   |/
   o  8f0162e483d0 aa
   
 
   $ hg histedit . --commands - << EOF
   > r 5db65b93a12b
   > EOF
   hg: parse error: first changeset cannot use verb "roll"
   [255]
   $ hg log -G -T '{node|short} {desc}'
   @  5db65b93a12b cc
   |
   | o  301d76bdc3ae bb
   |/
   o  8f0162e483d0 aa
   
 
   $ cd ..
 
 ====================================
 Test update-timestamp config option|
 ====================================
 
   $ addwithdate ()
   > {
   >     echo $1 > $1
   >     hg add $1
   >     hg ci -m $1 -d "$2 0"
   > }
 
   $ initrepo ()
   > {
   >     hg init r
   >     cd r
   >     addwithdate a 1
   >     addwithdate b 2
   >     addwithdate c 3
   >     addwithdate d 4
   >     addwithdate e 5
   >     addwithdate f 6
   > }
 
   $ initrepo
 
 log before edit
 
   $ hg log
   changeset:   5:178e35e0ce73
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:06 1970 +0000
   summary:     f
   
   changeset:   4:1ddb6c90f2ee
   user:        test
   date:        Thu Jan 01 00:00:05 1970 +0000
   summary:     e
   
   changeset:   3:532247a8969b
   user:        test
   date:        Thu Jan 01 00:00:04 1970 +0000
   summary:     d
   
   changeset:   2:ff2c9fa2018b
   user:        test
   date:        Thu Jan 01 00:00:03 1970 +0000
   summary:     c
   
   changeset:   1:97d72e5f12c7
   user:        test
   date:        Thu Jan 01 00:00:02 1970 +0000
   summary:     b
   
   changeset:   0:8580ff50825a
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     a
   
 
   $ hg histedit 1ddb6c90f2ee --commands - 2>&1 --config rewrite.update-timestamp=True <<EOF | fixbundle
   > pick 178e35e0ce73 f
   > fold 1ddb6c90f2ee e
   > EOF
 
 log after edit
 observe time from f is updated
 
   $ hg log
   changeset:   4:f7909b1863a2
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     f
   
   changeset:   3:532247a8969b
   user:        test
   date:        Thu Jan 01 00:00:04 1970 +0000
   summary:     d
   
   changeset:   2:ff2c9fa2018b
   user:        test
   date:        Thu Jan 01 00:00:03 1970 +0000
   summary:     c
   
   changeset:   1:97d72e5f12c7
   user:        test
   date:        Thu Jan 01 00:00:02 1970 +0000
   summary:     b
   
   changeset:   0:8580ff50825a
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     a
   
 post-fold manifest
   $ hg manifest
   a
   b
   c
   d
   e
   f
 
   $ cd ..

tests/test-histedit-no-backup.t

@@ -1,80 +1,80 b''
 #testcases abortcommand abortflag
 
 #if abortflag
   $ cat >> $HGRCPATH <<EOF
   > [alias]
   > abort = histedit --abort
   > EOF
 #endif
 
   $ . "$TESTDIR/histedit-helpers.sh"
 
 Enable extension used by this test
   $ cat >>$HGRCPATH <<EOF
   > [extensions]
   > histedit=
   > EOF
 
 =================================
 Test backup-bundle config option|
 =================================
 Repo setup:
   $ hg init foo
   $ cd foo
   $ echo first>file
   $ hg ci -qAm one
   $ echo second>>file
   $ hg ci -m two
   $ echo third>>file
   $ hg ci -m three
   $ echo forth>>file
   $ hg ci -m four
   $ hg log -G --style compact
   @  3[tip]   7d5187087c79   1970-01-01 00:00 +0000   test
   |    four
   |
   o  2   80d23dfa866d   1970-01-01 00:00 +0000   test
   |    three
   |
   o  1   6153eb23e623   1970-01-01 00:00 +0000   test
   |    two
   |
   o  0   36b4bdd91f5b   1970-01-01 00:00 +0000   test
        one
   
 Test when `backup-bundle` config option is enabled:
   $ hg histedit -r '36b4bdd91f5b' --commands - << EOF
   > pick 36b4bdd91f5b 0 one
   > pick 6153eb23e623 1 two
   > roll 80d23dfa866d 2 three
   > edit 7d5187087c79 3 four
   > EOF
   merging file
   Editing (7d5187087c79), you may commit or record as needed now.
   (hg histedit --continue to resume)
-  [1]
+  [240]
   $ hg abort
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/foo/.hg/strip-backup/1d8f701c7b35-cf7be322-backup.hg
   saved backup bundle to $TESTTMP/foo/.hg/strip-backup/5c0056670bce-b54b65d0-backup.hg
 
 Test when `backup-bundle` config option is not enabled
 Enable config option:
   $ cat >>$HGRCPATH <<EOF
   > [rewrite]
   > backup-bundle = False
   > EOF
 
   $ hg histedit -r '36b4bdd91f5b' --commands - << EOF
   > pick 36b4bdd91f5b 0 one
   > pick 6153eb23e623 1 two
   > roll 80d23dfa866d 2 three
   > edit 7d5187087c79 3 four
   > EOF
   merging file
   Editing (7d5187087c79), you may commit or record as needed now.
   (hg histedit --continue to resume)
-  [1]
+  [240]
 
   $ hg abort
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved